service/java/com/android/server/wifi/hotspot2/OsuNetworkConnection.java - platform/packages/modules/Wifi - Git at Google

 /*
  * Copyright 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.server.wifi.hotspot2;

 import static android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.net.LinkProperties;
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.net.NetworkRequest;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiEnterpriseConfig;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiSsid;
 import android.os.Handler;
 import android.text.TextUtils;
 import android.util.Log;

 /**
  * Responsible for setup/monitor on Wi-Fi state and connection to the OSU AP.
  */
 public class OsuNetworkConnection {
     private static final String TAG = "PasspointOsuNetworkConnection";
     private static final int TIMEOUT_MS = 10000;

     private final Context mContext;

     private boolean mVerboseLoggingEnabled = false;
     private WifiManager mWifiManager;
     private ConnectivityManager mConnectivityManager;
     private ConnectivityCallbacks mConnectivityCallbacks;
     private Callbacks mCallbacks;
     private Handler mHandler;
     private Network mNetwork = null;
     private boolean mConnected = false;
     private int mNetworkId = -1;
     private boolean mWifiEnabled = false;

     /**
      * Callbacks on Wi-Fi connection state changes.
      */
     public interface Callbacks {
         /**
          * Invoked when network connection is established with IP connectivity.
          *
          * @param network {@link Network} associated with the connected network.
          */
         void onConnected(Network network);

         /**
          * Invoked when the targeted network is disconnected.
          */
         void onDisconnected();

         /**
          * Invoked when a timer tracking connection request is not reset by successful connection.
          */
         void onTimeOut();

         /**
          * Invoked when Wifi is enabled.
          */
         void onWifiEnabled();

         /**
          * Invoked when Wifi is disabled.
          */
         void onWifiDisabled();
     }

     public OsuNetworkConnection(Context context) {
         mContext = context;
     }

     /**
      * Called to initialize tracking of wifi state and network events by registering for the
      * corresponding intents.
      */
     public void init(Handler handler) {
         IntentFilter filter = new IntentFilter();
         filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
         BroadcastReceiver receiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 String action = intent.getAction();
                 if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
                     int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
                             WifiManager.WIFI_STATE_UNKNOWN);
                     if (state == WifiManager.WIFI_STATE_DISABLED && mWifiEnabled) {
                         mWifiEnabled = false;
                         if (mCallbacks != null) mCallbacks.onWifiDisabled();
                     }
                     if (state == WifiManager.WIFI_STATE_ENABLED && !mWifiEnabled) {
                         mWifiEnabled = true;
                         if (mCallbacks != null) mCallbacks.onWifiEnabled();
                     }
                 }
             }
         };
         mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
         mContext.registerReceiver(receiver, filter, null, handler);
         mWifiEnabled = mWifiManager.isWifiEnabled();
         mConnectivityManager =
                 (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
         mConnectivityCallbacks = new ConnectivityCallbacks();
         mHandler = handler;
     }

     /**
      * Disconnect, if required in the two cases
      * - still connected to the OSU AP
      * - connection to OSU AP was requested and in progress
      */
     public void disconnectIfNeeded() {
         if (mNetworkId < 0) {
             if (mVerboseLoggingEnabled) {
                 Log.v(TAG, "No connection to tear down");
             }
             return;
         }
         mConnectivityManager.unregisterNetworkCallback(mConnectivityCallbacks);
         mWifiManager.removeNetwork(mNetworkId);
         mNetworkId = -1;
         mNetwork = null;
         mConnected = false;
     }

     /**
      * Register for network and Wifi state events
      *
      * @param callbacks The callbacks to be invoked on network change events
      */
     public void setEventCallback(Callbacks callbacks) {
         mCallbacks = callbacks;
     }

     /**
      * Connect to a OSU Wi-Fi network specified by the given SSID. The security type of the Wi-Fi
      * network is either open or OSEN (OSU Server-only authenticated layer 2 Encryption Network).
      * When network access identifier is provided, OSEN is used.
      *
      * @param ssid The SSID to connect to
      * @param nai Network access identifier of the network
      * @param friendlyName a friendly name of service provider
      *
      * @return boolean true if connection was successfully initiated
      */
     public boolean connect(WifiSsid ssid, String nai, String friendlyName) {
         if (mConnected) {
             if (mVerboseLoggingEnabled) {
                 // Already connected
                 Log.v(TAG, "Connect called twice");
             }
             return true;
         }
         if (!mWifiEnabled) {
             Log.w(TAG, "Wifi is not enabled");
             return false;
         }
         WifiConfiguration config = new WifiConfiguration();
         config.SSID = "\"" + ssid.toString() + "\"";

         // To suppress Wi-Fi has no internet access notification.
         config.noInternetAccessExpected = true;

         // To suppress Wi-Fi Sign-in notification for captive portal.
         config.osu = true;

         // Do not save this network
         config.ephemeral = true;
         config.providerFriendlyName = friendlyName;

         if (TextUtils.isEmpty(nai)) {
             config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
         } else {
             // Setup OSEN connection with Unauthenticated user TLS and WFA Root certs
             config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN);
             config.enterpriseConfig.setDomainSuffixMatch(nai);
             config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.UNAUTH_TLS);
             config.enterpriseConfig.setCaPath(WfaKeyStore.DEFAULT_WFA_CERT_DIR);
         }
         mNetworkId = mWifiManager.addNetwork(config);
         if (mNetworkId < 0) {
             Log.e(TAG, "Unable to add network");
             return false;
         }

         // NET_CAPABILITY_TRUSTED is added by builder by default.
         // But for ephemeral network, the capability needs to be removed
         // as wifi stack creates network agent without the capability.
         // That could cause connectivity service not to find the matching agent.
         NetworkRequest networkRequest = new NetworkRequest.Builder()
                 .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                 .removeCapability(NET_CAPABILITY_TRUSTED)
                 .build();
         mConnectivityManager.requestNetwork(networkRequest, mConnectivityCallbacks, mHandler,
                 TIMEOUT_MS);

         // TODO(b/112195429): replace it with new connectivity API.
         if (!mWifiManager.enableNetwork(mNetworkId, true)) {
             Log.e(TAG, "Unable to enable network " + mNetworkId);
             disconnectIfNeeded();
             return false;
         }

         if (mVerboseLoggingEnabled) {
             Log.v(TAG, "Current network ID " + mNetworkId);
         }
         return true;
     }

     /**
      * Method to update logging level in this class
      *
      * @param verbose enables verbose logging
      */
     public void enableVerboseLogging(boolean verbose) {
         mVerboseLoggingEnabled = verbose;
     }

     private class ConnectivityCallbacks extends ConnectivityManager.NetworkCallback {
         @Override
         public void onAvailable(Network network) {
             WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
             if (wifiInfo == null) {
                 Log.w(TAG, "wifiInfo is not valid");
                 return;
             }
             if (mNetworkId < 0 || mNetworkId != wifiInfo.getNetworkId()) {
                 Log.w(TAG, "Irrelevant network available notification for netId: "
                         + wifiInfo.getNetworkId());
                 return;
             }
             mNetwork = network;
             mConnected = true;
         }

         @Override
         public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
             if (mVerboseLoggingEnabled) {
                 Log.v(TAG, "onLinkPropertiesChanged for network=" + network
                                 + " isProvisioned?" + linkProperties.isProvisioned());
             }
             if (mNetwork == null) {
                 Log.w(TAG, "ignore onLinkPropertyChanged event for null network");
                 return;
             }
             if (linkProperties.isProvisioned()) {
                 if (mCallbacks != null) {
                     mCallbacks.onConnected(network);
                 }
             }
         }

         @Override
         public void onUnavailable() {
             if (mVerboseLoggingEnabled) {
                 Log.v(TAG, "onUnvailable ");
             }
             if (mCallbacks != null) {
                 mCallbacks.onTimeOut();
             }
         }

         @Override
         public void onLost(Network network) {
             if (mVerboseLoggingEnabled) {
                 Log.v(TAG, "onLost " + network);
             }
             if (network != mNetwork) {
                 Log.w(TAG, "Irrelevant network lost notification");
                 return;
             }
             if (mCallbacks != null) {
                 mCallbacks.onDisconnected();
             }
         }
     }
 }
	/*
	* Copyright 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.server.wifi.hotspot2;

	import static android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.net.ConnectivityManager;
	import android.net.LinkProperties;
	import android.net.Network;
	import android.net.NetworkCapabilities;
	import android.net.NetworkRequest;
	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiEnterpriseConfig;
	import android.net.wifi.WifiInfo;
	import android.net.wifi.WifiManager;
	import android.net.wifi.WifiSsid;
	import android.os.Handler;
	import android.text.TextUtils;
	import android.util.Log;

	/**
	* Responsible for setup/monitor on Wi-Fi state and connection to the OSU AP.
	*/
	public class OsuNetworkConnection {
	private static final String TAG = "PasspointOsuNetworkConnection";
	private static final int TIMEOUT_MS = 10000;

	private final Context mContext;

	private boolean mVerboseLoggingEnabled = false;
	private WifiManager mWifiManager;
	private ConnectivityManager mConnectivityManager;
	private ConnectivityCallbacks mConnectivityCallbacks;
	private Callbacks mCallbacks;
	private Handler mHandler;
	private Network mNetwork = null;
	private boolean mConnected = false;
	private int mNetworkId = -1;
	private boolean mWifiEnabled = false;

	/**
	* Callbacks on Wi-Fi connection state changes.
	*/
	public interface Callbacks {
	/**
	* Invoked when network connection is established with IP connectivity.
	*
	* @param network {@link Network} associated with the connected network.
	*/
	void onConnected(Network network);

	/**
	* Invoked when the targeted network is disconnected.
	*/
	void onDisconnected();

	/**
	* Invoked when a timer tracking connection request is not reset by successful connection.
	*/
	void onTimeOut();

	/**
	* Invoked when Wifi is enabled.
	*/
	void onWifiEnabled();

	/**
	* Invoked when Wifi is disabled.
	*/
	void onWifiDisabled();
	}

	public OsuNetworkConnection(Context context) {
	mContext = context;
	}

	/**
	* Called to initialize tracking of wifi state and network events by registering for the
	* corresponding intents.
	*/
	public void init(Handler handler) {
	IntentFilter filter = new IntentFilter();
	filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
	BroadcastReceiver receiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	String action = intent.getAction();
	if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
	int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
	WifiManager.WIFI_STATE_UNKNOWN);
	if (state == WifiManager.WIFI_STATE_DISABLED && mWifiEnabled) {
	mWifiEnabled = false;
	if (mCallbacks != null) mCallbacks.onWifiDisabled();
	}
	if (state == WifiManager.WIFI_STATE_ENABLED && !mWifiEnabled) {
	mWifiEnabled = true;
	if (mCallbacks != null) mCallbacks.onWifiEnabled();
	}
	}
	}
	};
	mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
	mContext.registerReceiver(receiver, filter, null, handler);
	mWifiEnabled = mWifiManager.isWifiEnabled();
	mConnectivityManager =
	(ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
	mConnectivityCallbacks = new ConnectivityCallbacks();
	mHandler = handler;
	}

	/**
	* Disconnect, if required in the two cases
	* - still connected to the OSU AP
	* - connection to OSU AP was requested and in progress
	*/
	public void disconnectIfNeeded() {
	if (mNetworkId < 0) {
	if (mVerboseLoggingEnabled) {
	Log.v(TAG, "No connection to tear down");
	}
	return;
	}
	mConnectivityManager.unregisterNetworkCallback(mConnectivityCallbacks);
	mWifiManager.removeNetwork(mNetworkId);
	mNetworkId = -1;
	mNetwork = null;
	mConnected = false;
	}

	/**
	* Register for network and Wifi state events
	*
	* @param callbacks The callbacks to be invoked on network change events
	*/
	public void setEventCallback(Callbacks callbacks) {
	mCallbacks = callbacks;
	}

	/**
	* Connect to a OSU Wi-Fi network specified by the given SSID. The security type of the Wi-Fi
	* network is either open or OSEN (OSU Server-only authenticated layer 2 Encryption Network).
	* When network access identifier is provided, OSEN is used.
	*
	* @param ssid The SSID to connect to
	* @param nai Network access identifier of the network
	* @param friendlyName a friendly name of service provider
	*
	* @return boolean true if connection was successfully initiated
	*/
	public boolean connect(WifiSsid ssid, String nai, String friendlyName) {
	if (mConnected) {
	if (mVerboseLoggingEnabled) {
	// Already connected
	Log.v(TAG, "Connect called twice");
	}
	return true;
	}
	if (!mWifiEnabled) {
	Log.w(TAG, "Wifi is not enabled");
	return false;
	}
	WifiConfiguration config = new WifiConfiguration();
	config.SSID = "\"" + ssid.toString() + "\"";

	// To suppress Wi-Fi has no internet access notification.
	config.noInternetAccessExpected = true;

	// To suppress Wi-Fi Sign-in notification for captive portal.
	config.osu = true;

	// Do not save this network
	config.ephemeral = true;
	config.providerFriendlyName = friendlyName;

	if (TextUtils.isEmpty(nai)) {
	config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
	} else {
	// Setup OSEN connection with Unauthenticated user TLS and WFA Root certs
	config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN);
	config.enterpriseConfig.setDomainSuffixMatch(nai);
	config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.UNAUTH_TLS);
	config.enterpriseConfig.setCaPath(WfaKeyStore.DEFAULT_WFA_CERT_DIR);
	}
	mNetworkId = mWifiManager.addNetwork(config);
	if (mNetworkId < 0) {
	Log.e(TAG, "Unable to add network");
	return false;
	}

	// NET_CAPABILITY_TRUSTED is added by builder by default.
	// But for ephemeral network, the capability needs to be removed
	// as wifi stack creates network agent without the capability.
	// That could cause connectivity service not to find the matching agent.
	NetworkRequest networkRequest = new NetworkRequest.Builder()
	.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
	.removeCapability(NET_CAPABILITY_TRUSTED)
	.build();
	mConnectivityManager.requestNetwork(networkRequest, mConnectivityCallbacks, mHandler,
	TIMEOUT_MS);

	// TODO(b/112195429): replace it with new connectivity API.
	if (!mWifiManager.enableNetwork(mNetworkId, true)) {
	Log.e(TAG, "Unable to enable network " + mNetworkId);
	disconnectIfNeeded();
	return false;
	}

	if (mVerboseLoggingEnabled) {
	Log.v(TAG, "Current network ID " + mNetworkId);
	}
	return true;
	}

	/**
	* Method to update logging level in this class
	*
	* @param verbose enables verbose logging
	*/
	public void enableVerboseLogging(boolean verbose) {
	mVerboseLoggingEnabled = verbose;
	}

	private class ConnectivityCallbacks extends ConnectivityManager.NetworkCallback {
	@Override
	public void onAvailable(Network network) {
	WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
	if (wifiInfo == null) {
	Log.w(TAG, "wifiInfo is not valid");
	return;
	}
	if (mNetworkId < 0 \|\| mNetworkId != wifiInfo.getNetworkId()) {
	Log.w(TAG, "Irrelevant network available notification for netId: "
	+ wifiInfo.getNetworkId());
	return;
	}
	mNetwork = network;
	mConnected = true;
	}

	@Override
	public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
	if (mVerboseLoggingEnabled) {
	Log.v(TAG, "onLinkPropertiesChanged for network=" + network
	+ " isProvisioned?" + linkProperties.isProvisioned());
	}
	if (mNetwork == null) {
	Log.w(TAG, "ignore onLinkPropertyChanged event for null network");
	return;
	}
	if (linkProperties.isProvisioned()) {
	if (mCallbacks != null) {
	mCallbacks.onConnected(network);
	}
	}
	}

	@Override
	public void onUnavailable() {
	if (mVerboseLoggingEnabled) {
	Log.v(TAG, "onUnvailable ");
	}
	if (mCallbacks != null) {
	mCallbacks.onTimeOut();
	}
	}

	@Override
	public void onLost(Network network) {
	if (mVerboseLoggingEnabled) {
	Log.v(TAG, "onLost " + network);
	}
	if (network != mNetwork) {
	Log.w(TAG, "Irrelevant network lost notification");
	return;
	}
	if (mCallbacks != null) {
	mCallbacks.onDisconnected();
	}
	}
	}
	}