telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl \
telephony/java/com/android/internal/telephony/IWapPushManager.aidl \
wifi/java/android/net/wifi/IWifiManager.aidl \
- wifi/java/android/net/wifi/nan/IWifiNanEventCallback.aidl \
- wifi/java/android/net/wifi/nan/IWifiNanManager.aidl \
- wifi/java/android/net/wifi/nan/IWifiNanDiscoverySessionCallback.aidl \
+ wifi/java/android/net/wifi/aware/IWifiAwareEventCallback.aidl \
+ wifi/java/android/net/wifi/aware/IWifiAwareManager.aidl \
+ wifi/java/android/net/wifi/aware/IWifiAwareDiscoverySessionCallback.aidl \
wifi/java/android/net/wifi/p2p/IWifiP2pManager.aidl \
wifi/java/android/net/wifi/IWifiScanner.aidl \
wifi/java/android/net/wifi/IRttManager.aidl \
frameworks/base/media/java/android/media/tv/TvTrackInfo.aidl \
frameworks/base/media/java/android/media/browse/MediaBrowser.aidl \
frameworks/base/wifi/java/android/net/wifi/ScanSettings.aidl \
- frameworks/base/wifi/java/android/net/wifi/nan/ConfigRequest.aidl \
- frameworks/base/wifi/java/android/net/wifi/nan/PublishConfig.aidl \
- frameworks/base/wifi/java/android/net/wifi/nan/SubscribeConfig.aidl \
+ frameworks/base/wifi/java/android/net/wifi/aware/ConfigRequest.aidl \
+ frameworks/base/wifi/java/android/net/wifi/aware/PublishConfig.aidl \
+ frameworks/base/wifi/java/android/net/wifi/aware/SubscribeConfig.aidl \
frameworks/base/wifi/java/android/net/wifi/p2p/WifiP2pInfo.aidl \
frameworks/base/wifi/java/android/net/wifi/p2p/WifiP2pDeviceList.aidl \
frameworks/base/wifi/java/android/net/wifi/p2p/WifiP2pConfig.aidl \
import android.net.wifi.RttManager;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiScanner;
-import android.net.wifi.nan.IWifiNanManager;
-import android.net.wifi.nan.WifiNanManager;
+import android.net.wifi.aware.IWifiAwareManager;
+import android.net.wifi.aware.WifiAwareManager;
import android.net.wifi.p2p.IWifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager;
import android.nfc.NfcManager;
return new WifiP2pManager(service);
}});
- registerService(Context.WIFI_NAN_SERVICE, WifiNanManager.class,
- new CachedServiceFetcher<WifiNanManager>() {
+ registerService(Context.WIFI_AWARE_SERVICE, WifiAwareManager.class,
+ new CachedServiceFetcher<WifiAwareManager>() {
@Override
- public WifiNanManager createService(ContextImpl ctx) {
- IBinder b = ServiceManager.getService(Context.WIFI_NAN_SERVICE);
- IWifiNanManager service = IWifiNanManager.Stub.asInterface(b);
+ public WifiAwareManager createService(ContextImpl ctx) {
+ IBinder b = ServiceManager.getService(Context.WIFI_AWARE_SERVICE);
+ IWifiAwareManager service = IWifiAwareManager.Stub.asInterface(b);
if (service == null) {
return null;
}
- return new WifiNanManager(ctx.getOuterContext(), service);
+ return new WifiAwareManager(ctx.getOuterContext(), service);
}});
registerService(Context.WIFI_SCANNING_SERVICE, WifiScanner.class,
NETWORK_STATS_SERVICE,
//@hide: NETWORK_POLICY_SERVICE,
WIFI_SERVICE,
- WIFI_NAN_SERVICE,
+ WIFI_AWARE_SERVICE,
WIFI_P2P_SERVICE,
WIFI_SCANNING_SERVICE,
//@hide: WIFI_RTT_SERVICE,
/**
* Use with {@link #getSystemService} to retrieve a
- * {@link android.net.wifi.nan.WifiNanManager} for handling management of
- * Wi-Fi NAN.
+ * {@link android.net.wifi.aware.WifiAwareManager} for handling management of
+ * Wi-Fi Aware.
*
* @see #getSystemService
- * @see android.net.wifi.nan.WifiNanManager
- * @hide PROPOSED_NAN_API
+ * @see android.net.wifi.aware.WifiAwareManager
+ * @hide PROPOSED_AWARE_API
*/
- public static final String WIFI_NAN_SERVICE = "wifinan";
+ public static final String WIFI_AWARE_SERVICE = "wifiaware";
/**
* Use with {@link #getSystemService} to retrieve a {@link
/**
* Feature for {@link #getSystemAvailableFeatures} and
- * {@link #hasSystemFeature}: The device supports Wi-Fi NAN.
+ * {@link #hasSystemFeature}: The device supports Wi-Fi Aware.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
@SdkConstant(SdkConstantType.FEATURE)
- public static final String FEATURE_WIFI_NAN = "android.hardware.wifi.nan";
+ public static final String FEATURE_WIFI_AWARE = "android.hardware.wifi.aware";
/**
* Feature for {@link #getSystemAvailableFeatures} and
public static final int TRANSPORT_VPN = 4;
/**
- * Indicates this network uses a Wi-Fi NAN transport.
+ * Indicates this network uses a Wi-Fi Aware transport.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
- public static final int TRANSPORT_WIFI_NAN = 5;
+ public static final int TRANSPORT_WIFI_AWARE = 5;
private static final int MIN_TRANSPORT = TRANSPORT_CELLULAR;
- private static final int MAX_TRANSPORT = TRANSPORT_WIFI_NAN;
+ private static final int MAX_TRANSPORT = TRANSPORT_WIFI_AWARE;
/**
* Adds the given transport type to this {@code NetworkCapability} instance.
case TRANSPORT_BLUETOOTH: transports += "BLUETOOTH"; break;
case TRANSPORT_ETHERNET: transports += "ETHERNET"; break;
case TRANSPORT_VPN: transports += "VPN"; break;
- case TRANSPORT_WIFI_NAN: transports += "WIFI_NAN"; break;
+ case TRANSPORT_WIFI_AWARE: transports += "WIFI_AWARE"; break;
}
if (++i < types.length) transports += "|";
}
<protected-broadcast android:name="android.net.wifi.WIFI_AP_STATE_CHANGED" />
<protected-broadcast android:name="android.net.wifi.WIFI_CREDENTIAL_CHANGED" />
<protected-broadcast android:name="android.net.wifi.WIFI_SCAN_AVAILABLE" />
- <protected-broadcast android:name="android.net.wifi.nan.action.WIFI_NAN_STATE_CHANGED" />
+ <protected-broadcast android:name="android.net.wifi.aware.action.WIFI_AWARE_STATE_CHANGED" />
<protected-broadcast android:name="android.net.wifi.SCAN_RESULTS" />
<protected-broadcast android:name="android.net.wifi.RSSI_CHANGED" />
<protected-broadcast android:name="android.net.wifi.STATE_CHANGE" />
<protected-broadcast android:name="android.net.wifi.CONFIGURED_NETWORKS_CHANGE" />
<protected-broadcast android:name="android.net.wifi.supplicant.CONNECTION_CHANGE" />
<protected-broadcast android:name="android.net.wifi.supplicant.STATE_CHANGE" />
- <protected-broadcast android:name="android.net.wifi.nan.STATE_CHANGED" />
<protected-broadcast android:name="android.net.wifi.p2p.STATE_CHANGED" />
<protected-broadcast android:name="android.net.wifi.p2p.DISCOVERY_STATE_CHANGE" />
<protected-broadcast android:name="android.net.wifi.p2p.THIS_DEVICE_CHANGED" />
"com.android.server.midi.MidiService$Lifecycle";
private static final String WIFI_SERVICE_CLASS =
"com.android.server.wifi.WifiService";
- private static final String WIFI_NAN_SERVICE_CLASS =
- "com.android.server.wifi.nan.WifiNanService";
+ private static final String WIFI_AWARE_SERVICE_CLASS =
+ "com.android.server.wifi.aware.WifiAwareService";
private static final String WIFI_P2P_SERVICE_CLASS =
"com.android.server.wifi.p2p.WifiP2pService";
private static final String ETHERNET_SERVICE_CLASS =
}
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
- if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_NAN)) {
- mSystemServiceManager.startService(WIFI_NAN_SERVICE_CLASS);
+ if (context.getPackageManager().hasSystemFeature(
+ PackageManager.FEATURE_WIFI_AWARE)) {
+ mSystemServiceManager.startService(WIFI_AWARE_SERVICE_CLASS);
} else {
- Slog.i(TAG, "No Wi-Fi NAN Service (NAN support Not Present)");
+ Slog.i(TAG, "No Wi-Fi Aware Service (Aware support Not Present)");
}
mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
/** @hide */
public static final int WIFI_FEATURE_SCANNER = 0x0020; // WifiScanner APIs
/** @hide */
- public static final int WIFI_FEATURE_NAN = 0x0040; // Neighbor Awareness Networking
+ public static final int WIFI_FEATURE_AWARE = 0x0040; // Wi-Fi AWare networking
/** @hide */
public static final int WIFI_FEATURE_D2D_RTT = 0x0080; // Device-to-device RTT
/** @hide */
* @return true if this adapter supports Neighbour Awareness Network APIs
* @hide
*/
- public boolean isNanSupported() {
- return isFeatureSupported(WIFI_FEATURE_NAN);
+ public boolean isWifiAwareSupported() {
+ return isFeatureSupported(WIFI_FEATURE_AWARE);
}
/**
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
parcelable ConfigRequest;
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.os.Parcel;
import android.os.Parcelable;
/**
- * Defines a request object to configure a Wi-Fi NAN network. Built using
+ * Defines a request object to configure a Wi-Fi Aware network. Built using
* {@link ConfigRequest.Builder}. Configuration is requested using
- * {@link WifiNanManager#attach(android.os.Handler, WifiNanAttachCallback)}.
+ * {@link WifiAwareManager#attach(android.os.Handler, WifiAwareAttachCallback)}.
* Note that the actual achieved configuration may be different from the
* requested configuration - since different applications may request different
* configurations.
}
/**
- * The Cluster ID is generated randomly for new NAN networks. Specify
+ * The Cluster ID is generated randomly for new Aware networks. Specify
* the lower range of the cluster ID. The upper range is specified using
* the {@link ConfigRequest.Builder#setClusterHigh(int)}. The permitted
* range is 0 (the default) to the value specified by
}
/**
- * The Cluster ID is generated randomly for new NAN networks. Specify
+ * The Cluster ID is generated randomly for new Aware networks. Specify
* the lower upper of the cluster ID. The lower range is specified using
* the {@link ConfigRequest.Builder#setClusterLow(int)}. The permitted
* range is the value specified by
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
/**
- * Callback interface that WifiNanManager implements
+ * Callback interface that WifiAwareManager implements
*
* {@hide}
*/
-oneway interface IWifiNanDiscoverySessionCallback
+oneway interface IWifiAwareDiscoverySessionCallback
{
void onSessionStarted(int discoverySessionId);
void onSessionConfigSuccess();
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
-import android.net.wifi.nan.ConfigRequest;
+import android.net.wifi.aware.ConfigRequest;
import android.net.wifi.RttManager;
/**
- * Callback interface that WifiNanManager implements
+ * Callback interface that WifiAwareManager implements
*
* {@hide}
*/
-oneway interface IWifiNanEventCallback
+oneway interface IWifiAwareEventCallback
{
void onConnectSuccess(int clientId);
void onConnectFail(int reason);
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.app.PendingIntent;
-import android.net.wifi.nan.ConfigRequest;
-import android.net.wifi.nan.IWifiNanDiscoverySessionCallback;
-import android.net.wifi.nan.IWifiNanEventCallback;
-import android.net.wifi.nan.PublishConfig;
-import android.net.wifi.nan.SubscribeConfig;
-import android.net.wifi.nan.WifiNanCharacteristics;
+import android.net.wifi.aware.ConfigRequest;
+import android.net.wifi.aware.IWifiAwareDiscoverySessionCallback;
+import android.net.wifi.aware.IWifiAwareEventCallback;
+import android.net.wifi.aware.PublishConfig;
+import android.net.wifi.aware.SubscribeConfig;
+import android.net.wifi.aware.WifiAwareCharacteristics;
import android.net.wifi.RttManager;
/**
- * Interface that WifiNanService implements
+ * Interface that WifiAwareService implements
*
* {@hide}
*/
-interface IWifiNanManager
+interface IWifiAwareManager
{
- // NAN API
+ // Aware API
void enableUsage();
void disableUsage();
boolean isUsageEnabled();
- WifiNanCharacteristics getCharacteristics();
+ WifiAwareCharacteristics getCharacteristics();
// client API
- void connect(in IBinder binder, in String callingPackage, in IWifiNanEventCallback callback,
+ void connect(in IBinder binder, in String callingPackage, in IWifiAwareEventCallback callback,
in ConfigRequest configRequest, boolean notifyOnIdentityChanged);
void disconnect(int clientId, in IBinder binder);
void publish(int clientId, in PublishConfig publishConfig,
- in IWifiNanDiscoverySessionCallback callback);
+ in IWifiAwareDiscoverySessionCallback callback);
void subscribe(int clientId, in SubscribeConfig subscribeConfig,
- in IWifiNanDiscoverySessionCallback callback);
+ in IWifiAwareDiscoverySessionCallback callback);
// session API
void updatePublish(int clientId, int discoverySessionId, in PublishConfig publishConfig);
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.Nullable;
* Length/Value format. The utilities accept a configuration of the size of
* the Length field.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
public class LvBufferUtils {
private LvBufferUtils() {
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
parcelable PublishConfig;
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.IntDef;
import android.annotation.NonNull;
import java.util.Arrays;
/**
- * Defines the configuration of a NAN publish session. Built using
+ * Defines the configuration of a Aware publish session. Built using
* {@link PublishConfig.Builder}. A publish session is created using
- * {@link WifiNanSession#publish(android.os.Handler, PublishConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#publish(android.os.Handler, PublishConfig,
+ * WifiAwareDiscoverySessionCallback)}
* or updated using
- * {@link WifiNanPublishDiscoverySession#updatePublish(PublishConfig)}.
+ * {@link WifiAwarePublishDiscoverySession#updatePublish(PublishConfig)}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
public final class PublishConfig implements Parcelable {
/** @hide */
*
* @hide
*/
- public void assertValid(WifiNanCharacteristics characteristics) throws IllegalArgumentException {
- WifiNanUtils.validateServiceName(mServiceName);
+ public void assertValid(WifiAwareCharacteristics characteristics)
+ throws IllegalArgumentException {
+ WifiAwareUtils.validateServiceName(mServiceName);
if (!LvBufferUtils.isValid(mMatchFilter, 1)) {
throw new IllegalArgumentException(
* Sets the number of times an unsolicited (configured using
* {@link PublishConfig.Builder#setPublishType(int)}) publish session
* will be broadcast. When the count is reached an event will be
- * generated for {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)}
- * with {@link WifiNanDiscoverySessionCallback#TERMINATE_REASON_DONE} [unless
+ * generated for {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)}
+ * with {@link WifiAwareDiscoverySessionCallback#TERMINATE_REASON_DONE} [unless
* {@link #setTerminateNotificationEnabled(boolean)} disables the callback].
* <p>
* Optional. 0 by default - indicating the session doesn't terminate on its own.
- * Session will be terminated when {@link WifiNanDiscoveryBaseSession#destroy()} is
+ * Session will be terminated when {@link WifiAwareDiscoveryBaseSession#destroy()} is
* called.
*
* @param publishCount Number of publish packets to broadcast.
* {@link PublishConfig.Builder#setPublishType(int)}) publish session
* will be alive - broadcasting a packet. When the TTL is reached
* an event will be generated for
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} with
- * {@link WifiNanDiscoverySessionCallback#TERMINATE_REASON_DONE} [unless
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} with
+ * {@link WifiAwareDiscoverySessionCallback#TERMINATE_REASON_DONE} [unless
* {@link #setTerminateNotificationEnabled(boolean)} disables the callback].
* <p>
* Optional. 0 by default - indicating the session doesn't terminate on its own.
- * Session will be terminated when {@link WifiNanDiscoveryBaseSession#destroy()} is
+ * Session will be terminated when {@link WifiAwareDiscoveryBaseSession#destroy()} is
* called.
*
* @param ttlSec Lifetime of a publish session in seconds.
/**
* Configure whether a publish terminate notification
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} is reported
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} is reported
* back to the callback.
*
* @param enable If true the terminate callback will be called when the
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
parcelable SubscribeConfig;
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.IntDef;
import android.annotation.NonNull;
import java.util.Arrays;
/**
- * Defines the configuration of a NAN subscribe session. Built using
+ * Defines the configuration of a Aware subscribe session. Built using
* {@link SubscribeConfig.Builder}. Subscribe is done using
- * {@link WifiNanSession#subscribe(android.os.Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#subscribe(android.os.Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)}
* or
- * {@link WifiNanSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
+ * {@link WifiAwareSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
public final class SubscribeConfig implements Parcelable {
/** @hide */
*
* @hide
*/
- public void assertValid(WifiNanCharacteristics characteristics) throws IllegalArgumentException {
- WifiNanUtils.validateServiceName(mServiceName);
+ public void assertValid(WifiAwareCharacteristics characteristics)
+ throws IllegalArgumentException {
+ WifiAwareUtils.validateServiceName(mServiceName);
if (!LvBufferUtils.isValid(mMatchFilter, 1)) {
throw new IllegalArgumentException(
* Sets the number of times an active (
* {@link SubscribeConfig.Builder#setSubscribeType(int)}) subscribe session
* will broadcast. When the count is reached an event will be
- * generated for {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)}
- * with {@link WifiNanDiscoverySessionCallback#TERMINATE_REASON_DONE}.
+ * generated for {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)}
+ * with {@link WifiAwareDiscoverySessionCallback#TERMINATE_REASON_DONE}.
* <p>
* Optional. 0 by default - indicating the session doesn't terminate on its own.
- * Session will be terminated when {@link WifiNanDiscoveryBaseSession#destroy()} is
+ * Session will be terminated when {@link WifiAwareDiscoveryBaseSession#destroy()} is
* called.
*
* @param subscribeCount Number of subscribe packets to broadcast.
* {@link SubscribeConfig.Builder#setSubscribeType(int)}) subscribe session
* will be alive - i.e. broadcasting a packet. When the TTL is reached
* an event will be generated for
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} with
- * {@link WifiNanDiscoverySessionCallback#TERMINATE_REASON_DONE}.
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} with
+ * {@link WifiAwareDiscoverySessionCallback#TERMINATE_REASON_DONE}.
* <p>
* Optional. 0 by default - indicating the session doesn't terminate on its own.
- * Session will be terminated when {@link WifiNanDiscoveryBaseSession#destroy()} is
+ * Session will be terminated when {@link WifiAwareDiscoveryBaseSession#destroy()} is
* called.
*
* @param ttlSec Lifetime of a subscribe session in seconds.
* Sets the match style of the subscription - how are matches from a
* single match session (corresponding to the same publish action on the
* peer) reported to the host (using the
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
* ). The options are: only report the first match and ignore the rest
* {@link SubscribeConfig#MATCH_STYLE_FIRST_ONLY} or report every single
* match {@link SubscribeConfig#MATCH_STYLE_ALL} (the default).
/**
* Configure whether a subscribe terminate notification
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} is reported
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} is reported
* back to the callback.
*
* @param enable If true the terminate callback will be called when the
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.Nullable;
* the Type field and the Length field. A Type field size of 0 is allowed -
* allowing usage for LV (no T) array formats.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
public class TlvBufferUtils {
private TlvBufferUtils() {
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
/**
- * Base class for NAN attach callbacks. Should be extended by applications and set when calling
- * {@link WifiNanManager#attach(android.os.Handler, WifiNanAttachCallback)}. These are callbacks
- * applying to the NAN connection as a whole - not to specific publish or subscribe sessions -
- * for that see {@link WifiNanDiscoverySessionCallback}.
+ * Base class for Aware attach callbacks. Should be extended by applications and set when calling
+ * {@link WifiAwareManager#attach(android.os.Handler, WifiAwareAttachCallback)}. These are callbacks
+ * applying to the Aware connection as a whole - not to specific publish or subscribe sessions -
+ * for that see {@link WifiAwareDiscoverySessionCallback}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanAttachCallback {
+public class WifiAwareAttachCallback {
/**
- * Called when NAN attach operation
- * {@link WifiNanManager#attach(android.os.Handler, WifiNanAttachCallback)}
+ * Called when Aware attach operation
+ * {@link WifiAwareManager#attach(android.os.Handler, WifiAwareAttachCallback)}
* is completed and that we can now start discovery sessions or connections.
*
- * @param session The NAN object on which we can execute further NAN operations - e.g.
+ * @param session The Aware object on which we can execute further Aware operations - e.g.
* discovery, connections.
*/
- public void onAttached(WifiNanSession session) {
+ public void onAttached(WifiAwareSession session) {
/* empty */
}
/**
- * Called when NAN attach operation
- * {@link WifiNanManager#attach(android.os.Handler, WifiNanAttachCallback)} failed.
+ * Called when Aware attach operation
+ * {@link WifiAwareManager#attach(android.os.Handler, WifiAwareAttachCallback)} failed.
*/
public void onAttachFailed() {
/* empty */
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
-parcelable WifiNanCharacteristics;
+parcelable WifiAwareCharacteristics;
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
/**
- * The characteristics of the Wi-Fi NAN implementation.
+ * The characteristics of the Wi-Fi Aware implementation.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanCharacteristics implements Parcelable {
+public class WifiAwareCharacteristics implements Parcelable {
/** @hide */
public static final String KEY_MAX_SERVICE_NAME_LENGTH = "key_max_service_name_length";
/** @hide */
private Bundle mCharacteristics = new Bundle();
/** @hide : should not be created by apps */
- public WifiNanCharacteristics(Bundle characteristics) {
+ public WifiAwareCharacteristics(Bundle characteristics) {
mCharacteristics = characteristics;
}
/**
- * Returns the maximum string length that can be used to specify a NAN service name. Restricts
+ * Returns the maximum string length that can be used to specify a Aware service name. Restricts
* the parameters of the {@link PublishConfig.Builder#setServiceName(String)} and
* {@link SubscribeConfig.Builder#setServiceName(String)}.
*
- * @return A positive integer, maximum string length of NAN service name.
+ * @return A positive integer, maximum string length of Aware service name.
*/
public int getMaxServiceNameLength() {
return mCharacteristics.getInt(KEY_MAX_SERVICE_NAME_LENGTH);
}
/**
- * Returns the maximum length of byte array that can be used to specify a NAN service specific
- * information field: the arbitrary load used in discovery or the message length of NAN
+ * Returns the maximum length of byte array that can be used to specify a Aware service specific
+ * information field: the arbitrary load used in discovery or the message length of Aware
* message exchange. Restricts the parameters of the
* {@link PublishConfig.Builder#setServiceSpecificInfo(byte[])},
* {@link SubscribeConfig.Builder#setServiceSpecificInfo(byte[])}, and
- * {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[])} variants.
+ * {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[])} variants.
*
- * @return A positive integer, maximum length of byte array for NAN messaging.
+ * @return A positive integer, maximum length of byte array for Aware messaging.
*/
public int getMaxServiceSpecificInfoLength() {
return mCharacteristics.getInt(KEY_MAX_SERVICE_SPECIFIC_INFO_LENGTH);
}
/**
- * Returns the maximum length of byte array that can be used to specify a NAN match filter.
+ * Returns the maximum length of byte array that can be used to specify a Aware match filter.
* Restricts the parameters of the {@link PublishConfig.Builder#setMatchFilter(byte[])} and
* {@link SubscribeConfig.Builder#setMatchFilter(byte[])}.
*
- * @return A positive integer, maximum legngth of byte array for NAN discovery match filter.
+ * @return A positive integer, maximum legngth of byte array for Aware discovery match filter.
*/
public int getMaxMatchFilterLength() {
return mCharacteristics.getInt(KEY_MAX_MATCH_FILTER_LENGTH);
return 0;
}
- public static final Creator<WifiNanCharacteristics> CREATOR =
- new Creator<WifiNanCharacteristics>() {
+ public static final Creator<WifiAwareCharacteristics> CREATOR =
+ new Creator<WifiAwareCharacteristics>() {
@Override
- public WifiNanCharacteristics createFromParcel(Parcel in) {
- WifiNanCharacteristics c = new WifiNanCharacteristics(in.readBundle());
+ public WifiAwareCharacteristics createFromParcel(Parcel in) {
+ WifiAwareCharacteristics c = new WifiAwareCharacteristics(in.readBundle());
return c;
}
@Override
- public WifiNanCharacteristics[] newArray(int size) {
- return new WifiNanCharacteristics[size];
+ public WifiAwareCharacteristics[] newArray(int size) {
+ return new WifiAwareCharacteristics[size];
}
};
}
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.NonNull;
import android.annotation.Nullable;
import java.lang.ref.WeakReference;
/**
- * A class representing a single publish or subscribe NAN session. This object
+ * A class representing a single publish or subscribe Aware session. This object
* will not be created directly - only its child classes are available:
- * {@link WifiNanPublishDiscoverySession} and {@link WifiNanSubscribeDiscoverySession}. This
+ * {@link WifiAwarePublishDiscoverySession} and {@link WifiAwareSubscribeDiscoverySession}. This
* class provides functionality common to both publish and subscribe discovery sessions:
* <ul>
* <li>Sending messages: {@link #sendMessage(Object, int, byte[])} or
* {@link #sendMessage(Object, int, byte[], int)} methods.
- * <li>Creating a network-specifier when requesting a NAN connection:
+ * <li>Creating a network-specifier when requesting a Aware connection:
* {@link #createNetworkSpecifier(int, Object, byte[])}.
* </ul>
* The {@link #destroy()} method must be called to destroy discovery sessions once they are
* no longer needed.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanDiscoveryBaseSession {
- private static final String TAG = "WifiNanDiscoveryBaseSsn";
+public class WifiAwareDiscoveryBaseSession {
+ private static final String TAG = "WifiAwareDiscBaseSsn";
private static final boolean DBG = false;
private static final boolean VDBG = false; // STOPSHIP if true
private static final int MAX_SEND_RETRY_COUNT = 5;
/** @hide */
- protected WeakReference<WifiNanManager> mMgr;
+ protected WeakReference<WifiAwareManager> mMgr;
/** @hide */
protected final int mClientId;
/** @hide */
}
/** @hide */
- public WifiNanDiscoveryBaseSession(WifiNanManager manager, int clientId, int sessionId) {
+ public WifiAwareDiscoveryBaseSession(WifiAwareManager manager, int clientId, int sessionId) {
if (VDBG) {
Log.v(TAG, "New discovery session created: manager=" + manager + ", clientId="
+ clientId + ", sessionId=" + sessionId);
* This operation must be done on a session which is no longer needed. Otherwise system
* resources will continue to be utilized until the application exits. The only
* exception is a session for which we received a termination callback,
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)}.
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)}.
*/
public void destroy() {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "destroy: called post GC on WifiNanManager");
+ Log.w(TAG, "destroy: called post GC on WifiAwareManager");
return;
}
mgr.terminateSession(mClientId, mSessionId);
}
/**
- * Sends a message to the specified destination. NAN messages are transmitted in the context
+ * Sends a message to the specified destination. Aware messages are transmitted in the context
* of a discovery session - executed subsequent to a publish/subscribe
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} event.
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} event.
* <p>
- * NAN messages are not guaranteed delivery. Callbacks on
- * {@link WifiNanDiscoverySessionCallback} indicate message was transmitted successfully,
- * {@link WifiNanDiscoverySessionCallback#onMessageSent(int)}, or transmission failed
+ * Aware messages are not guaranteed delivery. Callbacks on
+ * {@link WifiAwareDiscoverySessionCallback} indicate message was transmitted successfully,
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSent(int)}, or transmission failed
* (possibly after several retries) -
- * {@link WifiNanDiscoverySessionCallback#onMessageSendFailed(int)}.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSendFailed(int)}.
* <p>
* The peer will get a callback indicating a message was received using
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])}.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])}.
*
* @param peerHandle The peer's handle for the message. Must be a result of an
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
* or
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])} events.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])} events.
* @param messageId An arbitrary integer used by the caller to identify the message. The same
* integer ID will be returned in the callbacks indicating message send success or
- * failure. The {@code messageId} is not used internally by the NAN service - it
+ * failure. The {@code messageId} is not used internally by the Aware service - it
* can be arbitrary and non-unique.
* @param message The message to be transmitted.
* @param retryCount An integer specifying how many additional service-level (as opposed to PHY
Log.w(TAG, "sendMessage: called on terminated session");
return;
} else {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "sendMessage: called post GC on WifiNanManager");
+ Log.w(TAG, "sendMessage: called post GC on WifiAwareManager");
return;
}
}
/**
- * Sends a message to the specified destination. NAN messages are transmitted in the context
+ * Sends a message to the specified destination. Aware messages are transmitted in the context
* of a discovery session - executed subsequent to a publish/subscribe
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} event.
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} event.
* <p>
- * NAN messages are not guaranteed delivery. Callbacks on
- * {@link WifiNanDiscoverySessionCallback} indicate message was transmitted successfully,
- * {@link WifiNanDiscoverySessionCallback#onMessageSent(int)}, or transmission failed
+ * Aware messages are not guaranteed delivery. Callbacks on
+ * {@link WifiAwareDiscoverySessionCallback} indicate message was transmitted successfully,
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSent(int)}, or transmission failed
* (possibly after several retries) -
- * {@link WifiNanDiscoverySessionCallback#onMessageSendFailed(int)}.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSendFailed(int)}.
* <p>
* The peer will get a callback indicating a message was received using
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])}.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])}.
* Equivalent to {@link #sendMessage(Object, int, byte[], int)} with a {@code retryCount} of
* 0.
*
* @param peerHandle The peer's handle for the message. Must be a result of an
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])}
* or
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])} events.
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])} events.
* @param messageId An arbitrary integer used by the caller to identify the message. The same
* integer ID will be returned in the callbacks indicating message send success or
- * failure. The {@code messageId} is not used internally by the NAN service - it
+ * failure. The {@code messageId} is not used internally by the Aware service - it
* can be arbitrary and non-unique.
* @param message The message to be transmitted.
*/
/**
* Start a ranging operation with the specified peers. The peer IDs are obtained from an
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} or
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])} operation - can
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} or
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])} operation - can
* only range devices which are part of an ongoing discovery session.
*
* @param params RTT parameters - each corresponding to a specific peer ID (the array sizes
* {@link android.net.wifi.RttManager.RttParams#bssid} member must be set to
* a peer ID - not to a MAC address.
* @param listener The listener to receive the results of the ranging session.
- * @hide PROPOSED_NAN_SYSTEM_API [TODO: b/28847998 - track RTT API & visilibity]
+ * @hide PROPOSED_AWARE_SYSTEM_API
+ * [TODO: b/28847998 - track RTT API & visilibity]
*/
public void startRanging(RttManager.RttParams[] params, RttManager.RttListener listener) {
if (mTerminated) {
Log.w(TAG, "startRanging: called on terminated session");
return;
} else {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "startRanging: called post GC on WifiNanManager");
+ Log.w(TAG, "startRanging: called post GC on WifiAwareManager");
return;
}
/**
* Create a {@link android.net.NetworkRequest.Builder#setNetworkSpecifier(String)} for a
- * WiFi NAN connection to the specified peer. The
+ * WiFi Aware connection to the specified peer. The
* {@link android.net.NetworkRequest.Builder#addTransportType(int)} should be set to
- * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_NAN}.
+ * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_AWARE}.
* <p>
- * This method should be used when setting up a connection with a peer discovered through NAN
+ * This method should be used when setting up a connection with a peer discovered through Aware
* discovery or communication (in such scenarios the MAC address of the peer is shielded by
- * an opaque peer ID handle). If a NAN connection is needed to a peer discovered using other
+ * an opaque peer ID handle). If a Aware connection is needed to a peer discovered using other
* OOB (out-of-band) mechanism then use the alternative
- * {@link WifiNanSession#createNetworkSpecifier(int, byte[], byte[])} method - which uses the
+ * {@link WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])} method - which uses the
* peer's MAC address.
*
* @param role The role of this device:
- * {@link WifiNanManager#WIFI_NAN_DATA_PATH_ROLE_INITIATOR} or
- * {@link WifiNanManager#WIFI_NAN_DATA_PATH_ROLE_RESPONDER}
+ * {@link WifiAwareManager#WIFI_AWARE_DATA_PATH_ROLE_INITIATOR} or
+ * {@link WifiAwareManager#WIFI_AWARE_DATA_PATH_ROLE_RESPONDER}
* @param peerHandle The peer's handle obtained through
- * {@link WifiNanDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} or
- * {@link WifiNanDiscoverySessionCallback#onMessageReceived(Object, byte[])}. On a RESPONDER
+ * {@link WifiAwareDiscoverySessionCallback#onServiceDiscovered(Object, byte[], byte[])} or
+ * {@link WifiAwareDiscoverySessionCallback#onMessageReceived(Object, byte[])}. On a RESPONDER
* this value is used to gate the acceptance of a connection request from only
* that peer. A RESPONDER may specified a null - indicating that it will accept
* connection requests from any device.
*
* @return A string to be used to construct
* {@link android.net.NetworkRequest.Builder#setNetworkSpecifier(String)} to pass to
- * {@link android.net.ConnectivityManager#requestNetwork(android.net.NetworkRequest,android.net.ConnectivityManager.NetworkCallback)}
+ * {@link android.net.ConnectivityManager#requestNetwork(android.net.NetworkRequest,
+ * android.net.ConnectivityManager.NetworkCallback)}
* [or other varieties of that API].
*/
- public String createNetworkSpecifier(@WifiNanManager.DataPathRole int role,
+ public String createNetworkSpecifier(@WifiAwareManager.DataPathRole int role,
@Nullable Object peerHandle, @Nullable byte[] token) {
if (mTerminated) {
Log.w(TAG, "createNetworkSpecifier: called on terminated session");
return null;
} else {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "createNetworkSpecifier: called post GC on WifiNanManager");
+ Log.w(TAG, "createNetworkSpecifier: called post GC on WifiAwareManager");
return null;
}
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.IntDef;
import android.annotation.NonNull;
import java.lang.annotation.RetentionPolicy;
/**
- * Base class for NAN session events callbacks. Should be extended by
+ * Base class for Aware session events callbacks. Should be extended by
* applications wanting notifications. The callbacks are set when a
* publish or subscribe session is created using
- * {@link WifiNanSession#publish(android.os.Handler, PublishConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#publish(android.os.Handler, PublishConfig,
+ * WifiAwareDiscoverySessionCallback)}
* or
- * {@link WifiNanSession#subscribe(android.os.Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)} .
+ * {@link WifiAwareSession#subscribe(android.os.Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)} .
* <p>
* A single callback is set at session creation - it cannot be replaced.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanDiscoverySessionCallback {
+public class WifiAwareDiscoverySessionCallback {
/** @hide */
@IntDef({
TERMINATE_REASON_DONE, TERMINATE_REASON_FAIL })
* Indicates that publish or subscribe session is done - all the
* requested operations (per {@link PublishConfig} or
* {@link SubscribeConfig}) have been executed. Failure reason flag for
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} callback.
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} callback.
*/
public static final int TERMINATE_REASON_DONE = 100;
* Indicates that publish or subscribe session is terminated due to a
* failure.
* Failure reason flag for
- * {@link WifiNanDiscoverySessionCallback#onSessionTerminated(int)} callback.
+ * {@link WifiAwareDiscoverySessionCallback#onSessionTerminated(int)} callback.
*/
public static final int TERMINATE_REASON_FAIL = 101;
/**
* Called when a publish operation is started successfully in response to a
- * {@link WifiNanSession#publish(android.os.Handler, PublishConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#publish(android.os.Handler, PublishConfig,
+ * WifiAwareDiscoverySessionCallback)}
* operation.
*
- * @param session The {@link WifiNanPublishDiscoverySession} used to control the
+ * @param session The {@link WifiAwarePublishDiscoverySession} used to control the
* discovery session.
*/
- public void onPublishStarted(@NonNull WifiNanPublishDiscoverySession session) {
+ public void onPublishStarted(@NonNull WifiAwarePublishDiscoverySession session) {
/* empty */
}
/**
* Called when a subscribe operation is started successfully in response to a
- * {@link WifiNanSession#subscribe(android.os.Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#subscribe(android.os.Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)}
* operation.
*
- * @param session The {@link WifiNanSubscribeDiscoverySession} used to control the
+ * @param session The {@link WifiAwareSubscribeDiscoverySession} used to control the
* discovery session.
*/
- public void onSubscribeStarted(@NonNull WifiNanSubscribeDiscoverySession session) {
+ public void onSubscribeStarted(@NonNull WifiAwareSubscribeDiscoverySession session) {
/* empty */
}
/**
* Called when a publish or subscribe discovery session configuration update request
* succeeds. Called in response to
- * {@link WifiNanPublishDiscoverySession#updatePublish(PublishConfig)} or
- * {@link WifiNanSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
+ * {@link WifiAwarePublishDiscoverySession#updatePublish(PublishConfig)} or
+ * {@link WifiAwareSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
*/
public void onSessionConfigUpdated() {
/* empty */
/**
* Called when a publish or subscribe discovery session cannot be created:
- * {@link WifiNanSession#publish(android.os.Handler, PublishConfig, WifiNanDiscoverySessionCallback)}
+ * {@link WifiAwareSession#publish(android.os.Handler, PublishConfig,
+ * WifiAwareDiscoverySessionCallback)}
* or
- * {@link WifiNanSession#subscribe(android.os.Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)},
+ * {@link WifiAwareSession#subscribe(android.os.Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)},
* or when a configuration update fails:
- * {@link WifiNanPublishDiscoverySession#updatePublish(PublishConfig)} or
- * {@link WifiNanSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
+ * {@link WifiAwarePublishDiscoverySession#updatePublish(PublishConfig)} or
+ * {@link WifiAwareSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
* <p>
* For discovery session updates failure leaves the session running with its previous
* configuration - the discovery session is not terminated.
/**
* Called when a discovery session (publish or subscribe) terminates. Termination may be due
- * to user-request (either directly through {@link WifiNanDiscoveryBaseSession#destroy()} or
+ * to user-request (either directly through {@link WifiAwareDiscoveryBaseSession#destroy()} or
* application-specified expiration, e.g. {@link PublishConfig.Builder#setPublishCount(int)}
* or {@link SubscribeConfig.Builder#setTtlSec(int)}) or due to a failure.
*
* @param reason The termination reason using
- * {@code WifiNanDiscoverySessionCallback.TERMINATE_*} codes.
+ * {@code WifiAwareDiscoverySessionCallback.TERMINATE_*} codes.
*/
public void onSessionTerminated(@SessionTerminateCodes int reason) {
/* empty */
}
/**
- * Called in response to {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[])}
+ * Called in response to {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[])}
* when a message is transmitted successfully - i.e. when it was received successfully by the
* peer (corresponds to an ACK being received).
* <p>
* Note that either this callback or
- * {@link WifiNanDiscoverySessionCallback#onMessageSendFailed(int)} will be
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSendFailed(int)} will be
* received - never both.
*
* @param messageId The arbitrary message ID specified when sending the message.
/**
* Called when message transmission fails - when no ACK is received from the peer.
- * Retries when ACKs are not received are done by hardware, MAC, and in the NAN stack (using
- * the {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[], int)} method) - this
- * event is received after all retries are exhausted.
+ * Retries when ACKs are not received are done by hardware, MAC, and in the Aware stack (using
+ * the {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[], int)} method) -
+ * this event is received after all retries are exhausted.
* <p>
* Note that either this callback or
- * {@link WifiNanDiscoverySessionCallback#onMessageSent(int)} will be received
+ * {@link WifiAwareDiscoverySessionCallback#onMessageSent(int)} will be received
* - never both.
*
* @param messageId The arbitrary message ID specified when sending the message.
/**
* Called when a message is received from a discovery session peer - in response to the
- * peer's {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[])} or
- * {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[], int)}.
+ * peer's {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[])} or
+ * {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[], int)}.
*
* @param peerHandle An opaque handle to the peer matching our discovery operation.
* @param message A byte array containing the message.
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
/**
- * Base class for a listener which is called with the MAC address of the NAN interface whenever
+ * Base class for a listener which is called with the MAC address of the Aware interface whenever
* it is changed. Change may be due to device joining a cluster, starting a cluster, or discovery
* interface change (addresses are randomized at regular intervals). The implication is that
* peers you've been communicating with may no longer recognize you and you need to re-establish
* your identity - e.g. by starting a discovery session. This actual MAC address of the
- * interface may also be useful if the application uses alternative (non-NAN) discovery but needs
- * to set up a NAN connection. The provided NAN discovery interface MAC address can then be used
- * in {@link WifiNanSession#createNetworkSpecifier(int, byte[], byte[])}.
+ * interface may also be useful if the application uses alternative (non-Aware) discovery but needs
+ * to set up a Aware connection. The provided Aware discovery interface MAC address can then be used
+ * in {@link WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanIdentityChangedListener {
+public class WifiAwareIdentityChangedListener {
/**
- * @param mac The MAC address of the NAN discovery interface. The application must have the
+ * @param mac The MAC address of the Aware discovery interface. The application must have the
* {@link android.Manifest.permission#ACCESS_COARSE_LOCATION} to get the actual MAC address,
* otherwise all 0's will be provided.
*/
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.IntDef;
import android.annotation.NonNull;
import java.util.Arrays;
/**
- * This class provides the primary API for managing Wi-Fi NAN operations:
+ * This class provides the primary API for managing Wi-Fi Aware operations:
* discovery and peer-to-peer data connections. Get an instance of this class by calling
* {@link android.content.Context#getSystemService(String)
- * Context.getSystemService(Context.WIFI_NAN_SERVICE)}.
+ * Context.getSystemService(Context.WIFI_AWARE_SERVICE)}.
* <p>
* The class provides access to:
* <ul>
- * <li>Initialize a NAN cluster (peer-to-peer synchronization). Refer to
- * {@link #attach(Handler, WifiNanAttachCallback)}.
+ * <li>Initialize a Aware cluster (peer-to-peer synchronization). Refer to
+ * {@link #attach(Handler, WifiAwareAttachCallback)}.
* <li>Create discovery sessions (publish or subscribe sessions). Refer to
- * {@link WifiNanSession#publish(Handler, PublishConfig, WifiNanDiscoverySessionCallback)} and
- * {@link WifiNanSession#subscribe(Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)}.
- * <li>Create a NAN network specifier to be used with
+ * {@link WifiAwareSession#publish(Handler, PublishConfig, WifiAwareDiscoverySessionCallback)} and
+ * {@link WifiAwareSession#subscribe(Handler, SubscribeConfig, WifiAwareDiscoverySessionCallback)}.
+ * <li>Create a Aware network specifier to be used with
* {@link ConnectivityManager#requestNetwork(NetworkRequest, ConnectivityManager.NetworkCallback)}
- * to set-up a NAN connection with a peer. Refer to
- * {@link WifiNanDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])} and
- * {@link WifiNanSession#createNetworkSpecifier(int, byte[], byte[])}.
+ * to set-up a Aware connection with a peer. Refer to
+ * {@link WifiAwareDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])} and
+ * {@link WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])}.
* </ul>
* <p>
- * NAN may not be usable when Wi-Fi is disabled (and other conditions). To validate that
+ * Aware may not be usable when Wi-Fi is disabled (and other conditions). To validate that
* the functionality is available use the {@link #isAvailable()} function. To track
- * changes in NAN usability register for the {@link #ACTION_WIFI_NAN_STATE_CHANGED} broadcast.
- * Note that this broadcast is not sticky - you should register for it and then check the
- * above API to avoid a race condition.
+ * changes in Aware usability register for the {@link #ACTION_WIFI_AWARE_STATE_CHANGED}
+ * broadcast. Note that this broadcast is not sticky - you should register for it and then
+ * check the above API to avoid a race condition.
* <p>
- * An application must use {@link #attach(Handler, WifiNanAttachCallback)} to initialize a NAN
- * cluster - before making any other NAN operation. NAN cluster membership is a device-wide
- * operation - the API guarantees that the device is in a cluster or joins a NAN cluster (or
- * starts one if none can be found). Information about attach success (or failure) are
- * returned in callbacks of {@link WifiNanAttachCallback}. Proceed with NAN discovery or
- * connection setup only after receiving confirmation that NAN attach succeeded -
- * {@link WifiNanAttachCallback#onAttached(WifiNanSession)}. When an application is
- * finished using NAN it <b>must</b> use the {@link WifiNanSession#destroy()} API
- * to indicate to the NAN service that the device may detach from the NAN cluster. The
- * device will actually disable NAN once the last application detaches.
+ * An application must use {@link #attach(Handler, WifiAwareAttachCallback)} to initialize a
+ * Aware cluster - before making any other Aware operation. Aware cluster membership is a
+ * device-wide operation - the API guarantees that the device is in a cluster or joins a
+ * Aware cluster (or starts one if none can be found). Information about attach success (or
+ * failure) are returned in callbacks of {@link WifiAwareAttachCallback}. Proceed with Aware
+ * discovery or connection setup only after receiving confirmation that Aware attach
+ * succeeded - {@link WifiAwareAttachCallback#onAttached(WifiAwareSession)}. When an
+ * application is finished using Aware it <b>must</b> use the
+ * {@link WifiAwareSession#destroy()} API to indicate to the Aware service that the device
+ * may detach from the Aware cluster. The device will actually disable Aware once the last
+ * application detaches.
* <p>
- * Once a NAN attach is confirmed use the
- * {@link WifiNanSession#publish(Handler, PublishConfig, WifiNanDiscoverySessionCallback)} or
- * {@link WifiNanSession#subscribe(Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)}
- * to create publish or subscribe NAN discovery sessions. Events are called on the provided
- * callback object {@link WifiNanDiscoverySessionCallback}. Specifically, the
- * {@link WifiNanDiscoverySessionCallback#onPublishStarted(WifiNanPublishDiscoverySession)}
+ * Once a Aware attach is confirmed use the
+ * {@link WifiAwareSession#publish(Handler, PublishConfig, WifiAwareDiscoverySessionCallback)}
+ * or
+ * {@link WifiAwareSession#subscribe(Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)}
+ * to create publish or subscribe Aware discovery sessions. Events are called on the provided
+ * callback object {@link WifiAwareDiscoverySessionCallback}. Specifically, the
+ * {@link WifiAwareDiscoverySessionCallback#onPublishStarted(WifiAwarePublishDiscoverySession)}
* and
- * {@link WifiNanDiscoverySessionCallback#onSubscribeStarted(WifiNanSubscribeDiscoverySession)}
- * return {@link WifiNanPublishDiscoverySession} and {@link WifiNanSubscribeDiscoverySession}
+ * {@link WifiAwareDiscoverySessionCallback#onSubscribeStarted(
+ * WifiAwareSubscribeDiscoverySession)}
+ * return {@link WifiAwarePublishDiscoverySession} and
+ * {@link WifiAwareSubscribeDiscoverySession}
* objects respectively on which additional session operations can be performed, e.g. updating
- * the session {@link WifiNanPublishDiscoverySession#updatePublish(PublishConfig)} and
- * {@link WifiNanSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}. Sessions can also
- * be used to send messages using the
- * {@link WifiNanDiscoveryBaseSession#sendMessage(Object, int, byte[])} APIs. When an
+ * the session {@link WifiAwarePublishDiscoverySession#updatePublish(PublishConfig)} and
+ * {@link WifiAwareSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}. Sessions can
+ * also be used to send messages using the
+ * {@link WifiAwareDiscoveryBaseSession#sendMessage(Object, int, byte[])} APIs. When an
* application is finished with a discovery session it <b>must</b> terminate it using the
- * {@link WifiNanDiscoveryBaseSession#destroy()} API.
+ * {@link WifiAwareDiscoveryBaseSession#destroy()} API.
* <p>
- * Creating connections between NAN devices is managed by the standard
- * {@link ConnectivityManager#requestNetwork(NetworkRequest, ConnectivityManager.NetworkCallback)}.
+ * Creating connections between Aware devices is managed by the standard
+ * {@link ConnectivityManager#requestNetwork(NetworkRequest,
+ * ConnectivityManager.NetworkCallback)}.
* The {@link NetworkRequest} object should be constructed with:
* <ul>
* <li>{@link NetworkRequest.Builder#addTransportType(int)} of
- * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_NAN}.
+ * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_AWARE}.
* <li>{@link NetworkRequest.Builder#setNetworkSpecifier(String)} using
- * {@link WifiNanSession#createNetworkSpecifier(int, byte[], byte[])} or
- * {@link WifiNanDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])}.
+ * {@link WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])} or
+ * {@link WifiAwareDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])}.
* </ul>
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanManager {
- private static final String TAG = "WifiNanManager";
+public class WifiAwareManager {
+ private static final String TAG = "WifiAwareManager";
private static final boolean DBG = false;
private static final boolean VDBG = false; // STOPSHIP if true
/**
- * Keys used to generate a Network Specifier for the NAN network request. The network specifier
- * is formatted as a JSON string.
+ * Keys used to generate a Network Specifier for the Aware network request. The network
+ * specifier is formatted as a JSON string.
*/
/**
public static final String NETWORK_SPECIFIER_KEY_TOKEN = "token";
/**
- * Broadcast intent action to indicate that the state of Wi-Fi NAN availability has changed.
+ * Broadcast intent action to indicate that the state of Wi-Fi Aware availability has changed.
* Use the {@link #isAvailable()} to query the current status.
* This broadcast is <b>not</b> sticky, use the {@link #isAvailable()} API after registering
- * the broadcast to check the current state of Wi-Fi NAN.
+ * the broadcast to check the current state of Wi-Fi Aware.
* <p>Note: The broadcast is only delivered to registered receivers - no manifest registered
* components will be launched.
*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
- public static final String ACTION_WIFI_NAN_STATE_CHANGED =
- "android.net.wifi.nan.action.WIFI_NAN_STATE_CHANGED";
+ public static final String ACTION_WIFI_AWARE_STATE_CHANGED =
+ "android.net.wifi.aware.action.WIFI_AWARE_STATE_CHANGED";
/** @hide */
@IntDef({
- WIFI_NAN_DATA_PATH_ROLE_INITIATOR, WIFI_NAN_DATA_PATH_ROLE_RESPONDER})
+ WIFI_AWARE_DATA_PATH_ROLE_INITIATOR, WIFI_AWARE_DATA_PATH_ROLE_RESPONDER})
@Retention(RetentionPolicy.SOURCE)
public @interface DataPathRole {
}
/**
* Connection creation role is that of INITIATOR. Used to create a network specifier string
- * when requesting a NAN network.
+ * when requesting a Aware network.
*
- * @see WifiNanDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])
- * @see WifiNanSession#createNetworkSpecifier(int, byte[], byte[])
+ * @see WifiAwareDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])
+ * @see WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])
*/
- public static final int WIFI_NAN_DATA_PATH_ROLE_INITIATOR = 0;
+ public static final int WIFI_AWARE_DATA_PATH_ROLE_INITIATOR = 0;
/**
* Connection creation role is that of RESPONDER. Used to create a network specifier string
- * when requesting a NAN network.
+ * when requesting a Aware network.
*
- * @see WifiNanDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])
- * @see WifiNanSession#createNetworkSpecifier(int, byte[], byte[])
+ * @see WifiAwareDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])
+ * @see WifiAwareSession#createNetworkSpecifier(int, byte[], byte[])
*/
- public static final int WIFI_NAN_DATA_PATH_ROLE_RESPONDER = 1;
+ public static final int WIFI_AWARE_DATA_PATH_ROLE_RESPONDER = 1;
private final Context mContext;
- private final IWifiNanManager mService;
+ private final IWifiAwareManager mService;
private final Object mLock = new Object(); // lock access to the following vars
private SparseArray<RttManager.RttListener> mRangingListeners = new SparseArray<>();
/** @hide */
- public WifiNanManager(Context context, IWifiNanManager service) {
+ public WifiAwareManager(Context context, IWifiAwareManager service) {
mContext = context;
mService = service;
}
/**
- * Enable the usage of the NAN API. Doesn't actually turn on NAN cluster formation - that
- * only happens when an attach is attempted. {@link #ACTION_WIFI_NAN_STATE_CHANGED} broadcast
+ * Enable the usage of the Aware API. Doesn't actually turn on Aware cluster formation - that
+ * only happens when an attach is attempted. {@link #ACTION_WIFI_AWARE_STATE_CHANGED} broadcast
* will be triggered.
*
* @hide
}
/**
- * Disable the usage of the NAN API. All attempts to attach() will be rejected. All open
- * connections and sessions will be terminated. {@link #ACTION_WIFI_NAN_STATE_CHANGED} broadcast
- * will be triggered.
+ * Disable the usage of the Aware API. All attempts to attach() will be rejected. All open
+ * connections and sessions will be terminated. {@link #ACTION_WIFI_AWARE_STATE_CHANGED}
+ * broadcast will be triggered.
*
* @hide
*/
}
/**
- * Returns the current status of NAN API: whether or not NAN is available. To track changes
- * in the state of NAN API register for the {@link #ACTION_WIFI_NAN_STATE_CHANGED} broadcast.
+ * Returns the current status of Aware API: whether or not Aware is available. To track
+ * changes in the state of Aware API register for the
+ * {@link #ACTION_WIFI_AWARE_STATE_CHANGED} broadcast.
*
- * @return A boolean indicating whether the app can use the NAN API at this time (true) or
+ * @return A boolean indicating whether the app can use the Aware API at this time (true) or
* not (false).
*/
public boolean isAvailable() {
}
/**
- * Returns the characteristics of the Wi-Fi NAN interface: a set of parameters which specify
+ * Returns the characteristics of the Wi-Fi Aware interface: a set of parameters which specify
* limitations on configurations, e.g. the maximum service name length.
*
- * @return An object specifying configuration limitations of NAN.
+ * @return An object specifying configuration limitations of Aware.
*/
- public WifiNanCharacteristics getCharacteristics() {
+ public WifiAwareCharacteristics getCharacteristics() {
try {
return mService.getCharacteristics();
} catch (RemoteException e) {
}
/**
- * Attach to the Wi-Fi NAN service - enabling the application to create discovery sessions or
+ * Attach to the Wi-Fi Aware service - enabling the application to create discovery sessions or
* create connections to peers. The device will attach to an existing cluster if it can find
- * one or create a new cluster (if it is the first to enable NAN in its vicinity). Results
+ * one or create a new cluster (if it is the first to enable Aware in its vicinity). Results
* (e.g. successful attach to a cluster) are provided to the {@code attachCallback} object.
- * An application <b>must</b> call {@link WifiNanSession#destroy()} when done with the
- * Wi-Fi NAN object.
+ * An application <b>must</b> call {@link WifiAwareSession#destroy()} when done with the
+ * Wi-Fi Aware object.
* <p>
- * Note: a NAN cluster is a shared resource - if the device is already attached to a cluster
+ * Note: a Aware cluster is a shared resource - if the device is already attached to a cluster
* then this function will simply indicate success immediately using the same {@code
* attachCallback}.
*
* attachCallback} object. If a null is provided then the application's main thread will be
* used.
* @param attachCallback A callback for attach events, extended from
- * {@link WifiNanAttachCallback}.
+ * {@link WifiAwareAttachCallback}.
*/
- public void attach(@Nullable Handler handler, @NonNull WifiNanAttachCallback attachCallback) {
+ public void attach(@Nullable Handler handler, @NonNull WifiAwareAttachCallback attachCallback) {
attach(handler, null, attachCallback, null);
}
/**
- * Attach to the Wi-Fi NAN service - enabling the application to create discovery sessions or
+ * Attach to the Wi-Fi Aware service - enabling the application to create discovery sessions or
* create connections to peers. The device will attach to an existing cluster if it can find
- * one or create a new cluster (if it is the first to enable NAN in its vicinity). Results
+ * one or create a new cluster (if it is the first to enable Aware in its vicinity). Results
* (e.g. successful attach to a cluster) are provided to the {@code attachCallback} object.
- * An application <b>must</b> call {@link WifiNanSession#destroy()} when done with the
- * Wi-Fi NAN object.
+ * An application <b>must</b> call {@link WifiAwareSession#destroy()} when done with the
+ * Wi-Fi Aware object.
* <p>
- * Note: a NAN cluster is a shared resource - if the device is already attached to a cluster
+ * Note: a Aware cluster is a shared resource - if the device is already attached to a cluster
* then this function will simply indicate success immediately using the same {@code
* attachCallback}.
* <p>
- * This version of the API attaches a listener to receive the MAC address of the NAN interface
+ * This version of the API attaches a listener to receive the MAC address of the Aware interface
* on startup and whenever it is updated (it is randomized at regular intervals for privacy).
* The application must have the {@link android.Manifest.permission#ACCESS_COARSE_LOCATION}
* permission to execute this attach request. Otherwise, use the
- * {@link #attach(Handler, WifiNanAttachCallback)} version. Note that aside from permission
+ * {@link #attach(Handler, WifiAwareAttachCallback)} version. Note that aside from permission
* requirements this listener will wake up the host at regular intervals causing higher power
* consumption, do not use it unless the information is necessary (e.g. for OOB discovery).
*
* attachCallback} and {@code identityChangedListener} objects. If a null is provided then the
* application's main thread will be used.
* @param attachCallback A callback for attach events, extended from
- * {@link WifiNanAttachCallback}.
+ * {@link WifiAwareAttachCallback}.
* @param identityChangedListener A listener for changed identity, extended from
- * {@link WifiNanIdentityChangedListener}.
+ * {@link WifiAwareIdentityChangedListener}.
*/
- public void attach(@Nullable Handler handler, @NonNull WifiNanAttachCallback attachCallback,
- @NonNull WifiNanIdentityChangedListener identityChangedListener) {
+ public void attach(@Nullable Handler handler, @NonNull WifiAwareAttachCallback attachCallback,
+ @NonNull WifiAwareIdentityChangedListener identityChangedListener) {
attach(handler, null, attachCallback, identityChangedListener);
}
/** @hide */
public void attach(Handler handler, ConfigRequest configRequest,
- WifiNanAttachCallback attachCallback,
- WifiNanIdentityChangedListener identityChangedListener) {
+ WifiAwareAttachCallback attachCallback,
+ WifiAwareIdentityChangedListener identityChangedListener) {
if (VDBG) {
Log.v(TAG, "attach(): handler=" + handler + ", callback=" + attachCallback
+ ", configRequest=" + configRequest + ", identityChangedListener="
try {
Binder binder = new Binder();
mService.connect(binder, mContext.getOpPackageName(),
- new WifiNanEventCallbackProxy(this, looper, binder, attachCallback,
+ new WifiAwareEventCallbackProxy(this, looper, binder, attachCallback,
identityChangedListener), configRequest,
identityChangedListener != null);
} catch (RemoteException e) {
/** @hide */
public void publish(int clientId, Looper looper, PublishConfig publishConfig,
- WifiNanDiscoverySessionCallback callback) {
+ WifiAwareDiscoverySessionCallback callback) {
if (VDBG) Log.v(TAG, "publish(): clientId=" + clientId + ", config=" + publishConfig);
try {
mService.publish(clientId, publishConfig,
- new WifiNanDiscoverySessionCallbackProxy(this, looper, true, callback,
+ new WifiAwareDiscoverySessionCallbackProxy(this, looper, true, callback,
clientId));
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
/** @hide */
public void subscribe(int clientId, Looper looper, SubscribeConfig subscribeConfig,
- WifiNanDiscoverySessionCallback callback) {
+ WifiAwareDiscoverySessionCallback callback) {
if (VDBG) {
if (VDBG) {
Log.v(TAG,
try {
mService.subscribe(clientId, subscribeConfig,
- new WifiNanDiscoverySessionCallbackProxy(this, looper, false, callback,
+ new WifiAwareDiscoverySessionCallbackProxy(this, looper, false, callback,
clientId));
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
type = NETWORK_SPECIFIER_TYPE_1D;
}
- if (role != WIFI_NAN_DATA_PATH_ROLE_INITIATOR
- && role != WIFI_NAN_DATA_PATH_ROLE_RESPONDER) {
+ if (role != WIFI_AWARE_DATA_PATH_ROLE_INITIATOR
+ && role != WIFI_AWARE_DATA_PATH_ROLE_RESPONDER) {
throw new IllegalArgumentException(
"createNetworkSpecifier: Invalid 'role' argument when creating a network "
+ "specifier");
}
- if (role == WIFI_NAN_DATA_PATH_ROLE_INITIATOR) {
+ if (role == WIFI_AWARE_DATA_PATH_ROLE_INITIATOR) {
if (token == null) {
throw new IllegalArgumentException(
"createNetworkSpecifier: Invalid null token - not permitted on INITIATOR");
type = NETWORK_SPECIFIER_TYPE_2D;
}
- if (role != WIFI_NAN_DATA_PATH_ROLE_INITIATOR
- && role != WIFI_NAN_DATA_PATH_ROLE_RESPONDER) {
+ if (role != WIFI_AWARE_DATA_PATH_ROLE_INITIATOR
+ && role != WIFI_AWARE_DATA_PATH_ROLE_RESPONDER) {
throw new IllegalArgumentException(
"createNetworkSpecifier: Invalid 'role' argument when creating a network "
+ "specifier");
}
- if (role == WIFI_NAN_DATA_PATH_ROLE_INITIATOR) {
+ if (role == WIFI_AWARE_DATA_PATH_ROLE_INITIATOR) {
if (peer == null || peer.length != 6) {
throw new IllegalArgumentException(
"createNetworkSpecifier: Invalid peer MAC address");
return json.toString();
}
- private static class WifiNanEventCallbackProxy extends IWifiNanEventCallback.Stub {
+ private static class WifiAwareEventCallbackProxy extends IWifiAwareEventCallback.Stub {
private static final int CALLBACK_CONNECT_SUCCESS = 0;
private static final int CALLBACK_CONNECT_FAIL = 1;
private static final int CALLBACK_IDENTITY_CHANGED = 2;
private static final int CALLBACK_RANGING_ABORTED = 5;
private final Handler mHandler;
- private final WeakReference<WifiNanManager> mNanManager;
+ private final WeakReference<WifiAwareManager> mAwareManager;
private final Binder mBinder;
private final Looper mLooper;
RttManager.RttListener getAndRemoveRangingListener(int rangingId) {
- WifiNanManager mgr = mNanManager.get();
+ WifiAwareManager mgr = mAwareManager.get();
if (mgr == null) {
Log.w(TAG, "getAndRemoveRangingListener: called post GC");
return null;
}
/**
- * Constructs a {@link WifiNanAttachCallback} using the specified looper.
+ * Constructs a {@link WifiAwareAttachCallback} using the specified looper.
* All callbacks will delivered on the thread of the specified looper.
*
* @param looper The looper on which to execute the callbacks.
*/
- WifiNanEventCallbackProxy(WifiNanManager mgr, Looper looper, Binder binder,
- final WifiNanAttachCallback attachCallback,
- final WifiNanIdentityChangedListener identityChangedListener) {
- mNanManager = new WeakReference<>(mgr);
+ WifiAwareEventCallbackProxy(WifiAwareManager mgr, Looper looper, Binder binder,
+ final WifiAwareAttachCallback attachCallback,
+ final WifiAwareIdentityChangedListener identityChangedListener) {
+ mAwareManager = new WeakReference<>(mgr);
mLooper = looper;
mBinder = binder;
- if (VDBG) Log.v(TAG, "WifiNanEventCallbackProxy ctor: looper=" + looper);
+ if (VDBG) Log.v(TAG, "WifiAwareEventCallbackProxy ctor: looper=" + looper);
mHandler = new Handler(looper) {
@Override
public void handleMessage(Message msg) {
if (DBG) {
- Log.d(TAG, "WifiNanEventCallbackProxy: What=" + msg.what + ", msg=" + msg);
+ Log.d(TAG, "WifiAwareEventCallbackProxy: What=" + msg.what + ", msg="
+ + msg);
}
- WifiNanManager mgr = mNanManager.get();
+ WifiAwareManager mgr = mAwareManager.get();
if (mgr == null) {
- Log.w(TAG, "WifiNanEventCallbackProxy: handleMessage post GC");
+ Log.w(TAG, "WifiAwareEventCallbackProxy: handleMessage post GC");
return;
}
switch (msg.what) {
case CALLBACK_CONNECT_SUCCESS:
attachCallback.onAttached(
- new WifiNanSession(mgr, mBinder, msg.arg1));
+ new WifiAwareSession(mgr, mBinder, msg.arg1));
break;
case CALLBACK_CONNECT_FAIL:
- mNanManager.clear();
+ mAwareManager.clear();
attachCallback.onAttachFailed();
break;
case CALLBACK_IDENTITY_CHANGED:
}
}
- private static class WifiNanDiscoverySessionCallbackProxy extends
- IWifiNanDiscoverySessionCallback.Stub {
+ private static class WifiAwareDiscoverySessionCallbackProxy extends
+ IWifiAwareDiscoverySessionCallback.Stub {
private static final int CALLBACK_SESSION_STARTED = 0;
private static final int CALLBACK_SESSION_CONFIG_SUCCESS = 1;
private static final int CALLBACK_SESSION_CONFIG_FAIL = 2;
private static final String MESSAGE_BUNDLE_KEY_MESSAGE = "message";
private static final String MESSAGE_BUNDLE_KEY_MESSAGE2 = "message2";
- private final WeakReference<WifiNanManager> mNanManager;
+ private final WeakReference<WifiAwareManager> mAwareManager;
private final boolean mIsPublish;
- private final WifiNanDiscoverySessionCallback mOriginalCallback;
+ private final WifiAwareDiscoverySessionCallback mOriginalCallback;
private final int mClientId;
private final Handler mHandler;
- private WifiNanDiscoveryBaseSession mSession;
+ private WifiAwareDiscoveryBaseSession mSession;
- WifiNanDiscoverySessionCallbackProxy(WifiNanManager mgr, Looper looper, boolean isPublish,
- WifiNanDiscoverySessionCallback originalCallback, int clientId) {
- mNanManager = new WeakReference<>(mgr);
+ WifiAwareDiscoverySessionCallbackProxy(WifiAwareManager mgr, Looper looper,
+ boolean isPublish, WifiAwareDiscoverySessionCallback originalCallback,
+ int clientId) {
+ mAwareManager = new WeakReference<>(mgr);
mIsPublish = isPublish;
mOriginalCallback = originalCallback;
mClientId = clientId;
if (VDBG) {
- Log.v(TAG, "WifiNanDiscoverySessionCallbackProxy ctor: isPublish=" + isPublish);
+ Log.v(TAG, "WifiAwareDiscoverySessionCallbackProxy ctor: isPublish=" + isPublish);
}
mHandler = new Handler(looper) {
public void handleMessage(Message msg) {
if (DBG) Log.d(TAG, "What=" + msg.what + ", msg=" + msg);
- if (mNanManager.get() == null) {
- Log.w(TAG, "WifiNanDiscoverySessionCallbackProxy: handleMessage post GC");
+ if (mAwareManager.get() == null) {
+ Log.w(TAG, "WifiAwareDiscoverySessionCallbackProxy: handleMessage post GC");
return;
}
* creation failed (as opposed to update
* failing)
*/
- mNanManager.clear();
+ mAwareManager.clear();
}
break;
case CALLBACK_SESSION_TERMINATED:
"onSessionStarted: sessionId=" + sessionId + ": session already created!?");
}
- WifiNanManager mgr = mNanManager.get();
+ WifiAwareManager mgr = mAwareManager.get();
if (mgr == null) {
Log.w(TAG, "onProxySessionStarted: mgr GC'd");
return;
}
if (mIsPublish) {
- WifiNanPublishDiscoverySession session = new WifiNanPublishDiscoverySession(mgr,
+ WifiAwarePublishDiscoverySession session = new WifiAwarePublishDiscoverySession(mgr,
mClientId, sessionId);
mSession = session;
mOriginalCallback.onPublishStarted(session);
} else {
- WifiNanSubscribeDiscoverySession
- session = new WifiNanSubscribeDiscoverySession(mgr, mClientId, sessionId);
+ WifiAwareSubscribeDiscoverySession
+ session = new WifiAwareSubscribeDiscoverySession(mgr, mClientId, sessionId);
mSession = session;
mOriginalCallback.onSubscribeStarted(session);
}
} else {
Log.w(TAG, "Proxy: onSessionTerminated called but mSession is null!?");
}
- mNanManager.clear();
+ mAwareManager.clear();
mOriginalCallback.onSessionTerminated(reason);
}
}
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.NonNull;
import android.util.Log;
/**
- * A class representing a NAN publish session. Created when
- * {@link WifiNanSession#publish(android.os.Handler, PublishConfig, WifiNanDiscoverySessionCallback)}
+ * A class representing a Aware publish session. Created when
+ * {@link WifiAwareSession#publish(android.os.Handler, PublishConfig,
+ * WifiAwareDiscoverySessionCallback)}
* is called and a discovery session is created and returned in
- * {@link WifiNanDiscoverySessionCallback#onPublishStarted(WifiNanPublishDiscoverySession)}. See
- * baseline functionality of all discovery sessions in {@link WifiNanDiscoveryBaseSession}. This
+ * {@link WifiAwareDiscoverySessionCallback#onPublishStarted(WifiAwarePublishDiscoverySession)}. See
+ * baseline functionality of all discovery sessions in {@link WifiAwareDiscoveryBaseSession}. This
* object allows updating an existing/running publish discovery session using
* {@link #updatePublish(PublishConfig)}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanPublishDiscoverySession extends WifiNanDiscoveryBaseSession {
- private static final String TAG = "WifiNanPublishDiscSsn";
+public class WifiAwarePublishDiscoverySession extends WifiAwareDiscoveryBaseSession {
+ private static final String TAG = "WifiAwarePublishDiscSsn";
/** @hide */
- public WifiNanPublishDiscoverySession(WifiNanManager manager, int clientId, int sessionId) {
+ public WifiAwarePublishDiscoverySession(WifiAwareManager manager, int clientId, int sessionId) {
super(manager, clientId, sessionId);
}
/**
* Re-configure the currently active publish session. The
- * {@link WifiNanDiscoverySessionCallback} is not replaced - the same listener used
+ * {@link WifiAwareDiscoverySessionCallback} is not replaced - the same listener used
* at creation is still used. The results of the configuration are returned using
- * {@link WifiNanDiscoverySessionCallback}:
+ * {@link WifiAwareDiscoverySessionCallback}:
* <ul>
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigUpdated()}: configuration
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigUpdated()}: configuration
* update succeeded.
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigFailed()}: configuration
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigFailed()}: configuration
* update failed. The publish discovery session is still running using its previous
* configuration (i.e. update failure does not terminate the session).
* </ul>
Log.w(TAG, "updatePublish: called on terminated session");
return;
} else {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "updatePublish: called post GC on WifiNanManager");
+ Log.w(TAG, "updatePublish: called post GC on WifiAwareManager");
return;
}
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.NonNull;
import android.annotation.Nullable;
-import android.net.NetworkRequest;
import android.os.Binder;
import android.os.Handler;
import android.os.Looper;
import java.lang.ref.WeakReference;
/**
- * This class represents a Wi-Fi NAN session - an attachment to the Wi-Fi NAN service through
+ * This class represents a Wi-Fi Aware session - an attachment to the Wi-Fi Aware service through
* which the app can execute discovery operations.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanSession {
- private static final String TAG = "WifiNanSession";
+public class WifiAwareSession {
+ private static final String TAG = "WifiAwareSession";
private static final boolean DBG = false;
private static final boolean VDBG = false; // STOPSHIP if true
- private final WeakReference<WifiNanManager> mMgr;
+ private final WeakReference<WifiAwareManager> mMgr;
private final Binder mBinder;
private final int mClientId;
private final CloseGuard mCloseGuard = CloseGuard.get();
/** @hide */
- public WifiNanSession(WifiNanManager manager, Binder binder, int clientId) {
+ public WifiAwareSession(WifiAwareManager manager, Binder binder, int clientId) {
if (VDBG) Log.v(TAG, "New session created: manager=" + manager + ", clientId=" + clientId);
mMgr = new WeakReference<>(manager);
}
/**
- * Destroy the Wi-Fi NAN service session and, if no other applications are attached to NAN,
- * also disable NAN. This method destroys all outstanding operations - i.e. all publish and
+ * Destroy the Wi-Fi Aware service session and, if no other applications are attached to Aware,
+ * also disable Aware. This method destroys all outstanding operations - i.e. all publish and
* subscribes are terminated, and any outstanding data-links are shut-down. However, it is
* good practice to destroy these discovery sessions and connections explicitly before a
* session-wide destroy.
* <p>
* An application may re-attach after a destroy using
- * {@link WifiNanManager#attach(Handler, WifiNanAttachCallback)} .
+ * {@link WifiAwareManager#attach(Handler, WifiAwareAttachCallback)} .
*/
public void destroy() {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "destroy: called post GC on WifiNanManager");
+ Log.w(TAG, "destroy: called post GC on WifiAwareManager");
return;
}
mgr.disconnect(mClientId, mBinder);
}
/**
- * Issue a request to the NAN service to create a new NAN publish discovery session, using
+ * Issue a request to the Aware service to create a new Aware publish discovery session, using
* the specified {@code publishConfig} configuration. The results of the publish operation
- * are routed to the callbacks of {@link WifiNanDiscoverySessionCallback}:
+ * are routed to the callbacks of {@link WifiAwareDiscoverySessionCallback}:
* <ul>
* <li>
- * {@link WifiNanDiscoverySessionCallback#onPublishStarted(WifiNanPublishDiscoverySession)}
+ * {@link WifiAwareDiscoverySessionCallback#onPublishStarted(
+ * WifiAwarePublishDiscoverySession)}
* is called when the publish session is created and provides a handle to the session.
* Further operations on the publish session can be executed on that object.
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigFailed()} is called if the
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigFailed()} is called if the
* publish operation failed.
* </ul>
* <p>
* Other results of the publish session operations will also be routed to callbacks
* on the {@code callback} object. The resulting publish session can be modified using
- * {@link WifiNanPublishDiscoverySession#updatePublish(PublishConfig)}.
+ * {@link WifiAwarePublishDiscoverySession#updatePublish(PublishConfig)}.
* <p>
- * An application must use the {@link WifiNanDiscoveryBaseSession#destroy()} to
+ * An application must use the {@link WifiAwareDiscoveryBaseSession#destroy()} to
* terminate the publish discovery session once it isn't needed. This will free
* resources as well terminate any on-air transmissions.
* <p>The application must have the {@link android.Manifest.permission#ACCESS_COARSE_LOCATION}
* callback} object. If a null is provided then the application's main thread will be used.
* @param publishConfig The {@link PublishConfig} specifying the
* configuration of the requested publish session.
- * @param callback A {@link WifiNanDiscoverySessionCallback} derived object to be used for
+ * @param callback A {@link WifiAwareDiscoverySessionCallback} derived object to be used for
* session event callbacks.
*/
public void publish(@Nullable Handler handler, @NonNull PublishConfig publishConfig,
- @NonNull WifiNanDiscoverySessionCallback callback) {
- WifiNanManager mgr = mMgr.get();
+ @NonNull WifiAwareDiscoverySessionCallback callback) {
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.e(TAG, "publish: called post GC on WifiNanManager");
+ Log.e(TAG, "publish: called post GC on WifiAwareManager");
return;
}
if (mTerminated) {
}
/**
- * Issue a request to the NAN service to create a new NAN subscribe discovery session, using
+ * Issue a request to the Aware service to create a new Aware subscribe discovery session, using
* the specified {@code subscribeConfig} configuration. The results of the subscribe
- * operation are routed to the callbacks of {@link WifiNanDiscoverySessionCallback}:
+ * operation are routed to the callbacks of {@link WifiAwareDiscoverySessionCallback}:
* <ul>
* <li>
- * {@link WifiNanDiscoverySessionCallback#onSubscribeStarted(WifiNanSubscribeDiscoverySession)}
+ * {@link WifiAwareDiscoverySessionCallback#onSubscribeStarted(
+ * WifiAwareSubscribeDiscoverySession)}
* is called when the subscribe session is created and provides a handle to the session.
* Further operations on the subscribe session can be executed on that object.
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigFailed()} is called if the
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigFailed()} is called if the
* subscribe operation failed.
* </ul>
* <p>
* Other results of the subscribe session operations will also be routed to callbacks
* on the {@code callback} object. The resulting subscribe session can be modified using
- * {@link WifiNanSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
+ * {@link WifiAwareSubscribeDiscoverySession#updateSubscribe(SubscribeConfig)}.
* <p>
- * An application must use the {@link WifiNanDiscoveryBaseSession#destroy()} to
+ * An application must use the {@link WifiAwareDiscoveryBaseSession#destroy()} to
* terminate the subscribe discovery session once it isn't needed. This will free
* resources as well terminate any on-air transmissions.
* <p>The application must have the {@link android.Manifest.permission#ACCESS_COARSE_LOCATION}
* callback} object. If a null is provided then the application's main thread will be used.
* @param subscribeConfig The {@link SubscribeConfig} specifying the
* configuration of the requested subscribe session.
- * @param callback A {@link WifiNanDiscoverySessionCallback} derived object to be used for
+ * @param callback A {@link WifiAwareDiscoverySessionCallback} derived object to be used for
* session event callbacks.
*/
public void subscribe(@Nullable Handler handler, @NonNull SubscribeConfig subscribeConfig,
- @NonNull WifiNanDiscoverySessionCallback callback) {
- WifiNanManager mgr = mMgr.get();
+ @NonNull WifiAwareDiscoverySessionCallback callback) {
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.e(TAG, "publish: called post GC on WifiNanManager");
+ Log.e(TAG, "publish: called post GC on WifiAwareManager");
return;
}
if (mTerminated) {
}
/**
- * Create a {@link NetworkRequest.Builder#setNetworkSpecifier(String)} for a
- * WiFi NAN connection to the specified peer. The
- * {@link NetworkRequest.Builder#addTransportType(int)} should be set to
- * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_NAN}.
+ * Create a {@link android.net.NetworkRequest.Builder#setNetworkSpecifier(String)} for a
+ * WiFi Aware connection to the specified peer. The
+ * {@link android.net.NetworkRequest.Builder#addTransportType(int)} should be set to
+ * {@link android.net.NetworkCapabilities#TRANSPORT_WIFI_AWARE}.
* <p>
* This API is targeted for applications which can obtain the peer MAC address using OOB
- * (out-of-band) discovery. NAN discovery does not provide the MAC address of the peer -
- * when using NAN discovery use the alternative network specifier method -
- * {@link WifiNanDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])}.
+ * (out-of-band) discovery. Aware discovery does not provide the MAC address of the peer -
+ * when using Aware discovery use the alternative network specifier method -
+ * {@link WifiAwareDiscoveryBaseSession#createNetworkSpecifier(int, Object, byte[])}.
*
* @param role The role of this device:
- * {@link WifiNanManager#WIFI_NAN_DATA_PATH_ROLE_INITIATOR} or
- * {@link WifiNanManager#WIFI_NAN_DATA_PATH_ROLE_RESPONDER}
- * @param peer The MAC address of the peer's NAN discovery interface. On a RESPONDER this
+ * {@link WifiAwareManager#WIFI_AWARE_DATA_PATH_ROLE_INITIATOR} or
+ * {@link WifiAwareManager#WIFI_AWARE_DATA_PATH_ROLE_RESPONDER}
+ * @param peer The MAC address of the peer's Aware discovery interface. On a RESPONDER this
* value is used to gate the acceptance of a connection request from only that
* peer. A RESPONDER may specified a null - indicating that it will accept
* connection requests from any device.
*
* @return A string to be used to construct
* {@link android.net.NetworkRequest.Builder#setNetworkSpecifier(String)} to pass to
- * {@link android.net.ConnectivityManager#requestNetwork(NetworkRequest, android.net.ConnectivityManager.NetworkCallback)}
+ * {@link android.net.ConnectivityManager#requestNetwork(NetworkRequest,
+ * android.net.ConnectivityManager.NetworkCallback)}
* [or other varieties of that API].
*/
- public String createNetworkSpecifier(@WifiNanManager.DataPathRole int role, @Nullable byte[] peer,
- @Nullable byte[] token) {
- WifiNanManager mgr = mMgr.get();
+ public String createNetworkSpecifier(@WifiAwareManager.DataPathRole int role,
+ @Nullable byte[] peer, @Nullable byte[] token) {
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.e(TAG, "createNetworkSpecifier: called post GC on WifiNanManager");
+ Log.e(TAG, "createNetworkSpecifier: called post GC on WifiAwareManager");
return "";
}
if (mTerminated) {
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
import android.annotation.NonNull;
import android.util.Log;
/**
- * A class representing a NAN subscribe session. Created when
- * {@link WifiNanSession#subscribe(android.os.Handler, SubscribeConfig, WifiNanDiscoverySessionCallback)}
+ * A class representing a Aware subscribe session. Created when
+ * {@link WifiAwareSession#subscribe(android.os.Handler, SubscribeConfig,
+ * WifiAwareDiscoverySessionCallback)}
* is called and a discovery session is created and returned in
- * {@link WifiNanDiscoverySessionCallback#onSubscribeStarted(WifiNanSubscribeDiscoverySession)}.
- * See baseline functionality of all discovery sessions in {@link WifiNanDiscoveryBaseSession}.
+ * {@link WifiAwareDiscoverySessionCallback#onSubscribeStarted(WifiAwareSubscribeDiscoverySession)}.
+ * See baseline functionality of all discovery sessions in {@link WifiAwareDiscoveryBaseSession}.
* This object allows updating an existing/running subscribe discovery session using
* {@link #updateSubscribe(SubscribeConfig)}.
*
- * @hide PROPOSED_NAN_API
+ * @hide PROPOSED_AWARE_API
*/
-public class WifiNanSubscribeDiscoverySession extends WifiNanDiscoveryBaseSession {
- private static final String TAG = "WifiNanSubscribeDiscSsn";
+public class WifiAwareSubscribeDiscoverySession extends WifiAwareDiscoveryBaseSession {
+ private static final String TAG = "WifiAwareSubsDiscSsn";
/**
* {@hide}
*/
- public WifiNanSubscribeDiscoverySession(WifiNanManager manager, int clientId, int sessionId) {
+ public WifiAwareSubscribeDiscoverySession(WifiAwareManager manager, int clientId,
+ int sessionId) {
super(manager, clientId, sessionId);
}
/**
* Re-configure the currently active subscribe session. The
- * {@link WifiNanDiscoverySessionCallback} is not replaced - the same listener used
+ * {@link WifiAwareDiscoverySessionCallback} is not replaced - the same listener used
* at creation is still used. The results of the configuration are returned using
- * {@link WifiNanDiscoverySessionCallback}:
+ * {@link WifiAwareDiscoverySessionCallback}:
* <ul>
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigUpdated()}: configuration
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigUpdated()}: configuration
* update succeeded.
- * <li>{@link WifiNanDiscoverySessionCallback#onSessionConfigFailed()}: configuration
+ * <li>{@link WifiAwareDiscoverySessionCallback#onSessionConfigFailed()}: configuration
* update failed. The subscribe discovery session is still running using its previous
* configuration (i.e. update failure does not terminate the session).
* </ul>
Log.w(TAG, "updateSubscribe: called on terminated session");
return;
} else {
- WifiNanManager mgr = mMgr.get();
+ WifiAwareManager mgr = mMgr.get();
if (mgr == null) {
- Log.w(TAG, "updateSubscribe: called post GC on WifiNanManager");
+ Log.w(TAG, "updateSubscribe: called post GC on WifiAwareManager");
return;
}
* limitations under the License.
*/
-package android.net.wifi.nan;
+package android.net.wifi.aware;
/**
- * Provides utilities for the Wifi NAN manager/service.
+ * Provides utilities for the Wifi Aware manager/service.
*
* @hide
*/
-public class WifiNanUtils {
+public class WifiAwareUtils {
/**
* Per spec: The Service Name is a UTF-8 encoded string from 1 to 255 bytes in length. The
* only acceptable single-byte UTF-8 symbols for a Service Name are alphanumeric values (A-Z,
<HTML>
<BODY>
-<p>Provides classes which allow applications to use Wi-Fi NAN to discover peers and create
+<p>Provides classes which allow applications to use Wi-Fi Aware to discover peers and create
connections to them.</p>
-<p>Using the Wi-Fi NAN APIs, applications can advertise services, discover peers which are
+<p>Using the Wi-Fi Aware APIs, applications can advertise services, discover peers which are
advertising services, and connect to them.
- Wi-Fi NAN is independent of Wi-Fi infrastructure (i.e. a device may or may
- not be associated with an AP concurrent to using Wi-Fi NAN). </p>
-<p>The primary entry point to Wi-Fi NAN capabilities is the
- {@link android.net.wifi.nan.WifiNanManager} class, which is acquired by calling
+ Wi-Fi Aware is independent of Wi-Fi infrastructure (i.e. a device may or may
+ not be associated with an AP concurrent to using Wi-Fi Aware). </p>
+<p>The primary entry point to Wi-Fi Aware capabilities is the
+ {@link android.net.wifi.aware.WifiAwareManager} class, which is acquired by calling
{@link android.content.Context#getSystemService(String)
- Context.getSystemService(Context.WIFI_NAN_SERVICE)}</p>
+ Context.getSystemService(Context.WIFI_AWARE_SERVICE)}</p>
<p>Some APIs may require the following user permissions:</p>
<ul>
<li>{@link android.Manifest.permission#ACCESS_COARSE_LOCATION}</li>
</ul>
-<p class="note"><strong>Note:</strong> Not all Android-powered devices support Wi-Fi NAN
+<p class="note"><strong>Note:</strong> Not all Android-powered devices support Wi-Fi Aware
functionality.
- If your application only works with Wi-Fi NAN (i.e. it should only be installed on devices which
- support Wi-Fi NAN), declare so with a <a
+ If your application only works with Wi-Fi Aware (i.e. it should only be installed on devices which
+ support Wi-Fi Aware), declare so with a <a
href="{@docRoot}guide/topics/manifest/uses-feature-element.html">
{@code <uses-feature>}</a>
element in the manifest file:</p>
<pre>
<manifest ...>
- <uses-feature android:name="android.hardware.wifi.nan" />
+ <uses-feature android:name="android.hardware.wifi.aware" />
...
</manifest>
</pre>
-<p>Alternatively, if you application does not require Wi-Fi NAN but can take advantage of it if
+<p>Alternatively, if you application does not require Wi-Fi Aware but can take advantage of it if
available, you can perform
the check at run-time in your code using {@link
android.content.pm.PackageManager#hasSystemFeature(String)} with {@link
- android.content.pm.PackageManager#FEATURE_WIFI_NAN}:</p>
+ android.content.pm.PackageManager#FEATURE_WIFI_AWARE}:</p>
<pre>
- getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_NAN)
+ getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_AWARE)
</pre>
</BODY>
</HTML>