WifiManager: add APIs for LOHS (5adbc3fb) · Commits · e / os / android_frameworks_base

wifi/java/android/net/wifi/IWifiManager.aidl

+8 −0

Original line number	Diff line number	Diff line
		@@ -131,6 +131,14 @@ interface IWifiManager

		boolean stopSoftAp();

		WifiConfiguration startLocalOnlyHotspot(in Messenger messenger, in IBinder binder);

		void stopLocalOnlyHotspot();

		void startWatchLocalOnlyHotspot(in Messenger messenger, in IBinder binder);

		void stopWatchLocalOnlyHotspot();

		int getWifiApEnabledState();

		WifiConfiguration getWifiApConfiguration();

wifi/java/android/net/wifi/WifiManager.java

+280 −1

Original line number	Diff line number	Diff line
		@@ -40,10 +40,13 @@ import android.os.WorkSource;
		import android.util.Log;
		import android.util.SparseArray;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.util.AsyncChannel;
		import com.android.internal.util.Protocol;
		import com.android.server.net.NetworkPinner;

		import dalvik.system.CloseGuard;

		import java.net.InetAddress;
		import java.util.Collections;
		import java.util.List;
		@@ -362,7 +365,7 @@ public class WifiManager {
		/**
		* The look up key for an int that indicates why softAP started failed
		* currently support general and no_channel
		* @see #SAP_START_FAILURE_GENERAL
		* @see #SAP_START_FAILURE_GENERIC
		* @see #SAP_START_FAILURE_NO_CHANNEL
		*
		* @hide
		@@ -1808,6 +1811,131 @@ public class WifiManager {
		}
		}

		/**
		* Request a local only hotspot that an application can use to communicate between co-located
		* devices connected to the created WiFi hotspot. The network created by this method will not
		* have Internet access. Each application can make a single request for the hotspot, but
		* multiple applications could be requesting the hotspot at the same time. When multiple
		* applications have successfully registered concurrently, they will be sharing the underlying
		* hotspot. {@link LocalOnlyHotspotCallback#onStarted(LocalOnlyHotspotReservation)} is called
		* when the hotspot is ready for use by the application.
		* <p>
		* Each application can make a single active call to this method. The {@link
		* LocalOnlyHotspotCallback#onStarted(LocalOnlyHotspotReservation)} callback supplies the
		* requestor with a {@link LocalOnlyHotspotReservation} that contains a
		* {@link WifiConfiguration} with the SSID, security type and credentials needed to connect
		* to the hotspot. Communicating this information is up to the application.
		* <p>
		* If the LocalOnlyHotspot cannot be created, the {@link LocalOnlyHotspotCallback#onFailed(int)}
		* method will be called. Example failures include errors bringing up the network or if
		* there is an incompatible operating mode. For example, if the user is currently using Wifi
		* Tethering to provide an upstream to another device, LocalOnlyHotspot will not start due to
		* an incompatible mode. The possible error codes include:
		* {@link LocalOnlyHotspotCallback#ERROR_NO_CHANNEL},
		* {@link LocalOnlyHotspotCallback#ERROR_GENERIC} and
		* {@link LocalOnlyHotspotCallback#ERROR_INCOMPATIBLE_MODE}.
		* <p>
		* Internally, requests will be tracked to prevent the hotspot from being torn down while apps
		* are still using it. The {@link LocalOnlyHotspotReservation} object passed in the {@link
		* LocalOnlyHotspotCallback#onStarted(LocalOnlyHotspotReservation)} call should be closed when
		* the LocalOnlyHotspot is no longer needed using {@link LocalOnlyHotspotReservation#close()}.
		* Since the hotspot may be shared among multiple applications, removing the final registered
		* application request will trigger the hotspot teardown. This means that applications should
		* not listen to broadcasts containing wifi state to determine if the hotspot was stopped after
		* they are done using it. Additionally, once {@link LocalOnlyHotspotReservation#close()} is
		* called, applications will not receive callbacks of any kind.
		* <p>
		* Applications should be aware that the user may also stop the LocalOnlyHotspot through the
		* Settings UI; it is not guaranteed to stay up as long as there is a requesting application.
		* The requestors will be notified of this case via
		* {@link LocalOnlyHotspotCallback#onStopped()}. Other cases may arise where the hotspot is
		* torn down (Emergency mode, etc). Application developers should be aware that it can stop
		* unexpectedly, but they will receive a notification if they have properly registered.
		* <p>
		* Applications should also be aware that this network will be shared with other applications.
		* Applications are responsible for protecting their data on this network (e.g., TLS).
		* <p>
		* Applications need to have the following permissions to start LocalOnlyHotspot: {@link
		* android.Manifest.permission#CHANGE_WIFI_STATE} and {@link
		* android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_COARSE_LOCATION}. Callers without
		* the permissions will trigger a {@link java.lang.SecurityException}.
		* <p>
		* @param callback LocalOnlyHotspotCallback for the application to receive updates about
		* operating status.
		* @param handler Handler to be used for callbacks. If the caller passes a null Handler, the
		* main thread will be used.
		*
		* @hide
		*/
		public void startLocalOnlyHotspot(LocalOnlyHotspotCallback callback,
		@Nullable Handler handler) {
		throw new UnsupportedOperationException("LocalOnlyHotspot is still in development");
		}

		/**
		* Cancels a pending local only hotspot request. This can be used by the calling application to
		* cancel the existing request if the provided callback has not been triggered. Calling this
		* method will be equivalent to closing the returned LocalOnlyHotspotReservation, but it is not
		* explicitly required.
		* <p>
		* When cancelling this request, application developers should be aware that there may still be
		* outstanding local only hotspot requests and the hotspot may still start, or continue running.
		* Additionally, if a callback was registered, it will no longer be triggered after calling
		* cancel.
		*
		* @hide
		*/
		public void cancelLocalOnlyHotspotRequest() {
		throw new UnsupportedOperationException("LocalOnlyHotspot is still in development");
		}

		/**
		* Method used to inform WifiService that the LocalOnlyHotspot is no longer needed. This
		* method is used by WifiManager to release LocalOnlyHotspotReservations held by calling
		* applications and removes the internal tracking for the hotspot request. When all requesting
		* applications are finished using the hotspot, it will be stopped and WiFi will return to the
		* previous operational mode.
		*
		* This method should not be called by applications. Instead, they should call the close()
		* method on their LocalOnlyHotspotReservation.
		*/
		private void stopLocalOnlyHotspot() {
		throw new UnsupportedOperationException("LocalOnlyHotspot is still in development");
		}

		/**
		* Allow callers (Settings UI) to watch LocalOnlyHotspot state changes. Callers will
		* receive a {@link LocalOnlyHotspotSubscription} object as a parameter of the
		* {@link LocalOnlyHotspotObserver#onRegistered(LocalOnlyHotspotSubscription)}. The registered
		* callers will receive the {@link LocalOnlyHotspotObserver#onStarted(WifiConfiguration)} and
		* {@link LocalOnlyHotspotObserver#onStopped()} callbacks.
		* <p>
		* Applications should have the
		* {@link android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_COARSE_LOCATION}
		* permission. Callers without the permission will trigger a
		* {@link java.lang.SecurityException}.
		* <p>
		* @param observer LocalOnlyHotspotObserver callback.
		* @param handler Handler to use for callbacks
		*
		* @hide
		*/
		public void watchLocalOnlyHotspot(LocalOnlyHotspotObserver observer,
		@Nullable Handler handler) {
		throw new UnsupportedOperationException("LocalOnlyHotspot is still in development");
		}

		/**
		* Allow callers to stop watching LocalOnlyHotspot state changes. After calling this method,
		* applications will no longer receive callbacks.
		*
		* @hide
		*/
		public void unregisterLocalOnlyHotspotObserver() {
		throw new UnsupportedOperationException("LocalOnlyHotspot is still in development");
		}


		/**
		* Gets the Wi-Fi enabled state.
		* @return One of {@link #WIFI_AP_STATE_DISABLED},
		@@ -2064,6 +2192,157 @@ public class WifiManager {
		public void onFailure(int reason);
		}

		/**
		* LocalOnlyHotspotReservation that contains the {@link WifiConfiguration} for the active
		* LocalOnlyHotspot request.
		* <p>
		* Applications requesting LocalOnlyHotspot for sharing will receive an instance of the
		* LocalOnlyHotspotReservation in the
		* {@link LocalOnlyHotspotCallback#onStarted(LocalOnlyHotspotReservation)} call. This
		* reservation contains the relevant {@link WifiConfiguration}.
		* When an application is done with the LocalOnlyHotspot, they should call {@link
		* LocalOnlyHotspotReservation#close()}. Once this happens, the application will not receive
		* any further callbacks. If the LocalOnlyHotspot is stopped due to a
		* user triggered mode change, applications will be notified via the {@link
		* LocalOnlyHotspotCallback#onStopped()} callback.
		*
		* @hide
		*/
		public class LocalOnlyHotspotReservation implements AutoCloseable {

		private final CloseGuard mCloseGuard = CloseGuard.get();
		private final WifiConfiguration mConfig;

		/** @hide */
		@VisibleForTesting
		public LocalOnlyHotspotReservation(WifiConfiguration config) {
		mConfig = config;
		mCloseGuard.open("close");
		}

		public WifiConfiguration getConfig() {
		return mConfig;
		}

		@Override
		public void close() {
		try {
		stopLocalOnlyHotspot();
		mCloseGuard.close();
		} catch (Exception e) {
		Log.e(TAG, "Failed to stop Local Only Hotspot.");
		}
		}

		@Override
		protected void finalize() throws Throwable {
		try {
		if (mCloseGuard != null) {
		mCloseGuard.warnIfOpen();
		}
		close();
		} finally {
		super.finalize();
		}
		}
		}

		/**
		* Callback class for applications to receive updates about the LocalOnlyHotspot status.
		*
		* @hide
		*/
		public static class LocalOnlyHotspotCallback {
		public static final int ERROR_NO_CHANNEL = 1;
		public static final int ERROR_GENERIC = 2;
		public static final int ERROR_INCOMPATIBLE_MODE = 3;

		/** LocalOnlyHotspot start succeeded. */
		public void onStarted(LocalOnlyHotspotReservation reservation) {};

		/**
		* LocalOnlyHotspot stopped.
		* <p>
		* The LocalOnlyHotspot can be disabled at any time by the user. When this happens,
		* applications will be notified that it was stopped. This will not be invoked when an
		* application calls {@link LocalOnlyHotspotReservation#close()}.
		*/
		public void onStopped() {};

		/**
		* LocalOnlyHotspot failed to start.
		* <p>
		* Applications can attempt to call
		* {@link WifiManager#startLocalOnlyHotspot(LocalOnlyHotspotCallback, Handler)} again at
		* a later time.
		* <p>
		* @param reason The reason for failure could be one of: {@link #ERROR_INCOMPATIBLE_MODE},
		* {@link #ERROR_NO_CHANNEL}, or {@link #ERROR_GENERIC}.
		*/
		public void onFailed(int reason) { };
		}

		/**
		* LocalOnlyHotspotSubscription that is an AutoCloseable object for tracking applications
		* watching for LocalOnlyHotspot changes.
		*
		* @hide
		*/
		public class LocalOnlyHotspotSubscription implements AutoCloseable {
		private final CloseGuard mCloseGuard = CloseGuard.get();

		/** @hide */
		@VisibleForTesting
		public LocalOnlyHotspotSubscription() {
		mCloseGuard.open("close");
		}

		@Override
		public void close() {
		try {
		unregisterLocalOnlyHotspotObserver();
		mCloseGuard.close();
		} catch (Exception e) {
		Log.e(TAG, "Failed to unregister LocalOnlyHotspotObserver.");
		}
		}

		@Override
		protected void finalize() throws Throwable {
		try {
		if (mCloseGuard != null) {
		mCloseGuard.warnIfOpen();
		}
		close();
		} finally {
		super.finalize();
		}
		}
		}

		/**
		* Class to notify calling applications that watch for changes in LocalOnlyHotspot of updates.
		*
		* @hide
		*/
		public static class LocalOnlyHotspotObserver {
		/**
		* Confirm registration for LocalOnlyHotspotChanges by returning a
		* LocalOnlyHotspotSubscription.
		*/
		public void onRegistered(LocalOnlyHotspotSubscription subscription) {};

		/**
		* LocalOnlyHotspot started with the supplied config.
		*/
		public void onStarted(WifiConfiguration config) {};

		/**
		* LocalOnlyHotspot stopped.
		*/
		public void onStopped() {};
		}

		// Ensure that multiple ServiceHandler threads do not interleave message dispatch.
		private static final Object sServiceHandlerDispatchLock = new Object();