WifiP2pManager
open class WifiP2pManager
kotlin.Any | |
↳ | android.net.wifi.p2p.WifiP2pManager |
This class provides the API for managing Wi-Fi peer-to-peer connectivity. This lets an application discover available peers, setup connection to peers and query for the list of peers. When a p2p connection is formed over wifi, the device continues to maintain the uplink connection over mobile or any other available network for internet connectivity on the device.
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 initialize
before doing any p2p operation.
Most application calls need a ActionListener
instance for receiving callbacks ActionListener#onSuccess
or 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 ERROR
, P2P_UNSUPPORTED
or BUSY
.
An application can initiate discovery of peers with 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 stopPeerDiscovery
. Applications can listen to WIFI_P2P_DISCOVERY_CHANGED_ACTION
to know if a peer-to-peer discovery is running or stopped. Additionally, 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 requestPeers
. When the peer list is available PeerListListener#onPeersAvailable
is called with the device list.
An application can initiate a connection request to a peer through connect
. See 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 #createGroup which creates an access point whose details can be fetched with requestGroupInfo
.
After a successful group formation through #createGroup or through connect
, use requestConnectionInfo
to fetch the connection details. The connection info WifiP2pInfo
contains the address of the group owner WifiP2pInfo#groupOwnerAddress
and a flag 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, WifiP2pInfo#groupOwnerAddress
is anonymized unless the caller holds the android.Manifest.permission#LOCAL_MAC_ADDRESS
permission.
With peer discovery using 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 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 removeLocalService
removes a local service and 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 discoverServices
. Prior to initiating the discovery, application can add service discovery request with a call to addServiceRequest
, remove a service discovery request with a call to removeServiceRequest
or clear all requests with a call to 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 setDnsSdResponseListeners
for Bonjour or setUpnpServiceResponseListener
for Upnp.
Note: Registering an application handler with initialize
requires the permissions android.Manifest.permission#ACCESS_WIFI_STATE
and 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}
Summary
Nested classes | |
---|---|
abstract |
Interface for callback invocation on an application action |
open |
A channel that connects the application to the Wifi p2p framework. |
abstract |
Interface for callback invocation when framework channel is lost |
abstract |
Interface for callback invocation when connection info is available |
abstract |
Interface for callback invocation when |
abstract |
Interface for callback invocation when p2p state is available in response to |
abstract |
Interface for callback invocation when Bonjour service discovery response is received |
abstract |
Interface for callback invocation when Bonjour TXT record is available for a service |
abstract |
Interface for callback invocation when an incoming request is received. |
abstract |
Interface for callback invocation when group info is available |
abstract |
Interface for callback invocation when |
abstract |
Interface for callback invocation when p2p state is available in response to |
abstract |
Interface for callback invocation when peer list is available |
abstract |
Interface for callback invocation when service discovery response other than Upnp or Bonjour is received |
abstract |
Interface for callback invocation when upnp service discovery response is received |
abstract |
Interface used to listen to Wi-Fi p2p various changes such as device state change, discovery started/stopped, connection change, etc. |
Constants | |
---|---|
static String |
Broadcast intent action indicating that peer listen has either started or stopped. |
static String |
Broadcast intent action indicating whether or not current connecting request is accepted. |
static Int |
Passed with |
static Int |
Accept the incoming request. |
static Int |
Defer the PIN display to the Wi-Fi service (which will display a dialog to the user). |
static Int |
Defer the decision back to the Wi-Fi service (which will display a dialog to the user). |
static Int |
Reject the incoming request. |
static Int |
Passed with |
static String |
The lookup key for an int that indicates whether p2p discovery has started or stopped. |
static String |
The lookup key for an int that indicates whether p2p listen has started or stopped. |
static String |
The lookup key for a |
static String |
The lookup key for a |
static String |
The lookup key for the |
static String |
The lookup key for the result of a request, true if accepted, false otherwise. |
static String |
The lookup key for a |
static String |
The lookup key for a |
static String |
The lookup key for a |
static String |
The lookup key for an int that indicates whether Wi-Fi p2p is enabled or disabled. |
static Int |
P2p group creation failed because the connection has been cancelled. |
static Int |
P2p group creation failed because the group has been removed. |
static Int |
P2p group creation failed because invitation has failed. |
static Int |
P2p group creation failed because provision discovery has failed. |
static Int |
P2p group creation failed because it has timed out. |
static Int |
P2p group creation failed because user has rejected. |
static Int |
Passed with |
static Int |
Passed with |
static String |
Broadcast intent action indicating that the state of Wi-Fi p2p connectivity has changed. |
static String |
Broadcast intent action indicating that peer discovery has either started or stopped. |
static Int |
p2p discovery has started |
static Int |
p2p discovery has stopped |
static Int |
p2p listen has started |
static Int |
p2p listen has stopped |
static String |
Broadcast intent action indicating that the available peer list has changed. |
static Int |
Run P2P scan on all channels. |
static Int |
Run P2P scan only on a specific channel. |
static Int |
Run P2P scan only on social channels. |
static String |
Broadcast intent action to indicate whether Wi-Fi p2p is enabled or disabled. |
static Int |
Wi-Fi p2p is disabled. |
static Int |
Wi-Fi p2p is enabled. |
static String |
Broadcast intent action indicating that this device details have changed. |
Public methods | |
---|---|
open Unit |
addExternalApprover(c: WifiP2pManager.Channel, deviceAddress: MacAddress, listener: WifiP2pManager.ExternalApproverRequestListener) Set the external approver for a specific peer. |
open Unit |
addLocalService(channel: WifiP2pManager.Channel!, servInfo: WifiP2pServiceInfo!, listener: WifiP2pManager.ActionListener!) Register a local service for service discovery. |
open Unit |
addServiceRequest(channel: WifiP2pManager.Channel!, req: WifiP2pServiceRequest!, listener: WifiP2pManager.ActionListener!) Add a service discovery request. |
open Unit |
cancelConnect(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Cancel any ongoing p2p group negotiation |
open Unit |
clearLocalServices(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Clear all registered local services of service discovery. |
open Unit |
clearServiceRequests(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Clear all registered service discovery requests. |
open Unit |
connect(channel: WifiP2pManager.Channel!, config: WifiP2pConfig!, listener: WifiP2pManager.ActionListener!) Start a p2p connection to a device with the specified configuration. |
open Unit |
createGroup(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Create a p2p group with the current device as the group owner. |
open Unit |
createGroup(channel: WifiP2pManager.Channel, config: WifiP2pConfig?, listener: WifiP2pManager.ActionListener?) Create a p2p group with the current device as the group owner. |
open Unit |
discoverPeers(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Initiate peer discovery. |
open Unit |
discoverPeersOnSocialChannels(channel: WifiP2pManager.Channel, listener: WifiP2pManager.ActionListener?) Scan only the social channels. |
open Unit |
discoverPeersOnSpecificFrequency(channel: WifiP2pManager.Channel, frequencyMhz: Int, listener: WifiP2pManager.ActionListener?) Scan only a single channel specified by frequency. |
open Unit |
discoverServices(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Initiate service discovery. |
open Unit |
getListenState(c: WifiP2pManager.Channel, executor: Executor, resultsCallback: Consumer<Int!>) Get p2p listen state. |
open static Int |
Return the maximum total length (in bytes) of all Vendor specific information elements (VSIEs) which can be set using the |
open WifiP2pManager.Channel! |
initialize(srcContext: Context!, srcLooper: Looper!, listener: WifiP2pManager.ChannelListener!) Registers the application with the Wi-Fi framework. |
open Boolean |
Check if this device supports discovery limited to a specific frequency or the social channels. |
open Boolean |
Check if this device supports removing clients from a group. |
open Boolean |
Checks whether this device, while being a group client, can discover and deliver the group owner's IPv6 link-local address. |
open Boolean |
Check if this device supports setting vendor elements. |
open Unit |
registerWifiP2pListener(executor: Executor, listener: WifiP2pManager.WifiP2pListener) Add a listener to listen to Wi-Fi p2p various changes. |
open Unit |
removeClient(channel: WifiP2pManager.Channel, peerAddress: MacAddress, listener: WifiP2pManager.ActionListener?) Remove the client with the MAC address from the group. |
open Unit |
removeExternalApprover(c: WifiP2pManager.Channel, deviceAddress: MacAddress, listener: WifiP2pManager.ActionListener?) Remove the external approver for a specific peer. |
open Unit |
removeGroup(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Remove the current p2p group. |
open Unit |
removeLocalService(channel: WifiP2pManager.Channel!, servInfo: WifiP2pServiceInfo!, listener: WifiP2pManager.ActionListener!) Remove a registered local service added with |
open Unit |
removeServiceRequest(channel: WifiP2pManager.Channel!, req: WifiP2pServiceRequest!, listener: WifiP2pManager.ActionListener!) Remove a specified service discovery request added with |
open Unit |
requestConnectionInfo(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ConnectionInfoListener!) Request device connection info. |
open Unit |
Request Device Info |
open Unit |
Request p2p discovery state. |
open Unit |
requestGroupInfo(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.GroupInfoListener!) Request p2p group info. |
open Unit |
Request network info. |
open Unit |
requestP2pState(c: WifiP2pManager.Channel, listener: WifiP2pManager.P2pStateListener) Request p2p enabled state. |
open Unit |
requestPeers(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.PeerListListener!) Request the current list of peers. |
open Unit |
setConnectionRequestResult(c: WifiP2pManager.Channel, deviceAddress: MacAddress, result: Int, listener: WifiP2pManager.ActionListener?) Set the result for the incoming request from a specific peer. |
open Unit |
setConnectionRequestResult(c: WifiP2pManager.Channel, deviceAddress: MacAddress, result: Int, pin: String?, listener: WifiP2pManager.ActionListener?) Set the result with PIN for the incoming request from a specific peer. |
open Unit |
setDnsSdResponseListeners(channel: WifiP2pManager.Channel!, servListener: WifiP2pManager.DnsSdServiceResponseListener!, txtListener: WifiP2pManager.DnsSdTxtRecordListener!) Register a callback to be invoked on receiving Bonjour service discovery response. |
open Unit |
setServiceResponseListener(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ServiceResponseListener!) Register a callback to be invoked on receiving service discovery response. |
open Unit |
setUpnpServiceResponseListener(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.UpnpServiceResponseListener!) Register a callback to be invoked on receiving upnp service discovery response. |
open Unit |
setVendorElements(c: WifiP2pManager.Channel, vendorElements: MutableList<ScanResult.InformationElement!>, listener: WifiP2pManager.ActionListener?) Set/Clear vendor specific information elements (VSIEs) to be published during Wi-Fi Direct (P2P) discovery. |
open Unit |
setWfdInfo(channel: WifiP2pManager.Channel, wfdInfo: WifiP2pWfdInfo, listener: WifiP2pManager.ActionListener?) Set Wifi Display information. |
open Unit |
startListening(channel: WifiP2pManager.Channel, listener: WifiP2pManager.ActionListener?) Force p2p to enter listen state. |
open Unit |
startPeerDiscovery(channel: WifiP2pManager.Channel, config: WifiP2pDiscoveryConfig, listener: WifiP2pManager.ActionListener?) Initiate peer discovery. |
open Unit |
stopListening(channel: WifiP2pManager.Channel, listener: WifiP2pManager.ActionListener?) Force p2p to exit listen state. |
open Unit |
stopPeerDiscovery(channel: WifiP2pManager.Channel!, listener: WifiP2pManager.ActionListener!) Stop an ongoing peer discovery |
open Unit |
Remove a listener added using |
Constants
ACTION_WIFI_P2P_LISTEN_STATE_CHANGED
static val ACTION_WIFI_P2P_LISTEN_STATE_CHANGED: String
Broadcast intent action indicating that peer listen has either started or stopped. One extra EXTRA_LISTEN_STATE
indicates whether listen has started or stopped.
Value: "android.net.wifi.p2p.action.WIFI_P2P_LISTEN_STATE_CHANGED"
ACTION_WIFI_P2P_REQUEST_RESPONSE_CHANGED
static val ACTION_WIFI_P2P_REQUEST_RESPONSE_CHANGED: String
Broadcast intent action indicating whether or not current connecting request is accepted. The connecting request is initiated by connect(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pConfig,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
The EXTRA_REQUEST_RESPONSE
extra indicates whether or not current request is accepted or rejected.
The EXTRA_REQUEST_CONFIG
extra indicates the responsed configuration.
Value: "android.net.wifi.p2p.action.WIFI_P2P_REQUEST_RESPONSE_CHANGED"
BUSY
static val BUSY: Int
Passed with ActionListener#onFailure
. Indicates that the operation failed because the framework is busy and unable to service the request
Value: 2
CONNECTION_REQUEST_ACCEPT
static val CONNECTION_REQUEST_ACCEPT: Int
Accept the incoming request. Used in setConnectionRequestResult(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Value: 0
CONNECTION_REQUEST_DEFER_SHOW_PIN_TO_SERVICE
static val CONNECTION_REQUEST_DEFER_SHOW_PIN_TO_SERVICE: Int
Defer the PIN display to the Wi-Fi service (which will display a dialog to the user). Used in setConnectionRequestResult(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Value: 3
CONNECTION_REQUEST_DEFER_TO_SERVICE
static val CONNECTION_REQUEST_DEFER_TO_SERVICE: Int
Defer the decision back to the Wi-Fi service (which will display a dialog to the user). Used in setConnectionRequestResult(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Value: 2
CONNECTION_REQUEST_REJECT
static val CONNECTION_REQUEST_REJECT: Int
Reject the incoming request. Used in setConnectionRequestResult(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Value: 1
ERROR
static val ERROR: Int
Passed with ActionListener#onFailure
. Indicates that the operation failed due to an internal error.
Value: 0
EXTRA_DISCOVERY_STATE
static val EXTRA_DISCOVERY_STATE: String
The lookup key for an int that indicates whether p2p discovery has started or stopped. Retrieve it with android.content.Intent#getIntExtra(String,int)
.
Value: "discoveryState"
EXTRA_LISTEN_STATE
static val EXTRA_LISTEN_STATE: String
The lookup key for an int that indicates whether p2p listen has started or stopped. Retrieve it with android.content.Intent#getIntExtra(String,int)
.
Value: "android.net.wifi.p2p.extra.LISTEN_STATE"
EXTRA_NETWORK_INFO
static val EXTRA_NETWORK_INFO: String
The lookup key for a android.net.NetworkInfo
object associated with the p2p network. Retrieve with android.content.Intent#getParcelableExtra(String)
.
Value: "networkInfo"
EXTRA_P2P_DEVICE_LIST
static val EXTRA_P2P_DEVICE_LIST: String
The lookup key for a android.net.wifi.p2p.WifiP2pDeviceList
object representing the new peer list when WIFI_P2P_PEERS_CHANGED_ACTION
broadcast is sent.
Retrieve with android.content.Intent#getParcelableExtra(String)
.
Value: "wifiP2pDeviceList"
EXTRA_REQUEST_CONFIG
static val EXTRA_REQUEST_CONFIG: String
The lookup key for the WifiP2pConfig
object of a request.
Value: "android.net.wifi.p2p.extra.REQUEST_CONFIG"
EXTRA_REQUEST_RESPONSE
static val EXTRA_REQUEST_RESPONSE: String
The lookup key for the result of a request, true if accepted, false otherwise.
Value: "android.net.wifi.p2p.extra.REQUEST_RESPONSE"
EXTRA_WIFI_P2P_DEVICE
static val EXTRA_WIFI_P2P_DEVICE: String
The lookup key for a android.net.wifi.p2p.WifiP2pDevice
object Retrieve with android.content.Intent#getParcelableExtra(String)
.
Value: "wifiP2pDevice"
EXTRA_WIFI_P2P_GROUP
static val EXTRA_WIFI_P2P_GROUP: String
The lookup key for a android.net.wifi.p2p.WifiP2pGroup
object associated with the p2p network. Retrieve with android.content.Intent#getParcelableExtra(String)
.
Value: "p2pGroupInfo"
EXTRA_WIFI_P2P_INFO
static val EXTRA_WIFI_P2P_INFO: String
The lookup key for a android.net.wifi.p2p.WifiP2pInfo
object Retrieve with android.content.Intent#getParcelableExtra(String)
.
Value: "wifiP2pInfo"
EXTRA_WIFI_STATE
static val EXTRA_WIFI_STATE: String
The lookup key for an int that indicates whether Wi-Fi p2p is enabled or disabled. Retrieve it with android.content.Intent#getIntExtra(String,int)
.
Value: "wifi_p2p_state"
GROUP_CREATION_FAILURE_REASON_CONNECTION_CANCELLED
static val GROUP_CREATION_FAILURE_REASON_CONNECTION_CANCELLED: Int
P2p group creation failed because the connection has been cancelled. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 0
GROUP_CREATION_FAILURE_REASON_GROUP_REMOVED
static val GROUP_CREATION_FAILURE_REASON_GROUP_REMOVED: Int
P2p group creation failed because the group has been removed. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 4
GROUP_CREATION_FAILURE_REASON_INVITATION_FAILED
static val GROUP_CREATION_FAILURE_REASON_INVITATION_FAILED: Int
P2p group creation failed because invitation has failed. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 5
GROUP_CREATION_FAILURE_REASON_PROVISION_DISCOVERY_FAILED
static val GROUP_CREATION_FAILURE_REASON_PROVISION_DISCOVERY_FAILED: Int
P2p group creation failed because provision discovery has failed. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 3
GROUP_CREATION_FAILURE_REASON_TIMED_OUT
static val GROUP_CREATION_FAILURE_REASON_TIMED_OUT: Int
P2p group creation failed because it has timed out. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 1
GROUP_CREATION_FAILURE_REASON_USER_REJECTED
static val GROUP_CREATION_FAILURE_REASON_USER_REJECTED: Int
P2p group creation failed because user has rejected. Used in WifiP2pListener#onGroupCreationFailed(int reason)
.
Value: 2
NO_SERVICE_REQUESTS
static val NO_SERVICE_REQUESTS: Int
Passed with ActionListener#onFailure
. Indicates that the discoverServices
failed because no service requests are added. Use addServiceRequest
to add a service request.
Value: 3
P2P_UNSUPPORTED
static val P2P_UNSUPPORTED: Int
Passed with ActionListener#onFailure
. Indicates that the operation failed because p2p is unsupported on the device.
Value: 1
WIFI_P2P_CONNECTION_CHANGED_ACTION
static val WIFI_P2P_CONNECTION_CHANGED_ACTION: String
Broadcast intent action indicating that the state of Wi-Fi p2p connectivity has changed. One extra EXTRA_WIFI_P2P_INFO
provides the p2p connection info in the form of a WifiP2pInfo
object. Another extra EXTRA_NETWORK_INFO
provides the network info in the form of a android.net.NetworkInfo
. A third extra provides the details of the group and may contain a null
. All of these permissions are required to receive this broadcast: android.Manifest.permission#ACCESS_WIFI_STATE
and either android.Manifest.permission#ACCESS_FINE_LOCATION
or android.Manifest.permission#NEARBY_WIFI_DEVICES
Value: "android.net.wifi.p2p.CONNECTION_STATE_CHANGE"
WIFI_P2P_DISCOVERY_CHANGED_ACTION
static val WIFI_P2P_DISCOVERY_CHANGED_ACTION: String
Broadcast intent action indicating that peer discovery has either started or stopped. One extra 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.
Value: "android.net.wifi.p2p.DISCOVERY_STATE_CHANGE"
WIFI_P2P_DISCOVERY_STARTED
static val WIFI_P2P_DISCOVERY_STARTED: Int
p2p discovery has started
Value: 2
See Also
WIFI_P2P_DISCOVERY_STOPPED
static val WIFI_P2P_DISCOVERY_STOPPED: Int
p2p discovery has stopped
Value: 1
See Also
WIFI_P2P_LISTEN_STARTED
static val WIFI_P2P_LISTEN_STARTED: Int
p2p listen has started
Value: 2
WIFI_P2P_LISTEN_STOPPED
static val WIFI_P2P_LISTEN_STOPPED: Int
p2p listen has stopped
Value: 1
WIFI_P2P_PEERS_CHANGED_ACTION
static val WIFI_P2P_PEERS_CHANGED_ACTION: String
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: android.Manifest.permission#ACCESS_WIFI_STATE
and either android.Manifest.permission#ACCESS_FINE_LOCATION
or android.Manifest.permission#NEARBY_WIFI_DEVICES
An extra EXTRA_P2P_DEVICE_LIST
provides the full list of current peers. The full list of peers can also be obtained any time with requestPeers
.
Value: "android.net.wifi.p2p.PEERS_CHANGED"
See Also
WIFI_P2P_SCAN_FULL
static val WIFI_P2P_SCAN_FULL: Int
Run P2P scan on all channels.
Value: 0
WIFI_P2P_SCAN_SINGLE_FREQ
static val WIFI_P2P_SCAN_SINGLE_FREQ: Int
Run P2P scan only on a specific channel.
Value: 2
WIFI_P2P_SCAN_SOCIAL
static val WIFI_P2P_SCAN_SOCIAL: Int
Run P2P scan only on social channels.
Value: 1
WIFI_P2P_STATE_CHANGED_ACTION
static val WIFI_P2P_STATE_CHANGED_ACTION: String
Broadcast intent action to indicate whether Wi-Fi p2p is enabled or disabled. An extra EXTRA_WIFI_STATE
provides the state information as int.
Value: "android.net.wifi.p2p.STATE_CHANGED"
See Also
WIFI_P2P_STATE_DISABLED
static val WIFI_P2P_STATE_DISABLED: Int
Wi-Fi p2p is disabled.
Value: 1
See Also
WIFI_P2P_STATE_ENABLED
static val WIFI_P2P_STATE_ENABLED: Int
Wi-Fi p2p is enabled.
Value: 2
See Also
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
static val WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: String
Broadcast intent action indicating that this device details have changed.
An extra EXTRA_WIFI_P2P_DEVICE
provides this device details. The valid device details can also be obtained with requestDeviceInfo(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.DeviceInfoListener)
when p2p is enabled. To get information notifications on P2P getting enabled refers WIFI_P2P_STATE_ENABLED
.
The EXTRA_WIFI_P2P_DEVICE
extra contains an anonymized version of the device's MAC address. Callers holding the android.Manifest.permission#LOCAL_MAC_ADDRESS
permission can use requestDeviceInfo
to obtain the actual MAC address of this device. All of these permissions are required to receive this broadcast: android.Manifest.permission#ACCESS_WIFI_STATE
and either android.Manifest.permission#ACCESS_FINE_LOCATION
or android.Manifest.permission#NEARBY_WIFI_DEVICES
Value: "android.net.wifi.p2p.THIS_DEVICE_CHANGED"
See Also
Public methods
addExternalApprover
open fun addExternalApprover(
c: WifiP2pManager.Channel,
deviceAddress: MacAddress,
listener: WifiP2pManager.ExternalApproverRequestListener
): Unit
Set the external approver for a specific peer. This API associates a specific peer with an approver. When an incoming request is received from a peer, an authorization request is routed to the attached approver. The approver then calls setConnectionRequestResult(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
to send the result to the WiFi service. A specific peer (identified by its MacAddress
) can only be attached to a single approver. The previous approver will be detached once a new approver is attached. The approver will also be detached automatically when the channel is closed.
When an approver is attached, ExternalApproverRequestListener#onAttached(MacAddress)
is called. When an approver is detached, ExternalApproverRequestListener#onDetached(MacAddress, int)
is called. When an incoming request is received, ExternalApproverRequestListener#onConnectionRequested(int, WifiP2pConfig, WifiP2pDevice)
is called. When a WPS PIN is generated, ExternalApproverRequestListener#onPinGenerated(MacAddress, String)
is called.
The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Requires android.Manifest.permission#MANAGE_WIFI_NETWORK_SELECTION
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
deviceAddress |
MacAddress: the peer which is bound to the external approver. This value cannot be null . |
listener |
WifiP2pManager.ExternalApproverRequestListener: for callback when the framework needs to notify the external approver. This value cannot be null . |
addLocalService
open fun addLocalService(
channel: WifiP2pManager.Channel!,
servInfo: WifiP2pServiceInfo!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
The service information is set through WifiP2pServiceInfo
.
or its subclass calls WifiP2pUpnpServiceInfo#newInstance
or WifiP2pDnsSdServiceInfo#newInstance
for a Upnp or Bonjour service respectively
The service information can be cleared with calls to removeLocalService
or clearLocalServices
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
servInfo |
WifiP2pServiceInfo!: is a local service information. |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
addServiceRequest
open fun addServiceRequest(
channel: WifiP2pManager.Channel!,
req: WifiP2pServiceRequest!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
After service discovery request is added, you can initiate service discovery by discoverServices
.
The added service requests can be cleared with calls to removeServiceRequest(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.nsd.WifiP2pServiceRequest,android.net.wifi.p2p.WifiP2pManager.ActionListener)
or clearServiceRequests(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
req |
WifiP2pServiceRequest!: is the service discovery request. |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
cancelConnect
open fun cancelConnect(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
clearLocalServices
open fun clearLocalServices(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
clearServiceRequests
open fun clearServiceRequests(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
connect
open fun connect(
channel: WifiP2pManager.Channel!,
config: WifiP2pConfig!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
An app should use WifiP2pConfig.Builder
to build the configuration for this API, ex. call WifiP2pConfig.Builder#setDeviceAddress(MacAddress)
to set the peer MAC address and WifiP2pConfig.Builder#enablePersistentMode(boolean)
to configure the persistent mode.
Register for 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 #createGroup, an invitation to join the group is sent to the peer device.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
config |
WifiP2pConfig!: options as described in WifiP2pConfig class |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
createGroup
open fun createGroup(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
Application can request for the group details with requestGroupInfo
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
createGroup
open fun createGroup(
channel: WifiP2pManager.Channel,
config: WifiP2pConfig?,
listener: WifiP2pManager.ActionListener?
): Unit
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 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 ActionListener#onSuccess
or ActionListener#onFailure
.
Application can request for the group details with requestGroupInfo
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize . This value cannot be null . |
config |
WifiP2pConfig?: the configuration of a p2p group. This value may be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. Can be null. |
discoverPeers
open fun discoverPeers(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
Initiate peer discovery. A discovery process involves scanning for available Wi-Fi peers for the purpose of establishing a connection.
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 ActionListener#onSuccess
or ActionListener#onFailure
.
The discovery remains active until a connection is initiated or a p2p group is formed. Register for WIFI_P2P_PEERS_CHANGED_ACTION
intent to determine when the framework notifies of a change as peers are discovered.
Upon receiving a WIFI_P2P_PEERS_CHANGED_ACTION
intent, an application can request the list of peers using requestPeers
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
discoverPeersOnSocialChannels
open fun discoverPeersOnSocialChannels(
channel: WifiP2pManager.Channel,
listener: WifiP2pManager.ActionListener?
): Unit
Scan only the social channels. A discovery process involves scanning for available Wi-Fi peers for the purpose of establishing a connection.
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 ActionListener#onSuccess
or ActionListener#onFailure
.
The discovery remains active until a connection is initiated or a p2p group is formed. Register for WIFI_P2P_PEERS_CHANGED_ACTION
intent to determine when the framework notifies of a change as peers are discovered.
Upon receiving a WIFI_P2P_PEERS_CHANGED_ACTION
intent, an application can request the list of peers using requestPeers
.
The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Use isChannelConstrainedDiscoverySupported()
to determine whether the device supports this feature. If isChannelConstrainedDiscoverySupported()
return false
then this method will throw UnsupportedOperationException
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. This value may be null . |
discoverPeersOnSpecificFrequency
open fun discoverPeersOnSpecificFrequency(
channel: WifiP2pManager.Channel,
frequencyMhz: Int,
listener: WifiP2pManager.ActionListener?
): Unit
Scan only a single channel specified by frequency. A discovery process involves scanning for available Wi-Fi peers for the purpose of establishing a connection.
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 ActionListener#onSuccess
or ActionListener#onFailure
.
The discovery remains active until a connection is initiated or a p2p group is formed. Register for WIFI_P2P_PEERS_CHANGED_ACTION
intent to determine when the framework notifies of a change as peers are discovered.
Upon receiving a WIFI_P2P_PEERS_CHANGED_ACTION
intent, an application can request the list of peers using requestPeers
.
The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Use isChannelConstrainedDiscoverySupported()
to determine whether the device supports this feature. If isChannelConstrainedDiscoverySupported()
return false
then this method will throw UnsupportedOperationException
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize This value cannot be null . |
frequencyMhz |
Int: is the frequency of the channel to use for peer discovery. |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. This value may be null . |
discoverServices
open fun discoverServices(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
The services to be discovered are specified with calls to addServiceRequest
.
The application is notified of the response against the service discovery request through listener callbacks registered by setServiceResponseListener
or setDnsSdResponseListeners
, or setUpnpServiceResponseListener
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
getListenState
open fun getListenState(
c: WifiP2pManager.Channel,
executor: Executor,
resultsCallback: Consumer<Int!>
): Unit
Get p2p listen state.
This state indicates whether p2p listen has started or stopped. The valid value is one of WIFI_P2P_LISTEN_STOPPED
or WIFI_P2P_LISTEN_STARTED
.
This state is also included in the ACTION_WIFI_P2P_LISTEN_STATE_CHANGED
broadcast event with extra EXTRA_LISTEN_STATE
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
c |
WifiP2pManager.Channel: It is the channel created at initialize . This value cannot be null . |
executor |
Executor: The executor on which callback will be invoked. This value cannot be null . Callback and listener events are dispatched through this Executor , providing an easy way to control which thread is used. To dispatch events through the main thread of your application, you can use Context.getMainExecutor() . Otherwise, provide an Executor that dispatches to an appropriate thread. |
resultsCallback |
Consumer<Int!>: A callback that will return listen state WIFI_P2P_LISTEN_STOPPED or WIFI_P2P_LISTEN_STARTED This value cannot be null . |
getP2pMaxAllowedVendorElementsLengthBytes
open static fun getP2pMaxAllowedVendorElementsLengthBytes(): Int
Return the maximum total length (in bytes) of all Vendor specific information elements (VSIEs) which can be set using the setVendorElements(android.net.wifi.p2p.WifiP2pManager.Channel,java.util.List,android.net.wifi.p2p.WifiP2pManager.ActionListener)
. The length is calculated adding the payload length + 2 bytes for each VSIE (2 bytes: 1 byte for type and 1 byte for length).
initialize
open fun initialize(
srcContext: Context!,
srcLooper: Looper!,
listener: WifiP2pManager.ChannelListener!
): WifiP2pManager.Channel!
Registers the application with the Wi-Fi framework. This function must be the first to be called before any p2p operations are performed.
Parameters | |
---|---|
srcContext |
Context!: is the context of the source |
srcLooper |
Looper!: is the Looper on which the callbacks are receivied |
listener |
WifiP2pManager.ChannelListener!: for callback at loss of framework communication. Can be null. |
Return | |
---|---|
WifiP2pManager.Channel! |
Channel instance that is necessary for performing any further p2p operations |
isChannelConstrainedDiscoverySupported
open fun isChannelConstrainedDiscoverySupported(): Boolean
Check if this device supports discovery limited to a specific frequency or the social channels. Gates whether discoverPeersOnSpecificFrequency(android.net.wifi.p2p.WifiP2pManager.Channel,int,android.net.wifi.p2p.WifiP2pManager.ActionListener)
and discoverPeersOnSocialChannels(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
methods are functional on this device.
Return | |
---|---|
Boolean |
true if supported, false otherwise. |
isGroupClientRemovalSupported
open fun isGroupClientRemovalSupported(): Boolean
Check if this device supports removing clients from a group. Gates whether the removeClient(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.MacAddress,android.net.wifi.p2p.WifiP2pManager.ActionListener)
method is functional on this device.
Return | |
---|---|
Boolean |
true if supported, false otherwise. |
isGroupOwnerIPv6LinkLocalAddressProvided
open fun isGroupOwnerIPv6LinkLocalAddressProvided(): Boolean
Checks whether this device, while being a group client, can discover and deliver the group owner's IPv6 link-local address.
If this method returns true
and connect(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pConfig,android.net.wifi.p2p.WifiP2pManager.ActionListener)
method is called with WifiP2pConfig
having WifiP2pConfig#GROUP_CLIENT_IP_PROVISIONING_MODE_IPV6_LINK_LOCAL
as the group client IP provisioning mode, then the group owner's IPv6 link-local address will be delivered in the group client via WIFI_P2P_CONNECTION_CHANGED_ACTION
broadcast intent (i.e, group owner address in EXTRA_WIFI_P2P_INFO
). If this method returns false
, then IPv6 link-local addresses can still be used, but it is the responsibility of the caller to discover that address in other ways, e.g. using out-of-band communication.
Return | |
---|---|
Boolean |
true if supported, false otherwise. |
isSetVendorElementsSupported
open fun isSetVendorElementsSupported(): Boolean
Check if this device supports setting vendor elements. Gates whether the setVendorElements(android.net.wifi.p2p.WifiP2pManager.Channel,java.util.List,android.net.wifi.p2p.WifiP2pManager.ActionListener)
method is functional on this device.
Return | |
---|---|
Boolean |
true if supported, false otherwise. |
registerWifiP2pListener
open fun registerWifiP2pListener(
executor: Executor,
listener: WifiP2pManager.WifiP2pListener
): Unit
Add a listener to listen to Wi-Fi p2p various changes.
Parameters | |
---|---|
executor |
Executor: the Executor on which to execute the callbacks. This value cannot be null . Callback and listener events are dispatched through this Executor , providing an easy way to control which thread is used. To dispatch events through the main thread of your application, you can use Context.getMainExecutor() . Otherwise, provide an Executor that dispatches to an appropriate thread. |
listener |
WifiP2pManager.WifiP2pListener: listener for the Wi-Fi p2p connection changes. This value cannot be null . |
Exceptions | |
---|---|
java.lang.SecurityException |
if the caller is missing required permissions. |
java.lang.IllegalArgumentException |
if incorrect input arguments are provided. |
removeClient
open fun removeClient(
channel: WifiP2pManager.Channel,
peerAddress: MacAddress,
listener: WifiP2pManager.ActionListener?
): Unit
Remove the client with the MAC address from the group.
The function call immediately returns after sending a client removal request to the framework. The application is notified of a success or failure to initiate client removal through listener callbacks ActionListener#onSuccess
or ActionListener#onFailure
.
The callbacks are triggered on the thread specified when initializing the channel
, see initialize
.
Use isGroupClientRemovalSupported()
to determine whether the device supports this feature. If isGroupClientRemovalSupported()
return false
then this method will throw UnsupportedOperationException
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize This value cannot be null . |
peerAddress |
MacAddress: MAC address of the client. This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. Can be null. |
removeExternalApprover
open fun removeExternalApprover(
c: WifiP2pManager.Channel,
deviceAddress: MacAddress,
listener: WifiP2pManager.ActionListener?
): Unit
Remove the external approver for a specific peer. The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Requires android.Manifest.permission#MANAGE_WIFI_NETWORK_SELECTION
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
deviceAddress |
MacAddress: the peer which is bound to the external approver. This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callback on success or failure. This value may be null . |
removeGroup
open fun removeGroup(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
removeLocalService
open fun removeLocalService(
channel: WifiP2pManager.Channel!,
servInfo: WifiP2pServiceInfo!,
listener: WifiP2pManager.ActionListener!
): Unit
Remove a registered local service added with 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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
servInfo |
WifiP2pServiceInfo!: is the local service information. |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
removeServiceRequest
open fun removeServiceRequest(
channel: WifiP2pManager.Channel!,
req: WifiP2pServiceRequest!,
listener: WifiP2pManager.ActionListener!
): Unit
Remove a specified service discovery request added with 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 ActionListener#onSuccess
or ActionListener#onFailure
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
req |
WifiP2pServiceRequest!: is the service discovery request. |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
requestConnectionInfo
open fun requestConnectionInfo(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ConnectionInfoListener!
): Unit
Request device connection info.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ConnectionInfoListener!: for callback when connection info is available. Can be null. |
requestDeviceInfo
open fun requestDeviceInfo(
c: WifiP2pManager.Channel,
listener: WifiP2pManager.DeviceInfoListener
): Unit
Request Device Info
This method provides the device info in the form of a android.net.wifi.p2p.WifiP2pDevice
. Valid android.net.wifi.p2p.WifiP2pDevice
is returned when p2p is enabled. To get information notifications on P2P getting enabled refers WIFI_P2P_STATE_ENABLED
.
This android.net.wifi.p2p.WifiP2pDevice
is returned using the DeviceInfoListener
listener.
android.net.wifi.p2p.WifiP2pDevice#deviceAddress
is only available if the caller holds the 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 WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
broadcast event with extra EXTRA_WIFI_P2P_DEVICE
.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
listener |
WifiP2pManager.DeviceInfoListener: for callback when network info is available. This value cannot be null . |
requestDiscoveryState
open fun requestDiscoveryState(
c: WifiP2pManager.Channel,
listener: WifiP2pManager.DiscoveryStateListener
): Unit
Request p2p discovery state.
This state indicates whether p2p discovery has started or stopped. The valid value is one of WIFI_P2P_DISCOVERY_STARTED
or WIFI_P2P_DISCOVERY_STOPPED
. The state is returned using the DiscoveryStateListener
listener.
This state is also included in the WIFI_P2P_DISCOVERY_CHANGED_ACTION
broadcast event with extra EXTRA_DISCOVERY_STATE
.
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize . This value cannot be null . |
listener |
WifiP2pManager.DiscoveryStateListener: for callback when discovery state is available. This value cannot be null . |
requestGroupInfo
open fun requestGroupInfo(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.GroupInfoListener!
): Unit
Request p2p group info.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.GroupInfoListener!: for callback when group info is available. Can be null. |
requestNetworkInfo
open fun requestNetworkInfo(
c: WifiP2pManager.Channel,
listener: WifiP2pManager.NetworkInfoListener
): Unit
Request network info.
This method provides the network info in the form of a android.net.NetworkInfo
. android.net.NetworkInfo#isAvailable()
indicates the p2p availability and android.net.NetworkInfo#getDetailedState()
reports the current fine-grained state of the network. This android.net.NetworkInfo
is returned using the NetworkInfoListener
listener.
This information is also included in the WIFI_P2P_CONNECTION_CHANGED_ACTION
broadcast event with extra EXTRA_NETWORK_INFO
.
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize . This value cannot be null . |
listener |
WifiP2pManager.NetworkInfoListener: for callback when network info is available. This value cannot be null . |
requestP2pState
open fun requestP2pState(
c: WifiP2pManager.Channel,
listener: WifiP2pManager.P2pStateListener
): Unit
Request p2p enabled state.
This state indicates whether Wi-Fi p2p is enabled or disabled. The valid value is one of WIFI_P2P_STATE_DISABLED
or WIFI_P2P_STATE_ENABLED
. The state is returned using the P2pStateListener
listener.
This state is also included in the WIFI_P2P_STATE_CHANGED_ACTION
broadcast event with extra EXTRA_WIFI_STATE
.
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize . This value cannot be null . |
listener |
WifiP2pManager.P2pStateListener: for callback when p2p state is available. This value cannot be null . |
requestPeers
open fun requestPeers(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.PeerListListener!
): Unit
Request the current list of peers.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.PeerListListener!: for callback when peer list is available. Can be null. |
setConnectionRequestResult
open fun setConnectionRequestResult(
c: WifiP2pManager.Channel,
deviceAddress: MacAddress,
result: Int,
listener: WifiP2pManager.ActionListener?
): Unit
Set the result for the incoming request from a specific peer. The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Requires android.Manifest.permission#MANAGE_WIFI_NETWORK_SELECTION
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
deviceAddress |
MacAddress: the peer which is bound to the external approver. This value cannot be null . |
result |
Int: the response for the incoming request. Value is android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_ACCEPT , android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_REJECT , android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_DEFER_TO_SERVICE , or android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_DEFER_SHOW_PIN_TO_SERVICE |
listener |
WifiP2pManager.ActionListener?: for callback on success or failure. This value may be null . |
setConnectionRequestResult
open fun setConnectionRequestResult(
c: WifiP2pManager.Channel,
deviceAddress: MacAddress,
result: Int,
pin: String?,
listener: WifiP2pManager.ActionListener?
): Unit
Set the result with PIN for the incoming request from a specific peer. The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Requires android.Manifest.permission#MANAGE_WIFI_NETWORK_SELECTION
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
deviceAddress |
MacAddress: the peer which is bound to the external approver. This value cannot be null . |
result |
Int: the response for the incoming request. Value is android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_ACCEPT , android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_REJECT , android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_DEFER_TO_SERVICE , or android.net.wifi.p2p.WifiP2pManager#CONNECTION_REQUEST_DEFER_SHOW_PIN_TO_SERVICE |
pin |
String?: the PIN for the incoming request. This value may be null . |
listener |
WifiP2pManager.ActionListener?: for callback on success or failure. This value may be null . |
setDnsSdResponseListeners
open fun setDnsSdResponseListeners(
channel: WifiP2pManager.Channel!,
servListener: WifiP2pManager.DnsSdServiceResponseListener!,
txtListener: WifiP2pManager.DnsSdTxtRecordListener!
): Unit
Register a callback to be invoked on receiving Bonjour service discovery response.
see discoverServices
for the detail.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: |
servListener |
WifiP2pManager.DnsSdServiceResponseListener!: is for listening to a Bonjour service response |
txtListener |
WifiP2pManager.DnsSdTxtRecordListener!: is for listening to a Bonjour TXT record response |
setServiceResponseListener
open fun setServiceResponseListener(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ServiceResponseListener!
): Unit
Register a callback to be invoked on receiving service discovery response. Used only for vendor specific protocol right now. For Bonjour or Upnp, use setDnsSdResponseListeners
or setUpnpServiceResponseListener
respectively.
see discoverServices
for the detail.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ServiceResponseListener!: for callbacks on receiving service discovery response. |
setUpnpServiceResponseListener
open fun setUpnpServiceResponseListener(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.UpnpServiceResponseListener!
): Unit
Register a callback to be invoked on receiving upnp service discovery response.
see discoverServices
for the detail.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.UpnpServiceResponseListener!: for callbacks on receiving service discovery response. |
setVendorElements
open fun setVendorElements(
c: WifiP2pManager.Channel,
vendorElements: MutableList<ScanResult.InformationElement!>,
listener: WifiP2pManager.ActionListener?
): Unit
Set/Clear vendor specific information elements (VSIEs) to be published during Wi-Fi Direct (P2P) discovery. Once Channel#close()
is called, the vendor information elements will be cleared from framework. The information element format is defined in the IEEE 802.11-2016 spec Table 9-77.
To clear the previously set vendor elements, call this API with an empty List.
The maximum accumulated length of all VSIEs must be before the limit specified by getP2pMaxAllowedVendorElementsLengthBytes()
.
To publish vendor elements, this API should be called before peer discovery API, ex. discoverPeers(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
.
Use isSetVendorElementsSupported()
to determine whether the device supports this feature. If isSetVendorElementsSupported()
return false
then this method will throw UnsupportedOperationException
.
Requires android.Manifest.permission#NEARBY_WIFI_DEVICES
and android.Manifest.permission#OVERRIDE_WIFI_CONFIG
Parameters | |
---|---|
c |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) . This value cannot be null . |
vendorElements |
MutableList<ScanResult.InformationElement!>: application information as vendor-specific information elements. This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callback when network info is available. This value may be null . |
setWfdInfo
open fun setWfdInfo(
channel: WifiP2pManager.Channel,
wfdInfo: WifiP2pWfdInfo,
listener: WifiP2pManager.ActionListener?
): Unit
Set Wifi Display information.
Requires android.Manifest.permission#CONFIGURE_WIFI_DISPLAY
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize This value cannot be null . |
wfdInfo |
WifiP2pWfdInfo: the Wifi Display information to set This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. Can be null. |
startListening
open fun startListening(
channel: WifiP2pManager.Channel,
listener: WifiP2pManager.ActionListener?
): Unit
Force p2p to enter listen state. When this API is called, this device will periodically enter LISTENING state until stopListening(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
or stopPeerDiscovery(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
are called. While in LISTENING state, this device will dwell at its social channel and respond to probe requests from other Wi-Fi Direct peers.
If targeting android.os.Build.VERSION_CODES#TIRAMISU
or later, the application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
. If targeting an earlier release than android.os.Build.VERSION_CODES#TIRAMISU
, the application must have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. This value may be null . |
startPeerDiscovery
open fun startPeerDiscovery(
channel: WifiP2pManager.Channel,
config: WifiP2pDiscoveryConfig,
listener: WifiP2pManager.ActionListener?
): Unit
Initiate peer discovery. A discovery process involves scanning for available Wi-Fi peers for the purpose of establishing a connection. See discoverPeers(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
for more details. This method accepts a WifiP2pDiscoveryConfig
object specifying the desired parameters for the peer discovery. The configuration object allows the specification of the scan type (ex. FULL, SOCIAL) and the inclusion of vendor-specific configuration data. The application must have android.Manifest.permission#NEARBY_WIFI_DEVICES
with android:usesPermissionFlags="neverForLocation". If the application does not declare android:usesPermissionFlags="neverForLocation", then it must also have android.Manifest.permission#ACCESS_FINE_LOCATION
.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize This value cannot be null . |
config |
WifiP2pDiscoveryConfig: is the configuration for this peer discovery This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. This value may be null . |
stopListening
open fun stopListening(
channel: WifiP2pManager.Channel,
listener: WifiP2pManager.ActionListener?
): Unit
Force p2p to exit listen state. When this API is called, this device will stop entering LISTENING state periodically which is triggered by startListening(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
. If there are running peer discovery which is triggered by discoverPeers(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
or running service discovery which is triggered by discoverServices(android.net.wifi.p2p.WifiP2pManager.Channel,android.net.wifi.p2p.WifiP2pManager.ActionListener)
, they will be stopped as well.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel: is the channel created at initialize(android.content.Context,android.os.Looper,android.net.wifi.p2p.WifiP2pManager.ChannelListener) This value cannot be null . |
listener |
WifiP2pManager.ActionListener?: for callbacks on success or failure. This value may be null . |
stopPeerDiscovery
open fun stopPeerDiscovery(
channel: WifiP2pManager.Channel!,
listener: WifiP2pManager.ActionListener!
): Unit
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 ActionListener#onSuccess
or ActionListener#onFailure
.
If P2P Group is in the process of being created, this call will fail (report failure via listener
. The applicantion should listen to WIFI_P2P_CONNECTION_CHANGED_ACTION
to ensure the state is not android.net.NetworkInfo.State#CONNECTING
and repeat calling when the state changes.
Parameters | |
---|---|
channel |
WifiP2pManager.Channel!: is the channel created at initialize |
listener |
WifiP2pManager.ActionListener!: for callbacks on success or failure. Can be null. |
unregisterWifiP2pListener
open fun unregisterWifiP2pListener(listener: WifiP2pManager.WifiP2pListener): Unit
Remove a listener added using registerWifiP2pListener(java.util.concurrent.Executor,android.net.wifi.p2p.WifiP2pManager.WifiP2pListener)
Parameters | |
---|---|
listener |
WifiP2pManager.WifiP2pListener: the listener to be removed. This value cannot be null . |
Exceptions | |
---|---|
java.lang.IllegalArgumentException |
if incorrect input arguments are provided. |