/*
* 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 android.net.wifi;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pGroup;
import android.net.wifi.p2p.WifiP2pDevice;
import android.util.Log;
import java.io.InputStream;
import java.lang.Process;
import java.util.ArrayList;
import java.util.List;
/**
* Native calls for sending requests to the supplicant daemon, and for
* receiving asynchronous events. All methods of the form "xxxxCommand()"
* must be single-threaded, to avoid requests and responses initiated
* from multiple threads from being intermingled.
* <p/>
* Note that methods whose names are not of the form "xxxCommand()" do
* not talk to the supplicant daemon.
* Also, note that all WifiNative calls should happen in the
* WifiStateTracker class except for waitForEvent() call which is
* on a separate monitor channel for WifiMonitor
*
* TODO: clean up the API and move the functionality from JNI to here. We should
* be able to get everything done with doBooleanCommand, doIntCommand and
* doStringCommand native commands
*
* {@hide}
*/
public class WifiNative {
static final int BLUETOOTH_COEXISTENCE_MODE_ENABLED = 0;
static final int BLUETOOTH_COEXISTENCE_MODE_DISABLED = 1;
static final int BLUETOOTH_COEXISTENCE_MODE_SENSE = 2;
public native static String getErrorString(int errorCode);
public native static boolean loadDriver();
public native static boolean isDriverLoaded();
public native static boolean unloadDriver();
public native static boolean startSupplicant();
public native static boolean startP2pSupplicant();
/* Does a graceful shutdown of supplicant. Is a common stop function for both p2p and sta.
*
* Note that underneath we use a harsh-sounding "terminate" supplicant command
* for a graceful stop and a mild-sounding "stop" interface
* to kill the process
*/
public native static boolean stopSupplicant();
/* Sends a kill signal to supplicant. To be used when we have lost connection
or when the supplicant is hung */
public native static boolean killSupplicant();
public native static boolean connectToSupplicant();
public native static void closeSupplicantConnection();
public native static boolean pingCommand();
public native static boolean scanCommand(boolean forceActive);
public native static boolean setScanModeCommand(boolean setActive);
public native static String listNetworksCommand();
public native static int addNetworkCommand();
public native static boolean setNetworkVariableCommand(int netId, String name, String value);
public native static String getNetworkVariableCommand(int netId, String name);
public native static boolean removeNetworkCommand(int netId);
public native static boolean enableNetworkCommand(int netId, boolean disableOthers);
public native static boolean disableNetworkCommand(int netId);
public native static boolean reconnectCommand();
public native static boolean reassociateCommand();
public native static boolean disconnectCommand();
public native static String statusCommand();
public native static String getMacAddressCommand();
public native static String scanResultsCommand();
public native static boolean startDriverCommand();
public native static boolean stopDriverCommand();
/**
* Start filtering out Multicast V4 packets
* @return {@code true} if the operation succeeded, {@code false} otherwise
*/
public native static boolean startFilteringMulticastV4Packets();
/**
* Stop filtering out Multicast V4 packets.
* @return {@code true} if the operation succeeded, {@code false} otherwise
*/
public native static boolean stopFilteringMulticastV4Packets();
/**
* Start filtering out Multicast V6 packets
* @return {@code true} if the operation succeeded, {@code false} otherwise
*/
public native static boolean startFilteringMulticastV6Packets();
/**
* Stop filtering out Multicast V6 packets.
* @return {@code true} if the operation succeeded, {@code false} otherwise
*/
public native static boolean stopFilteringMulticastV6Packets();
public native static boolean setPowerModeCommand(int mode);
public native static int getBandCommand();
public native static boolean setBandCommand(int band);
public native static int getPowerModeCommand();
/**
* Sets the bluetooth coexistence mode.
*
* @param mode One of {@link #BLUETOOTH_COEXISTENCE_MODE_DISABLED},
* {@link #BLUETOOTH_COEXISTENCE_MODE_ENABLED}, or
* {@link #BLUETOOTH_COEXISTENCE_MODE_SENSE}.
* @return Whether the mode was successfully set.
*/
public native static boolean setBluetoothCoexistenceModeCommand(int mode);
/**
* Enable or disable Bluetooth coexistence scan mode. When this mode is on,
* some of the low-level scan parameters used by the driver are changed to
* reduce interference with A2DP streaming.
*
* @param isSet whether to enable or disable this mode
* @return {@code true} if the command succeeded, {@code false} otherwise.
*/
public native static boolean setBluetoothCoexistenceScanModeCommand(boolean setCoexScanMode);
public native static boolean saveConfigCommand();
public native static boolean reloadConfigCommand();
public native static boolean setScanResultHandlingCommand(int mode);
public native static boolean addToBlacklistCommand(String bssid);
public native static boolean clearBlacklistCommand();
public native static boolean startWpsPbcCommand(String bssid);
public native static boolean startWpsWithPinFromAccessPointCommand(String bssid, String apPin);
public native static String startWpsWithPinFromDeviceCommand(String bssid);
public native static boolean setSuspendOptimizationsCommand(boolean enabled);
public native static boolean setCountryCodeCommand(String countryCode);
/**
* Wait for the supplicant to send an event, returning the event string.
* @return the event string sent by the supplicant.
*/
public native static String waitForEvent();
public native static void enableBackgroundScanCommand(boolean enable);
public native static void setScanIntervalCommand(int scanInterval);
private native static boolean doBooleanCommand(String command);
private native static int doIntCommand(String command);
private native static String doStringCommand(String command);
/** Example output:
* RSSI=-65
* LINKSPEED=48
* NOISE=9999
* FREQUENCY=0
*/
public static String signalPoll() {
return doStringCommand("SIGNAL_POLL");
}
public static boolean wpsPbc() {
return doBooleanCommand("WPS_PBC");
}
public static boolean wpsPin(String pin) {
return doBooleanCommand("WPS_PIN any " + pin);
}
public static boolean setPersistentReconnect(boolean enabled) {
int value = (enabled == true) ? 1 : 0;
return WifiNative.doBooleanCommand("SET persistent_reconnect " + value);
}
public static boolean setDeviceName(String name) {
return WifiNative.doBooleanCommand("SET device_name " + name);
}
public static boolean setDeviceType(String type) {
return WifiNative.doBooleanCommand("SET device_type " + type);
}
public static boolean p2pFind() {
return doBooleanCommand("P2P_FIND");
}
public static boolean p2pFind(int timeout) {
if (timeout <= 0) {
return p2pFind();
}
return doBooleanCommand("P2P_FIND " + timeout);
}
public static boolean p2pListen() {
return doBooleanCommand("P2P_LISTEN");
}
public static boolean p2pListen(int timeout) {
if (timeout <= 0) {
return p2pListen();
}
return doBooleanCommand("P2P_LISTEN " + timeout);
}
public static boolean p2pFlush() {
return doBooleanCommand("P2P_FLUSH");
}
/* p2p_connect <peer device address> <pbc|pin|PIN#> [label|display|keypad]
[persistent] [join|auth] [go_intent=<0..15>] [freq=<in MHz>] */
public static String p2pConnect(WifiP2pConfig config, boolean joinExistingGroup) {
if (config == null) return null;
List<String> args = new ArrayList<String>();
WpsInfo wps = config.wps;
args.add(config.deviceAddress);
switch (wps.setup) {
case WpsInfo.PBC:
args.add("pbc");
break;
case WpsInfo.DISPLAY:
//TODO: pass the pin back for display
args.add("pin");
args.add("display");
break;
case WpsInfo.KEYPAD:
args.add(wps.pin);
args.add("keypad");
break;
case WpsInfo.LABEL:
args.add(wps.pin);
args.add("label");
default:
break;
}
//TODO: Add persist behavior once the supplicant interaction is fixed for both
// group and client scenarios
/* Persist unless there is an explicit request to not do so*/
//if (config.persist != WifiP2pConfig.Persist.NO) args.add("persistent");
if (joinExistingGroup) args.add("join");
int groupOwnerIntent = config.groupOwnerIntent;
if (groupOwnerIntent < 0 || groupOwnerIntent > 15) {
groupOwnerIntent = 3; //default value
}
args.add("go_intent=" + groupOwnerIntent);
String command = "P2P_CONNECT ";
for (String s : args) command += s + " ";
return doStringCommand(command);
}
public static boolean p2pCancelConnect() {
return doBooleanCommand("P2P_CANCEL");
}
public static boolean p2pGroupAdd() {
return doBooleanCommand("P2P_GROUP_ADD");
}
public static boolean p2pGroupRemove(String iface) {
if (iface == null) return false;
return doBooleanCommand("P2P_GROUP_REMOVE " + iface);
}
public static boolean p2pReject(String deviceAddress) {
return doBooleanCommand("P2P_REJECT " + deviceAddress);
}
/* Invite a peer to a group */
public static boolean p2pInvite(WifiP2pGroup group, String deviceAddress) {
if (deviceAddress == null) return false;
if (group == null) {
return doBooleanCommand("P2P_INVITE peer=" + deviceAddress);
} else {
return doBooleanCommand("P2P_INVITE group=" + group.getInterface()
+ " peer=" + deviceAddress + " go_dev_addr=" + group.getOwner().deviceAddress);
}
}
/* Reinvoke a persistent connection */
public static boolean p2pReinvoke(int netId, String deviceAddress) {
if (deviceAddress == null || netId < 0) return false;
return doBooleanCommand("P2P_INVITE persistent=" + netId + " peer=" + deviceAddress);
}
public static String p2pGetInterfaceAddress(String deviceAddress) {
if (deviceAddress == null) return null;
// "p2p_peer deviceAddress" returns a multi-line result containing
// intended_addr=fa:7b:7a:42:82:13
String peerInfo = p2pPeer(deviceAddress);
if (peerInfo == null) return null;
String[] tokens= peerInfo.split("\n");
for (String token : tokens) {
//TODO: update from interface_addr when wpa_supplicant implementation is fixed
if (token.startsWith("intended_addr=")) {
String[] nameValue = token.split("=");
if (nameValue.length != 2) break;
return nameValue[1];
}
}
return null;
}
public static String p2pGetDeviceAddress() {
String status = statusCommand();
if (status == null) return "";
String[] tokens = status.split("\n");
for (String token : tokens) {
if (token.startsWith("p2p_device_address=")) {
String[] nameValue = token.split("=");
if (nameValue.length != 2) break;
return nameValue[1];
}
}
return "";
}
public static String p2pPeer(String deviceAddress) {
return doStringCommand("P2P_PEER " + deviceAddress);
}
}