| /* |
| * Copyright (C) 2008 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 com.android.server.wifi.p2p; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.hardware.wifi.V1_0.IWifiP2pIface; |
| import android.net.wifi.CoexUnsafeChannel; |
| import android.net.wifi.nl80211.WifiNl80211Manager; |
| import android.net.wifi.p2p.WifiP2pConfig; |
| import android.net.wifi.p2p.WifiP2pGroup; |
| import android.net.wifi.p2p.WifiP2pGroupList; |
| import android.net.wifi.p2p.nsd.WifiP2pServiceInfo; |
| import android.os.Handler; |
| import android.os.WorkSource; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.server.wifi.HalDeviceManager; |
| import com.android.server.wifi.PropertyService; |
| import com.android.server.wifi.WifiNative; |
| import com.android.server.wifi.WifiVendorHal; |
| |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Native calls for bring up/shut down of the supplicant daemon and for |
| * sending requests to the supplicant daemon |
| */ |
| public class WifiP2pNative { |
| private static final String TAG = "WifiP2pNative"; |
| private boolean mVerboseLoggingEnabled = false; |
| private final SupplicantP2pIfaceHal mSupplicantP2pIfaceHal; |
| private final WifiNative mWifiNative; |
| private final WifiNl80211Manager mWifiNl80211Manager; |
| private final HalDeviceManager mHalDeviceManager; |
| private final PropertyService mPropertyService; |
| private final WifiVendorHal mWifiVendorHal; |
| private IWifiP2pIface mIWifiP2pIface; |
| private InterfaceDestroyedListenerInternal mInterfaceDestroyedListener; |
| |
| // Internal callback registered to HalDeviceManager. |
| private class InterfaceDestroyedListenerInternal implements |
| HalDeviceManager.InterfaceDestroyedListener { |
| private final HalDeviceManager.InterfaceDestroyedListener mExternalListener; |
| private boolean mValid; |
| |
| InterfaceDestroyedListenerInternal( |
| HalDeviceManager.InterfaceDestroyedListener externalListener) { |
| mExternalListener = externalListener; |
| mValid = true; |
| } |
| |
| public void teardownAndInvalidate(@Nullable String ifaceName) { |
| if (!TextUtils.isEmpty(ifaceName)) { |
| mSupplicantP2pIfaceHal.teardownIface(ifaceName); |
| } |
| mIWifiP2pIface = null; |
| mValid = false; |
| } |
| |
| @Override |
| public void onDestroyed(String ifaceName) { |
| Log.d(TAG, "P2P InterfaceDestroyedListener " + ifaceName); |
| if (!mValid) { |
| Log.d(TAG, "Ignoring stale interface destroyed listener"); |
| return; |
| } |
| teardownAndInvalidate(ifaceName); |
| mExternalListener.onDestroyed(ifaceName); |
| } |
| } |
| |
| public WifiP2pNative( |
| WifiNl80211Manager wifiNl80211Manager, |
| WifiNative wifiNative, |
| WifiVendorHal wifiVendorHal, |
| SupplicantP2pIfaceHal p2pIfaceHal, |
| HalDeviceManager halDeviceManager, |
| PropertyService propertyService) { |
| mWifiNative = wifiNative; |
| mWifiNl80211Manager = wifiNl80211Manager; |
| mWifiVendorHal = wifiVendorHal; |
| mSupplicantP2pIfaceHal = p2pIfaceHal; |
| mHalDeviceManager = halDeviceManager; |
| mPropertyService = propertyService; |
| } |
| |
| /** |
| * Enable verbose logging for all sub modules. |
| */ |
| public void enableVerboseLogging(int verbose) { |
| mVerboseLoggingEnabled = verbose > 0; |
| SupplicantP2pIfaceHal.enableVerboseLogging(verbose); |
| } |
| |
| private static final int CONNECT_TO_SUPPLICANT_SAMPLING_INTERVAL_MS = 100; |
| private static final int CONNECT_TO_SUPPLICANT_MAX_SAMPLES = 50; |
| /** |
| * This method is called to wait for establishing connection to wpa_supplicant. |
| * |
| * @return true if connection is established, false otherwise. |
| */ |
| private boolean waitForSupplicantConnection() { |
| // Start initialization if not already started. |
| if (!mSupplicantP2pIfaceHal.isInitializationStarted() |
| && !mSupplicantP2pIfaceHal.initialize()) { |
| return false; |
| } |
| int connectTries = 0; |
| while (connectTries++ < CONNECT_TO_SUPPLICANT_MAX_SAMPLES) { |
| // Check if the initialization is complete. |
| if (mSupplicantP2pIfaceHal.isInitializationComplete()) { |
| return true; |
| } |
| try { |
| Thread.sleep(CONNECT_TO_SUPPLICANT_SAMPLING_INTERVAL_MS); |
| } catch (InterruptedException ignore) { |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Close supplicant connection. |
| */ |
| public void closeSupplicantConnection() { |
| // Nothing to do for HIDL. |
| } |
| |
| /** |
| * Returns whether HAL (HIDL) is supported on this device or not. |
| */ |
| public boolean isHalInterfaceSupported() { |
| return mHalDeviceManager.isSupported(); |
| } |
| |
| private static final String P2P_IFACE_NAME = "p2p0"; |
| private static final String P2P_INTERFACE_PROPERTY = "wifi.direct.interface"; |
| /** |
| * Helper function to handle creation of P2P iface. |
| * For devices which do not the support the HAL, this will bypass HalDeviceManager & |
| * teardown any existing iface. |
| */ |
| private String createP2pIface(Handler handler, WorkSource requestorWs) { |
| if (mHalDeviceManager.isSupported()) { |
| mIWifiP2pIface = mHalDeviceManager |
| .createP2pIface(mInterfaceDestroyedListener, handler, requestorWs); |
| if (mIWifiP2pIface == null) { |
| Log.e(TAG, "Failed to create P2p iface in HalDeviceManager"); |
| return null; |
| } |
| String ifaceName = HalDeviceManager.getName(mIWifiP2pIface); |
| if (TextUtils.isEmpty(ifaceName)) { |
| Log.e(TAG, "Failed to get p2p iface name"); |
| teardownInterface(); |
| return null; |
| } |
| return ifaceName; |
| } else { |
| Log.i(TAG, "Vendor Hal is not supported, ignoring createP2pIface."); |
| return mPropertyService.getString(P2P_INTERFACE_PROPERTY, P2P_IFACE_NAME); |
| } |
| } |
| |
| /** |
| * Setup Interface for P2p mode. |
| * |
| * @param destroyedListener Listener to be invoked when the interface is destroyed. |
| * @param handler Handler to be used for invoking the destroyedListener. |
| * @param requestorWs Worksource to attribute the request to. |
| */ |
| public String setupInterface( |
| @NonNull HalDeviceManager.InterfaceDestroyedListener destroyedListener, |
| @NonNull Handler handler, @NonNull WorkSource requestorWs) { |
| Log.d(TAG, "Setup P2P interface"); |
| if (mIWifiP2pIface == null) { |
| mInterfaceDestroyedListener = |
| new InterfaceDestroyedListenerInternal(destroyedListener); |
| String ifaceName = createP2pIface(handler, requestorWs); |
| if (ifaceName == null) { |
| Log.e(TAG, "Failed to create P2p iface"); |
| return null; |
| } |
| if (!waitForSupplicantConnection()) { |
| Log.e(TAG, "Failed to connect to supplicant"); |
| teardownInterface(); |
| return null; |
| } |
| if (!mSupplicantP2pIfaceHal.setupIface(ifaceName)) { |
| Log.e(TAG, "Failed to setup P2p iface in supplicant"); |
| teardownInterface(); |
| return null; |
| } |
| Log.i(TAG, "P2P interface setup completed"); |
| return ifaceName; |
| } else { |
| Log.i(TAG, "P2P interface is already existed"); |
| return mHalDeviceManager.isSupported() |
| ? HalDeviceManager.getName(mIWifiP2pIface) |
| : mPropertyService.getString(P2P_INTERFACE_PROPERTY, P2P_IFACE_NAME); |
| } |
| } |
| |
| /** |
| * Teardown P2p interface. |
| */ |
| public void teardownInterface() { |
| Log.d(TAG, "Teardown P2P interface"); |
| if (mHalDeviceManager.isSupported()) { |
| if (mIWifiP2pIface != null) { |
| String ifaceName = HalDeviceManager.getName(mIWifiP2pIface); |
| mHalDeviceManager.removeIface(mIWifiP2pIface); |
| mInterfaceDestroyedListener.teardownAndInvalidate(ifaceName); |
| Log.i(TAG, "P2P interface teardown completed"); |
| } |
| } else { |
| Log.i(TAG, "HAL (HIDL) is not supported. Destroy listener for the interface."); |
| String ifaceName = mPropertyService.getString(P2P_INTERFACE_PROPERTY, P2P_IFACE_NAME); |
| mInterfaceDestroyedListener.teardownAndInvalidate(ifaceName); |
| } |
| } |
| |
| /** |
| * Replace requestorWs in-place when iface is already enabled. |
| */ |
| public boolean replaceRequestorWs(WorkSource requestorWs) { |
| if (mHalDeviceManager.isSupported()) { |
| if (mIWifiP2pIface == null) return false; |
| return mHalDeviceManager.replaceRequestorWs(mIWifiP2pIface, requestorWs); |
| } else { |
| Log.i(TAG, "HAL (HIDL) is not supported. Ignore replace requestorWs"); |
| return true; |
| } |
| } |
| |
| /** |
| * Set WPS device name. |
| * |
| * @param name String to be set. |
| * @return true if request is sent successfully, false otherwise. |
| */ |
| public boolean setDeviceName(String name) { |
| return mSupplicantP2pIfaceHal.setWpsDeviceName(name); |
| } |
| |
| /** |
| * Populate list of available networks or update existing list. |
| * |
| * @return true, if list has been modified. |
| */ |
| public boolean p2pListNetworks(WifiP2pGroupList groups) { |
| return mSupplicantP2pIfaceHal.loadGroups(groups); |
| } |
| |
| /** |
| * Initiate WPS Push Button setup. |
| * The PBC operation requires that a button is also pressed at the |
| * AP/Registrar at about the same time (2 minute window). |
| * |
| * @param iface Group interface name to use. |
| * @param bssid BSSID of the AP. Use zero'ed bssid to indicate wildcard. |
| * @return true, if operation was successful. |
| */ |
| public boolean startWpsPbc(String iface, String bssid) { |
| return mSupplicantP2pIfaceHal.startWpsPbc(iface, bssid); |
| } |
| |
| /** |
| * Initiate WPS Pin Keypad setup. |
| * |
| * @param iface Group interface name to use. |
| * @param pin 8 digit pin to be used. |
| * @return true, if operation was successful. |
| */ |
| public boolean startWpsPinKeypad(String iface, String pin) { |
| return mSupplicantP2pIfaceHal.startWpsPinKeypad(iface, pin); |
| } |
| |
| /** |
| * Initiate WPS Pin Display setup. |
| * |
| * @param iface Group interface name to use. |
| * @param bssid BSSID of the AP. Use zero'ed bssid to indicate wildcard. |
| * @return generated pin if operation was successful, null otherwise. |
| */ |
| public String startWpsPinDisplay(String iface, String bssid) { |
| return mSupplicantP2pIfaceHal.startWpsPinDisplay(iface, bssid); |
| } |
| |
| /** |
| * Remove network with provided id. |
| * |
| * @param netId Id of the network to lookup. |
| * @return true, if operation was successful. |
| */ |
| public boolean removeP2pNetwork(int netId) { |
| return mSupplicantP2pIfaceHal.removeNetwork(netId); |
| } |
| |
| /** |
| * Set WPS device name. |
| * |
| * @param name String to be set. |
| * @return true if request is sent successfully, false otherwise. |
| */ |
| public boolean setP2pDeviceName(String name) { |
| return mSupplicantP2pIfaceHal.setWpsDeviceName(name); |
| } |
| |
| /** |
| * Set WPS device type. |
| * |
| * @param type Type specified as a string. Used format: <categ>-<OUI>-<subcateg> |
| * @return true if request is sent successfully, false otherwise. |
| */ |
| public boolean setP2pDeviceType(String type) { |
| return mSupplicantP2pIfaceHal.setWpsDeviceType(type); |
| } |
| |
| /** |
| * Set WPS config methods |
| * |
| * @param cfg List of config methods. |
| * @return true if request is sent successfully, false otherwise. |
| */ |
| public boolean setConfigMethods(String cfg) { |
| return mSupplicantP2pIfaceHal.setWpsConfigMethods(cfg); |
| } |
| |
| /** |
| * Set the postfix to be used for P2P SSID's. |
| * |
| * @param postfix String to be appended to SSID. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean setP2pSsidPostfix(String postfix) { |
| return mSupplicantP2pIfaceHal.setSsidPostfix(postfix); |
| } |
| |
| /** |
| * Set the Maximum idle time in seconds for P2P groups. |
| * This value controls how long a P2P group is maintained after there |
| * is no other members in the group. As a group owner, this means no |
| * associated stations in the group. As a P2P client, this means no |
| * group owner seen in scan results. |
| * |
| * @param iface Group interface name to use. |
| * @param time Timeout value in seconds. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean setP2pGroupIdle(String iface, int time) { |
| return mSupplicantP2pIfaceHal.setGroupIdle(iface, time); |
| } |
| |
| /** |
| * Turn on/off power save mode for the interface. |
| * |
| * @param iface Group interface name to use. |
| * @param enabled Indicate if power save is to be turned on/off. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean setP2pPowerSave(String iface, boolean enabled) { |
| return mSupplicantP2pIfaceHal.setPowerSave(iface, enabled); |
| } |
| |
| /** |
| * Enable/Disable Wifi Display. |
| * |
| * @param enable true to enable, false to disable. |
| * @return true, if operation was successful. |
| */ |
| public boolean setWfdEnable(boolean enable) { |
| return mSupplicantP2pIfaceHal.enableWfd(enable); |
| } |
| |
| /** |
| * Set Wifi Display device info. |
| * |
| * @param hex WFD device info as described in section 5.1.2 of WFD technical |
| * specification v1.0.0. |
| * @return true, if operation was successful. |
| */ |
| public boolean setWfdDeviceInfo(String hex) { |
| return mSupplicantP2pIfaceHal.setWfdDeviceInfo(hex); |
| } |
| |
| /** |
| * Initiate a P2P service discovery indefinitely. |
| * Will trigger {@link WifiP2pMonitor#P2P_DEVICE_FOUND_EVENT} on finding devices. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pFind() { |
| return p2pFind(0); |
| } |
| |
| /** |
| * Initiate a P2P service discovery with a (optional) timeout. |
| * |
| * @param timeout Max time to be spent is peforming discovery. |
| * Set to 0 to indefinely continue discovery untill and explicit |
| * |stopFind| is sent. |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pFind(int timeout) { |
| return mSupplicantP2pIfaceHal.find(timeout); |
| } |
| |
| /** |
| * Stop an ongoing P2P service discovery. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pStopFind() { |
| return mSupplicantP2pIfaceHal.stopFind(); |
| } |
| |
| /** |
| * Configure Extended Listen Timing. |
| * |
| * If enabled, listen state must be entered every |intervalInMillis| for at |
| * least |periodInMillis|. Both values have acceptable range of 1-65535 |
| * (with interval obviously having to be larger than or equal to duration). |
| * If the P2P module is not idle at the time the Extended Listen Timing |
| * timeout occurs, the Listen State operation must be skipped. |
| * |
| * @param enable Enables or disables listening. |
| * @param period Period in milliseconds. |
| * @param interval Interval in milliseconds. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pExtListen(boolean enable, int period, int interval) { |
| return mSupplicantP2pIfaceHal.configureExtListen(enable, period, interval); |
| } |
| |
| /** |
| * Set P2P Listen channel. |
| * |
| * When specifying a social channel on the 2.4 GHz band (1/6/11) there is no |
| * need to specify the operating class since it defaults to 81. When |
| * specifying a social channel on the 60 GHz band (2), specify the 60 GHz |
| * operating class (180). |
| * |
| * @param lc Wifi channel. eg, 1, 6, 11. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pSetListenChannel(int lc) { |
| return mSupplicantP2pIfaceHal.setListenChannel(lc); |
| } |
| |
| /** |
| * Set P2P operating channel. |
| * |
| * @param oc Wifi channel, eg, 1, 6, 11. |
| * @param unsafeChannels channels are not allowed. |
| * @return true if operation was successful. |
| */ |
| public boolean p2pSetOperatingChannel(int oc, @NonNull List<CoexUnsafeChannel> unsafeChannels) { |
| if (null == unsafeChannels) { |
| Log.wtf(TAG, "unsafeChannels is null."); |
| return false; |
| } |
| return mSupplicantP2pIfaceHal.setOperatingChannel(oc, unsafeChannels); |
| } |
| |
| /** |
| * Flush P2P peer table and state. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pFlush() { |
| return mSupplicantP2pIfaceHal.flush(); |
| } |
| |
| /** |
| * Start P2P group formation with a discovered P2P peer. This includes |
| * optional group owner negotiation, group interface setup, provisioning, |
| * and establishing data connection. |
| * |
| * @param config Configuration to use to connect to remote device. |
| * @param joinExistingGroup Indicates that this is a command to join an |
| * existing group as a client. It skips the group owner negotiation |
| * part. This must send a Provision Discovery Request message to the |
| * target group owner before associating for WPS provisioning. |
| * |
| * @return String containing generated pin, if selected provision method |
| * uses PIN. |
| */ |
| public String p2pConnect(WifiP2pConfig config, boolean joinExistingGroup) { |
| return mSupplicantP2pIfaceHal.connect(config, joinExistingGroup); |
| } |
| |
| /** |
| * Cancel an ongoing P2P group formation and joining-a-group related |
| * operation. This operation unauthorizes the specific peer device (if any |
| * had been authorized to start group formation), stops P2P find (if in |
| * progress), stops pending operations for join-a-group, and removes the |
| * P2P group interface (if one was used) that is in the WPS provisioning |
| * step. If the WPS provisioning step has been completed, the group is not |
| * terminated. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pCancelConnect() { |
| return mSupplicantP2pIfaceHal.cancelConnect(); |
| } |
| |
| /** |
| * Send P2P provision discovery request to the specified peer. The |
| * parameters for this command are the P2P device address of the peer and the |
| * desired configuration method. |
| * |
| * @param config Config class describing peer setup. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pProvisionDiscovery(WifiP2pConfig config) { |
| return mSupplicantP2pIfaceHal.provisionDiscovery(config); |
| } |
| |
| /** |
| * Set up a P2P group owner manually. |
| * This is a helper method that invokes groupAdd(networkId, isPersistent) internally. |
| * |
| * @param persistent Used to request a persistent group to be formed. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pGroupAdd(boolean persistent) { |
| return mSupplicantP2pIfaceHal.groupAdd(persistent); |
| } |
| |
| /** |
| * Set up a P2P group owner manually (i.e., without group owner |
| * negotiation with a specific peer). This is also known as autonomous |
| * group owner. |
| * |
| * @param netId Used to specify the restart of a persistent group. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pGroupAdd(int netId) { |
| return mSupplicantP2pIfaceHal.groupAdd(netId, true); |
| } |
| |
| /** |
| * Set up a P2P group as Group Owner or join a group with a configuration. |
| * |
| * @param config Used to specify config for setting up a P2P group |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pGroupAdd(WifiP2pConfig config, boolean join) { |
| int freq = 0; |
| switch (config.groupOwnerBand) { |
| case WifiP2pConfig.GROUP_OWNER_BAND_2GHZ: |
| freq = 2; |
| break; |
| case WifiP2pConfig.GROUP_OWNER_BAND_5GHZ: |
| freq = 5; |
| break; |
| // treat it as frequency. |
| default: |
| freq = config.groupOwnerBand; |
| } |
| abortWifiRunningScanIfNeeded(join); |
| return mSupplicantP2pIfaceHal.groupAdd( |
| config.networkName, |
| config.passphrase, |
| (config.netId == WifiP2pGroup.NETWORK_ID_PERSISTENT), |
| freq, config.deviceAddress, join); |
| } |
| |
| private void abortWifiRunningScanIfNeeded(boolean isJoin) { |
| if (!isJoin) return; |
| |
| Set<String> wifiClientInterfaces = mWifiNative.getClientInterfaceNames(); |
| |
| for (String interfaceName: wifiClientInterfaces) { |
| mWifiNl80211Manager.abortScan(interfaceName); |
| } |
| } |
| |
| /** |
| * Terminate a P2P group. If a new virtual network interface was used for |
| * the group, it must also be removed. The network interface name of the |
| * group interface is used as a parameter for this command. |
| * |
| * @param iface Group interface name to use. |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pGroupRemove(String iface) { |
| return mSupplicantP2pIfaceHal.groupRemove(iface); |
| } |
| |
| /** |
| * Reject connection attempt from a peer (specified with a device |
| * address). This is a mechanism to reject a pending group owner negotiation |
| * with a peer and request to automatically block any further connection or |
| * discovery of the peer. |
| * |
| * @param deviceAddress MAC address of the device to reject. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pReject(String deviceAddress) { |
| return mSupplicantP2pIfaceHal.reject(deviceAddress); |
| } |
| |
| /** |
| * Invite a device to a persistent group. |
| * If the peer device is the group owner of the persistent group, the peer |
| * parameter is not needed. Otherwise it is used to specify which |
| * device to invite. |goDeviceAddress| parameter may be used to override |
| * the group owner device address for Invitation Request should it not be |
| * known for some reason (this should not be needed in most cases). |
| * |
| * @param group Group object to use. |
| * @param deviceAddress MAC address of the device to invite. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pInvite(WifiP2pGroup group, String deviceAddress) { |
| return mSupplicantP2pIfaceHal.invite(group, deviceAddress); |
| } |
| |
| /** |
| * Reinvoke a device from a persistent group. |
| * |
| * @param netId Used to specify the persistent group. |
| * @param deviceAddress MAC address of the device to reinvoke. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pReinvoke(int netId, String deviceAddress) { |
| return mSupplicantP2pIfaceHal.reinvoke(netId, deviceAddress); |
| } |
| |
| /** |
| * Gets the operational SSID of the device. |
| * |
| * @param deviceAddress MAC address of the peer. |
| * |
| * @return SSID of the device. |
| */ |
| public String p2pGetSsid(String deviceAddress) { |
| return mSupplicantP2pIfaceHal.getSsid(deviceAddress); |
| } |
| |
| /** |
| * Gets the MAC address of the device. |
| * |
| * @return MAC address of the device. |
| */ |
| public String p2pGetDeviceAddress() { |
| return mSupplicantP2pIfaceHal.getDeviceAddress(); |
| } |
| |
| /** |
| * Gets the capability of the group which the device is a |
| * member of. |
| * |
| * @param deviceAddress MAC address of the peer. |
| * |
| * @return combination of |GroupCapabilityMask| values. |
| */ |
| public int getGroupCapability(String deviceAddress) { |
| return mSupplicantP2pIfaceHal.getGroupCapability(deviceAddress); |
| } |
| |
| /** |
| * This command can be used to add a upnp/bonjour service. |
| * |
| * @param servInfo List of service queries. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pServiceAdd(WifiP2pServiceInfo servInfo) { |
| return mSupplicantP2pIfaceHal.serviceAdd(servInfo); |
| } |
| |
| /** |
| * This command can be used to remove a upnp/bonjour service. |
| * |
| * @param servInfo List of service queries. |
| * |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pServiceDel(WifiP2pServiceInfo servInfo) { |
| return mSupplicantP2pIfaceHal.serviceRemove(servInfo); |
| } |
| |
| /** |
| * This command can be used to flush all services from the |
| * device. |
| * |
| * @return boolean value indicating whether operation was successful. |
| */ |
| public boolean p2pServiceFlush() { |
| return mSupplicantP2pIfaceHal.serviceFlush(); |
| } |
| |
| /** |
| * Schedule a P2P service discovery request. The parameters for this command |
| * are the device address of the peer device (or 00:00:00:00:00:00 for |
| * wildcard query that is sent to every discovered P2P peer that supports |
| * service discovery) and P2P Service Query TLV(s) as hexdump. |
| * |
| * @param addr MAC address of the device to discover. |
| * @param query Hex dump of the query data. |
| * @return identifier Identifier for the request. Can be used to cancel the |
| * request. |
| */ |
| public String p2pServDiscReq(String addr, String query) { |
| return mSupplicantP2pIfaceHal.requestServiceDiscovery(addr, query); |
| } |
| |
| /** |
| * Cancel a previous service discovery request. |
| * |
| * @param id Identifier for the request to cancel. |
| * @return true, if operation was successful. |
| */ |
| public boolean p2pServDiscCancelReq(String id) { |
| return mSupplicantP2pIfaceHal.cancelServiceDiscovery(id); |
| } |
| |
| /** |
| * Send driver command to set Miracast mode. |
| * |
| * @param mode Mode of Miracast. |
| * 0 = disabled |
| * 1 = operating as source |
| * 2 = operating as sink |
| */ |
| public void setMiracastMode(int mode) { |
| mSupplicantP2pIfaceHal.setMiracastMode(mode); |
| } |
| |
| /** |
| * Get NFC handover request message. |
| * |
| * @return select message if created successfully, null otherwise. |
| */ |
| public String getNfcHandoverRequest() { |
| return mSupplicantP2pIfaceHal.getNfcHandoverRequest(); |
| } |
| |
| /** |
| * Get NFC handover select message. |
| * |
| * @return select message if created successfully, null otherwise. |
| */ |
| public String getNfcHandoverSelect() { |
| return mSupplicantP2pIfaceHal.getNfcHandoverSelect(); |
| } |
| |
| /** |
| * Report NFC handover select message. |
| * |
| * @return true if reported successfully, false otherwise. |
| */ |
| public boolean initiatorReportNfcHandover(String selectMessage) { |
| return mSupplicantP2pIfaceHal.initiatorReportNfcHandover(selectMessage); |
| } |
| |
| /** |
| * Report NFC handover request message. |
| * |
| * @return true if reported successfully, false otherwise. |
| */ |
| public boolean responderReportNfcHandover(String requestMessage) { |
| return mSupplicantP2pIfaceHal.responderReportNfcHandover(requestMessage); |
| } |
| |
| /** |
| * Set the client list for the provided network. |
| * |
| * @param netId Id of the network. |
| * @return Space separated list of clients if successfull, null otherwise. |
| */ |
| public String getP2pClientList(int netId) { |
| return mSupplicantP2pIfaceHal.getClientList(netId); |
| } |
| |
| /** |
| * Set the client list for the provided network. |
| * |
| * @param netId Id of the network. |
| * @param list Space separated list of clients. |
| * @return true, if operation was successful. |
| */ |
| public boolean setP2pClientList(int netId, String list) { |
| return mSupplicantP2pIfaceHal.setClientList(netId, list); |
| } |
| |
| /** |
| * Save the current configuration to p2p_supplicant.conf. |
| * |
| * @return true on success, false otherwise. |
| */ |
| public boolean saveConfig() { |
| return mSupplicantP2pIfaceHal.saveConfig(); |
| } |
| |
| /** |
| * Enable/Disable MAC randomization. |
| * |
| * @param enable true to enable, false to disable. |
| * @return true, if operation was successful. |
| */ |
| public boolean setMacRandomization(boolean enable) { |
| return mSupplicantP2pIfaceHal.setMacRandomization(enable); |
| } |
| |
| /** |
| * Get the supported features |
| * |
| * @param ifaceName Name of the interface. |
| * @return bitmask defined by WifiManager.WIFI_FEATURE_* |
| */ |
| public long getSupportedFeatureSet(@NonNull String ifaceName) { |
| return mWifiVendorHal.getSupportedFeatureSet(ifaceName); |
| } |
| |
| /** |
| * Set Wifi Display R2 device info. |
| * |
| * @param hex WFD device info as described in section 5.1.12 of WFD technical |
| * specification v2.1.0. |
| * @return true, if operation was successful. |
| */ |
| public boolean setWfdR2DeviceInfo(String hex) { |
| return mSupplicantP2pIfaceHal.setWfdR2DeviceInfo(hex); |
| } |
| } |
