Android之Wifi模块开发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
public class WifiAdmin {
    // 定义WifiManager对象
        public WifiManager mWifiManager;
        // 定义WifiInfo对象
        public WifiInfo mWifiInfo;
        // 扫描出的网络连接列表
        public List<ScanResult> mWifiList;
        // 网络连接列表
        public List<WifiConfiguration> mWifiConfiguration;
        // 定义一个WifiLock
        WifiLock mWifiLock;

        public WifiAdmin(Context context){
            mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            System.out.println("mWifiManager="+mWifiManager);
            // 取得WifiInfo对象
            mWifiInfo = mWifiManager.getConnectionInfo();
        }

        public WifiConfiguration checkWiFiConfig(String str) {
            for (WifiConfiguration C : mWifiConfiguration) {
                if (C.SSID.equals(""" +str+ """)) {
                    return C;
                }
            }
            return null;
        }

        public void getWifiList() {
            // mWifiManager.;
            mWifiManager.startScan();
            // 得到扫描结果
            mWifiList = mWifiManager.getScanResults();
            System.out.println("mWifiList="+mWifiList);
            // 得到配置好的网络连接
            mWifiConfiguration = mWifiManager.getConfiguredNetworks();
        }

        // 打开WIFI
        public void openWifi() {
            if (!mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(true);
            }
        }

        // 得到WifiInfo的所有信息包
        public String getWifiInfo() {
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
        }

        // 关闭WIFI
        public void closeWifi() {
            if (mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(false);
            }
        }

        // 指定配置好的网络进行连接
        public void connectConfiguration(int index) {
            // 索引大于配置好的网络索引返回
            if (index > mWifiConfiguration.size()) {
                return;
            }
            // 连接配置好的指定ID的网络
            mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
                    true);
        }

        // 检查当前WIFI状态
        public int checkState() {
            return mWifiManager.getWifiState();
        }

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

        //验证wifi密码，如果成功则返回一个配置好的WIFI信息
        public WifiConfiguration createWifiInfo(String SSID, String Password,
                int Type) {
            //Log.v(TAG, "SSID = " + SSID + "## Password = " + Password + "## Type = " + Type);
            System.out.println("SSID = " + SSID + "## Password = " + Password + "## Type = " + Type);
            if (SSID == null || Password == null || SSID.equals("")) {
                //Log.e(TAG, "addNetwork() ## nullpointer error!");
                System.out.println("addNetwork() ## nullpointer error!");
                return null;
            }
            WifiConfiguration config = new WifiConfiguration();
            config.allowedAuthAlgorithms.clear();
            config.allowedGroupCiphers.clear();
            config.allowedKeyManagement.clear();
            config.allowedPairwiseCiphers.clear();
            config.allowedProtocols.clear();
            config.SSID = """ + SSID + """;

            WifiConfiguration tempConfig = isExsits(SSID, mWifiManager);
            if (tempConfig != null) {
                mWifiManager.removeNetwork(tempConfig.networkId);
            }

            if (Type == 1) // WIFICIPHER_NOPASS
            {
                config.wepKeys[0] = "";
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.wepTxKeyIndex = 0;
            }
            if (Type == 2) // WIFICIPHER_WEP
            {
                config.hiddenSSID = true;
                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;
            }
            if (Type == 3) // WIFICIPHER_WPA
            {
                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.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedPairwiseCiphers
                        .set(WifiConfiguration.PairwiseCipher.CCMP);
                config.status = WifiConfiguration.Status.ENABLED;
            }
            return config;
        }

        /**
         * 判断wifi是否存在
         * 
         * @param SSID
         * @param wifiManager
         * @return
         */
        public static WifiConfiguration isExsits(String SSID,
                WifiManager wifiManager) {
            List<WifiConfiguration> existingConfigs = wifiManager
                    .getConfiguredNetworks();
            for (WifiConfiguration existingConfig : existingConfigs) {
                if (existingConfig.SSID.equals(""" + SSID + """)) {
                    return existingConfig;
                }
            }
            return null;
        }

        public boolean ifConfigured(String ssid, WifiManager mWifiManager2) {
            // TODO Auto-generated method stub
            if(isExsits(ssid, mWifiManager2) != null)
                return true;
            return false;
        }

}