Merge "P2p cleanup" (224333c0) · Commits · e / os / android_frameworks_base

wifi/java/android/net/wifi/p2p/WifiP2pConfig.java

+5 −1

Original line number	Diff line number	Diff line
		@@ -30,7 +30,7 @@ public class WifiP2pConfig implements Parcelable {
		/**
		* The device MAC address uniquely identifies a Wi-Fi p2p device
		*/
		public String deviceAddress;
		public String deviceAddress = "";

		/**
		* Wi-Fi Protected Setup information
		@@ -60,6 +60,10 @@ public class WifiP2pConfig implements Parcelable {
		wps.setup = WpsInfo.PBC;
		}

		void invalidate() {
		deviceAddress = "";
		}

		/** P2P-GO-NEG-REQUEST 42:fc:89:a8:96:09 dev_passwd_id=4 {@hide}*/
		public WifiP2pConfig(String supplicantEvent) throws IllegalArgumentException {
		String[] tokens = supplicantEvent.split(" ");

wifi/java/android/net/wifi/p2p/WifiP2pDeviceList.java

+24 −12

Original line number	Diff line number	Diff line
		@@ -58,6 +58,19 @@ public class WifiP2pDeviceList implements Parcelable {
		}
		}

		private void validateDevice(WifiP2pDevice device) {
		if (device == null) throw new IllegalArgumentException("Null device");
		if (TextUtils.isEmpty(device.deviceAddress)) {
		throw new IllegalArgumentException("Empty deviceAddress");
		}
		}

		private void validateDeviceAddress(String deviceAddress) {
		if (TextUtils.isEmpty(deviceAddress)) {
		throw new IllegalArgumentException("Empty deviceAddress");
		}
		}

		/** Clear the list @hide */
		public boolean clear() {
		if (mDevices.isEmpty()) return false;
		@@ -72,14 +85,13 @@ public class WifiP2pDeviceList implements Parcelable {
		* @hide
		*/
		public void update(WifiP2pDevice device) {
		if (device == null \|\| device.deviceAddress == null) return;
		updateSupplicantDetails(device);
		mDevices.get(device.deviceAddress).status = device.status;
		}

		/** Only updates details fetched from the supplicant @hide */
		void updateSupplicantDetails(WifiP2pDevice device) {
		if (device == null \|\| device.deviceAddress == null) return;
		validateDevice(device);
		WifiP2pDevice d = mDevices.get(device.deviceAddress);
		if (d != null) {
		d.deviceName = device.deviceName;
		@@ -97,7 +109,7 @@ public class WifiP2pDeviceList implements Parcelable {

		/** @hide */
		void updateGroupCapability(String deviceAddress, int groupCapab) {
		if (TextUtils.isEmpty(deviceAddress)) return;
		validateDeviceAddress(deviceAddress);
		WifiP2pDevice d = mDevices.get(deviceAddress);
		if (d != null) {
		d.groupCapability = groupCapab;
		@@ -106,7 +118,7 @@ public class WifiP2pDeviceList implements Parcelable {

		/** @hide */
		void updateStatus(String deviceAddress, int status) {
		if (TextUtils.isEmpty(deviceAddress)) return;
		validateDeviceAddress(deviceAddress);
		WifiP2pDevice d = mDevices.get(deviceAddress);
		if (d != null) {
		d.status = status;
		@@ -119,14 +131,13 @@ public class WifiP2pDeviceList implements Parcelable {
		* @return WifiP2pDevice device found, or null if none found
		*/
		public WifiP2pDevice get(String deviceAddress) {
		if (deviceAddress == null) return null;

		validateDeviceAddress(deviceAddress);
		return mDevices.get(deviceAddress);
		}

		/** @hide */
		public boolean remove(WifiP2pDevice device) {
		if (device == null \|\| device.deviceAddress == null) return false;
		validateDevice(device);
		return mDevices.remove(device.deviceAddress) != null;
		}

		@@ -137,7 +148,7 @@ public class WifiP2pDeviceList implements Parcelable {
		* @hide
		*/
		public WifiP2pDevice remove(String deviceAddress) {
		if (deviceAddress == null) return null;
		validateDeviceAddress(deviceAddress);
		return mDevices.remove(deviceAddress);
		}

		@@ -157,11 +168,12 @@ public class WifiP2pDeviceList implements Parcelable {

		/** @hide */
		public boolean isGroupOwner(String deviceAddress) {
		if (deviceAddress != null) {
		validateDeviceAddress(deviceAddress);
		WifiP2pDevice device = mDevices.get(deviceAddress);
		if (device != null) return device.isGroupOwner();
		if (device == null) {
		throw new IllegalArgumentException("Device not found " + deviceAddress);
		}
		return false;
		return device.isGroupOwner();
		}

		public String toString() {

wifi/java/android/net/wifi/p2p/WifiP2pManager.java

+71 −37

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import android.annotation.SdkConstant.SdkConstantType;
		import android.content.Context;
		import android.net.ConnectivityManager;
		import android.net.IConnectivityManager;
		import android.net.wifi.WpsInfo;
		import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo;
		import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceResponse;
		import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
		@@ -37,6 +38,7 @@ import android.os.Messenger;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.os.WorkSource;
		import android.text.TextUtils;
		import android.util.Log;

		import com.android.internal.util.AsyncChannel;
		@@ -421,6 +423,13 @@ public class WifiP2pManager {
		/** @hide */
		public static final int SET_WFD_INFO_SUCCEEDED = BASE + 61;

		/** @hide */
		public static final int START_WPS = BASE + 62;
		/** @hide */
		public static final int START_WPS_FAILED = BASE + 63;
		/** @hide */
		public static final int START_WPS_SUCCEEDED = BASE + 64;

		/**
		* Create a new WifiP2pManager instance. Applications use
		* {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve
		@@ -641,70 +650,72 @@ public class WifiP2pManager {
		}
		break;
		/* ActionListeners grouped together */
		case WifiP2pManager.DISCOVER_PEERS_FAILED:
		case WifiP2pManager.STOP_DISCOVERY_FAILED:
		case WifiP2pManager.DISCOVER_SERVICES_FAILED:
		case WifiP2pManager.CONNECT_FAILED:
		case WifiP2pManager.CANCEL_CONNECT_FAILED:
		case WifiP2pManager.CREATE_GROUP_FAILED:
		case WifiP2pManager.REMOVE_GROUP_FAILED:
		case WifiP2pManager.ADD_LOCAL_SERVICE_FAILED:
		case WifiP2pManager.REMOVE_LOCAL_SERVICE_FAILED:
		case WifiP2pManager.CLEAR_LOCAL_SERVICES_FAILED:
		case WifiP2pManager.ADD_SERVICE_REQUEST_FAILED:
		case WifiP2pManager.REMOVE_SERVICE_REQUEST_FAILED:
		case WifiP2pManager.CLEAR_SERVICE_REQUESTS_FAILED:
		case WifiP2pManager.SET_DEVICE_NAME_FAILED:
		case WifiP2pManager.DELETE_PERSISTENT_GROUP_FAILED:
		case WifiP2pManager.SET_WFD_INFO_FAILED:
		case DISCOVER_PEERS_FAILED:
		case STOP_DISCOVERY_FAILED:
		case DISCOVER_SERVICES_FAILED:
		case CONNECT_FAILED:
		case CANCEL_CONNECT_FAILED:
		case CREATE_GROUP_FAILED:
		case REMOVE_GROUP_FAILED:
		case ADD_LOCAL_SERVICE_FAILED:
		case REMOVE_LOCAL_SERVICE_FAILED:
		case CLEAR_LOCAL_SERVICES_FAILED:
		case ADD_SERVICE_REQUEST_FAILED:
		case REMOVE_SERVICE_REQUEST_FAILED:
		case CLEAR_SERVICE_REQUESTS_FAILED:
		case SET_DEVICE_NAME_FAILED:
		case DELETE_PERSISTENT_GROUP_FAILED:
		case SET_WFD_INFO_FAILED:
		case START_WPS_FAILED:
		if (listener != null) {
		((ActionListener) listener).onFailure(message.arg1);
		}
		break;
		/* ActionListeners grouped together */
		case WifiP2pManager.DISCOVER_PEERS_SUCCEEDED:
		case WifiP2pManager.STOP_DISCOVERY_SUCCEEDED:
		case WifiP2pManager.DISCOVER_SERVICES_SUCCEEDED:
		case WifiP2pManager.CONNECT_SUCCEEDED:
		case WifiP2pManager.CANCEL_CONNECT_SUCCEEDED:
		case WifiP2pManager.CREATE_GROUP_SUCCEEDED:
		case WifiP2pManager.REMOVE_GROUP_SUCCEEDED:
		case WifiP2pManager.ADD_LOCAL_SERVICE_SUCCEEDED:
		case WifiP2pManager.REMOVE_LOCAL_SERVICE_SUCCEEDED:
		case WifiP2pManager.CLEAR_LOCAL_SERVICES_SUCCEEDED:
		case WifiP2pManager.ADD_SERVICE_REQUEST_SUCCEEDED:
		case WifiP2pManager.REMOVE_SERVICE_REQUEST_SUCCEEDED:
		case WifiP2pManager.CLEAR_SERVICE_REQUESTS_SUCCEEDED:
		case WifiP2pManager.SET_DEVICE_NAME_SUCCEEDED:
		case WifiP2pManager.DELETE_PERSISTENT_GROUP_SUCCEEDED:
		case WifiP2pManager.SET_WFD_INFO_SUCCEEDED:
		case DISCOVER_PEERS_SUCCEEDED:
		case STOP_DISCOVERY_SUCCEEDED:
		case DISCOVER_SERVICES_SUCCEEDED:
		case CONNECT_SUCCEEDED:
		case CANCEL_CONNECT_SUCCEEDED:
		case CREATE_GROUP_SUCCEEDED:
		case REMOVE_GROUP_SUCCEEDED:
		case ADD_LOCAL_SERVICE_SUCCEEDED:
		case REMOVE_LOCAL_SERVICE_SUCCEEDED:
		case CLEAR_LOCAL_SERVICES_SUCCEEDED:
		case ADD_SERVICE_REQUEST_SUCCEEDED:
		case REMOVE_SERVICE_REQUEST_SUCCEEDED:
		case CLEAR_SERVICE_REQUESTS_SUCCEEDED:
		case SET_DEVICE_NAME_SUCCEEDED:
		case DELETE_PERSISTENT_GROUP_SUCCEEDED:
		case SET_WFD_INFO_SUCCEEDED:
		case START_WPS_SUCCEEDED:
		if (listener != null) {
		((ActionListener) listener).onSuccess();
		}
		break;
		case WifiP2pManager.RESPONSE_PEERS:
		case RESPONSE_PEERS:
		WifiP2pDeviceList peers = (WifiP2pDeviceList) message.obj;
		if (listener != null) {
		((PeerListListener) listener).onPeersAvailable(peers);
		}
		break;
		case WifiP2pManager.RESPONSE_CONNECTION_INFO:
		case RESPONSE_CONNECTION_INFO:
		WifiP2pInfo wifiP2pInfo = (WifiP2pInfo) message.obj;
		if (listener != null) {
		((ConnectionInfoListener) listener).onConnectionInfoAvailable(wifiP2pInfo);
		}
		break;
		case WifiP2pManager.RESPONSE_GROUP_INFO:
		case RESPONSE_GROUP_INFO:
		WifiP2pGroup group = (WifiP2pGroup) message.obj;
		if (listener != null) {
		((GroupInfoListener) listener).onGroupInfoAvailable(group);
		}
		break;
		case WifiP2pManager.RESPONSE_SERVICE:
		case RESPONSE_SERVICE:
		WifiP2pServiceResponse resp = (WifiP2pServiceResponse) message.obj;
		handleServiceResponse(resp);
		break;
		case WifiP2pManager.RESPONSE_PERSISTENT_GROUP_INFO:
		case RESPONSE_PERSISTENT_GROUP_INFO:
		WifiP2pGroupList groups = (WifiP2pGroupList) message.obj;
		if (listener != null) {
		((PersistentGroupInfoListener) listener).
		@@ -790,6 +801,13 @@ public class WifiP2pManager {
		if (req == null) throw new IllegalArgumentException("service request is null");
		}

		private static void checkP2pConfig(WifiP2pConfig c) {
		if (c == null) throw new IllegalArgumentException("config cannot be null");
		if (TextUtils.isEmpty(c.deviceAddress)) {
		throw new IllegalArgumentException("deviceAddress cannot be empty");
		}
		}

		/**
		* Registers the application with the Wi-Fi framework. This function
		* must be the first to be called before any p2p operations are performed.
		@@ -876,6 +894,7 @@ public class WifiP2pManager {
		*/
		public void connect(Channel c, WifiP2pConfig config, ActionListener listener) {
		checkChannel(c);
		checkP2pConfig(config);
		c.mAsyncChannel.sendMessage(CONNECT, 0, c.putListener(listener), config);
		}

		@@ -936,6 +955,21 @@ public class WifiP2pManager {
		c.mAsyncChannel.sendMessage(REMOVE_GROUP, 0, c.putListener(listener));
		}

		/**
		* Start a Wi-Fi Protected Setup (WPS) session.
		*
		* <p> The function call immediately returns after sending a request to start a
		* WPS session. Currently, this is only valid if the current device is running
		* as a group owner to allow any new clients to join the group. The application
		* is notified of a success or failure to initiate WPS through listener callbacks
		* {@link ActionListener#onSuccess} or {@link ActionListener#onFailure}.
		* @hide
		*/
		public void startWps(Channel c, WpsInfo wps, ActionListener listener) {
		checkChannel(c);
		c.mAsyncChannel.sendMessage(START_WPS, 0, c.putListener(listener), wps);
		}

		/**
		* Register a local service for service discovery. If a local service is registered,
		* the framework automatically responds to a service discovery request from a peer.

wifi/java/android/net/wifi/p2p/WifiP2pService.java

+196 −148

File changed.

Preview size limit exceeded, changes collapsed.