src/com/android/car/settings/wifi/WifiUtil.java - platform/packages/apps/Car/Settings - Gitiles

 /*
  * Copyright (C) 2017 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.car.settings.wifi;

 import android.annotation.DrawableRes;
 import android.app.admin.DevicePolicyManager;
 import android.content.ComponentName;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
 import android.provider.Settings;
 import android.widget.Toast;

 import androidx.annotation.StringRes;

 import com.android.car.settings.R;
 import com.android.car.settings.common.Logger;
 import com.android.settingslib.wifi.AccessPoint;

 import java.util.regex.Pattern;

 /**
  * A collections of util functions for WIFI.
  */
 public class WifiUtil {

     private static final Logger LOG = new Logger(WifiUtil.class);

     /** Value that is returned when we fail to connect wifi. */
     public static final int INVALID_NET_ID = -1;
     private static final Pattern HEX_PATTERN = Pattern.compile("^[0-9A-F]+$");

     @DrawableRes
     public static int getIconRes(int state) {
         switch (state) {
             case WifiManager.WIFI_STATE_ENABLING:
             case WifiManager.WIFI_STATE_DISABLED:
                 return R.drawable.ic_settings_wifi_disabled;
             default:
                 return R.drawable.ic_settings_wifi;
         }
     }

     public static boolean isWifiOn(int state) {
         switch (state) {
             case WifiManager.WIFI_STATE_ENABLING:
             case WifiManager.WIFI_STATE_DISABLED:
                 return false;
             default:
                 return true;
         }
     }

     /**
      * @return 0 if no proper description can be found.
      */
     @StringRes
     public static Integer getStateDesc(int state) {
         switch (state) {
             case WifiManager.WIFI_STATE_ENABLING:
                 return R.string.wifi_starting;
             case WifiManager.WIFI_STATE_DISABLING:
                 return R.string.wifi_stopping;
             case WifiManager.WIFI_STATE_DISABLED:
                 return R.string.wifi_disabled;
             default:
                 return 0;
         }
     }

     /**
      * Returns {@Code true} if wifi is available on this device.
      */
     public static boolean isWifiAvailable(Context context) {
         return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI);
     }

     /**
      * Gets a unique key for a {@link AccessPoint}.
      */
     public static String getKey(AccessPoint accessPoint) {
         return String.valueOf(accessPoint.hashCode());
     }

     /**
      * This method is a stripped and negated version of WifiConfigStore.canModifyNetwork.
      *
      * @param context Context of caller
      * @param config  The WiFi config.
      * @return {@code true} if Settings cannot modify the config due to lockDown.
      */
     public static boolean isNetworkLockedDown(Context context, WifiConfiguration config) {
         if (config == null) {
             return false;
         }

         final DevicePolicyManager dpm =
                 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
         final PackageManager pm = context.getPackageManager();

         // Check if device has DPM capability. If it has and dpm is still null, then we
         // treat this case with suspicion and bail out.
         if (pm.hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN) && dpm == null) {
             return true;
         }

         boolean isConfigEligibleForLockdown = false;
         if (dpm != null) {
             final ComponentName deviceOwner = dpm.getDeviceOwnerComponentOnAnyUser();
             if (deviceOwner != null) {
                 final int deviceOwnerUserId = dpm.getDeviceOwnerUserId();
                 try {
                     final int deviceOwnerUid = pm.getPackageUidAsUser(deviceOwner.getPackageName(),
                             deviceOwnerUserId);
                     isConfigEligibleForLockdown = deviceOwnerUid == config.creatorUid;
                 } catch (PackageManager.NameNotFoundException e) {
                     // don't care
                 }
             }
         }
         if (!isConfigEligibleForLockdown) {
             return false;
         }

         final ContentResolver resolver = context.getContentResolver();
         final boolean isLockdownFeatureEnabled = Settings.Global.getInt(resolver,
                 Settings.Global.WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN, 0) != 0;
         return isLockdownFeatureEnabled;
     }

     /**
      * Returns {@code true} if the provided NetworkCapabilities indicate a captive portal network.
      */
     public static boolean canSignIntoNetwork(NetworkCapabilities capabilities) {
         return (capabilities != null
                 && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL));
     }

     /**
      * Returns netId. -1 if connection fails.
      */
     public static int connectToAccessPoint(Context context, String ssid, int security,
             String password, boolean hidden) {
         WifiManager wifiManager = context.getSystemService(WifiManager.class);
         WifiConfiguration wifiConfig = new WifiConfiguration();
         wifiConfig.SSID = String.format("\"%s\"", ssid);
         wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
         wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
         wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
         wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
         wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
         wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
         wifiConfig.hiddenSSID = hidden;
         switch (security) {
             case AccessPoint.SECURITY_NONE:
                 wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                 wifiConfig.allowedAuthAlgorithms.clear();
                 wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                 wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                 break;
             case AccessPoint.SECURITY_WEP:
                 wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                 wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                 wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
                 wifiConfig.wepKeys[0] = isHexString(password) ? password
                         : "\"" + password + "\"";
                 wifiConfig.wepTxKeyIndex = 0;
                 break;
             case AccessPoint.SECURITY_PSK:
             case AccessPoint.SECURITY_EAP:
                 wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                 wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                 wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                 wifiConfig.preSharedKey = String.format("\"%s\"", password);
                 break;
             default:
                 throw new IllegalArgumentException("invalid security type");
         }
         int netId = wifiManager.addNetwork(wifiConfig);
         // This only means wifiManager failed writing the new wifiConfig to the db. It doesn't mean
         // the network is invalid.
         if (netId == INVALID_NET_ID) {
             Toast.makeText(context, R.string.wifi_failed_connect_message,
                     Toast.LENGTH_SHORT).show();
         } else {
             wifiManager.enableNetwork(netId, true);
         }
         return netId;
     }

     /** Forget the network specified by {@code accessPoint}. */
     public static void forget(Context context, AccessPoint accessPoint) {
         WifiManager wifiManager = context.getSystemService(WifiManager.class);
         if (!accessPoint.isSaved()) {
             if (accessPoint.getNetworkInfo() != null
                     && accessPoint.getNetworkInfo().getState() != NetworkInfo.State.DISCONNECTED) {
                 // Network is active but has no network ID - must be ephemeral.
                 wifiManager.disableEphemeralNetwork(
                         AccessPoint.convertToQuotedString(accessPoint.getSsidStr()));
             } else {
                 // Should not happen, but a monkey seems to trigger it
                 LOG.e("Failed to forget invalid network " + accessPoint.getConfig());
                 return;
             }
         } else {
             wifiManager.forget(accessPoint.getConfig().networkId,
                     new ActionFailedListener(context, R.string.wifi_failed_forget_message));
         }
     }

     /** Returns {@code true} if the access point was disabled due to the wrong password. */
     public static boolean isAccessPointDisabledByWrongPassword(AccessPoint accessPoint) {
         WifiConfiguration config = accessPoint.getConfig();
         if (config == null) {
             return false;
         }
         WifiConfiguration.NetworkSelectionStatus networkStatus =
                 config.getNetworkSelectionStatus();
         if (networkStatus == null || networkStatus.isNetworkEnabled()) {
             return false;
         }
         return networkStatus.getNetworkSelectionDisableReason()
                 == WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD;
     }

     private static boolean isHexString(String password) {
         return HEX_PATTERN.matcher(password).matches();
     }

     /**
      * A shared implementation of {@link WifiManager.ActionListener} which shows a failure message
      * in a toast.
      */
     public static class ActionFailedListener implements WifiManager.ActionListener {
         private final Context mContext;
         @StringRes
         private final int mFailureMessage;

         public ActionFailedListener(Context context, @StringRes int failureMessage) {
             mContext = context;
             mFailureMessage = failureMessage;
         }

         @Override
         public void onSuccess() {
         }

         @Override
         public void onFailure(int reason) {
             Toast.makeText(mContext, mFailureMessage, Toast.LENGTH_SHORT).show();
         }
     }
 }
	/*
	* Copyright (C) 2017 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.car.settings.wifi;

	import android.annotation.DrawableRes;
	import android.app.admin.DevicePolicyManager;
	import android.content.ComponentName;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.net.NetworkCapabilities;
	import android.net.NetworkInfo;
	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiManager;
	import android.provider.Settings;
	import android.widget.Toast;

	import androidx.annotation.StringRes;

	import com.android.car.settings.R;
	import com.android.car.settings.common.Logger;
	import com.android.settingslib.wifi.AccessPoint;

	import java.util.regex.Pattern;

	/**
	* A collections of util functions for WIFI.
	*/
	public class WifiUtil {

	private static final Logger LOG = new Logger(WifiUtil.class);

	/** Value that is returned when we fail to connect wifi. */
	public static final int INVALID_NET_ID = -1;
	private static final Pattern HEX_PATTERN = Pattern.compile("^[0-9A-F]+$");

	@DrawableRes
	public static int getIconRes(int state) {
	switch (state) {
	case WifiManager.WIFI_STATE_ENABLING:
	case WifiManager.WIFI_STATE_DISABLED:
	return R.drawable.ic_settings_wifi_disabled;
	default:
	return R.drawable.ic_settings_wifi;
	}
	}

	public static boolean isWifiOn(int state) {
	switch (state) {
	case WifiManager.WIFI_STATE_ENABLING:
	case WifiManager.WIFI_STATE_DISABLED:
	return false;
	default:
	return true;
	}
	}

	/**
	* @return 0 if no proper description can be found.
	*/
	@StringRes
	public static Integer getStateDesc(int state) {
	switch (state) {
	case WifiManager.WIFI_STATE_ENABLING:
	return R.string.wifi_starting;
	case WifiManager.WIFI_STATE_DISABLING:
	return R.string.wifi_stopping;
	case WifiManager.WIFI_STATE_DISABLED:
	return R.string.wifi_disabled;
	default:
	return 0;
	}
	}

	/**
	* Returns {@Code true} if wifi is available on this device.
	*/
	public static boolean isWifiAvailable(Context context) {
	return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI);
	}

	/**
	* Gets a unique key for a {@link AccessPoint}.
	*/
	public static String getKey(AccessPoint accessPoint) {
	return String.valueOf(accessPoint.hashCode());
	}

	/**
	* This method is a stripped and negated version of WifiConfigStore.canModifyNetwork.
	*
	* @param context Context of caller
	* @param config The WiFi config.
	* @return {@code true} if Settings cannot modify the config due to lockDown.
	*/
	public static boolean isNetworkLockedDown(Context context, WifiConfiguration config) {
	if (config == null) {
	return false;
	}

	final DevicePolicyManager dpm =
	(DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
	final PackageManager pm = context.getPackageManager();

	// Check if device has DPM capability. If it has and dpm is still null, then we
	// treat this case with suspicion and bail out.
	if (pm.hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN) && dpm == null) {
	return true;
	}

	boolean isConfigEligibleForLockdown = false;
	if (dpm != null) {
	final ComponentName deviceOwner = dpm.getDeviceOwnerComponentOnAnyUser();
	if (deviceOwner != null) {
	final int deviceOwnerUserId = dpm.getDeviceOwnerUserId();
	try {
	final int deviceOwnerUid = pm.getPackageUidAsUser(deviceOwner.getPackageName(),
	deviceOwnerUserId);
	isConfigEligibleForLockdown = deviceOwnerUid == config.creatorUid;
	} catch (PackageManager.NameNotFoundException e) {
	// don't care
	}
	}
	}
	if (!isConfigEligibleForLockdown) {
	return false;
	}

	final ContentResolver resolver = context.getContentResolver();
	final boolean isLockdownFeatureEnabled = Settings.Global.getInt(resolver,
	Settings.Global.WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN, 0) != 0;
	return isLockdownFeatureEnabled;
	}

	/**
	* Returns {@code true} if the provided NetworkCapabilities indicate a captive portal network.
	*/
	public static boolean canSignIntoNetwork(NetworkCapabilities capabilities) {
	return (capabilities != null
	&& capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL));
	}

	/**
	* Returns netId. -1 if connection fails.
	*/
	public static int connectToAccessPoint(Context context, String ssid, int security,
	String password, boolean hidden) {
	WifiManager wifiManager = context.getSystemService(WifiManager.class);
	WifiConfiguration wifiConfig = new WifiConfiguration();
	wifiConfig.SSID = String.format("\"%s\"", ssid);
	wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
	wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
	wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
	wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
	wifiConfig.hiddenSSID = hidden;
	switch (security) {
	case AccessPoint.SECURITY_NONE:
	wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
	wifiConfig.allowedAuthAlgorithms.clear();
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
	break;
	case AccessPoint.SECURITY_WEP:
	wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
	wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
	wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
	wifiConfig.wepKeys[0] = isHexString(password) ? password
	: "\"" + password + "\"";
	wifiConfig.wepTxKeyIndex = 0;
	break;
	case AccessPoint.SECURITY_PSK:
	case AccessPoint.SECURITY_EAP:
	wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
	wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
	wifiConfig.preSharedKey = String.format("\"%s\"", password);
	break;
	default:
	throw new IllegalArgumentException("invalid security type");
	}
	int netId = wifiManager.addNetwork(wifiConfig);
	// This only means wifiManager failed writing the new wifiConfig to the db. It doesn't mean
	// the network is invalid.
	if (netId == INVALID_NET_ID) {
	Toast.makeText(context, R.string.wifi_failed_connect_message,
	Toast.LENGTH_SHORT).show();
	} else {
	wifiManager.enableNetwork(netId, true);
	}
	return netId;
	}

	/** Forget the network specified by {@code accessPoint}. */
	public static void forget(Context context, AccessPoint accessPoint) {
	WifiManager wifiManager = context.getSystemService(WifiManager.class);
	if (!accessPoint.isSaved()) {
	if (accessPoint.getNetworkInfo() != null
	&& accessPoint.getNetworkInfo().getState() != NetworkInfo.State.DISCONNECTED) {
	// Network is active but has no network ID - must be ephemeral.
	wifiManager.disableEphemeralNetwork(
	AccessPoint.convertToQuotedString(accessPoint.getSsidStr()));
	} else {
	// Should not happen, but a monkey seems to trigger it
	LOG.e("Failed to forget invalid network " + accessPoint.getConfig());
	return;
	}
	} else {
	wifiManager.forget(accessPoint.getConfig().networkId,
	new ActionFailedListener(context, R.string.wifi_failed_forget_message));
	}
	}

	/** Returns {@code true} if the access point was disabled due to the wrong password. */
	public static boolean isAccessPointDisabledByWrongPassword(AccessPoint accessPoint) {
	WifiConfiguration config = accessPoint.getConfig();
	if (config == null) {
	return false;
	}
	WifiConfiguration.NetworkSelectionStatus networkStatus =
	config.getNetworkSelectionStatus();
	if (networkStatus == null \|\| networkStatus.isNetworkEnabled()) {
	return false;
	}
	return networkStatus.getNetworkSelectionDisableReason()
	== WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD;
	}

	private static boolean isHexString(String password) {
	return HEX_PATTERN.matcher(password).matches();
	}

	/**
	* A shared implementation of {@link WifiManager.ActionListener} which shows a failure message
	* in a toast.
	*/
	public static class ActionFailedListener implements WifiManager.ActionListener {
	private final Context mContext;
	@StringRes
	private final int mFailureMessage;

	public ActionFailedListener(Context context, @StringRes int failureMessage) {
	mContext = context;
	mFailureMessage = failureMessage;
	}

	@Override
	public void onSuccess() {
	}

	@Override
	public void onFailure(int reason) {
	Toast.makeText(mContext, mFailureMessage, Toast.LENGTH_SHORT).show();
	}
	}
	}