| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.net.wifi.p2p; |
| |
| import android.annotation.SdkConstant; |
| import android.annotation.SdkConstant.SdkConstantType; |
| import android.content.Context; |
| import android.net.wifi.WpsInfo; |
| import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo; |
| import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceResponse; |
| import android.net.wifi.p2p.nsd.WifiP2pServiceInfo; |
| import android.net.wifi.p2p.nsd.WifiP2pServiceRequest; |
| import android.net.wifi.p2p.nsd.WifiP2pServiceResponse; |
| import android.net.wifi.p2p.nsd.WifiP2pUpnpServiceInfo; |
| import android.net.wifi.p2p.nsd.WifiP2pUpnpServiceResponse; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.Messenger; |
| import android.os.RemoteException; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.util.AsyncChannel; |
| import com.android.internal.util.Protocol; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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}. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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}. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p>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. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p class="note"><strong>Note:</strong> |
| * 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. |
| * |
| * Get an instance of this class by calling {@link android.content.Context#getSystemService(String) |
| * Context.getSystemService(Context.WIFI_P2P_SERVICE)}. |
| * |
| * {@see WifiP2pConfig} |
| * {@see WifiP2pInfo} |
| * {@see WifiP2pGroup} |
| * {@see WifiP2pDevice} |
| * {@see WifiP2pDeviceList} |
| * {@see android.net.wifi.WpsInfo} |
| */ |
| 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"; |
| |
| /** |
| * 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. |
| * |
| * @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. |
| * |
| * <p> 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. |
| * |
| * <p>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. |
| * |
| * <p>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"; |
| |
| /** |
| * 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. |
| */ |
| @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. |
| * @hide |
| */ |
| public static final String WIFI_P2P_PERSISTENT_GROUPS_CHANGED_ACTION = |
| "android.net.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"; |
| |
| 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 */ |
| 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; |
| |
| |
| /** |
| * 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. |
| */ |
| 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. |
| * |
| * <p>This function is invoked when the device with the specified Bonjour |
| * registration type returned the instance name. |
| * @param instanceName instance name.<br> |
| * e.g) "MyPrinter". |
| * @param registrationType <br> |
| * 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. |
| * |
| * <p>This function is invoked when the device with the specified full |
| * service domain service returned TXT record. |
| * |
| * @param fullDomainName full domain name. <br> |
| * 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<String, String> txtRecordMap, |
| WifiP2pDevice srcDevice); |
| } |
| |
| /** |
| * Interface for callback invocation when upnp service discovery response |
| * is received |
| * */ |
| public interface UpnpServiceResponseListener { |
| |
| /** |
| * The requested upnp service response is available. |
| * |
| * <p>This function is invoked when the specified device or service is found. |
| * |
| * @param uniqueServiceNames The list of unique service names.<br> |
| * e.g) uuid:6859dede-8574-59ab-9332-123456789012::urn:schemas-upnp-org:device: |
| * MediaServer:1 |
| * @param srcDevice source device. |
| */ |
| public void onUpnpServiceAvailable(List<String> uniqueServiceNames, |
| WifiP2pDevice srcDevice); |
| } |
| |
| |
| /** Interface for callback invocation when stored group info list is available {@hide}*/ |
| public interface PersistentGroupInfoListener { |
| /** |
| * The requested stored p2p group info list is available |
| * @param groups Wi-Fi p2p group info list |
| */ |
| public void onPersistentGroupInfoAvailable(WifiP2pGroupList groups); |
| } |
| |
| /** |
| * Interface for callback invocation when Handover Request or Select Message is available |
| * @hide |
| */ |
| public interface HandoverMessageListener { |
| public void onHandoverMessageAvailable(String handoverMessage); |
| } |
| |
| /** |
| * A channel that connects the application to the Wifi p2p framework. |
| * Most p2p operations require a Channel as an argument. An instance of Channel is obtained |
| * by doing a call on {@link #initialize} |
| */ |
| public static class Channel { |
| Channel(Context context, Looper looper, ChannelListener l) { |
| mAsyncChannel = new AsyncChannel(); |
| mHandler = new P2pHandler(looper); |
| mChannelListener = l; |
| mContext = context; |
| } |
| private final static int INVALID_LISTENER_KEY = 0; |
| private ChannelListener mChannelListener; |
| private ServiceResponseListener mServRspListener; |
| private DnsSdServiceResponseListener mDnsSdServRspListener; |
| private DnsSdTxtRecordListener mDnsSdTxtListener; |
| private UpnpServiceResponseListener mUpnpServRspListener; |
| private HashMap<Integer, Object> mListenerMap = new HashMap<Integer, Object>(); |
| private Object mListenerMapLock = new Object(); |
| private int mListenerKey = 0; |
| |
| private AsyncChannel mAsyncChannel; |
| private P2pHandler mHandler; |
| Context mContext; |
| class P2pHandler extends Handler { |
| P2pHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message message) { |
| Object listener = getListener(message.arg2); |
| switch (message.what) { |
| case AsyncChannel.CMD_CHANNEL_DISCONNECTED: |
| if (mChannelListener != null) { |
| mChannelListener.onChannelDisconnected(); |
| mChannelListener = null; |
| } |
| break; |
| /* ActionListeners grouped together */ |
| case DISCOVER_PEERS_FAILED: |
| case STOP_DISCOVERY_FAILED: |
| case DISCOVER_SERVICES_FAILED: |
| case CONNECT_FAILED: |
| case CANCEL_CONNECT_FAILED: |
| case CREATE_GROUP_FAILED: |
| case REMOVE_GROUP_FAILED: |
| case ADD_LOCAL_SERVICE_FAILED: |
| case REMOVE_LOCAL_SERVICE_FAILED: |
| case CLEAR_LOCAL_SERVICES_FAILED: |
| case ADD_SERVICE_REQUEST_FAILED: |
| case REMOVE_SERVICE_REQUEST_FAILED: |
| case CLEAR_SERVICE_REQUESTS_FAILED: |
| case SET_DEVICE_NAME_FAILED: |
| case DELETE_PERSISTENT_GROUP_FAILED: |
| case SET_WFD_INFO_FAILED: |
| case START_WPS_FAILED: |
| case START_LISTEN_FAILED: |
| case STOP_LISTEN_FAILED: |
| case SET_CHANNEL_FAILED: |
| case REPORT_NFC_HANDOVER_FAILED: |
| if (listener != null) { |
| ((ActionListener) listener).onFailure(message.arg1); |
| } |
| break; |
| /* ActionListeners grouped together */ |
| case DISCOVER_PEERS_SUCCEEDED: |
| case STOP_DISCOVERY_SUCCEEDED: |
| case DISCOVER_SERVICES_SUCCEEDED: |
| case CONNECT_SUCCEEDED: |
| case CANCEL_CONNECT_SUCCEEDED: |
| case CREATE_GROUP_SUCCEEDED: |
| case REMOVE_GROUP_SUCCEEDED: |
| case ADD_LOCAL_SERVICE_SUCCEEDED: |
| case REMOVE_LOCAL_SERVICE_SUCCEEDED: |
| case CLEAR_LOCAL_SERVICES_SUCCEEDED: |
| case ADD_SERVICE_REQUEST_SUCCEEDED: |
| case REMOVE_SERVICE_REQUEST_SUCCEEDED: |
| case CLEAR_SERVICE_REQUESTS_SUCCEEDED: |
| case SET_DEVICE_NAME_SUCCEEDED: |
| case DELETE_PERSISTENT_GROUP_SUCCEEDED: |
| case SET_WFD_INFO_SUCCEEDED: |
| case START_WPS_SUCCEEDED: |
| case START_LISTEN_SUCCEEDED: |
| case STOP_LISTEN_SUCCEEDED: |
| case SET_CHANNEL_SUCCEEDED: |
| case REPORT_NFC_HANDOVER_SUCCEEDED: |
| if (listener != null) { |
| ((ActionListener) listener).onSuccess(); |
| } |
| break; |
| case RESPONSE_PEERS: |
| WifiP2pDeviceList peers = (WifiP2pDeviceList) message.obj; |
| if (listener != null) { |
| ((PeerListListener) listener).onPeersAvailable(peers); |
| } |
| break; |
| case RESPONSE_CONNECTION_INFO: |
| WifiP2pInfo wifiP2pInfo = (WifiP2pInfo) message.obj; |
| if (listener != null) { |
| ((ConnectionInfoListener) listener).onConnectionInfoAvailable(wifiP2pInfo); |
| } |
| break; |
| case RESPONSE_GROUP_INFO: |
| WifiP2pGroup group = (WifiP2pGroup) message.obj; |
| if (listener != null) { |
| ((GroupInfoListener) listener).onGroupInfoAvailable(group); |
| } |
| break; |
| case RESPONSE_SERVICE: |
| WifiP2pServiceResponse resp = (WifiP2pServiceResponse) message.obj; |
| handleServiceResponse(resp); |
| break; |
| case RESPONSE_PERSISTENT_GROUP_INFO: |
| WifiP2pGroupList groups = (WifiP2pGroupList) message.obj; |
| if (listener != null) { |
| ((PersistentGroupInfoListener) listener). |
| onPersistentGroupInfoAvailable(groups); |
| } |
| break; |
| case RESPONSE_GET_HANDOVER_MESSAGE: |
| Bundle handoverBundle = (Bundle) message.obj; |
| if (listener != null) { |
| String handoverMessage = handoverBundle != null |
| ? handoverBundle.getString(EXTRA_HANDOVER_MESSAGE) |
| : null; |
| ((HandoverMessageListener) listener) |
| .onHandoverMessageAvailable(handoverMessage); |
| } |
| break; |
| default: |
| Log.d(TAG, "Ignored " + message); |
| break; |
| } |
| } |
| } |
| |
| private void handleServiceResponse(WifiP2pServiceResponse resp) { |
| if (resp instanceof WifiP2pDnsSdServiceResponse) { |
| handleDnsSdServiceResponse((WifiP2pDnsSdServiceResponse)resp); |
| } else if (resp instanceof WifiP2pUpnpServiceResponse) { |
| if (mUpnpServRspListener != null) { |
| handleUpnpServiceResponse((WifiP2pUpnpServiceResponse)resp); |
| } |
| } else { |
| if (mServRspListener != null) { |
| mServRspListener.onServiceAvailable(resp.getServiceType(), |
| resp.getRawData(), resp.getSrcDevice()); |
| } |
| } |
| } |
| |
| private void handleUpnpServiceResponse(WifiP2pUpnpServiceResponse resp) { |
| mUpnpServRspListener.onUpnpServiceAvailable(resp.getUniqueServiceNames(), |
| resp.getSrcDevice()); |
| } |
| |
| private void handleDnsSdServiceResponse(WifiP2pDnsSdServiceResponse resp) { |
| if (resp.getDnsType() == WifiP2pDnsSdServiceInfo.DNS_TYPE_PTR) { |
| if (mDnsSdServRspListener != null) { |
| mDnsSdServRspListener.onDnsSdServiceAvailable( |
| resp.getInstanceName(), |
| resp.getDnsQueryName(), |
| resp.getSrcDevice()); |
| } |
| } else if (resp.getDnsType() == WifiP2pDnsSdServiceInfo.DNS_TYPE_TXT) { |
| if (mDnsSdTxtListener != null) { |
| mDnsSdTxtListener.onDnsSdTxtRecordAvailable( |
| resp.getDnsQueryName(), |
| resp.getTxtRecord(), |
| resp.getSrcDevice()); |
| } |
| } else { |
| Log.e(TAG, "Unhandled resp " + resp); |
| } |
| } |
| |
| private int putListener(Object listener) { |
| if (listener == null) return INVALID_LISTENER_KEY; |
| int key; |
| synchronized (mListenerMapLock) { |
| do { |
| key = mListenerKey++; |
| } while (key == INVALID_LISTENER_KEY); |
| mListenerMap.put(key, listener); |
| } |
| return key; |
| } |
| |
| private Object getListener(int key) { |
| if (key == INVALID_LISTENER_KEY) return null; |
| synchronized (mListenerMapLock) { |
| return mListenerMap.remove(key); |
| } |
| } |
| } |
| |
| private static void checkChannel(Channel c) { |
| if (c == null) throw new IllegalArgumentException("Channel needs to be initialized"); |
| } |
| |
| private static void checkServiceInfo(WifiP2pServiceInfo info) { |
| if (info == null) throw new IllegalArgumentException("service info is null"); |
| } |
| |
| private static void checkServiceRequest(WifiP2pServiceRequest req) { |
| if (req == null) throw new IllegalArgumentException("service request is null"); |
| } |
| |
| private static void checkP2pConfig(WifiP2pConfig c) { |
| if (c == null) throw new IllegalArgumentException("config cannot be null"); |
| if (TextUtils.isEmpty(c.deviceAddress)) { |
| throw new IllegalArgumentException("deviceAddress cannot be empty"); |
| } |
| } |
| |
| /** |
| * Registers the application with the Wi-Fi framework. This function |
| * must be the first to be called before any p2p operations are performed. |
| * |
| * @param srcContext is the context of the source |
| * @param srcLooper is the Looper on which the callbacks are receivied |
| * @param listener for callback at loss of framework communication. Can be null. |
| * @return Channel instance that is necessary for performing any further p2p operations |
| */ |
| public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener) { |
| return initalizeChannel(srcContext, srcLooper, listener, getMessenger()); |
| } |
| |
| /** |
| * Registers the application with the Wi-Fi framework. Enables system-only functionality. |
| * @hide |
| */ |
| public Channel initializeInternal(Context srcContext, Looper srcLooper, |
| ChannelListener listener) { |
| return initalizeChannel(srcContext, srcLooper, listener, getP2pStateMachineMessenger()); |
| } |
| |
| private Channel initalizeChannel(Context srcContext, Looper srcLooper, ChannelListener listener, |
| Messenger messenger) { |
| if (messenger == null) return null; |
| |
| Channel c = new Channel(srcContext, srcLooper, listener); |
| if (c.mAsyncChannel.connectSync(srcContext, c.mHandler, messenger) |
| == AsyncChannel.STATUS_SUCCESSFUL) { |
| return c; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Initiate peer discovery. A discovery process involves scanning for available Wi-Fi peers |
| * for the purpose of establishing a connection. |
| * |
| * <p> 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}. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| */ |
| public void discoverPeers(Channel c, ActionListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(DISCOVER_PEERS, 0, c.putListener(listener)); |
| } |
| |
| /** |
| * Stop an ongoing peer discovery |
| * |
| * <p> 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. |
| * |
| * <p> 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}. |
| * |
| * <p> Register for {@link #WIFI_P2P_CONNECTION_CHANGED_ACTION} intent to |
| * determine when the framework notifies of a change in connectivity. |
| * |
| * <p> If the current device is not part of a p2p group, a connect request initiates |
| * a group negotiation with the peer. |
| * |
| * <p> 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. |
| */ |
| 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 |
| * |
| * <p> 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. |
| * |
| * <p class="note"><strong>Note:</strong> |
| * This function would normally not be used unless the current device needs |
| * to form a p2p connection with a legacy client |
| * |
| * <p> 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}. |
| * |
| * <p> 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. |
| */ |
| public void createGroup(Channel c, ActionListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(CREATE_GROUP, WifiP2pGroup.PERSISTENT_NET_ID, |
| c.putListener(listener)); |
| } |
| |
| /** |
| * Remove the current p2p group. |
| * |
| * <p> 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)); |
| } |
| |
| /** @hide */ |
| public void listen(Channel c, boolean enable, ActionListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(enable ? START_LISTEN : STOP_LISTEN, |
| 0, c.putListener(listener)); |
| } |
| |
| /** @hide */ |
| public void setWifiP2pChannels(Channel c, int lc, int oc, ActionListener listener) { |
| checkChannel(c); |
| Bundle p2pChannels = new Bundle(); |
| p2pChannels.putInt("lc", lc); |
| p2pChannels.putInt("oc", oc); |
| c.mAsyncChannel.sendMessage(SET_CHANNEL, 0, c.putListener(listener), p2pChannels); |
| } |
| |
| /** |
| * Start a Wi-Fi Protected Setup (WPS) session. |
| * |
| * <p> 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 |
| */ |
| 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. |
| * |
| * <p> 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}. |
| * |
| * <p>The service information is set through {@link WifiP2pServiceInfo}.<br> |
| * or its subclass calls {@link WifiP2pUpnpServiceInfo#newInstance} or |
| * {@link WifiP2pDnsSdServiceInfo#newInstance} for a Upnp or Bonjour service |
| * respectively |
| * |
| * <p>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. |
| */ |
| 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} |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| * |
| * <p> 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}. |
| * |
| * <p> The services to be discovered are specified with calls to {@link #addServiceRequest}. |
| * |
| * <p>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. |
| */ |
| public void discoverServices(Channel c, ActionListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(DISCOVER_SERVICES, 0, c.putListener(listener)); |
| } |
| |
| /** |
| * Add a service discovery request. |
| * |
| * <p> 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}. |
| * |
| * <p>After service discovery request is added, you can initiate service discovery by |
| * {@link #discoverServices}. |
| * |
| * <p>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} |
| * |
| * <p> 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. |
| * |
| * <p> 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. |
| */ |
| 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. |
| */ |
| public void requestGroupInfo(Channel c, GroupInfoListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(REQUEST_GROUP_INFO, 0, c.putListener(listener)); |
| } |
| |
| /** |
| * Set p2p device name. |
| * @hide |
| * @param c is the channel created at {@link #initialize} |
| * @param listener for callback when group info is available. Can be null. |
| */ |
| public void setDeviceName(Channel c, String devName, ActionListener listener) { |
| checkChannel(c); |
| WifiP2pDevice d = new WifiP2pDevice(); |
| d.deviceName = devName; |
| c.mAsyncChannel.sendMessage(SET_DEVICE_NAME, 0, c.putListener(listener), d); |
| } |
| |
| /** @hide */ |
| public void setWFDInfo( |
| Channel c, WifiP2pWfdInfo wfdInfo, |
| ActionListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(SET_WFD_INFO, 0, c.putListener(listener), wfdInfo); |
| } |
| |
| |
| /** |
| * Delete a stored persistent group from the system settings. |
| * |
| * <p> 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}. |
| * |
| * <p>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 he network id of the p2p group. |
| * @param listener for callbacks on success or failure. Can be null. |
| * @hide |
| */ |
| public void deletePersistentGroup(Channel c, int netId, 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 |
| */ |
| public void requestPersistentGroupInfo(Channel c, PersistentGroupInfoListener listener) { |
| checkChannel(c); |
| c.mAsyncChannel.sendMessage(REQUEST_PERSISTENT_GROUP_INFO, 0, c.putListener(listener)); |
| } |
| |
| /** @hide */ |
| public static final int MIRACAST_DISABLED = 0; |
| /** @hide */ |
| public static final int MIRACAST_SOURCE = 1; |
| /** @hide */ |
| public static final int MIRACAST_SINK = 2; |
| /** Internal use only @hide */ |
| public void setMiracastMode(int mode) { |
| try { |
| mService.setMiracastMode(mode); |
| } catch(RemoteException e) { |
| // ignore |
| } |
| } |
| |
| /** |
| * Get a reference to WifiP2pService handler. This is used to establish |
| * an AsyncChannel communication with WifiService |
| * |
| * @return Messenger pointing to the WifiP2pService handler |
| * @hide |
| */ |
| public Messenger getMessenger() { |
| try { |
| return mService.getMessenger(); |
| } catch (RemoteException e) { |
| return 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) { |
| return null; |
| } |
| } |
| |
| /** |
| * 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); |
| } |
| } |
