android - 使用 Nexus 7 创建接入点

Question

目标是什么？

使用 Android 设备(在我的例子中是 Nexus 7)创建一个接入点。最终目的是将 WiFly 卡连接到这个创建的网络并在这些设备之间交换数据。

硬件:

• Android 版本 4.2.2 的 Nexus 7 root ROM CyanogenMod 10.1
• WiFly 卡:Arduino shield 与使用 Wifi 的 Zigbee 卡布局相同 (the product)

软件:

我了解到 Android 版本 4.2.2 不允许创建访问点(该服务以编程方式禁用)。这就是为什么我使用 CyanogenMod 的 ROM 对我的设备进行 root 的原因。此 ROM 启用此服务。

Google 隐藏了类 WifiManager 中的一些方法。具体来说，方法 setWifiApEnabled。这就是我在下面的代码中使用反射来调用方法的原因。

源代码海量!关注方法createAccessPoint()。我选择将整个源代码放在一起，以帮助那些想知道我是如何做到这一切的人。

public class TestAccessPoint extends Activity {

static final String TAG = "AP_TEST";
static final String SSID = "\"Awesome Access Point\"";
static final String PSK = "\"helloworld\"";
String numberOfClientsConnected;
String wifiApEnable;
String wifiApState;
WifiConfiguration wifiApConfig;
WifiManager wifiManager;
WifiConfiguration wifiConfiguration;
BroadcastReceiver receiver;
BroadcastReceiver receiverWifiDisabled;
TextView textView;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.accesspoint_test);
    textView = (TextView) findViewById(R.id.textView);

    wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
    wifiConfiguration = new WifiConfiguration();

    if(wifiManager.isWifiEnabled()) {
        createAccessPoint();
    } else {
        Log.d(TAG, "Set wifi Enable");
        wifiManager.setWifiEnabled(true);
        receiverWifiDisabled = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN);
                if ( wifiState == WifiManager.WIFI_STATE_ENABLED ) {
                    Log.d(TAG, "Wifi enable");
                    createAccessPoint();
                }
            }
        };
        registerReceiver(receiverWifiDisabled, new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION));
    }

    final Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    textView.setText(
                        wifiApEnable + "\n" + 
                        wifiApState + "\n" +
                        "Nb of clients connected: " + numberOfClientsConnected + "\n" + 
                        "Wifi AP configuration: " + "\n" +
                        wifiApConfig.toString() + "\n" +
                        "WifiManager connection info: " +  "\n" + 
                        wifiManager.getConnectionInfo().toString() +
                        "DHCP state: " + wifiManager.getDhcpInfo().toString()
                    );
                break;
            }
        }
    };

    Thread thread = new Thread(new Runnable() {
        boolean alive = true;
        @Override
        public void run() {
            while(alive) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) { e.printStackTrace(); }

                numberOfClientsConnected = numberOfClientsConnected();
                wifiApEnable = isWifiApEnabled();
                wifiApState = getWifiApState();
                wifiApConfig = getWifiApConfiguration();

                mHandler.sendMessage(mHandler.obtainMessage(1));
            }
        }
    });
    thread.start();
}

@Override 
public void onDestroy() {
    super.onDestroy();
    if(receiver != null) {
        unregisterReceiver(receiver);
    }
    if(receiverWifiDisabled != null) {
        unregisterReceiver(receiverWifiDisabled);
    }
}

protected void createAccessPoint() {
    // Check if the Wifi configuration already exists
    List<WifiConfiguration> list = wifiManager.getConfiguredNetworks();
    int networkID = -1;
    if(list != null){
        for(WifiConfiguration conf : list) {
            Log.d(TAG, "Network ID: " + String.valueOf(conf.networkId) + " ; Network SSID: " + conf.SSID);
            if(conf.SSID.equals(SSID)) {
                Log.d(TAG, "SSID found");
                networkID = conf.networkId;
                wifiConfiguration = conf;
                break;
            }
        } 
    } else
        Log.d(TAG, "List of WifiConfiguration is null");

    // If the configuration exists, remove it to recreate it from scratch
    if(networkID != -1) {
        wifiManager.removeNetwork(networkID);
    }

    // Create a new WiFi configuration
    wifiConfiguration.SSID = SSID;
    wifiConfiguration.preSharedKey = PSK;
    wifiConfiguration.hiddenSSID = false;
    wifiConfiguration.status = WifiConfiguration.Status.ENABLED;

    wifiConfiguration.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
    wifiConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);

    wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);

    wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);

    wifiConfiguration.allowedProtocols.set(WifiConfiguration.Protocol.RSN);

    // Catch Enumeration IpAssignment and ProxySettings from WifiConfiguration
    Enum ipAssignment = catchEnumIpAssignmentFromWifiConfiguration();
    Enum proxySettings = catchEnumProxySettingsFromWifiConfiguration();

    // Set IP address, gateway, DNS, etc
    try {
        Log.d(TAG, "Try to set IP, gateway and DNS");
        setIpAssignment(ipAssignment, wifiConfiguration);
        Log.d(TAG, "IpAssignment: Ok");
        setProxySettings(proxySettings, wifiConfiguration);
        Log.d(TAG, "ProxySettings: Ok");
        setIpAddress(InetAddress.getByName("192.168.2.100"), 24, wifiConfiguration);
        Log.d(TAG, "IpAddress: Ok");
        setGateway(InetAddress.getByName("192.168.2.1"), wifiConfiguration);
        Log.d(TAG, "Gateway: Ok");
        setDNS(InetAddress.getByName("192.168.2.1"), wifiConfiguration);
        Log.d(TAG, "DNS: Ok");
    } catch(Exception e) {
        e.printStackTrace();
    }

    // Add this new configuration to the wpa_supplicant file
    networkID = wifiManager.addNetwork(wifiConfiguration);
    if(networkID != -1)
        Log.d(TAG, "Succeed to update the WiFi configuration: " + networkID);
    else
        Log.d(TAG, "Failed to update the WiFi configuration");

    // Save the new configuration on the wpa_supplicant
    if(wifiManager.saveConfiguration())
        Log.d(TAG, "Succeed to save the wpa_supplicant");
    else
        Log.d(TAG, "Failed to save the wpa_supplicant");

    // Set the Wifi disable to be able to start the Access Point
    Log.d(TAG, "Set wifi disable");
    wifiManager.setWifiEnabled(false);

    receiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN);
            if ( wifiState == WifiManager.WIFI_STATE_DISABLED ) {
                Log.d(TAG, "Wifi disabled");
                // When the Wifi is disable
                // Create the Access Point with the WiFi configuration
                try {
                    Method m = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
                    boolean succeed = (Boolean) m.invoke(wifiManager, wifiConfiguration, true);
                    if(succeed)
                        Log.d(TAG, "Succeed to set wifi AP");
                    else
                        Log.d(TAG, "A problem occured while setting the wifi AP");
                } catch (Exception e) {
                    Log.e(TAG, "Failed to set wifi AP", e);
                }
            }
        }
    };
    registerReceiver(receiver, new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION));
}

protected String getWifiApState() {
    try {
        Method m3 = wifiManager.getClass().getMethod("getWifiApState");
        return "WiFi Ap State: " + String.valueOf(m3.invoke(wifiManager));
    } catch (NoSuchMethodException e1) {    e1.printStackTrace();
    } catch (IllegalArgumentException e) {  e.printStackTrace();
    } catch (IllegalAccessException e) {    e.printStackTrace();
    } catch (InvocationTargetException e) { e.printStackTrace(); }
    return null;
}

protected WifiConfiguration getWifiApConfiguration() {
    WifiConfiguration wifiConfiguration = null;
    try {
        Method m4 = wifiManager.getClass().getMethod("getWifiApConfiguration");
        wifiConfiguration = (WifiConfiguration) m4.invoke(wifiManager);
    } catch (Exception e) { e.printStackTrace(); }
    return wifiConfiguration;
}

protected String isWifiApEnabled() {
    try {
        Method m = wifiManager.getClass().getMethod("isWifiApEnabled");
        if((Boolean) m.invoke(wifiManager))
            return "WiFiAP enabled";
        else
            return "WiFiAP not enabled";
    } catch (Exception e) { e.printStackTrace(); }
    return null;
}

protected String numberOfClientsConnected() {
    int macCount = 0;
    BufferedReader br = null;
    try {
        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) {
                String mac = splitted[3];
                if (mac.matches("..:..:..:..:..:..")) {
                    macCount++;
                } 
            }
        }
    } catch (Exception e) { e.printStackTrace();
    } finally {
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return String.valueOf(macCount);        
}

@SuppressWarnings({ "unchecked", "rawtypes" })
protected Enum catchEnumIpAssignmentFromWifiConfiguration() {
    Enum DHCP = null;
    try {
        Class<Enum> enumIpAssignment = (Class<Enum>) Class.forName("android.net.wifi.WifiConfiguration$IpAssignment");
        DHCP = Enum.valueOf(enumIpAssignment, "DHCP");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return DHCP;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
protected Enum catchEnumProxySettingsFromWifiConfiguration() {
    Enum ProxySet = null;
    try {
        Class<Enum> enumProxySettings = (Class<Enum>) Class.forName("android.net.wifi.WifiConfiguration$ProxySettings");
        ProxySet = Enum.valueOf(enumProxySettings, "NONE");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return ProxySet;
}

public static void setIpAssignment(Object assign , WifiConfiguration wifiConf)
        throws SecurityException, IllegalArgumentException, NoSuchFieldException, IllegalAccessException {
    setEnumField(wifiConf, assign, "ipAssignment");     
}

public static void setProxySettings(Object assign , WifiConfiguration wifiConf)
        throws SecurityException, IllegalArgumentException, NoSuchFieldException, IllegalAccessException {
    setEnumField(wifiConf, assign, "proxySettings");     
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public static void setIpAddress(InetAddress addr, int prefixLength, WifiConfiguration wifiConf)
        throws SecurityException, IllegalArgumentException, NoSuchFieldException, IllegalAccessException,
        NoSuchMethodException, ClassNotFoundException, InstantiationException, InvocationTargetException {
    Object linkProperties = getField(wifiConf, "linkProperties");
    if(linkProperties == null) return;
    Class laClass = Class.forName("android.net.LinkAddress");
    Constructor laConstructor = laClass.getConstructor(new Class[]{InetAddress.class, int.class});
    Object linkAddress = laConstructor.newInstance(addr, prefixLength);

    ArrayList mLinkAddresses = (ArrayList)getDeclaredField(linkProperties, "mLinkAddresses");
    mLinkAddresses.clear();
    mLinkAddresses.add(linkAddress);     
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public static void setGateway(InetAddress gateway, WifiConfiguration wifiConf)
        throws SecurityException, IllegalArgumentException, NoSuchFieldException, IllegalAccessException, 
        ClassNotFoundException, NoSuchMethodException, InstantiationException, InvocationTargetException {
    Object linkProperties = getField(wifiConf, "linkProperties");
    if(linkProperties == null)return;
    Class routeInfoClass = Class.forName("android.net.RouteInfo");
    Constructor routeInfoConstructor = routeInfoClass.getConstructor(new Class[]{InetAddress.class});
    Object routeInfo = routeInfoConstructor.newInstance(gateway);

    ArrayList mRoutes = (ArrayList)getDeclaredField(linkProperties, "mRoutes");
    mRoutes.clear();
    mRoutes.add(routeInfo);
}

@SuppressWarnings("unchecked")
public static void setDNS(InetAddress dns, WifiConfiguration wifiConf)
        throws SecurityException, IllegalArgumentException, NoSuchFieldException, IllegalAccessException {
    Object linkProperties = getField(wifiConf, "linkProperties");
    if(linkProperties == null)return;

    ArrayList<InetAddress> mDnses = (ArrayList<InetAddress>)getDeclaredField(linkProperties, "mDnses");
    mDnses.clear();
    mDnses.add(dns); 
}

public static Object getField(Object obj, String name)
        throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
    Field f = obj.getClass().getField(name);
    Object out = f.get(obj);
    return out;
}

public static Object getDeclaredField(Object obj, String name)
        throws SecurityException, NoSuchFieldException,
        IllegalArgumentException, IllegalAccessException {
    Field f = obj.getClass().getDeclaredField(name);
    f.setAccessible(true);
    Object out = f.get(obj);
    return out;
}  

public static void setEnumField(Object obj, Object value, String name)
        throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
    Field f = obj.getClass().getField(name);
    f.set(obj, value);
}
}

此代码在我的 Nexus 7 上运行良好。它创建了一个接入点。我的笔记本电脑看到网络链接:

它要求我输入 WPA key 。无论它是否有效，我都需要用引号将其括起来 ("helloworld")。

在那之后，我的笔记本电脑连接到网络但带有软件Xirrus我意识到 DHCP 模块不提供任何 IP 地址。

日志:

我得到两个有趣的日志。这是我启动应用程序时的情况:

E/hostapd(): Configuration file: /data/misc/wifi/hostapd.conf
E/hostapd(): HT (IEEE 802.11n) in 11b mode is not allowed, disabling HT capabilites
I/hostapd(): rfkill: Cannot open RFKILL control device
W/hostapd(): wlan0: Could not connect to kernel driver
E/hostapd(): Using interface wlan0 with hwaddr 02:1a:11:fd:32:58 and ssid "\"Awesome Access Point\""
E/hostapd(): random: Cannot read from /dev/random: Try again
I/hostapd(): random: Only 0/20 bytes of strong random data available from /dev/random
I/hostapd(): random: Allow operation to proceed based on internal entropy

这是我将笔记本电脑与接入点连接和断开连接时的情况:

I/hostapd(): wlan0: AP-STA-DISCONNECTED 00:27:10:ca:f0:80
I/hostapd(): wlan0: AP-STA-CONNECTED 00:27:10:ca:f0:80

问题:

• 如果您认为我做错了，能告诉我更好的方法吗？
• 你知道为什么我没有从 DHCP 模块获得 IP 地址吗？
• 你知道我可以从 DHCP 模块获得更多信息/日志吗？

感谢您的支持。

Answer 1

不幸的是，这是不可能的。用于 Nexus 7 的 Android ROM 的库存版本根本没有创建 WiFi 接入点的能力(默认情况下它是关闭的)。唯一合理的方法是根设备并加载一些自定义 ROM，如 CyanogenMod 或类似的东西。例如，CyanogenMod 已启用该功能。

很抱歉让您失望了，但是对于常规固件，这是根本不可能的。