The API is asynchronous and responses to requests from an application are on listener * callbacks provided by the application. The application needs to do an initialization with * {@link #initialize} before doing any p2p operation. * *
Most application calls need a {@link ActionListener} instance for receiving callbacks * {@link ActionListener#onSuccess} or {@link ActionListener#onFailure}. Action callbacks * indicate whether the initiation of the action was a success or a failure. * Upon failure, the reason of failure can be one of {@link #ERROR}, {@link #P2P_UNSUPPORTED} * or {@link #BUSY}. * *
An application can initiate discovery of peers with {@link #discoverPeers}. An initiated * discovery request from an application stays active until the device starts connecting to a peer * ,forms a p2p group or there is an explicit {@link #stopPeerDiscovery}. * Applications can listen to {@link #WIFI_P2P_DISCOVERY_CHANGED_ACTION} to know if a peer-to-peer * discovery is running or stopped. Additionally, {@link #WIFI_P2P_PEERS_CHANGED_ACTION} indicates * if the peer list has changed. * *
When an application needs to fetch the current list of peers, it can request the list * of peers with {@link #requestPeers}. When the peer list is available * {@link PeerListListener#onPeersAvailable} is called with the device list. * *
An application can initiate a connection request to a peer through {@link #connect}. See * {@link WifiP2pConfig} for details on setting up the configuration. For communication with legacy * Wi-Fi devices that do not support p2p, an app can create a group using {@link #createGroup} * which creates an access point whose details can be fetched with {@link #requestGroupInfo}. * *
After a successful group formation through {@link #createGroup} or through {@link #connect}, * use {@link #requestConnectionInfo} to fetch the connection details. The connection info * {@link WifiP2pInfo} contains the address of the group owner * {@link WifiP2pInfo#groupOwnerAddress} and a flag {@link WifiP2pInfo#isGroupOwner} to indicate * if the current device is a p2p group owner. A p2p client can thus communicate with * the p2p group owner through a socket connection. If the current device is the p2p group owner, * {@link WifiP2pInfo#groupOwnerAddress} is anonymized unless the caller holds the * {@code android.Manifest.permission#LOCAL_MAC_ADDRESS} permission. * *
With peer discovery using {@link #discoverPeers}, an application discovers the neighboring * peers, but has no good way to figure out which peer to establish a connection with. For example, * if a game application is interested in finding all the neighboring peers that are also running * the same game, it has no way to find out until after the connection is setup. Pre-association * service discovery is meant to address this issue of filtering the peers based on the running * services. * *
With pre-association service discovery, an application can advertise a service for a * application on a peer device prior to a connection setup between the devices. * Currently, DNS based service discovery (Bonjour) and Upnp are the higher layer protocols * supported. Get Bonjour resources at dns-sd.org and Upnp resources at upnp.org * As an example, a video application can discover a Upnp capable media renderer * prior to setting up a Wi-fi p2p connection with the device. * *
An application can advertise a Upnp or a Bonjour service with a call to * {@link #addLocalService}. After a local service is added, * the framework automatically responds to a peer application discovering the service prior * to establishing a p2p connection. A call to {@link #removeLocalService} removes a local * service and {@link #clearLocalServices} can be used to clear all local services. * *
An application that is looking for peer devices that support certain services * can do so with a call to {@link #discoverServices}. Prior to initiating the discovery, * application can add service discovery request with a call to {@link #addServiceRequest}, * remove a service discovery request with a call to {@link #removeServiceRequest} or clear * all requests with a call to {@link #clearServiceRequests}. When no service requests remain, * a previously running service discovery will stop. * * The application is notified of a result of service discovery request through listener callbacks * set through {@link #setDnsSdResponseListeners} for Bonjour or * {@link #setUpnpServiceResponseListener} for Upnp. * *
Note: * Registering an application handler with {@link #initialize} requires the permissions * {@link android.Manifest.permission#ACCESS_WIFI_STATE} and * {@link android.Manifest.permission#CHANGE_WIFI_STATE} to perform any further peer-to-peer * operations. * * {@see WifiP2pConfig} * {@see WifiP2pInfo} * {@see WifiP2pGroup} * {@see WifiP2pDevice} * {@see WifiP2pDeviceList} * {@see android.net.wifi.WpsInfo} */ @SystemService(Context.WIFI_P2P_SERVICE) public class WifiP2pManager { private static final String TAG = "WifiP2pManager"; /** * Broadcast intent action to indicate whether Wi-Fi p2p is enabled or disabled. An * extra {@link #EXTRA_WIFI_STATE} provides the state information as int. * * @see #EXTRA_WIFI_STATE */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String WIFI_P2P_STATE_CHANGED_ACTION = "android.net.wifi.p2p.STATE_CHANGED"; /** * The lookup key for an int that indicates whether Wi-Fi p2p is enabled or disabled. * Retrieve it with {@link android.content.Intent#getIntExtra(String,int)}. * * @see #WIFI_P2P_STATE_DISABLED * @see #WIFI_P2P_STATE_ENABLED */ public static final String EXTRA_WIFI_STATE = "wifi_p2p_state"; /** @hide */ @IntDef({ WIFI_P2P_STATE_DISABLED, WIFI_P2P_STATE_ENABLED}) @Retention(RetentionPolicy.SOURCE) public @interface WifiP2pState { } /** * Wi-Fi p2p is disabled. * * @see #WIFI_P2P_STATE_CHANGED_ACTION */ public static final int WIFI_P2P_STATE_DISABLED = 1; /** * Wi-Fi p2p is enabled. * * @see #WIFI_P2P_STATE_CHANGED_ACTION */ public static final int WIFI_P2P_STATE_ENABLED = 2; /** * Broadcast intent action indicating that the state of Wi-Fi p2p connectivity * has changed. One extra {@link #EXTRA_WIFI_P2P_INFO} provides the p2p connection info in * the form of a {@link WifiP2pInfo} object. Another extra {@link #EXTRA_NETWORK_INFO} provides * the network info in the form of a {@link android.net.NetworkInfo}. A third extra provides * the details of the group and may contain a {@code null}. * * All of these permissions are required to receive this broadcast: * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and * {@link android.Manifest.permission#ACCESS_WIFI_STATE} * * @see #EXTRA_WIFI_P2P_INFO * @see #EXTRA_NETWORK_INFO * @see #EXTRA_WIFI_P2P_GROUP */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String WIFI_P2P_CONNECTION_CHANGED_ACTION = "android.net.wifi.p2p.CONNECTION_STATE_CHANGE"; /** * The lookup key for a {@link android.net.wifi.p2p.WifiP2pInfo} object * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. */ public static final String EXTRA_WIFI_P2P_INFO = "wifiP2pInfo"; /** * The lookup key for a {@link android.net.NetworkInfo} object associated with the * p2p network. Retrieve with * {@link android.content.Intent#getParcelableExtra(String)}. */ public static final String EXTRA_NETWORK_INFO = "networkInfo"; /** * The lookup key for a {@link android.net.wifi.p2p.WifiP2pGroup} object * associated with the p2p network. Retrieve with * {@link android.content.Intent#getParcelableExtra(String)}. */ public static final String EXTRA_WIFI_P2P_GROUP = "p2pGroupInfo"; /** * Broadcast intent action indicating that the available peer list has changed. This * can be sent as a result of peers being found, lost or updated. * * All of these permissions are required to receive this broadcast: * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and * {@link android.Manifest.permission#ACCESS_WIFI_STATE} * *
An extra {@link #EXTRA_P2P_DEVICE_LIST} provides the full list of * current peers. The full list of peers can also be obtained any time with * {@link #requestPeers}. * * @see #EXTRA_P2P_DEVICE_LIST */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String WIFI_P2P_PEERS_CHANGED_ACTION = "android.net.wifi.p2p.PEERS_CHANGED"; /** * The lookup key for a {@link android.net.wifi.p2p.WifiP2pDeviceList} object representing * the new peer list when {@link #WIFI_P2P_PEERS_CHANGED_ACTION} broadcast is sent. * *
Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. */ public static final String EXTRA_P2P_DEVICE_LIST = "wifiP2pDeviceList"; /** * Broadcast intent action indicating that peer discovery has either started or stopped. * One extra {@link #EXTRA_DISCOVERY_STATE} indicates whether discovery has started * or stopped. * *
Note that discovery will be stopped during a connection setup. If the application tries * to re-initiate discovery during this time, it can fail. */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String WIFI_P2P_DISCOVERY_CHANGED_ACTION = "android.net.wifi.p2p.DISCOVERY_STATE_CHANGE"; /** * The lookup key for an int that indicates whether p2p discovery has started or stopped. * Retrieve it with {@link android.content.Intent#getIntExtra(String,int)}. * * @see #WIFI_P2P_DISCOVERY_STARTED * @see #WIFI_P2P_DISCOVERY_STOPPED */ public static final String EXTRA_DISCOVERY_STATE = "discoveryState"; /** @hide */ @IntDef({ WIFI_P2P_DISCOVERY_STOPPED, WIFI_P2P_DISCOVERY_STARTED}) @Retention(RetentionPolicy.SOURCE) public @interface WifiP2pDiscoveryState { } /** * p2p discovery has stopped * * @see #WIFI_P2P_DISCOVERY_CHANGED_ACTION */ public static final int WIFI_P2P_DISCOVERY_STOPPED = 1; /** * p2p discovery has started * * @see #WIFI_P2P_DISCOVERY_CHANGED_ACTION */ public static final int WIFI_P2P_DISCOVERY_STARTED = 2; /** * Broadcast intent action indicating that this device details have changed. * *
An extra {@link #EXTRA_WIFI_P2P_DEVICE} provides this device details. * The valid device details can also be obtained with * {@link #requestDeviceInfo(Channel, DeviceInfoListener)} when p2p is enabled. * To get information notifications on P2P getting enabled refers * {@link #WIFI_P2P_STATE_ENABLED}. * *
The {@link #EXTRA_WIFI_P2P_DEVICE} extra contains an anonymized version of the device's * MAC address. Callers holding the {@code android.Manifest.permission#LOCAL_MAC_ADDRESS} * permission can use {@link #requestDeviceInfo} to obtain the actual MAC address of this * device. * * All of these permissions are required to receive this broadcast: * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and * {@link android.Manifest.permission#ACCESS_WIFI_STATE} * * @see #EXTRA_WIFI_P2P_DEVICE */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String WIFI_P2P_THIS_DEVICE_CHANGED_ACTION = "android.net.wifi.p2p.THIS_DEVICE_CHANGED"; /** * The lookup key for a {@link android.net.wifi.p2p.WifiP2pDevice} object * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. */ public static final String EXTRA_WIFI_P2P_DEVICE = "wifiP2pDevice"; /** * Broadcast intent action indicating that remembered persistent groups have changed. * * You can not receive this through components declared * in manifests, only by explicitly registering for it with * {@link android.content.Context#registerReceiver(android.content.BroadcastReceiver, * android.content.IntentFilter) Context.registerReceiver()}. * * @hide */ @SystemApi public static final String ACTION_WIFI_P2P_PERSISTENT_GROUPS_CHANGED = "android.net.wifi.p2p.action.WIFI_P2P_PERSISTENT_GROUPS_CHANGED"; /** * The lookup key for a handover message returned by the WifiP2pService. * @hide */ public static final String EXTRA_HANDOVER_MESSAGE = "android.net.wifi.p2p.EXTRA_HANDOVER_MESSAGE"; /** * The lookup key for a calling package name from WifiP2pManager * @hide */ public static final String CALLING_PACKAGE = "android.net.wifi.p2p.CALLING_PACKAGE"; /** * The lookup key for a calling feature id from WifiP2pManager * @hide */ public static final String CALLING_FEATURE_ID = "android.net.wifi.p2p.CALLING_FEATURE_ID"; /** * The lookup key for a calling package binder from WifiP2pManager * @hide */ public static final String CALLING_BINDER = "android.net.wifi.p2p.CALLING_BINDER"; IWifiP2pManager mService; private static final int BASE = Protocol.BASE_WIFI_P2P_MANAGER; /** @hide */ public static final int DISCOVER_PEERS = BASE + 1; /** @hide */ public static final int DISCOVER_PEERS_FAILED = BASE + 2; /** @hide */ public static final int DISCOVER_PEERS_SUCCEEDED = BASE + 3; /** @hide */ public static final int STOP_DISCOVERY = BASE + 4; /** @hide */ public static final int STOP_DISCOVERY_FAILED = BASE + 5; /** @hide */ public static final int STOP_DISCOVERY_SUCCEEDED = BASE + 6; /** @hide */ public static final int CONNECT = BASE + 7; /** @hide */ public static final int CONNECT_FAILED = BASE + 8; /** @hide */ public static final int CONNECT_SUCCEEDED = BASE + 9; /** @hide */ public static final int CANCEL_CONNECT = BASE + 10; /** @hide */ public static final int CANCEL_CONNECT_FAILED = BASE + 11; /** @hide */ public static final int CANCEL_CONNECT_SUCCEEDED = BASE + 12; /** @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) public static final int CREATE_GROUP = BASE + 13; /** @hide */ public static final int CREATE_GROUP_FAILED = BASE + 14; /** @hide */ public static final int CREATE_GROUP_SUCCEEDED = BASE + 15; /** @hide */ public static final int REMOVE_GROUP = BASE + 16; /** @hide */ public static final int REMOVE_GROUP_FAILED = BASE + 17; /** @hide */ public static final int REMOVE_GROUP_SUCCEEDED = BASE + 18; /** @hide */ public static final int REQUEST_PEERS = BASE + 19; /** @hide */ public static final int RESPONSE_PEERS = BASE + 20; /** @hide */ public static final int REQUEST_CONNECTION_INFO = BASE + 21; /** @hide */ public static final int RESPONSE_CONNECTION_INFO = BASE + 22; /** @hide */ public static final int REQUEST_GROUP_INFO = BASE + 23; /** @hide */ public static final int RESPONSE_GROUP_INFO = BASE + 24; /** @hide */ public static final int ADD_LOCAL_SERVICE = BASE + 28; /** @hide */ public static final int ADD_LOCAL_SERVICE_FAILED = BASE + 29; /** @hide */ public static final int ADD_LOCAL_SERVICE_SUCCEEDED = BASE + 30; /** @hide */ public static final int REMOVE_LOCAL_SERVICE = BASE + 31; /** @hide */ public static final int REMOVE_LOCAL_SERVICE_FAILED = BASE + 32; /** @hide */ public static final int REMOVE_LOCAL_SERVICE_SUCCEEDED = BASE + 33; /** @hide */ public static final int CLEAR_LOCAL_SERVICES = BASE + 34; /** @hide */ public static final int CLEAR_LOCAL_SERVICES_FAILED = BASE + 35; /** @hide */ public static final int CLEAR_LOCAL_SERVICES_SUCCEEDED = BASE + 36; /** @hide */ public static final int ADD_SERVICE_REQUEST = BASE + 37; /** @hide */ public static final int ADD_SERVICE_REQUEST_FAILED = BASE + 38; /** @hide */ public static final int ADD_SERVICE_REQUEST_SUCCEEDED = BASE + 39; /** @hide */ public static final int REMOVE_SERVICE_REQUEST = BASE + 40; /** @hide */ public static final int REMOVE_SERVICE_REQUEST_FAILED = BASE + 41; /** @hide */ public static final int REMOVE_SERVICE_REQUEST_SUCCEEDED = BASE + 42; /** @hide */ public static final int CLEAR_SERVICE_REQUESTS = BASE + 43; /** @hide */ public static final int CLEAR_SERVICE_REQUESTS_FAILED = BASE + 44; /** @hide */ public static final int CLEAR_SERVICE_REQUESTS_SUCCEEDED = BASE + 45; /** @hide */ public static final int DISCOVER_SERVICES = BASE + 46; /** @hide */ public static final int DISCOVER_SERVICES_FAILED = BASE + 47; /** @hide */ public static final int DISCOVER_SERVICES_SUCCEEDED = BASE + 48; /** @hide */ public static final int PING = BASE + 49; /** @hide */ public static final int RESPONSE_SERVICE = BASE + 50; /** @hide */ public static final int SET_DEVICE_NAME = BASE + 51; /** @hide */ public static final int SET_DEVICE_NAME_FAILED = BASE + 52; /** @hide */ public static final int SET_DEVICE_NAME_SUCCEEDED = BASE + 53; /** @hide */ public static final int DELETE_PERSISTENT_GROUP = BASE + 54; /** @hide */ public static final int DELETE_PERSISTENT_GROUP_FAILED = BASE + 55; /** @hide */ public static final int DELETE_PERSISTENT_GROUP_SUCCEEDED = BASE + 56; /** @hide */ public static final int REQUEST_PERSISTENT_GROUP_INFO = BASE + 57; /** @hide */ public static final int RESPONSE_PERSISTENT_GROUP_INFO = BASE + 58; /** @hide */ public static final int SET_WFD_INFO = BASE + 59; /** @hide */ public static final int SET_WFD_INFO_FAILED = BASE + 60; /** @hide */ public static final int SET_WFD_INFO_SUCCEEDED = BASE + 61; /** @hide */ public static final int START_WPS = BASE + 62; /** @hide */ public static final int START_WPS_FAILED = BASE + 63; /** @hide */ public static final int START_WPS_SUCCEEDED = BASE + 64; /** @hide */ public static final int START_LISTEN = BASE + 65; /** @hide */ public static final int START_LISTEN_FAILED = BASE + 66; /** @hide */ public static final int START_LISTEN_SUCCEEDED = BASE + 67; /** @hide */ public static final int STOP_LISTEN = BASE + 68; /** @hide */ public static final int STOP_LISTEN_FAILED = BASE + 69; /** @hide */ public static final int STOP_LISTEN_SUCCEEDED = BASE + 70; /** @hide */ public static final int SET_CHANNEL = BASE + 71; /** @hide */ public static final int SET_CHANNEL_FAILED = BASE + 72; /** @hide */ public static final int SET_CHANNEL_SUCCEEDED = BASE + 73; /** @hide */ public static final int GET_HANDOVER_REQUEST = BASE + 75; /** @hide */ public static final int GET_HANDOVER_SELECT = BASE + 76; /** @hide */ public static final int RESPONSE_GET_HANDOVER_MESSAGE = BASE + 77; /** @hide */ public static final int INITIATOR_REPORT_NFC_HANDOVER = BASE + 78; /** @hide */ public static final int RESPONDER_REPORT_NFC_HANDOVER = BASE + 79; /** @hide */ public static final int REPORT_NFC_HANDOVER_SUCCEEDED = BASE + 80; /** @hide */ public static final int REPORT_NFC_HANDOVER_FAILED = BASE + 81; /** @hide */ public static final int FACTORY_RESET = BASE + 82; /** @hide */ public static final int FACTORY_RESET_FAILED = BASE + 83; /** @hide */ public static final int FACTORY_RESET_SUCCEEDED = BASE + 84; /** @hide */ public static final int REQUEST_ONGOING_PEER_CONFIG = BASE + 85; /** @hide */ public static final int RESPONSE_ONGOING_PEER_CONFIG = BASE + 86; /** @hide */ public static final int SET_ONGOING_PEER_CONFIG = BASE + 87; /** @hide */ public static final int SET_ONGOING_PEER_CONFIG_FAILED = BASE + 88; /** @hide */ public static final int SET_ONGOING_PEER_CONFIG_SUCCEEDED = BASE + 89; /** @hide */ public static final int REQUEST_P2P_STATE = BASE + 90; /** @hide */ public static final int RESPONSE_P2P_STATE = BASE + 91; /** @hide */ public static final int REQUEST_DISCOVERY_STATE = BASE + 92; /** @hide */ public static final int RESPONSE_DISCOVERY_STATE = BASE + 93; /** @hide */ public static final int REQUEST_NETWORK_INFO = BASE + 94; /** @hide */ public static final int RESPONSE_NETWORK_INFO = BASE + 95; /** @hide */ public static final int UPDATE_CHANNEL_INFO = BASE + 96; /** @hide */ public static final int REQUEST_DEVICE_INFO = BASE + 97; /** @hide */ public static final int RESPONSE_DEVICE_INFO = BASE + 98; /** * Create a new WifiP2pManager instance. Applications use * {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve * the standard {@link android.content.Context#WIFI_P2P_SERVICE Context.WIFI_P2P_SERVICE}. * @param service the Binder interface * @hide - hide this because it takes in a parameter of type IWifiP2pManager, which * is a system private class. */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) public WifiP2pManager(IWifiP2pManager service) { mService = service; } /** * Passed with {@link ActionListener#onFailure}. * Indicates that the operation failed due to an internal error. */ public static final int ERROR = 0; /** * Passed with {@link ActionListener#onFailure}. * Indicates that the operation failed because p2p is unsupported on the device. */ public static final int P2P_UNSUPPORTED = 1; /** * Passed with {@link ActionListener#onFailure}. * Indicates that the operation failed because the framework is busy and * unable to service the request */ public static final int BUSY = 2; /** * Passed with {@link ActionListener#onFailure}. * Indicates that the {@link #discoverServices} failed because no service * requests are added. Use {@link #addServiceRequest} to add a service * request. */ public static final int NO_SERVICE_REQUESTS = 3; /** Interface for callback invocation when framework channel is lost */ public interface ChannelListener { /** * The channel to the framework has been disconnected. * Application could try re-initializing using {@link #initialize} */ public void onChannelDisconnected(); } /** Interface for callback invocation on an application action */ public interface ActionListener { /** The operation succeeded */ public void onSuccess(); /** * The operation failed * @param reason The reason for failure could be one of {@link #P2P_UNSUPPORTED}, * {@link #ERROR} or {@link #BUSY} */ public void onFailure(int reason); } /** Interface for callback invocation when peer list is available */ public interface PeerListListener { /** * The requested peer list is available * @param peers List of available peers */ public void onPeersAvailable(WifiP2pDeviceList peers); } /** Interface for callback invocation when connection info is available */ public interface ConnectionInfoListener { /** * The requested connection info is available * @param info Wi-Fi p2p connection info */ public void onConnectionInfoAvailable(WifiP2pInfo info); } /** Interface for callback invocation when group info is available */ public interface GroupInfoListener { /** * The requested p2p group info is available * @param group Wi-Fi p2p group info */ public void onGroupInfoAvailable(WifiP2pGroup group); } /** * Interface for callback invocation when service discovery response other than * Upnp or Bonjour is received */ public interface ServiceResponseListener { /** * The requested service response is available. * * @param protocolType protocol type. currently only * {@link WifiP2pServiceInfo#SERVICE_TYPE_VENDOR_SPECIFIC}. * @param responseData service discovery response data based on the requested * service protocol type. The format depends on the service type. * @param srcDevice source device. */ public void onServiceAvailable(int protocolType, byte[] responseData, WifiP2pDevice srcDevice); } /** * Interface for callback invocation when Bonjour service discovery response * is received */ public interface DnsSdServiceResponseListener { /** * The requested Bonjour service response is available. * *
This function is invoked when the device with the specified Bonjour
* registration type returned the instance name.
* @param instanceName instance name.
* e.g) "MyPrinter".
* @param registrationType
* e.g) "_ipp._tcp.local."
* @param srcDevice source device.
*/
public void onDnsSdServiceAvailable(String instanceName,
String registrationType, WifiP2pDevice srcDevice);
}
/**
* Interface for callback invocation when Bonjour TXT record is available
* for a service
*/
public interface DnsSdTxtRecordListener {
/**
* The requested Bonjour service response is available.
*
*
This function is invoked when the device with the specified full
* service domain service returned TXT record.
*
* @param fullDomainName full domain name. This function is invoked when the specified device or service is found.
*
* @param uniqueServiceNames The list of unique service names. The function call immediately returns after sending a discovery request
* to the framework. The application is notified of a success or failure to initiate
* discovery through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* The discovery remains active until a connection is initiated or
* a p2p group is formed. Register for {@link #WIFI_P2P_PEERS_CHANGED_ACTION} intent to
* determine when the framework notifies of a change as peers are discovered.
*
* Upon receiving a {@link #WIFI_P2P_PEERS_CHANGED_ACTION} intent, an application
* can request for the list of peers using {@link #requestPeers}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void discoverPeers(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(DISCOVER_PEERS, 0, c.putListener(listener));
}
/**
* Stop an ongoing peer discovery
*
* The function call immediately returns after sending a stop request
* to the framework. The application is notified of a success or failure to initiate
* stop through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
public void stopPeerDiscovery(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(STOP_DISCOVERY, 0, c.putListener(listener));
}
/**
* Start a p2p connection to a device with the specified configuration.
*
* The function call immediately returns after sending a connection request
* to the framework. The application is notified of a success or failure to initiate
* connect through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* Register for {@link #WIFI_P2P_CONNECTION_CHANGED_ACTION} intent to
* determine when the framework notifies of a change in connectivity.
*
* If the current device is not part of a p2p group, a connect request initiates
* a group negotiation with the peer.
*
* If the current device is part of an existing p2p group or has created
* a p2p group with {@link #createGroup}, an invitation to join the group is sent to
* the peer device.
*
* @param c is the channel created at {@link #initialize}
* @param config options as described in {@link WifiP2pConfig} class
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void connect(Channel c, WifiP2pConfig config, ActionListener listener) {
checkChannel(c);
checkP2pConfig(config);
c.mAsyncChannel.sendMessage(CONNECT, 0, c.putListener(listener), config);
}
/**
* Cancel any ongoing p2p group negotiation
*
* The function call immediately returns after sending a connection cancellation request
* to the framework. The application is notified of a success or failure to initiate
* cancellation through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
public void cancelConnect(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(CANCEL_CONNECT, 0, c.putListener(listener));
}
/**
* Create a p2p group with the current device as the group owner. This essentially creates
* an access point that can accept connections from legacy clients as well as other p2p
* devices.
*
* Note:
* This function would normally not be used unless the current device needs
* to form a p2p connection with a legacy client
*
* The function call immediately returns after sending a group creation request
* to the framework. The application is notified of a success or failure to initiate
* group creation through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* Application can request for the group details with {@link #requestGroupInfo}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void createGroup(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(CREATE_GROUP, WifiP2pGroup.NETWORK_ID_PERSISTENT,
c.putListener(listener));
}
/**
* Create a p2p group with the current device as the group owner. This essentially creates
* an access point that can accept connections from legacy clients as well as other p2p
* devices.
*
* An app should use {@link WifiP2pConfig.Builder} to build the configuration
* for a group.
*
* Note:
* This function would normally not be used unless the current device needs
* to form a p2p group as a Group Owner and allow peers to join it as either
* Group Clients or legacy Wi-Fi STAs.
*
* The function call immediately returns after sending a group creation request
* to the framework. The application is notified of a success or failure to initiate
* group creation through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* Application can request for the group details with {@link #requestGroupInfo}.
*
* @param c is the channel created at {@link #initialize}.
* @param config the configuration of a p2p group.
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void createGroup(@NonNull Channel c,
@Nullable WifiP2pConfig config,
@Nullable ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(CREATE_GROUP, 0,
c.putListener(listener), config);
}
/**
* Remove the current p2p group.
*
* The function call immediately returns after sending a group removal request
* to the framework. The application is notified of a success or failure to initiate
* group removal through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
public void removeGroup(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REMOVE_GROUP, 0, c.putListener(listener));
}
/**
* Force p2p to enter listen state
*
* @param c is the channel created at {@link #initialize(Context, Looper, ChannelListener)}
* @param listener for callbacks on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.NETWORK_SETTINGS)
public void startListening(@NonNull Channel c, @Nullable ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(START_LISTEN, 0, c.putListener(listener));
}
/**
* Force p2p to exit listen state
*
* @param c is the channel created at {@link #initialize(Context, Looper, ChannelListener)}
* @param listener for callbacks on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.NETWORK_SETTINGS)
public void stopListening(@NonNull Channel c, @Nullable ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(STOP_LISTEN, 0, c.putListener(listener));
}
/**
* Set P2P listening and operating channel.
*
* @param c is the channel created at {@link #initialize}
* @param listeningChannel the listening channel's Wifi channel number. e.g. 1, 6, 11.
* @param operatingChannel the operating channel's Wifi channel number. e.g. 1, 6, 11.
* @param listener for callbacks on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(anyOf = {
android.Manifest.permission.NETWORK_SETTINGS,
android.Manifest.permission.NETWORK_STACK,
android.Manifest.permission.OVERRIDE_WIFI_CONFIG
})
public void setWifiP2pChannels(@NonNull Channel c, int listeningChannel, int operatingChannel,
@Nullable ActionListener listener) {
checkChannel(c);
Bundle p2pChannels = new Bundle();
p2pChannels.putInt("lc", listeningChannel);
p2pChannels.putInt("oc", operatingChannel);
c.mAsyncChannel.sendMessage(SET_CHANNEL, 0, c.putListener(listener), p2pChannels);
}
/**
* Start a Wi-Fi Protected Setup (WPS) session.
*
* The function call immediately returns after sending a request to start a
* WPS session. Currently, this is only valid if the current device is running
* as a group owner to allow any new clients to join the group. The application
* is notified of a success or failure to initiate WPS through listener callbacks
* {@link ActionListener#onSuccess} or {@link ActionListener#onFailure}.
* @hide
*/
@UnsupportedAppUsage(trackingBug = 185141982)
public void startWps(Channel c, WpsInfo wps, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(START_WPS, 0, c.putListener(listener), wps);
}
/**
* Register a local service for service discovery. If a local service is registered,
* the framework automatically responds to a service discovery request from a peer.
*
* The function call immediately returns after sending a request to add a local
* service to the framework. The application is notified of a success or failure to
* add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* The service information is set through {@link WifiP2pServiceInfo}. The service information can be cleared with calls to
* {@link #removeLocalService} or {@link #clearLocalServices}.
*
* @param c is the channel created at {@link #initialize}
* @param servInfo is a local service information.
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void addLocalService(Channel c, WifiP2pServiceInfo servInfo, ActionListener listener) {
checkChannel(c);
checkServiceInfo(servInfo);
c.mAsyncChannel.sendMessage(ADD_LOCAL_SERVICE, 0, c.putListener(listener), servInfo);
}
/**
* Remove a registered local service added with {@link #addLocalService}
*
* The function call immediately returns after sending a request to remove a
* local service to the framework. The application is notified of a success or failure to
* add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param servInfo is the local service information.
* @param listener for callbacks on success or failure. Can be null.
*/
public void removeLocalService(Channel c, WifiP2pServiceInfo servInfo,
ActionListener listener) {
checkChannel(c);
checkServiceInfo(servInfo);
c.mAsyncChannel.sendMessage(REMOVE_LOCAL_SERVICE, 0, c.putListener(listener), servInfo);
}
/**
* Clear all registered local services of service discovery.
*
* The function call immediately returns after sending a request to clear all
* local services to the framework. The application is notified of a success or failure to
* add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
public void clearLocalServices(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(CLEAR_LOCAL_SERVICES, 0, c.putListener(listener));
}
/**
* Register a callback to be invoked on receiving service discovery response.
* Used only for vendor specific protocol right now. For Bonjour or Upnp, use
* {@link #setDnsSdResponseListeners} or {@link #setUpnpServiceResponseListener}
* respectively.
*
* see {@link #discoverServices} for the detail.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on receiving service discovery response.
*/
public void setServiceResponseListener(Channel c,
ServiceResponseListener listener) {
checkChannel(c);
c.mServRspListener = listener;
}
/**
* Register a callback to be invoked on receiving Bonjour service discovery
* response.
*
* see {@link #discoverServices} for the detail.
*
* @param c
* @param servListener is for listening to a Bonjour service response
* @param txtListener is for listening to a Bonjour TXT record response
*/
public void setDnsSdResponseListeners(Channel c,
DnsSdServiceResponseListener servListener, DnsSdTxtRecordListener txtListener) {
checkChannel(c);
c.mDnsSdServRspListener = servListener;
c.mDnsSdTxtListener = txtListener;
}
/**
* Register a callback to be invoked on receiving upnp service discovery
* response.
*
* see {@link #discoverServices} for the detail.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on receiving service discovery response.
*/
public void setUpnpServiceResponseListener(Channel c,
UpnpServiceResponseListener listener) {
checkChannel(c);
c.mUpnpServRspListener = listener;
}
/**
* Initiate service discovery. A discovery process involves scanning for
* requested services for the purpose of establishing a connection to a peer
* that supports an available service.
*
* The function call immediately returns after sending a request to start service
* discovery to the framework. The application is notified of a success or failure to initiate
* discovery through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* The services to be discovered are specified with calls to {@link #addServiceRequest}.
*
* The application is notified of the response against the service discovery request
* through listener callbacks registered by {@link #setServiceResponseListener} or
* {@link #setDnsSdResponseListeners}, or {@link #setUpnpServiceResponseListener}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void discoverServices(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(DISCOVER_SERVICES, 0, c.putListener(listener));
}
/**
* Add a service discovery request.
*
* The function call immediately returns after sending a request to add service
* discovery request to the framework. The application is notified of a success or failure to
* add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* After service discovery request is added, you can initiate service discovery by
* {@link #discoverServices}.
*
* The added service requests can be cleared with calls to
* {@link #removeServiceRequest(Channel, WifiP2pServiceRequest, ActionListener)} or
* {@link #clearServiceRequests(Channel, ActionListener)}.
*
* @param c is the channel created at {@link #initialize}
* @param req is the service discovery request.
* @param listener for callbacks on success or failure. Can be null.
*/
public void addServiceRequest(Channel c,
WifiP2pServiceRequest req, ActionListener listener) {
checkChannel(c);
checkServiceRequest(req);
c.mAsyncChannel.sendMessage(ADD_SERVICE_REQUEST, 0,
c.putListener(listener), req);
}
/**
* Remove a specified service discovery request added with {@link #addServiceRequest}
*
* The function call immediately returns after sending a request to remove service
* discovery request to the framework. The application is notified of a success or failure to
* add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param req is the service discovery request.
* @param listener for callbacks on success or failure. Can be null.
*/
public void removeServiceRequest(Channel c, WifiP2pServiceRequest req,
ActionListener listener) {
checkChannel(c);
checkServiceRequest(req);
c.mAsyncChannel.sendMessage(REMOVE_SERVICE_REQUEST, 0,
c.putListener(listener), req);
}
/**
* Clear all registered service discovery requests.
*
* The function call immediately returns after sending a request to clear all
* service discovery requests to the framework. The application is notified of a success
* or failure to add service through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callbacks on success or failure. Can be null.
*/
public void clearServiceRequests(Channel c, ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(CLEAR_SERVICE_REQUESTS,
0, c.putListener(listener));
}
/**
* Request the current list of peers.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when peer list is available. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void requestPeers(Channel c, PeerListListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REQUEST_PEERS, 0, c.putListener(listener));
}
/**
* Request device connection info.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when connection info is available. Can be null.
*/
public void requestConnectionInfo(Channel c, ConnectionInfoListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REQUEST_CONNECTION_INFO, 0, c.putListener(listener));
}
/**
* Request p2p group info.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when group info is available. Can be null.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void requestGroupInfo(Channel c, GroupInfoListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REQUEST_GROUP_INFO, 0, c.putListener(listener));
}
/**
* Set p2p device name.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when group info is available. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(anyOf = {
android.Manifest.permission.NETWORK_SETTINGS,
android.Manifest.permission.NETWORK_STACK,
android.Manifest.permission.OVERRIDE_WIFI_CONFIG
})
public void setDeviceName(@NonNull Channel c, @NonNull String devName,
@Nullable ActionListener listener) {
checkChannel(c);
WifiP2pDevice d = new WifiP2pDevice();
d.deviceName = devName;
c.mAsyncChannel.sendMessage(SET_DEVICE_NAME, 0, c.putListener(listener), d);
}
/**
* Set Wifi Display information.
*
* @param c is the channel created at {@link #initialize}
* @param wfdInfo the Wifi Display information to set
* @param listener for callbacks on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.CONFIGURE_WIFI_DISPLAY)
public void setWfdInfo(@NonNull Channel c, @NonNull WifiP2pWfdInfo wfdInfo,
@Nullable ActionListener listener) {
setWFDInfo(c, wfdInfo, listener);
}
/** @hide */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
@RequiresPermission(android.Manifest.permission.CONFIGURE_WIFI_DISPLAY)
public void setWFDInfo(@NonNull Channel c, @NonNull WifiP2pWfdInfo wfdInfo,
@Nullable ActionListener listener) {
checkChannel(c);
try {
mService.checkConfigureWifiDisplayPermission();
} catch (RemoteException e) {
e.rethrowFromSystemServer();
}
c.mAsyncChannel.sendMessage(SET_WFD_INFO, 0, c.putListener(listener), wfdInfo);
}
/**
* Delete a stored persistent group from the system settings.
*
* The function call immediately returns after sending a persistent group removal request
* to the framework. The application is notified of a success or failure to initiate
* group removal through listener callbacks {@link ActionListener#onSuccess} or
* {@link ActionListener#onFailure}.
*
* The persistent p2p group list stored in the system can be obtained by
* {@link #requestPersistentGroupInfo(Channel, PersistentGroupInfoListener)} and
* a network id can be obtained by {@link WifiP2pGroup#getNetworkId()}.
*
* @param c is the channel created at {@link #initialize}
* @param netId the network id of the p2p group.
* @param listener for callbacks on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(anyOf = {
android.Manifest.permission.NETWORK_SETTINGS,
android.Manifest.permission.NETWORK_STACK,
android.Manifest.permission.OVERRIDE_WIFI_CONFIG
})
public void deletePersistentGroup(@NonNull Channel c, int netId,
@Nullable ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(DELETE_PERSISTENT_GROUP, netId, c.putListener(listener));
}
/**
* Request a list of all the persistent p2p groups stored in system.
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when persistent group info list is available. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(anyOf = {
android.Manifest.permission.NETWORK_SETTINGS,
android.Manifest.permission.NETWORK_STACK,
android.Manifest.permission.READ_WIFI_CREDENTIAL
})
public void requestPersistentGroupInfo(@NonNull Channel c,
@Nullable PersistentGroupInfoListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REQUEST_PERSISTENT_GROUP_INFO, 0, c.putListener(listener));
}
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = {"MIRACAST_"}, value = {
MIRACAST_DISABLED,
MIRACAST_SOURCE,
MIRACAST_SINK})
public @interface MiracastMode {}
/**
* Miracast is disabled.
* @hide
*/
@SystemApi
public static final int MIRACAST_DISABLED = 0;
/**
* Device acts as a Miracast source.
* @hide
*/
@SystemApi
public static final int MIRACAST_SOURCE = 1;
/**
* Device acts as a Miracast sink.
* @hide
*/
@SystemApi
public static final int MIRACAST_SINK = 2;
/**
* This is used to provide information to drivers to optimize performance depending
* on the current mode of operation.
* {@link #MIRACAST_DISABLED} - disabled
* {@link #MIRACAST_SOURCE} - source operation
* {@link #MIRACAST_SINK} - sink operation
*
* As an example, the driver could reduce the channel dwell time during scanning
* when acting as a source or sink to minimize impact on Miracast.
*
* @param mode mode of operation. One of {@link #MIRACAST_DISABLED}, {@link #MIRACAST_SOURCE},
* or {@link #MIRACAST_SINK}
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.CONFIGURE_WIFI_DISPLAY)
public void setMiracastMode(@MiracastMode int mode) {
try {
mService.setMiracastMode(mode);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
private Messenger getMessenger(@NonNull Binder binder, @Nullable String packageName) {
try {
return mService.getMessenger(binder, packageName);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Get a reference to WifiP2pService handler. This is used to establish
* an AsyncChannel communication with WifiService
*
* @param binder A binder for the service to associate with this client.
*
* @return Messenger pointing to the WifiP2pService handler
* @hide
*/
public Messenger getMessenger(Binder binder) {
// No way to determine package name in this case.
return getMessenger(binder, null);
}
/**
* Get a reference to P2pStateMachine handler. This is used to establish
* a priveleged AsyncChannel communication with WifiP2pService.
*
* @return Messenger pointing to the WifiP2pService handler
* @hide
*/
public Messenger getP2pStateMachineMessenger() {
try {
return mService.getP2pStateMachineMessenger();
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Get a handover request message for use in WFA NFC Handover transfer.
* @hide
*/
public void getNfcHandoverRequest(Channel c, HandoverMessageListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(GET_HANDOVER_REQUEST, 0, c.putListener(listener));
}
/**
* Get a handover select message for use in WFA NFC Handover transfer.
* @hide
*/
public void getNfcHandoverSelect(Channel c, HandoverMessageListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(GET_HANDOVER_SELECT, 0, c.putListener(listener));
}
/**
* @hide
*/
public void initiatorReportNfcHandover(Channel c, String handoverSelect,
ActionListener listener) {
checkChannel(c);
Bundle bundle = new Bundle();
bundle.putString(EXTRA_HANDOVER_MESSAGE, handoverSelect);
c.mAsyncChannel.sendMessage(INITIATOR_REPORT_NFC_HANDOVER, 0,
c.putListener(listener), bundle);
}
/**
* @hide
*/
public void responderReportNfcHandover(Channel c, String handoverRequest,
ActionListener listener) {
checkChannel(c);
Bundle bundle = new Bundle();
bundle.putString(EXTRA_HANDOVER_MESSAGE, handoverRequest);
c.mAsyncChannel.sendMessage(RESPONDER_REPORT_NFC_HANDOVER, 0,
c.putListener(listener), bundle);
}
/**
* Removes all saved p2p groups.
*
* @param c is the channel created at {@link #initialize}.
* @param listener for callback on success or failure. Can be null.
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.NETWORK_SETTINGS)
public void factoryReset(@NonNull Channel c, @Nullable ActionListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(FACTORY_RESET, 0, c.putListener(listener));
}
/**
* Request saved WifiP2pConfig which used for an ongoing peer connection
*
* @param c is the channel created at {@link #initialize}
* @param listener for callback when ongoing peer config updated. Can't be null.
*
* @hide
*/
@RequiresPermission(android.Manifest.permission.NETWORK_STACK)
public void requestOngoingPeerConfig(@NonNull Channel c,
@NonNull OngoingPeerInfoListener listener) {
checkChannel(c);
c.mAsyncChannel.sendMessage(REQUEST_ONGOING_PEER_CONFIG,
Binder.getCallingUid(), c.putListener(listener));
}
/**
* Set saved WifiP2pConfig which used for an ongoing peer connection
*
* @param c is the channel created at {@link #initialize}
* @param config used for change an ongoing peer connection
* @param listener for callback when ongoing peer config updated. Can be null.
*
* @hide
*/
@RequiresPermission(android.Manifest.permission.NETWORK_STACK)
public void setOngoingPeerConfig(@NonNull Channel c, @NonNull WifiP2pConfig config,
@Nullable ActionListener listener) {
checkChannel(c);
checkP2pConfig(config);
c.mAsyncChannel.sendMessage(SET_ONGOING_PEER_CONFIG, 0,
c.putListener(listener), config);
}
/**
* Request p2p enabled state.
*
* This state indicates whether Wi-Fi p2p is enabled or disabled.
* The valid value is one of {@link #WIFI_P2P_STATE_DISABLED} or
* {@link #WIFI_P2P_STATE_ENABLED}. The state is returned using the
* {@link P2pStateListener} listener.
*
* This state is also included in the {@link #WIFI_P2P_STATE_CHANGED_ACTION}
* broadcast event with extra {@link #EXTRA_WIFI_STATE}.
*
* @param c is the channel created at {@link #initialize}.
* @param listener for callback when p2p state is available..
*/
public void requestP2pState(@NonNull Channel c,
@NonNull P2pStateListener listener) {
checkChannel(c);
if (listener == null) throw new IllegalArgumentException("This listener cannot be null.");
c.mAsyncChannel.sendMessage(REQUEST_P2P_STATE, 0, c.putListener(listener));
}
/**
* Request p2p discovery state.
*
* This state indicates whether p2p discovery has started or stopped.
* The valid value is one of {@link #WIFI_P2P_DISCOVERY_STARTED} or
* {@link #WIFI_P2P_DISCOVERY_STOPPED}. The state is returned using the
* {@link DiscoveryStateListener} listener.
*
* This state is also included in the {@link #WIFI_P2P_DISCOVERY_CHANGED_ACTION}
* broadcast event with extra {@link #EXTRA_DISCOVERY_STATE}.
*
* @param c is the channel created at {@link #initialize}.
* @param listener for callback when discovery state is available..
*/
public void requestDiscoveryState(@NonNull Channel c,
@NonNull DiscoveryStateListener listener) {
checkChannel(c);
if (listener == null) throw new IllegalArgumentException("This listener cannot be null.");
c.mAsyncChannel.sendMessage(REQUEST_DISCOVERY_STATE, 0, c.putListener(listener));
}
/**
* Request network info.
*
* This method provides the network info in the form of a {@link android.net.NetworkInfo}.
* {@link android.net.NetworkInfo#isAvailable()} indicates the p2p availability and
* {@link android.net.NetworkInfo#getDetailedState()} reports the current fine-grained state
* of the network. This {@link android.net.NetworkInfo} is returned using the
* {@link NetworkInfoListener} listener.
*
* This information is also included in the {@link #WIFI_P2P_CONNECTION_CHANGED_ACTION}
* broadcast event with extra {@link #EXTRA_NETWORK_INFO}.
*
* @param c is the channel created at {@link #initialize}.
* @param listener for callback when network info is available..
*/
public void requestNetworkInfo(@NonNull Channel c,
@NonNull NetworkInfoListener listener) {
checkChannel(c);
if (listener == null) throw new IllegalArgumentException("This listener cannot be null.");
c.mAsyncChannel.sendMessage(REQUEST_NETWORK_INFO, 0, c.putListener(listener));
}
/**
* Request Device Info
*
* This method provides the device info
* in the form of a {@link android.net.wifi.p2p.WifiP2pDevice}.
* Valid {@link android.net.wifi.p2p.WifiP2pDevice} is returned when p2p is enabled.
* To get information notifications on P2P getting enabled refers
* {@link #WIFI_P2P_STATE_ENABLED}.
*
* This {@link android.net.wifi.p2p.WifiP2pDevice} is returned using the
* {@link DeviceInfoListener} listener.
*
* {@link android.net.wifi.p2p.WifiP2pDevice#deviceAddress} is only available if the caller
* holds the {@code android.Manifest.permission#LOCAL_MAC_ADDRESS} permission, and holds the
* anonymized MAC address (02:00:00:00:00:00) otherwise.
*
* This information is also included in the {@link #WIFI_P2P_THIS_DEVICE_CHANGED_ACTION}
* broadcast event with extra {@link #EXTRA_WIFI_P2P_DEVICE}.
*
* @param c is the channel created at {@link #initialize(Context, Looper, ChannelListener)}.
* @param listener for callback when network info is available.
*/
@RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION)
public void requestDeviceInfo(@NonNull Channel c, @NonNull DeviceInfoListener listener) {
checkChannel(c);
if (listener == null) throw new IllegalArgumentException("This listener cannot be null.");
c.mAsyncChannel.sendMessage(REQUEST_DEVICE_INFO, 0, c.putListener(listener));
}
}
* e.g) "MyPrinter._ipp._tcp.local.".
* @param txtRecordMap TXT record data as a map of key/value pairs
* @param srcDevice source device.
*/
public void onDnsSdTxtRecordAvailable(String fullDomainName,
Map
* e.g) uuid:6859dede-8574-59ab-9332-123456789012::urn:schemas-upnp-org:device:
* MediaServer:1
* @param srcDevice source device.
*/
public void onUpnpServiceAvailable(List
* or its subclass calls {@link WifiP2pUpnpServiceInfo#newInstance} or
* {@link WifiP2pDnsSdServiceInfo#newInstance} for a Upnp or Bonjour service
* respectively
*
*