Android Wifi Hotspot Manager Class

zhouyi

　　http://www.whitebyte.info/android/android-wifi-hotspot-manager-class
　　



package com.whitebyte.wifihotspotutils;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.util.ArrayList;
import android.content.Context;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.util.Log;
public class WifiApManager {
private final WifiManager mWifiManager;
public WifiApManager(Context context) {
mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
}
/**
* Start AccessPoint mode with the specified
* configuration. If the radio is already running in
* AP mode, update the new configuration
* Note that starting in access point mode disables station
* mode operation
* @param wifiConfig SSID, security and channel details as part of WifiConfiguration
* @return {@code true} if the operation succeeds, {@code false} otherwise
*/
public boolean setWifiApEnabled(WifiConfiguration wifiConfig, boolean enabled) {
try {
if (enabled) { // disable WiFi in any case
mWifiManager.setWifiEnabled(false);
}
Method method = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
return (Boolean) method.invoke(mWifiManager, wifiConfig, enabled);
} catch (Exception e) {
Log.e(this.getClass().toString(), "", e);
return false;
}
}
/**
* Gets the Wi-Fi enabled state.
* @return {@link WIFI_AP_STATE}
* @see #isWifiApEnabled()
*/
public WIFI_AP_STATE getWifiApState() {
try {
Method method = mWifiManager.getClass().getMethod("getWifiApState");
int tmp = ((Integer)method.invoke(mWifiManager));
// Fix for Android 4
if (tmp > 10) {
tmp = tmp - 10;
}
return WIFI_AP_STATE.class.getEnumConstants()[tmp];
} catch (Exception e) {
Log.e(this.getClass().toString(), "", e);
return WIFI_AP_STATE.WIFI_AP_STATE_FAILED;
}
}
/**
* Return whether Wi-Fi AP is enabled or disabled.
* @return {@code true} if Wi-Fi AP is enabled
* @see #getWifiApState()
*
* @hide Dont open yet
*/
public boolean isWifiApEnabled() {
return getWifiApState() == WIFI_AP_STATE.WIFI_AP_STATE_ENABLED;
}
/**
* Gets the Wi-Fi AP Configuration.
* @return AP details in {@link WifiConfiguration}
*/
public WifiConfiguration getWifiApConfiguration() {
try {
Method method = mWifiManager.getClass().getMethod("getWifiApConfiguration");
return (WifiConfiguration) method.invoke(mWifiManager);
} catch (Exception e) {
Log.e(this.getClass().toString(), "", e);
return null;
}
}
/**
* Sets the Wi-Fi AP Configuration.
* @return {@code true} if the operation succeeded, {@code false} otherwise
*/
public boolean setWifiApConfiguration(WifiConfiguration wifiConfig) {
try {
Method method = mWifiManager.getClass().getMethod("setWifiApConfiguration", WifiConfiguration.class);
return (Boolean) method.invoke(mWifiManager, wifiConfig);
} catch (Exception e) {
Log.e(this.getClass().toString(), "", e);
return false;
}
}
/**
* Gets a list of the clients connected to the Hotspot, reachable timeout is 300
* @param onlyReachables {@code false} if the list should contain unreachable (probably disconnected) clients, {@code true} otherwise
* @return ArrayList of {@link ClientScanResult}
*/
public ArrayList<ClientScanResult> getClientList(boolean onlyReachables) {
return getClientList(onlyReachables, 300);
}
/**
* Gets a list of the clients connected to the Hotspot
* @param onlyReachables {@code false} if the list should contain unreachable (probably disconnected) clients, {@code true} otherwise
* @param reachableTimeout Reachable Timout in miliseconds
* @return ArrayList of {@link ClientScanResult}
*/
public ArrayList<ClientScanResult> getClientList(boolean onlyReachables, int reachableTimeout) {
BufferedReader br = null;
ArrayList<ClientScanResult> result = null;
try {
result = new ArrayList<ClientScanResult>();
br = new BufferedReader(new FileReader("/proc/net/arp"));
String line;
while ((line = br.readLine()) != null) {
String[] splitted = line.split(" +");
if ((splitted != null) && (splitted.length >= 4)) {
// Basic sanity check
String mac = splitted[3];
if (mac.matches("..:..:..:..:..:..")) {
boolean isReachable = InetAddress.getByName(splitted[0]).isReachable(reachableTimeout);
if (!onlyReachables || isReachable) {
result.add(new ClientScanResult(splitted[0], splitted[3], splitted[5], isReachable));
}
}
}
}
} catch (Exception e) {
Log.e(this.getClass().toString(), e.getMessage());
} finally {
try {
br.close();
} catch (IOException e) {
Log.e(this.getClass().toString(), e.getMessage());
}
}
return result;
}
}
　　http://xiaxingwork.iteye.com/blog/1727722
　　以下基于android ics系统
　　
　　Android AP接口属性为 @hide，不对外开放，但通过revoke机制调用到。
　　
　　Ap的几个重要接口
　　getWifiApState
　　setWifiApEnabled
　　getWifiApConfiguration
　　isWifiApEnabled



package com.lenovo.channel.method.ap.hotspot;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Build;
import com.lenovo.channel.method.ap.hotspot.Hotspot.WifiApState;
import com.lenovo.common.BeanUtils;
import com.lenovo.common.Logger;
class WifiApManager {
private static final String tag = "WifiApManager";
private static final String METHOD_GET_WIFI_AP_STATE = "getWifiApState";
private static final String METHOD_SET_WIFI_AP_ENABLED = "setWifiApEnabled";
private static final String METHOD_GET_WIFI_AP_CONFIG = "getWifiApConfiguration";
private static final String METHOD_IS_WIFI_AP_ENABLED = "isWifiApEnabled";
private static final Map<String, Method> methodMap = new HashMap<String, Method>();
private static Boolean mIsSupport;
private static boolean mIsHtc;
public synchronized static final boolean isSupport() {
if (mIsSupport != null) {
return mIsSupport;
}
boolean result = Build.VERSION.SDK_INT > Build.VERSION_CODES.FROYO;
if (result) {
try {
Field field = WifiConfiguration.class.getDeclaredField("mWifiApProfile");
mIsHtc = field != null;
} catch (Exception e) {
}
}
if (result) {
try {
String name = METHOD_GET_WIFI_AP_STATE;
Method method = WifiManager.class.getMethod(name);
methodMap.put(name, method);
result = method != null;
} catch (SecurityException e) {
Logger.e(tag, "SecurityException", e);
} catch (NoSuchMethodException e) {
Logger.e(tag, "NoSuchMethodException", e);
}
}
if (result) {
try {
String name = METHOD_SET_WIFI_AP_ENABLED;
Method method = WifiManager.class.getMethod(name, WifiConfiguration.class, boolean.class);
methodMap.put(name, method);
result = method != null;
} catch (SecurityException e) {
Logger.e(tag, "SecurityException", e);
} catch (NoSuchMethodException e) {
Logger.e(tag, "NoSuchMethodException", e);
}
}
if (result) {
try {
String name = METHOD_GET_WIFI_AP_CONFIG;
Method method = WifiManager.class.getMethod(name);
methodMap.put(name, method);
result = method != null;
} catch (SecurityException e) {
Logger.e(tag, "SecurityException", e);
} catch (NoSuchMethodException e) {
Logger.e(tag, "NoSuchMethodException", e);
}
}
if (result) {
try {
String name = getSetWifiApConfigName();
Method method = WifiManager.class.getMethod(name, WifiConfiguration.class);
methodMap.put(name, method);
result = method != null;
} catch (SecurityException e) {
Logger.e(tag, "SecurityException", e);
} catch (NoSuchMethodException e) {
Logger.e(tag, "NoSuchMethodException", e);
}
}
if (result) {
try {
String name = METHOD_IS_WIFI_AP_ENABLED;
Method method = WifiManager.class.getMethod(name);
methodMap.put(name, method);
result = method != null;
} catch (SecurityException e) {
Logger.e(tag, "SecurityException", e);
} catch (NoSuchMethodException e) {
Logger.e(tag, "NoSuchMethodException", e);
}
}
mIsSupport = result;
return isSupport();
}
private final WifiManager mWifiManager;
WifiApManager(WifiManager manager) {
if (!isSupport()) {
throw new RuntimeException("Unsupport Ap!");
}
Logger.i(tag, "Build.BRAND -----------> " + Build.BRAND);
mWifiManager = manager;
}
public WifiManager getWifiManager() {
return mWifiManager;
}
public int getWifiApState() {
try {
Method method = methodMap.get(METHOD_GET_WIFI_AP_STATE);
return (Integer) method.invoke(mWifiManager);
} catch (Exception e) {
Logger.e(tag, e.getMessage(), e);
}
return WifiApState.WIFI_AP_STATE_UNKWON;
}
private WifiConfiguration getHtcWifiApConfiguration(WifiConfiguration standard){
WifiConfiguration htcWifiConfig = standard;
try {
Object mWifiApProfileValue = BeanUtils.getFieldValue(standard, "mWifiApProfile");
if (mWifiApProfileValue != null) {
htcWifiConfig.SSID = (String)BeanUtils.getFieldValue(mWifiApProfileValue, "SSID");
}
} catch (Exception e) {
Logger.e(tag, "" + e.getMessage(), e);
}
return htcWifiConfig;
}
public WifiConfiguration getWifiApConfiguration() {
WifiConfiguration configuration = null;
try {
Method method = methodMap.get(METHOD_GET_WIFI_AP_CONFIG);
configuration = (WifiConfiguration) method.invoke(mWifiManager);
if(isHtc()){
configuration = getHtcWifiApConfiguration(configuration);
}
} catch (Exception e) {
Logger.e(tag, e.getMessage(), e);
}
return configuration;
}
public boolean setWifiApConfiguration(WifiConfiguration netConfig) {
boolean result = false;
try {
if (isHtc()) {
setupHtcWifiConfiguration(netConfig);
}
Method method = methodMap.get(getSetWifiApConfigName());
Class<?>[] params = method.getParameterTypes();
for (Class<?> clazz : params) {
Logger.i(tag, "param -> " + clazz.getSimpleName());
}
if (isHtc()) {
int rValue = (Integer) method.invoke(mWifiManager, netConfig);
Logger.i(tag, "rValue -> " + rValue);
result = rValue > 0;
} else {
result = (Boolean) method.invoke(mWifiManager, netConfig);
}
} catch (Exception e) {
Logger.e(tag, "", e);
}
return result;
}
public boolean setWifiApEnabled(WifiConfiguration configuration, boolean enabled) {
boolean result = false;
try {
Method method = methodMap.get(METHOD_SET_WIFI_AP_ENABLED);
result = (Boolean)method.invoke(mWifiManager, configuration, enabled);
} catch (Exception e) {
Logger.e(tag, e.getMessage(), e);
}
return result;
}
public boolean isWifiApEnabled() {
boolean result = false;
try {
Method method = methodMap.get(METHOD_IS_WIFI_AP_ENABLED);
result = (Boolean)method.invoke(mWifiManager);
} catch (Exception e) {
Logger.e(tag, e.getMessage(), e);
}
return result;
}
private void setupHtcWifiConfiguration(WifiConfiguration config) {
try {
Logger.d(tag, "config=  " + config);
Object mWifiApProfileValue = BeanUtils.getFieldValue(config, "mWifiApProfile");
if (mWifiApProfileValue != null) {
BeanUtils.setFieldValue(mWifiApProfileValue, "SSID", config.SSID);
BeanUtils.setFieldValue(mWifiApProfileValue, "BSSID", config.BSSID);
BeanUtils.setFieldValue(mWifiApProfileValue, "secureType", "open");
BeanUtils.setFieldValue(mWifiApProfileValue, "dhcpEnable", 1);
}
} catch (Exception e) {
Logger.e(tag, "" + e.getMessage(), e);
}
}
public static boolean isHtc() {
return mIsHtc;
}
private static String getSetWifiApConfigName() {
return mIsHtc? "setWifiApConfig": "setWifiApConfiguration";
}
}