Android wifi 使用与工具类

1.背景需求

根据客户需求，在Android系统的WIFI模块的基础上，对WIFI机能进行自定义开发。主要还是调用Android中WIFI相关的API，具体的实现过程后续会详细讲解。

2.开发流程

（1）注册WIFIBroadcastReceiver.
    WIFI的开关状态，连接状态等都是通过系统的广播通知的，我们需要WIFIBroadcastReceiver来接收WIFI的各种状态通知。

    注册之前，先需要添加相关的权限，否则无法收到系统广播
    //允许程序读写系统安全敏感的设置项
    <permission android:name="android.permission.WRITE_SECURE_SETTINGS"/>           
    //允许程序改变网络连接状态
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />      
    //改变WLAN状态的开关
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />         
    //获取网络信息状态
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />      
    //获取使用Wi-Fi等WLAN无线网络
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />  

    对于BroadcastReceiver的注册方式，可以有两种：
    ①动态注册（代码中实现）
        m_broadCastReceiver = SysMangerWIFIBroadcastReceiver.getInstance();
        m_intentFilter = new IntentFilter();
        m_intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        m_intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        m_intentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        m_intentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
        m_intentFilter.addAction(WifiClient.ACTION_WPS_PROGRESS_CHANGED);
        m_intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        context.registerReceiver(m_broadCastReceiver, m_intentFilter);

    ②Manifest文件中注册
        <receiver android:name=".SysMangerWIFIBroadcastReceiver" >
            <intent-filter>
                <action android:name="android.net.wifi.WIFI_STATE_CHANGED" />
                <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
                <action android:name="android.net.wifi.STATE_CHANGE" />
                ......
            </intent-filter>
        </receiver>

（2）新建SysMangerWIFIBroadcastReceiver.java类继承BroadcastReceiver.
    代码中接收WIFI通知，处理相关的事件。

    public void onReceive(Context arg0, Intent arg1) {

        //get the status of wifi
        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(arg1.getAction())) {
            int wifiState = arg1.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
            switch (wifiState) {
            case WifiManager.WIFI_STATE_DISABLED:
                //SysLog.out(TAG, "onReceive", "wifi disabled");
            break；
            case WifiManager.WIFI_STATE_DISABLING:
                //SysLog.out(TAG, "onReceive", "wifi disabling");
            break；
            case WifiManager.WIFI_STATE_ENABLED:
                //SysLog.out(TAG, "onReceive", "wifi enabled");
            break；
            case WifiManager.WIFI_WIFI_STATE_ENABLING:
                //SysLog.out(TAG, "onReceive", "wifi enabling");
            break；
        }

        //get the notification of pwd error
        if(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION.equals(arg1.getAction())){
            int State = arg1.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, 0);
            if(State==WifiManager.ERROR_AUTHENTICATING){
                //SysLog.out(TAG,"onReceive" , "wificonnect failure(pwd error)");
            }

        }

        //get the notification of wpsconnect
        if (WifiClient.ACTION_WPS_PROGRESS_CHANGED.equals(arg1.getAction())) {
            int status = arg1.getIntExtra(
                    WifiClient.EXTRA_WPS_PROGRESS_STATE, -1);
            switch (status) {
            case WifiClient.WPS_PROGRESS_START_COMPLETION:
                //SysLog.out(TAG, "onReceive", "Wps Completion");
            break;
            case WifiClient.WPS_PROGRESS_START_FAILURE:
                //SysLog.out(TAG, "onReceive", "Wps Start Failure");
            break;
            case WifiClient.WPS_PROGRESS_START_SUCCESS:
                //SysLog.out(TAG, "onReceive", "Wps Start Success");
            break;
            case WifiClient.WPS_PROGRESS_CANCEL_FAILURE:
                //SysLog.out(TAG, "onReceive", "Wps Cancel Failure");
            break;
        }

        //get the notification of  AP connected
        if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(arg1.getAction())) {  
            Parcelable parcelableExtra = arg1.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);  
                    if (null != parcelableExtra) {  
                        NetworkInfo wifi = (NetworkInfo) parcelableExtra;  

                        if (wifi != null) {
                            if (NetworkInfo.State.CONNECTED == wifi.getState()) {
                                //SysLog.out(TAG, "onReceive", "wifi connected");
                            }else if(NetworkInfo.State.DISCONNECTING == wifi.getState()){
                                //SysLog.out(TAG, "onReceive", "wifi disconnecting");   
                            }else if (NetworkInfo.State.DISCONNECTED == wifi.getState()) {
                                //SysLog.out(TAG, "onReceive", "wifi disconnected");
                            }else if (NetworkInfo.State.CONNECTING == wifi.getState()) {
                            //SysLog.out(TAG, "onReceive", "wifi connecting");
                            }

                        }
                    }

} 3.开发流程

上篇讲到注册相关的BroadcastReceiver以及通过BroadcastReceiver来获取WIFI的各种通知，本篇接着上一篇来解析WIFI开发的过程，现在我们需要新建操作WIFI的工具类SysManagerWIFIUtil.java.

    private SysManagerWIFIAdmin(Context context) {
        m_context = context;
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
    }

    public static SysManagerWIFIUtil getInstance(Context context) {
        if (null == m_instance) {
            SysLog.out(TAG, "SysManagerWIFIUtil getInstance", "create singleton instance");
            synchronized (SysManagerWIFIUtil.class) {
                if (null == m_instance) {
                    m_instance = new SysManagerWIFIUtil(context);
                }
            }
        }
        return m_instance;
    }

    public void openWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    public void closeWifi() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    public int checkState() {
        return mWifiManager.getWifiState();
    }

    public WifiManager getWifiManager() {
        return mWifiManager;
    }

    public synchronized List<WifiConfiguration> getConfiguration() {
        // saved AP
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();
        return mWifiConfiguration;
    }

    public synchronized WifiInfo getConnectionInfo() {
        mWifiInfo = mWifiManager.getConnectionInfo();
        // SysLog.out(TAG, "connect", "" + mWifiInfo.toString());
        return mWifiInfo;
    }

    // connect savedAP
    public boolean connectConfiguration(int netid) {
        if (netid < -1) {
            return false;
        }
        SysLog.out(TAG, "SysManagerWIFIAdmin enableNetwork", "start");
        boolean c = mWifiManager.enableNetwork(netid, true);
        return c;
    }

    public synchronized void saveConfiguration() {
        SysLog.out(TAG, "SysManagerWIFIAdmin saveConfiguration", "start");
        mWifiManager.saveConfiguration();
    }

    public synchronized void startScan() {
        SysLog.out(TAG, "SysManagerWIFIAdmin startScan", "start");
        mWifiManager.startScan();
    }

    public synchronized List<ScanResult> getWifiList() {
        // scaned AP
        mWifiList = mWifiManager.getScanResults();
        return mWifiList;
    }

    public synchronized String getMacAddress() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiInfo = mWifiManager.getConnectionInfo();
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
        }
        return null;
    }


    public synchronized String getBSSID() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiInfo = mWifiManager.getConnectionInfo();
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
        }
        return "";
    }

    public synchronized String getSSID() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiInfo = mWifiManager.getConnectionInfo();
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();
        }
        return "";
    }

    public synchronized int getIPAddress() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiInfo = mWifiManager.getConnectionInfo();
            return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
        }
        return 0;
    }

    public synchronized int getNetworkId() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiInfo = mWifiManager.getConnectionInfo();
            return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
        }
        return 0;
    }

    public synchronized boolean deleteConfiguration(int netId) {
        SysLog.out(TAG, "SysManagerWIFIAdmin deleteConfiguration", "start");
        boolean b = mWifiManager.removeNetwork(netId);
        return b;
    }

    public synchronized int addNetwork(String ssid, String passwd, int type,
            String bssid) {
        SysLog.out(TAG, "SysManagerWIFIAdmin addNetwork", "start");
        int status = addNetwork(CreateWifiInfo(ssid, passwd, type, bssid));
        return status;
    }

    // add net and connect
    private int addNetwork(WifiConfiguration wcg) {
        int wcgID = mWifiManager.addNetwork(wcg);
        SysLog.out(TAG, "SysManagerWIFIAdmin addNetwork(enableNetwork)",
                "start"+", netID = "+wcgID);
        boolean b = mWifiManager.enableNetwork(wcgID, true);
        getConnectionInfo();
        return wcgID;
    }

    private WifiConfiguration CreateWifiInfo(String SSID, String Password,
            int Type, String BSSID) {
        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID =  toHexString(SSID.getBytes());
        SysLog.out(TAG, "SysManagerWIFIAdmin addNetwork", "SSID="+config.SSID);

        if (null == BSSID) {
        } else {
            config.BSSID = BSSID;
        }
        if ((null != SSID)&&(null != BSSID)) {
            WifiConfiguration tempConfig = this.IsExsits(SSID,BSSID);
            if (tempConfig != null) {
                mWifiManager.removeNetwork(tempConfig.networkId);
            }
        }

        if (TYPE_NO_PASSWD == Type) // WIFICIPHER_NOPASS
        {
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        } else if (TYPE_WEP == Type) { // WIFICIPHER_WEP
            config.hiddenSSID = true;
            int len = Password.length();
            if ((len == 10 || len == 26 || len == 58)
                    && Password.matches("[0-9A-Fa-f]*")) {
                config.wepKeys[0] = Password;
            } else {
                config.wepKeys[0] = '"' + Password + '"';
            }
            config.allowedAuthAlgorithms
                    .set(WifiConfiguration.AuthAlgorithm.SHARED);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            config.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.WEP104);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        } else if (TYPE_WPA == Type) { // WIFICIPHER_WPA
            if (Password.matches("[0-9A-Fa-f]{64}")) {
                config.preSharedKey = Password;
            } else {
                config.preSharedKey = '"' + Password + '"';
            }

            config.hiddenSSID = true;
            config.allowedAuthAlgorithms
                    .set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        } else {

        }
        return config;
    }

    public int isWifiContected(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo wifiNetworkInfo = connectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_WIFI);

        if (wifiNetworkInfo.isConnected()) {
            return WIFI_CONNECTED;
        } else {
            return WIFI_CONNECT_FAILED;
        }
    }

    public WifiConfiguration IsExsits(String SSID,String BSSID) {
        List<WifiConfiguration> existingConfigs = mWifiManager
                .getConfiguredNetworks();
        for (WifiConfiguration existingConfig : existingConfigs) {
            if (null != BSSID && (("\"" + SSID + "\"").equals(existingConfig.SSID))&&(BSSID.equals(existingConfig.BSSID))) {
                return existingConfig;
            }
        }
        return null;
    }

    public synchronized void disconnectWifi(int netId) {
        mWifiManager.disableNetwork(netId);
        if(netId == getNetworkId()){
            mWifiManager.disconnect();
            SysLog.out(TAG, "SysManagerWIFIAdmin disconnectWifi(netID)",
                    "Ap is disconnect = "+netId);
        }
    }