/*
* 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();
}
}
}