wifi/java/android/net/wifi/nan/WifiNanManager.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 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 android.net.wifi.nan;

 import android.os.Binder;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.util.Log;

 /**
  * This class provides the primary API for managing Wi-Fi NAN operation:
  * including discovery and data-links. Get an instance of this class by calling
  * {@link android.content.Context#getSystemService(String)
  * Context.getSystemService(Context.WIFI_NAN_SERVICE)}.
  * <p>
  * The class provides access to:
  * <ul>
  * <li>Configure a NAN connection and register for events.
  * <li>Create publish and subscribe sessions.
  * <li>Create NAN network specifier to be used to create a NAN network.
  * </ul>
  *
  * @hide PROPOSED_NAN_API
  */
 public class WifiNanManager {
     private static final String TAG = "WifiNanManager";
     private static final boolean DBG = false;
     private static final boolean VDBG = false; // STOPSHIP if true

     private IBinder mBinder;

     private IWifiNanManager mService;

     /**
      * {@hide}
      */
     public WifiNanManager(IWifiNanManager service) {
         mService = service;
     }

     /**
      * Re-connect to the Wi-Fi NAN service - enabling the application to execute
      * {@link WifiNanManager} APIs. Application don't normally need to call this
      * API since it is executed in the constructor. However, applications which
      * have explicitly {@link WifiNanManager#disconnect()} need to call this
      * function to re-connect.
      *
      * @param listener A listener extended from {@link WifiNanEventListener}.
      * @param events The set of events to be delivered to the {@code listener}.
      *            OR'd event flags from {@link WifiNanEventListener
      *            NanEventListener.LISTEN*}.
      */
     public void connect(WifiNanEventListener listener, int events) {
         try {
             if (VDBG) Log.v(TAG, "connect()");
             if (listener == null) {
                 throw new IllegalArgumentException("Invalid listener - must not be null");
             }
             if (mBinder == null) {
                 mBinder = new Binder();
             }
             mService.connect(mBinder, listener.callback, events);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * Disconnect from the Wi-Fi NAN service and destroy all outstanding
      * operations - i.e. all publish and subscribes are terminated, any
      * outstanding data-link is shut-down, and all requested NAN configurations
      * are cancelled.
      * <p>
      * An application may then re-connect using
      * {@link WifiNanManager#connect(WifiNanEventListener, int)} .
      */
     public void disconnect() {
         try {
             if (VDBG) Log.v(TAG, "disconnect()");
             mService.disconnect(mBinder);
             mBinder = null;
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * Requests a NAN configuration, specified by {@link ConfigRequest}. Note
      * that NAN is a shared resource and the device can only be a member of a
      * single cluster. Thus the service may merge configuration requests from
      * multiple applications and configure NAN differently from individual
      * requests.
      * <p>
      * The {@link WifiNanEventListener#onConfigCompleted(ConfigRequest)} will be
      * called when configuration is completed (if a listener is registered for
      * this specific event).
      *
      * @param configRequest The requested NAN configuration.
      */
     public void requestConfig(ConfigRequest configRequest) {
         if (VDBG) Log.v(TAG, "requestConfig(): configRequest=" + configRequest);
         try {
             mService.requestConfig(configRequest);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * Request a NAN publish session. The results of the publish session
      * operation will result in callbacks to the indicated listener:
      * {@link WifiNanSessionListener NanSessionListener.on*}.
      *
      * @param publishData The {@link PublishData} specifying the contents of the
      *            publish session.
      * @param publishSettings The {@link PublishSettings} specifying the
      *            settings for the publish session.
      * @param listener The {@link WifiNanSessionListener} derived objects to be used
      *            for the event callbacks specified by {@code events}.
      * @param events The list of events to be delivered to the {@code listener}
      *            object. An OR'd value of {@link WifiNanSessionListener
      *            NanSessionListener.LISTEN_*}.
      * @return The {@link WifiNanPublishSession} which can be used to further
      *         control the publish session.
      */
     public WifiNanPublishSession publish(PublishData publishData, PublishSettings publishSettings,
             WifiNanSessionListener listener, int events) {
         return publishRaw(publishData, publishSettings, listener,
                 events | WifiNanSessionListener.LISTEN_HIDDEN_FLAGS);
     }

     /**
      * Same as publish(*) but does not modify the event flag
      *
      * @hide
      */
     public WifiNanPublishSession publishRaw(PublishData publishData,
             PublishSettings publishSettings, WifiNanSessionListener listener, int events) {
         if (VDBG) Log.v(TAG, "publish(): data='" + publishData + "', settings=" + publishSettings);

         if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_UNSOLICITED
                 && publishData.mRxFilterLength != 0) {
             throw new IllegalArgumentException("Invalid publish data & settings: UNSOLICITED "
                     + "publishes (active) can't have an Rx filter");
         }
         if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_SOLICITED
                 && publishData.mTxFilterLength != 0) {
             throw new IllegalArgumentException("Invalid publish data & settings: SOLICITED "
                     + "publishes (passive) can't have a Tx filter");
         }
         if (listener == null) {
             throw new IllegalArgumentException("Invalid listener - must not be null");
         }

         int sessionId;

         try {
             sessionId = mService.createSession(listener.callback, events);
             if (DBG) Log.d(TAG, "publish: session created - sessionId=" + sessionId);
             mService.publish(sessionId, publishData, publishSettings);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }

         return new WifiNanPublishSession(this, sessionId);
     }

     /**
      * {@hide}
      */
     public void publish(int sessionId, PublishData publishData, PublishSettings publishSettings) {
         if (VDBG) Log.v(TAG, "publish(): data='" + publishData + "', settings=" + publishSettings);

         if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_UNSOLICITED
                 && publishData.mRxFilterLength != 0) {
             throw new IllegalArgumentException("Invalid publish data & settings: UNSOLICITED "
                     + "publishes (active) can't have an Rx filter");
         }
         if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_SOLICITED
                 && publishData.mTxFilterLength != 0) {
             throw new IllegalArgumentException("Invalid publish data & settings: SOLICITED "
                     + "publishes (passive) can't have a Tx filter");
         }

         try {
             mService.publish(sessionId, publishData, publishSettings);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }
     /**
      * Request a NAN subscribe session. The results of the subscribe session
      * operation will result in callbacks to the indicated listener:
      * {@link WifiNanSessionListener NanSessionListener.on*}.
      *
      * @param subscribeData The {@link SubscribeData} specifying the contents of
      *            the subscribe session.
      * @param subscribeSettings The {@link SubscribeSettings} specifying the
      *            settings for the subscribe session.
      * @param listener The {@link WifiNanSessionListener} derived objects to be used
      *            for the event callbacks specified by {@code events}.
      * @param events The list of events to be delivered to the {@code listener}
      *            object. An OR'd value of {@link WifiNanSessionListener
      *            NanSessionListener.LISTEN_*}.
      * @return The {@link WifiNanSubscribeSession} which can be used to further
      *         control the subscribe session.
      */
     public WifiNanSubscribeSession subscribe(SubscribeData subscribeData,
             SubscribeSettings subscribeSettings,
             WifiNanSessionListener listener, int events) {
         return subscribeRaw(subscribeData, subscribeSettings, listener,
                 events | WifiNanSessionListener.LISTEN_HIDDEN_FLAGS);
     }

     /**
      * Same as subscribe(*) but does not modify the event flag
      *
      * @hide
      */
     public WifiNanSubscribeSession subscribeRaw(SubscribeData subscribeData,
             SubscribeSettings subscribeSettings, WifiNanSessionListener listener, int events) {
         if (VDBG) {
             Log.v(TAG, "subscribe(): data='" + subscribeData + "', settings=" + subscribeSettings);
         }

         if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_ACTIVE
                 && subscribeData.mRxFilterLength != 0) {
             throw new IllegalArgumentException(
                     "Invalid subscribe data & settings: ACTIVE subscribes can't have an Rx filter");
         }
         if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE
                 && subscribeData.mTxFilterLength != 0) {
             throw new IllegalArgumentException(
                     "Invalid subscribe data & settings: PASSIVE subscribes can't have a Tx filter");
         }

         int sessionId;

         try {
             sessionId = mService.createSession(listener.callback, events);
             if (DBG) Log.d(TAG, "subscribe: session created - sessionId=" + sessionId);
             mService.subscribe(sessionId, subscribeData, subscribeSettings);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }

         return new WifiNanSubscribeSession(this, sessionId);
     }

     /**
      * {@hide}
      */
     public void subscribe(int sessionId, SubscribeData subscribeData,
             SubscribeSettings subscribeSettings) {
         if (VDBG) {
             Log.v(TAG, "subscribe(): data='" + subscribeData + "', settings=" + subscribeSettings);
         }

         if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_ACTIVE
                 && subscribeData.mRxFilterLength != 0) {
             throw new IllegalArgumentException(
                     "Invalid subscribe data & settings: ACTIVE subscribes can't have an Rx filter");
         }
         if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE
                 && subscribeData.mTxFilterLength != 0) {
             throw new IllegalArgumentException(
                     "Invalid subscribe data & settings: PASSIVE subscribes can't have a Tx filter");
         }

         try {
             mService.subscribe(sessionId, subscribeData, subscribeSettings);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * {@hide}
      */
     public void stopSession(int sessionId) {
         if (DBG) Log.d(TAG, "Stop NAN session #" + sessionId);

         try {
             mService.stopSession(sessionId);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * {@hide}
      */
     public void destroySession(int sessionId) {
         if (DBG) Log.d(TAG, "Destroy NAN session #" + sessionId);

         try {
             mService.destroySession(sessionId);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }

     /**
      * {@hide}
      */
     public void sendMessage(int sessionId, int peerId, byte[] message, int messageLength,
             int messageId) {
         try {
             if (VDBG) {
                 Log.v(TAG, "sendMessage(): sessionId=" + sessionId + ", peerId=" + peerId
                         + ", messageLength=" + messageLength + ", messageId=" + messageId);
             }
             mService.sendMessage(sessionId, peerId, message, messageLength, messageId);
         } catch (RemoteException e) {
             throw e.rethrowFromSystemServer();
         }
     }
 }
	/*
	* Copyright (C) 2016 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 android.net.wifi.nan;

	import android.os.Binder;
	import android.os.IBinder;
	import android.os.RemoteException;
	import android.util.Log;

	/**
	* This class provides the primary API for managing Wi-Fi NAN operation:
	* including discovery and data-links. Get an instance of this class by calling
	* {@link android.content.Context#getSystemService(String)
	* Context.getSystemService(Context.WIFI_NAN_SERVICE)}.
	* <p>
	* The class provides access to:
	* <ul>
	* <li>Configure a NAN connection and register for events.
	* <li>Create publish and subscribe sessions.
	* <li>Create NAN network specifier to be used to create a NAN network.
	* </ul>
	*
	* @hide PROPOSED_NAN_API
	*/
	public class WifiNanManager {
	private static final String TAG = "WifiNanManager";
	private static final boolean DBG = false;
	private static final boolean VDBG = false; // STOPSHIP if true

	private IBinder mBinder;

	private IWifiNanManager mService;

	/**
	* {@hide}
	*/
	public WifiNanManager(IWifiNanManager service) {
	mService = service;
	}

	/**
	* Re-connect to the Wi-Fi NAN service - enabling the application to execute
	* {@link WifiNanManager} APIs. Application don't normally need to call this
	* API since it is executed in the constructor. However, applications which
	* have explicitly {@link WifiNanManager#disconnect()} need to call this
	* function to re-connect.
	*
	* @param listener A listener extended from {@link WifiNanEventListener}.
	* @param events The set of events to be delivered to the {@code listener}.
	* OR'd event flags from {@link WifiNanEventListener
	* NanEventListener.LISTEN*}.
	*/
	public void connect(WifiNanEventListener listener, int events) {
	try {
	if (VDBG) Log.v(TAG, "connect()");
	if (listener == null) {
	throw new IllegalArgumentException("Invalid listener - must not be null");
	}
	if (mBinder == null) {
	mBinder = new Binder();
	}
	mService.connect(mBinder, listener.callback, events);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* Disconnect from the Wi-Fi NAN service and destroy all outstanding
	* operations - i.e. all publish and subscribes are terminated, any
	* outstanding data-link is shut-down, and all requested NAN configurations
	* are cancelled.
	* <p>
	* An application may then re-connect using
	* {@link WifiNanManager#connect(WifiNanEventListener, int)} .
	*/
	public void disconnect() {
	try {
	if (VDBG) Log.v(TAG, "disconnect()");
	mService.disconnect(mBinder);
	mBinder = null;
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* Requests a NAN configuration, specified by {@link ConfigRequest}. Note
	* that NAN is a shared resource and the device can only be a member of a
	* single cluster. Thus the service may merge configuration requests from
	* multiple applications and configure NAN differently from individual
	* requests.
	* <p>
	* The {@link WifiNanEventListener#onConfigCompleted(ConfigRequest)} will be
	* called when configuration is completed (if a listener is registered for
	* this specific event).
	*
	* @param configRequest The requested NAN configuration.
	*/
	public void requestConfig(ConfigRequest configRequest) {
	if (VDBG) Log.v(TAG, "requestConfig(): configRequest=" + configRequest);
	try {
	mService.requestConfig(configRequest);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* Request a NAN publish session. The results of the publish session
	* operation will result in callbacks to the indicated listener:
	* {@link WifiNanSessionListener NanSessionListener.on*}.
	*
	* @param publishData The {@link PublishData} specifying the contents of the
	* publish session.
	* @param publishSettings The {@link PublishSettings} specifying the
	* settings for the publish session.
	* @param listener The {@link WifiNanSessionListener} derived objects to be used
	* for the event callbacks specified by {@code events}.
	* @param events The list of events to be delivered to the {@code listener}
	* object. An OR'd value of {@link WifiNanSessionListener
	* NanSessionListener.LISTEN_*}.
	* @return The {@link WifiNanPublishSession} which can be used to further
	* control the publish session.
	*/
	public WifiNanPublishSession publish(PublishData publishData, PublishSettings publishSettings,
	WifiNanSessionListener listener, int events) {
	return publishRaw(publishData, publishSettings, listener,
	events \| WifiNanSessionListener.LISTEN_HIDDEN_FLAGS);
	}

	/**
	* Same as publish(*) but does not modify the event flag
	*
	* @hide
	*/
	public WifiNanPublishSession publishRaw(PublishData publishData,
	PublishSettings publishSettings, WifiNanSessionListener listener, int events) {
	if (VDBG) Log.v(TAG, "publish(): data='" + publishData + "', settings=" + publishSettings);

	if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_UNSOLICITED
	&& publishData.mRxFilterLength != 0) {
	throw new IllegalArgumentException("Invalid publish data & settings: UNSOLICITED "
	+ "publishes (active) can't have an Rx filter");
	}
	if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_SOLICITED
	&& publishData.mTxFilterLength != 0) {
	throw new IllegalArgumentException("Invalid publish data & settings: SOLICITED "
	+ "publishes (passive) can't have a Tx filter");
	}
	if (listener == null) {
	throw new IllegalArgumentException("Invalid listener - must not be null");
	}

	int sessionId;

	try {
	sessionId = mService.createSession(listener.callback, events);
	if (DBG) Log.d(TAG, "publish: session created - sessionId=" + sessionId);
	mService.publish(sessionId, publishData, publishSettings);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}

	return new WifiNanPublishSession(this, sessionId);
	}

	/**
	* {@hide}
	*/
	public void publish(int sessionId, PublishData publishData, PublishSettings publishSettings) {
	if (VDBG) Log.v(TAG, "publish(): data='" + publishData + "', settings=" + publishSettings);

	if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_UNSOLICITED
	&& publishData.mRxFilterLength != 0) {
	throw new IllegalArgumentException("Invalid publish data & settings: UNSOLICITED "
	+ "publishes (active) can't have an Rx filter");
	}
	if (publishSettings.mPublishType == PublishSettings.PUBLISH_TYPE_SOLICITED
	&& publishData.mTxFilterLength != 0) {
	throw new IllegalArgumentException("Invalid publish data & settings: SOLICITED "
	+ "publishes (passive) can't have a Tx filter");
	}

	try {
	mService.publish(sessionId, publishData, publishSettings);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}
	/**
	* Request a NAN subscribe session. The results of the subscribe session
	* operation will result in callbacks to the indicated listener:
	* {@link WifiNanSessionListener NanSessionListener.on*}.
	*
	* @param subscribeData The {@link SubscribeData} specifying the contents of
	* the subscribe session.
	* @param subscribeSettings The {@link SubscribeSettings} specifying the
	* settings for the subscribe session.
	* @param listener The {@link WifiNanSessionListener} derived objects to be used
	* for the event callbacks specified by {@code events}.
	* @param events The list of events to be delivered to the {@code listener}
	* object. An OR'd value of {@link WifiNanSessionListener
	* NanSessionListener.LISTEN_*}.
	* @return The {@link WifiNanSubscribeSession} which can be used to further
	* control the subscribe session.
	*/
	public WifiNanSubscribeSession subscribe(SubscribeData subscribeData,
	SubscribeSettings subscribeSettings,
	WifiNanSessionListener listener, int events) {
	return subscribeRaw(subscribeData, subscribeSettings, listener,
	events \| WifiNanSessionListener.LISTEN_HIDDEN_FLAGS);
	}

	/**
	* Same as subscribe(*) but does not modify the event flag
	*
	* @hide
	*/
	public WifiNanSubscribeSession subscribeRaw(SubscribeData subscribeData,
	SubscribeSettings subscribeSettings, WifiNanSessionListener listener, int events) {
	if (VDBG) {
	Log.v(TAG, "subscribe(): data='" + subscribeData + "', settings=" + subscribeSettings);
	}

	if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_ACTIVE
	&& subscribeData.mRxFilterLength != 0) {
	throw new IllegalArgumentException(
	"Invalid subscribe data & settings: ACTIVE subscribes can't have an Rx filter");
	}
	if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE
	&& subscribeData.mTxFilterLength != 0) {
	throw new IllegalArgumentException(
	"Invalid subscribe data & settings: PASSIVE subscribes can't have a Tx filter");
	}

	int sessionId;

	try {
	sessionId = mService.createSession(listener.callback, events);
	if (DBG) Log.d(TAG, "subscribe: session created - sessionId=" + sessionId);
	mService.subscribe(sessionId, subscribeData, subscribeSettings);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}

	return new WifiNanSubscribeSession(this, sessionId);
	}

	/**
	* {@hide}
	*/
	public void subscribe(int sessionId, SubscribeData subscribeData,
	SubscribeSettings subscribeSettings) {
	if (VDBG) {
	Log.v(TAG, "subscribe(): data='" + subscribeData + "', settings=" + subscribeSettings);
	}

	if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_ACTIVE
	&& subscribeData.mRxFilterLength != 0) {
	throw new IllegalArgumentException(
	"Invalid subscribe data & settings: ACTIVE subscribes can't have an Rx filter");
	}
	if (subscribeSettings.mSubscribeType == SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE
	&& subscribeData.mTxFilterLength != 0) {
	throw new IllegalArgumentException(
	"Invalid subscribe data & settings: PASSIVE subscribes can't have a Tx filter");
	}

	try {
	mService.subscribe(sessionId, subscribeData, subscribeSettings);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* {@hide}
	*/
	public void stopSession(int sessionId) {
	if (DBG) Log.d(TAG, "Stop NAN session #" + sessionId);

	try {
	mService.stopSession(sessionId);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* {@hide}
	*/
	public void destroySession(int sessionId) {
	if (DBG) Log.d(TAG, "Destroy NAN session #" + sessionId);

	try {
	mService.destroySession(sessionId);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}

	/**
	* {@hide}
	*/
	public void sendMessage(int sessionId, int peerId, byte[] message, int messageLength,
	int messageId) {
	try {
	if (VDBG) {
	Log.v(TAG, "sendMessage(): sessionId=" + sessionId + ", peerId=" + peerId
	+ ", messageLength=" + messageLength + ", messageId=" + messageId);
	}
	mService.sendMessage(sessionId, peerId, message, messageLength, messageId);
	} catch (RemoteException e) {
	throw e.rethrowFromSystemServer();
	}
	}
	}