1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.connectivitymanagertest.unit;
18
19import android.content.BroadcastReceiver;
20import android.content.Intent;
21import android.content.IntentFilter;
22import android.content.Context;
23import android.net.NetworkInfo;
24import android.net.wifi.WifiManager;
25import android.net.wifi.WifiConfiguration;
26import android.net.wifi.WifiConfiguration.KeyMgmt;
27import android.net.wifi.WifiConfiguration.Status;
28import android.net.wifi.SupplicantState;
29
30import android.test.suitebuilder.annotation.LargeTest;
31import android.test.AndroidTestCase;
32
33import java.util.List;
34
35/**
36 * Test wifi client
37 */
38public class WifiClientTest extends AndroidTestCase {
39
40    private WifiManager mWifiManager;
41
42    //10s delay for turning on wifi
43    private static final int DELAY = 10000;
44    private WifiStateListener mWifiStateListener;
45    int mWifiState;
46    int mDisableBroadcastCounter = 0;
47    int mEnableBroadcastCounter = 0;
48    NetworkInfo mNetworkInfo;
49    boolean mSupplicantConnection;
50    SupplicantState mSupplicantState;
51
52    private class WifiStateListener extends BroadcastReceiver {
53        @Override
54        public void onReceive(Context context, Intent intent) {
55            String action = intent.getAction();
56            if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
57                mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
58                        WifiManager.WIFI_STATE_UNKNOWN);
59                switch (mWifiState) {
60                    case WifiManager.WIFI_STATE_DISABLING:
61                        if (mDisableBroadcastCounter == 0) mDisableBroadcastCounter++;
62                        break;
63                    case WifiManager.WIFI_STATE_DISABLED:
64                        if (mDisableBroadcastCounter == 1) mDisableBroadcastCounter++;
65                        break;
66                    case WifiManager.WIFI_STATE_ENABLING:
67                        if (mEnableBroadcastCounter == 0) mEnableBroadcastCounter++;
68                        break;
69                    case WifiManager.WIFI_STATE_ENABLED:
70                        if (mEnableBroadcastCounter == 1) mEnableBroadcastCounter++;
71                        break;
72                }
73            } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
74                mNetworkInfo = (NetworkInfo)
75                        intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
76            } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
77                mSupplicantState = (SupplicantState)
78                        intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE);
79            } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) {
80                mSupplicantConnection =
81                        intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false);
82            }
83        }
84    }
85
86    @Override
87    protected void setUp() throws Exception {
88        super.setUp();
89
90        // register a connectivity receiver for CONNECTIVITY_ACTION;
91
92        mWifiStateListener = new WifiStateListener();
93        IntentFilter mIntentFilter = new IntentFilter();
94        mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
95        mIntentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
96        mIntentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
97        mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
98        getContext().registerReceiver(mWifiStateListener, mIntentFilter);
99
100        mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
101        mWifiManager.setWifiEnabled(true);
102        assertNotNull(mWifiManager);
103    }
104
105    private void sleepAfterWifiEnable() {
106        try {
107            Thread.sleep(DELAY);
108        } catch (Exception e) {
109            fail("Sleep timeout " + e);
110        }
111    }
112
113    // Test case 1: add/remove a open network
114    @LargeTest
115    public void testAddRemoveNetwork() {
116        WifiConfiguration config = new WifiConfiguration();
117        config.SSID = "\"TestSSID1\"";
118        config.allowedKeyManagement.set(KeyMgmt.NONE);
119
120        //add
121        int netId = mWifiManager.addNetwork(config);
122        assertTrue(netId != -1);
123
124        //check config list
125        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
126        boolean found = false;
127        for (WifiConfiguration c : configList) {
128            if (c.networkId == netId && c.SSID.equals(config.SSID)) {
129                found = true;
130            }
131        }
132        assertTrue(found);
133
134        //remove
135        boolean ret = mWifiManager.removeNetwork(netId);
136        assertTrue(ret);
137
138        //check config list
139        configList = mWifiManager.getConfiguredNetworks();
140        found = false;
141        for (WifiConfiguration c : configList) {
142            if (c.networkId == netId) {
143                found = true;
144            }
145        }
146
147        assertFalse(found);
148    }
149
150    // Test case 2: enable/disable a open network
151    @LargeTest
152    public void testEnableDisableNetwork() {
153        WifiConfiguration config = new WifiConfiguration();
154        config.SSID = "\"TestSSID2\"";
155        config.allowedKeyManagement.set(KeyMgmt.NONE);
156
157        //add
158        int netId = mWifiManager.addNetwork(config);
159        assertTrue(netId != -1);
160
161        //enable network and disable others
162        boolean ret = mWifiManager.enableNetwork(netId, true);
163        assertTrue(ret);
164
165        //check config list
166        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
167        for (WifiConfiguration c : configList) {
168            if (c.networkId == netId) {
169                assertTrue(c.status == Status.ENABLED);
170            } else {
171                assertFalse(c.status == Status.ENABLED);
172            }
173        }
174
175        //disable network
176        ret = mWifiManager.disableNetwork(netId);
177        assertTrue(ret);
178
179        //check config list
180        configList = mWifiManager.getConfiguredNetworks();
181        for (WifiConfiguration c : configList) {
182            if (c.networkId == netId) {
183                assertTrue(c.status == Status.DISABLED);
184            }
185        }
186    }
187
188    // Test case 3: ping supplicant
189    @LargeTest
190    public void testPingSupplicant() {
191        assertTrue(mWifiManager.pingSupplicant());
192        mWifiManager.setWifiEnabled(false);
193        sleepAfterWifiEnable();
194
195        assertFalse(mWifiManager.pingSupplicant());
196        mWifiManager.setWifiEnabled(true);
197        sleepAfterWifiEnable();
198    }
199
200    // Test case 4: save config
201    @LargeTest
202    public void testSaveConfig() {
203        WifiConfiguration config = new WifiConfiguration();
204        config.SSID = "\"TestSSID3\"";
205        config.allowedKeyManagement.set(KeyMgmt.NONE);
206
207        //add
208        int netId = mWifiManager.addNetwork(config);
209        assertTrue(netId != -1);
210
211        mWifiManager.saveConfiguration();
212
213        //restart wifi
214        mWifiManager.setWifiEnabled(false);
215        mWifiManager.setWifiEnabled(true);
216
217        sleepAfterWifiEnable();
218
219        //check config list
220        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
221        boolean found = false;
222        for (WifiConfiguration c : configList) {
223            if (c.SSID.equals("TestSSID3")) {
224                found = true;
225            }
226        }
227        assertTrue(found);
228
229        //restore config
230        boolean ret = mWifiManager.removeNetwork(netId);
231        assertTrue(ret);
232        mWifiManager.saveConfiguration();
233    }
234
235    // Test case 5: test wifi state change broadcasts
236    @LargeTest
237    public void testWifiBroadcasts() {
238
239        /* Initialize */
240        mWifiManager.setWifiEnabled(false);
241        sleepAfterWifiEnable();
242        mDisableBroadcastCounter = 0;
243        mEnableBroadcastCounter = 0;
244        mSupplicantConnection = false;
245        mNetworkInfo = null;
246        mSupplicantState = null;
247
248        /* Enable wifi */
249        mWifiManager.setWifiEnabled(true);
250        sleepAfterWifiEnable();
251        assertTrue(mEnableBroadcastCounter == 2);
252        assertTrue(mSupplicantConnection == true);
253        assertTrue(mNetworkInfo.isConnected());
254        assertTrue(mSupplicantState == SupplicantState.COMPLETED);
255
256
257        /* Disable wifi */
258        mWifiManager.setWifiEnabled(false);
259        sleepAfterWifiEnable();
260        assertTrue(mDisableBroadcastCounter == 2);
261        assertTrue(mSupplicantConnection == false);
262        assertTrue(!mNetworkInfo.isConnected());
263        assertTrue(mSupplicantState != SupplicantState.COMPLETED);
264
265    }
266
267    // Test case 6: test configured network status
268    @LargeTest
269    public void testWifiConfiguredNetworkStatus() {
270
271        /* Initialize */
272        mWifiManager.setWifiEnabled(false);
273        sleepAfterWifiEnable();
274
275        /* Ensure no network is CURRENT */
276        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
277        for (WifiConfiguration c : configList) {
278            assertTrue(c.status != WifiConfiguration.Status.CURRENT);
279        }
280
281        /* Enable wifi */
282        mWifiManager.setWifiEnabled(true);
283        sleepAfterWifiEnable();
284
285        /* Ensure connected network is CURRENT */
286        String connectedSSID = mWifiManager.getConnectionInfo().getSSID();
287        configList = mWifiManager.getConfiguredNetworks();
288        for (WifiConfiguration c : configList) {
289            if (c.SSID.contains(connectedSSID)) {
290                assertTrue(c.status == WifiConfiguration.Status.CURRENT);
291            } else {
292                assertTrue(c.status != WifiConfiguration.Status.CURRENT);
293            }
294        }
295
296        /* Disable wifi */
297        mWifiManager.setWifiEnabled(false);
298        sleepAfterWifiEnable();
299
300        /* Ensure no network is CURRENT */
301        configList = mWifiManager.getConfiguredNetworks();
302        for (WifiConfiguration c : configList) {
303            assertTrue(c.status != WifiConfiguration.Status.CURRENT);
304        }
305    }
306
307
308
309}
310