Merge "wifi: Using framework uri parsing" into main (c310438a) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/development/AdbQrcodeScannerFragment.java

+12 −7

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		package com.android.settings.development;

		import android.annotation.Nullable;
		import android.app.Activity;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		@@ -26,6 +27,7 @@ import android.debug.IAdbManager;
		import android.graphics.Matrix;
		import android.graphics.Rect;
		import android.graphics.SurfaceTexture;
		import android.net.wifi.WifiConfiguration;
		import android.os.Bundle;
		import android.os.Handler;
		import android.os.Message;
		@@ -47,7 +49,6 @@ import com.android.settings.R;
		import com.android.settings.SetupWizardUtils;
		import com.android.settings.wifi.dpp.AdbQrCode;
		import com.android.settings.wifi.dpp.WifiDppQrCodeBaseFragment;
		import com.android.settings.wifi.dpp.WifiNetworkConfig;
		import com.android.settingslib.qrcode.QrCamera;
		import com.android.settingslib.qrcode.QrDecorateView;

		@@ -81,7 +82,8 @@ public class AdbQrcodeScannerFragment extends WifiDppQrCodeBaseFragment implemen

		/** QR code data scanned by camera */
		private AdbQrCode mAdbQrCode;
		private WifiNetworkConfig mAdbConfig;
		@Nullable
		private WifiConfiguration mAdbConfig;

		private IAdbManager mAdbManager;

		@@ -287,14 +289,17 @@ public class AdbQrcodeScannerFragment extends WifiDppQrCodeBaseFragment implemen
		AdbQrCode.triggerVibrationForQrCodeRecognition(getContext());
		mVerifyingTextView.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
		try {
		mAdbManager.enablePairingByQrCode(mAdbConfig.getSsid(),
		mAdbConfig.getPreSharedKey());
		if (mAdbConfig != null) {
		mAdbManager.enablePairingByQrCode(mAdbConfig.SSID,
		mAdbConfig.preSharedKey);
		return;
		}
		} catch (RemoteException e) {
		Log.e(TAG, "Unable to enable QR code pairing");
		Log.e(TAG, "Unable to enable QR code pairing" + e);
		}
		getActivity().setResult(Activity.RESULT_CANCELED);
		getActivity().finish();
		}
		}

		@Override
		public void handleCameraFailure() {

src/com/android/settings/wifi/dpp/AdbQrCode.java

+13 −9

Original line number	Diff line number	Diff line
		@@ -16,8 +16,12 @@
		package com.android.settings.wifi.dpp;

		import android.content.Context;
		import android.net.wifi.UriParserResults;
		import android.net.wifi.WifiConfiguration;
		import android.text.TextUtils;

		import androidx.annotation.NonNull;

		/**
		* Extension of WifiQrCode to support ADB QR code format.
		* It will be based on the ZXing format:
		@@ -27,31 +31,31 @@ import android.text.TextUtils;
		public class AdbQrCode extends WifiQrCode {
		static final String SECURITY_ADB = "ADB";

		private WifiNetworkConfig mAdbConfig;
		private WifiConfiguration mAdbConfig;

		public AdbQrCode(String qrCode) throws IllegalArgumentException {
		super(qrCode);

		// Only accept the zxing format.
		if (!WifiQrCode.SCHEME_ZXING_WIFI_NETWORK_CONFIG.equals(getScheme())) {
		if (getScheme() != UriParserResults.URI_SCHEME_ZXING_WIFI_NETWORK_CONFIG) {
		throw new IllegalArgumentException("DPP format not supported for ADB QR code");
		}
		mAdbConfig = getWifiConfiguration();

		mAdbConfig = getWifiNetworkConfig();
		if (!SECURITY_ADB.equals(mAdbConfig.getSecurity())) {
		throw new IllegalArgumentException("Invalid security type");
		if (mAdbConfig == null) {
		throw new IllegalArgumentException("Null config when parsing ADB QR code");
		}

		if (TextUtils.isEmpty(mAdbConfig.getSsid())) {
		if (TextUtils.isEmpty(mAdbConfig.SSID)) {
		throw new IllegalArgumentException("Empty service name");
		}

		if (TextUtils.isEmpty(mAdbConfig.getPreSharedKey())) {
		if (TextUtils.isEmpty(mAdbConfig.preSharedKey)) {
		throw new IllegalArgumentException("Empty password");
		}
		}

		public WifiNetworkConfig getAdbNetworkConfig() {
		@NonNull
		public WifiConfiguration getAdbNetworkConfig() {
		return mAdbConfig;
		}

src/com/android/settings/wifi/dpp/WifiDppQrCodeScannerFragment.java

+26 −27

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@ import android.graphics.Matrix;
		import android.graphics.Rect;
		import android.graphics.SurfaceTexture;
		import android.net.wifi.EasyConnectStatusCallback;
		import android.net.wifi.UriParserResults;
		import android.net.wifi.WifiConfiguration;
		import android.net.wifi.WifiManager;
		import android.os.Bundle;
		@@ -183,33 +184,30 @@ public class WifiDppQrCodeScannerFragment extends WifiDppQrCodeBaseFragment impl
		// one for open network and one for enhanced open network.
		final WifiManager wifiManager =
		context.getSystemService(WifiManager.class);
		final WifiNetworkConfig qrCodeWifiNetworkConfig =
		(WifiNetworkConfig)msg.obj;
		final List<WifiConfiguration> qrCodeWifiConfigurations =
		qrCodeWifiNetworkConfig.getWifiConfigurations();
		final WifiConfiguration qrCodeWifiConfiguration = (WifiConfiguration) msg.obj;

		// Adds all Wi-Fi networks in QR code to the set of configured networks and
		// connects to it if it's reachable.
		boolean hasHiddenOrReachableWifiNetwork = false;
		for (WifiConfiguration qrCodeWifiConfiguration : qrCodeWifiConfigurations) {
		final int id = wifiManager.addNetwork(qrCodeWifiConfiguration);
		if (id == -1) {
		continue;
		return;
		}

		if (!canConnectWifi(qrCodeWifiConfiguration.SSID)) return;
		if (!canConnectWifi(qrCodeWifiConfiguration.SSID)) {
		return;
		}

		wifiManager.enableNetwork(id, /* attemptConnect */ false);
		// WifiTracker only contains a hidden SSID Wi-Fi network if it's saved.
		// We can't check if a hidden SSID Wi-Fi network is reachable in advance.
		if (qrCodeWifiConfiguration.hiddenSSID \|\|
		isReachableWifiNetwork(qrCodeWifiConfiguration)) {
		if (qrCodeWifiConfiguration.hiddenSSID
		\|\| isReachableWifiNetwork(qrCodeWifiConfiguration)) {
		hasHiddenOrReachableWifiNetwork = true;
		mEnrolleeWifiConfiguration = qrCodeWifiConfiguration;
		wifiManager.connect(id,
		/* listener */ WifiDppQrCodeScannerFragment.this);
		}
		}

		if (!hasHiddenOrReachableWifiNetwork) {
		showErrorMessageAndRestartCamera(
		@@ -530,8 +528,9 @@ public class WifiDppQrCodeScannerFragment extends WifiDppQrCodeBaseFragment impl
		}

		// It's impossible to provision other device with ZXing Wi-Fi Network config format
		final String scheme = mWifiQrCode.getScheme();
		if (mIsConfiguratorMode && WifiQrCode.SCHEME_ZXING_WIFI_NETWORK_CONFIG.equals(scheme)) {
		if (mIsConfiguratorMode
		&& mWifiQrCode.getScheme()
		== UriParserResults.URI_SCHEME_ZXING_WIFI_NETWORK_CONFIG) {
		showErrorMessage(R.string.wifi_dpp_qr_code_is_not_valid_format);
		return false;
		}
		@@ -545,11 +544,11 @@ public class WifiDppQrCodeScannerFragment extends WifiDppQrCodeBaseFragment impl
		@Override
		public void handleSuccessfulResult(String qrCode) {
		switch (mWifiQrCode.getScheme()) {
		case WifiQrCode.SCHEME_DPP:
		case UriParserResults.URI_SCHEME_DPP:
		handleWifiDpp();
		break;

		case WifiQrCode.SCHEME_ZXING_WIFI_NETWORK_CONFIG:
		case UriParserResults.URI_SCHEME_ZXING_WIFI_NETWORK_CONFIG:
		handleZxingWifiFormat();
		break;

		@@ -567,7 +566,7 @@ public class WifiDppQrCodeScannerFragment extends WifiDppQrCodeBaseFragment impl

		private void handleZxingWifiFormat() {
		Message message = mHandler.obtainMessage(MESSAGE_SCAN_ZXING_WIFI_FORMAT_SUCCESS);
		message.obj = new WifiQrCode(mWifiQrCode.getQrCode()).getWifiNetworkConfig();
		message.obj = new WifiQrCode(mWifiQrCode.getQrCode()).getWifiConfiguration();

		mHandler.sendMessageDelayed(message, SHOW_SUCCESS_SQUARE_INTERVAL);
		}

src/com/android/settings/wifi/dpp/WifiQrCode.java

+16 −131

Original line number	Diff line number	Diff line
		@@ -16,14 +16,12 @@

		package com.android.settings.wifi.dpp;

		import android.annotation.NonNull;
		import android.net.wifi.UriParserResults;
		import android.net.wifi.WifiConfiguration;
		import android.net.wifi.WifiUriParser;
		import android.text.TextUtils;

		import androidx.annotation.VisibleForTesting;

		import java.util.Arrays;
		import java.util.List;
		import java.util.regex.Pattern;
		import android.util.Log;

		/**
		* Supports to parse 2 types of QR code
		@@ -70,19 +68,8 @@ public class WifiQrCode {
		static final String SECURITY_SAE = "SAE";

		private String mQrCode;

		/**
		* SCHEME_DPP for standard Wi-Fi device provision protocol; SCHEME_ZXING_WIFI_NETWORK_CONFIG
		* for ZXing reader library' Wi-Fi Network config format
		*/
		private String mScheme;

		// Data from parsed Wi-Fi DPP QR code
		private String mPublicKey;
		private String mInformation;

		// Data from parsed ZXing reader library's Wi-Fi Network config format
		private WifiNetworkConfig mWifiNetworkConfig;
		@NonNull
		private UriParserResults mUriParserResults;

		public WifiQrCode(String qrCode) throws IllegalArgumentException {
		if (TextUtils.isEmpty(qrCode)) {
		@@ -90,111 +77,14 @@ public class WifiQrCode {
		}

		mQrCode = qrCode;

		if (qrCode.startsWith(PREFIX_DPP)) {
		mScheme = SCHEME_DPP;
		parseWifiDppQrCode(qrCode);
		} else if (qrCode.startsWith(PREFIX_ZXING_WIFI_NETWORK_CONFIG)) {
		mScheme = SCHEME_ZXING_WIFI_NETWORK_CONFIG;
		parseZxingWifiQrCode(qrCode);
		} else {
		try {
		mUriParserResults = WifiUriParser.parseUri(mQrCode);
		Log.i("WifiQrCode", "mUriParserResults = " + mUriParserResults);
		} catch (IllegalArgumentException ie) {
		throw new IllegalArgumentException("Invalid scheme");
		}
		}

		/** Parses Wi-Fi DPP QR code string */
		private void parseWifiDppQrCode(String qrCode) throws IllegalArgumentException {
		List<String> keyValueList = getKeyValueList(qrCode, PREFIX_DPP, DELIMITER_QR_CODE);

		String publicKey = getValueOrNull(keyValueList, PREFIX_DPP_PUBLIC_KEY);
		if (TextUtils.isEmpty(publicKey)) {
		throw new IllegalArgumentException("Invalid format");
		}
		mPublicKey = publicKey;

		mInformation = getValueOrNull(keyValueList, PREFIX_DPP_INFORMATION);
		}

		/** Parses ZXing reader library's Wi-Fi Network config format */
		private void parseZxingWifiQrCode(String qrCode) throws IllegalArgumentException {
		List<String> keyValueList = getKeyValueList(qrCode, PREFIX_ZXING_WIFI_NETWORK_CONFIG,
		DELIMITER_QR_CODE);

		String security = getValueOrNull(keyValueList, PREFIX_ZXING_SECURITY);
		String ssid = getValueOrNull(keyValueList, PREFIX_ZXING_SSID);
		String password = getValueOrNull(keyValueList, PREFIX_ZXING_PASSWORD);
		String hiddenSsidString = getValueOrNull(keyValueList, PREFIX_ZXING_HIDDEN_SSID);

		boolean hiddenSsid = "true".equalsIgnoreCase(hiddenSsidString);

		//"\", ";", "," and ":" are escaped with a backslash "\", should remove at first
		security = removeBackSlash(security);
		ssid = removeBackSlash(ssid);
		password = removeBackSlash(password);

		mWifiNetworkConfig = WifiNetworkConfig.getValidConfigOrNull(security, ssid, password,
		hiddenSsid, WifiConfiguration.INVALID_NETWORK_ID, /* isHotspot */ false);

		if (mWifiNetworkConfig == null) {
		throw new IllegalArgumentException("Invalid format");
		}
		}

		/**
		* Splits key/value pairs from qrCode
		*
		* @param qrCode the QR code raw string
		* @param prefixQrCode the string before all key/value pairs in qrCode
		* @param delimiter the string to split key/value pairs, can't contain a backslash
		* @return a list contains string of key/value (e.g. K:key1)
		*/
		private List<String> getKeyValueList(String qrCode, String prefixQrCode,
		String delimiter) {
		String keyValueString = qrCode.substring(prefixQrCode.length());

		// Should not treat \delimiter as a delimiter
		String regex = "(?<!\\\\)" + Pattern.quote(delimiter);

		return Arrays.asList(keyValueString.split(regex));
		}

		private String getValueOrNull(List<String> keyValueList, String prefix) {
		for (String keyValue : keyValueList) {
		String strippedKeyValue = keyValue.stripLeading();
		if (strippedKeyValue.startsWith(prefix)) {
		return strippedKeyValue.substring(prefix.length());
		}
		}

		return null;
		}

		@VisibleForTesting
		String removeBackSlash(String input) {
		if (input == null) {
		return null;
		}

		StringBuilder sb = new StringBuilder();
		boolean backSlash = false;
		for (char ch : input.toCharArray()) {
		if (ch != '\\') {
		sb.append(ch);
		backSlash = false;
		} else {
		if (backSlash) {
		sb.append(ch);
		backSlash = false;
		continue;
		}

		backSlash = true;
		}
		}

		return sb.toString();
		}

		String getQrCode() {
		return mQrCode;
		}
		@@ -205,28 +95,23 @@ public class WifiQrCode {
		* SCHEME_DPP for standard Wi-Fi device provision protocol; SCHEME_ZXING_WIFI_NETWORK_CONFIG
		* for ZXing reader library' Wi-Fi Network config format
		*/
		public String getScheme() {
		return mScheme;
		public int getScheme() {
		return mUriParserResults.getUriScheme();
		}

		/** Available when {@code getScheme()} returns SCHEME_DPP */
		@VisibleForTesting
		String getPublicKey() {
		return mPublicKey;
		return mUriParserResults.getPublicKey();
		}

		/** May be available when {@code getScheme()} returns SCHEME_DPP */
		public String getInformation() {
		return mInformation;
		return mUriParserResults.getInformation();
		}

		/** Available when {@code getScheme()} returns SCHEME_ZXING_WIFI_NETWORK_CONFIG */
		WifiNetworkConfig getWifiNetworkConfig() {
		if (mWifiNetworkConfig == null) {
		return null;
		}

		return new WifiNetworkConfig(mWifiNetworkConfig);
		WifiConfiguration getWifiConfiguration() {
		return mUriParserResults.getWifiConfiguration();
		}

		static WifiQrCode getValidWifiDppQrCodeOrNull(String qrCode) {

tests/unit/src/com/android/settings/wifi/dpp/WifiQrCodeTest.java

deleted100644 → 0

+0 −74

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.settings.wifi.dpp;

		import static com.google.common.truth.Truth.assertThat;

		import androidx.test.ext.junit.runners.AndroidJUnit4;

		import org.junit.Test;
		import org.junit.runner.RunWith;

		@RunWith(AndroidJUnit4.class)
		public class WifiQrCodeTest {
		@Test
		public void testZxParsing_validCode() {
		WifiNetworkConfig config = new WifiQrCode("WIFI:S:testAbC;T:nopass").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("testAbC");
		assertThat(config.getSecurity()).isEqualTo("nopass");

		config = new WifiQrCode(
		"WIFI:S:reallyLONGone;T:WEP;P:somepasswo#%^**123rd").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("reallyLONGone");
		assertThat(config.getSecurity()).isEqualTo("WEP");
		assertThat(config.getPreSharedKey()).isEqualTo("somepasswo#%^**123rd");

		config = new WifiQrCode("WIFI:S:anotherone;T:WPA;P:3#=3j9asicla").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("anotherone");
		assertThat(config.getSecurity()).isEqualTo("WPA");
		assertThat(config.getPreSharedKey()).isEqualTo("3#=3j9asicla");

		config = new WifiQrCode("WIFI:S:xx;T:SAE;P:a").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("xx");
		assertThat(config.getSecurity()).isEqualTo("SAE");
		assertThat(config.getPreSharedKey()).isEqualTo("a");
		}

		@Test
		public void testZxParsing_invalidCodeButShouldWork() {
		WifiNetworkConfig config = new WifiQrCode(
		"WIFI:S:testAbC; T:nopass").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("testAbC");
		assertThat(config.getSecurity()).isEqualTo("nopass");

		config = new WifiQrCode(
		"WIFI:S:reallyLONGone;T:WEP; P:somepassword").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("reallyLONGone");
		assertThat(config.getSecurity()).isEqualTo("WEP");
		assertThat(config.getPreSharedKey()).isEqualTo("somepassword");

		config = new WifiQrCode("WIFI: S:anotherone;T:WPA;P:abcdefghihklmn").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("anotherone");
		assertThat(config.getSecurity()).isEqualTo("WPA");
		assertThat(config.getPreSharedKey()).isEqualTo("abcdefghihklmn");

		config = new WifiQrCode("WIFI: S:xx; T:SAE; P:a").getWifiNetworkConfig();
		assertThat(config.getSsid()).isEqualTo("xx");
		assertThat(config.getSecurity()).isEqualTo("SAE");
		assertThat(config.getPreSharedKey()).isEqualTo("a");
		}
		}