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    private final String TAG = "WifiClientTest";
42
43    //10s delay for turning on wifi
44    private static final int DELAY = 10000;
45    private WifiStateListener mWifiStateListener;
46    int mWifiState;
47    int mDisableBroadcastCounter = 0;
48    int mEnableBroadcastCounter = 0;
49    NetworkInfo mNetworkInfo;
50    boolean mSupplicantConnection;
51    SupplicantState mSupplicantState;
52
53    private class WifiStateListener extends BroadcastReceiver {
54        @Override
55        public void onReceive(Context context, Intent intent) {
56            String action = intent.getAction();
57            if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
58                mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
59                        WifiManager.WIFI_STATE_UNKNOWN);
60                switch (mWifiState) {
61                    case WifiManager.WIFI_STATE_DISABLING:
62                        if (mDisableBroadcastCounter == 0) mDisableBroadcastCounter++;
63                        break;
64                    case WifiManager.WIFI_STATE_DISABLED:
65                        if (mDisableBroadcastCounter == 1) mDisableBroadcastCounter++;
66                        break;
67                    case WifiManager.WIFI_STATE_ENABLING:
68                        if (mEnableBroadcastCounter == 0) mEnableBroadcastCounter++;
69                        break;
70                    case WifiManager.WIFI_STATE_ENABLED:
71                        if (mEnableBroadcastCounter == 1) mEnableBroadcastCounter++;
72                        break;
73                }
74            } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
75                mNetworkInfo = (NetworkInfo)
76                        intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
77            } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
78                mSupplicantState = (SupplicantState)
79                        intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE);
80            } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) {
81                mSupplicantConnection =
82                        intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false);
83            }
84        }
85    }
86
87    @Override
88    protected void setUp() throws Exception {
89        super.setUp();
90
91        // register a connectivity receiver for CONNECTIVITY_ACTION;
92
93        mWifiStateListener = new WifiStateListener();
94        IntentFilter mIntentFilter = new IntentFilter();
95        mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
96        mIntentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
97        mIntentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
98        mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
99        getContext().registerReceiver(mWifiStateListener, mIntentFilter);
100
101        mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
102        mWifiManager.setWifiEnabled(true);
103        assertNotNull(mWifiManager);
104    }
105
106    private void sleepAfterWifiEnable() {
107        try {
108            Thread.sleep(DELAY);
109        } catch (Exception e) {
110            fail("Sleep timeout " + e);
111        }
112    }
113
114    // Test case 1: add/remove a open network
115    @LargeTest
116    public void testAddRemoveNetwork() {
117        WifiConfiguration config = new WifiConfiguration();
118        config.SSID = "\"TestSSID1\"";
119        config.allowedKeyManagement.set(KeyMgmt.NONE);
120
121        //add
122        int netId = mWifiManager.addNetwork(config);
123        assertTrue(netId != -1);
124
125        //check config list
126        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
127        boolean found = false;
128        for (WifiConfiguration c : configList) {
129            if (c.networkId == netId && c.SSID.equals(config.SSID)) {
130                found = true;
131            }
132        }
133        assertTrue(found);
134
135        //remove
136        boolean ret = mWifiManager.removeNetwork(netId);
137        assertTrue(ret);
138
139        //check config list
140        configList = mWifiManager.getConfiguredNetworks();
141        found = false;
142        for (WifiConfiguration c : configList) {
143            if (c.networkId == netId) {
144                found = true;
145            }
146        }
147
148        assertFalse(found);
149    }
150
151    // Test case 2: enable/disable a open network
152    @LargeTest
153    public void testEnableDisableNetwork() {
154        WifiConfiguration config = new WifiConfiguration();
155        config.SSID = "\"TestSSID2\"";
156        config.allowedKeyManagement.set(KeyMgmt.NONE);
157
158        //add
159        int netId = mWifiManager.addNetwork(config);
160        assertTrue(netId != -1);
161
162        //enable network and disable others
163        boolean ret = mWifiManager.enableNetwork(netId, true);
164        assertTrue(ret);
165
166        //check config list
167        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
168        for (WifiConfiguration c : configList) {
169            if (c.networkId == netId) {
170                assertTrue(c.status == Status.ENABLED);
171            } else {
172                assertFalse(c.status == Status.ENABLED);
173            }
174        }
175
176        //disable network
177        ret = mWifiManager.disableNetwork(netId);
178        assertTrue(ret);
179
180        //check config list
181        configList = mWifiManager.getConfiguredNetworks();
182        for (WifiConfiguration c : configList) {
183            if (c.networkId == netId) {
184                assertTrue(c.status == Status.DISABLED);
185            }
186        }
187    }
188
189    // Test case 3: ping supplicant
190    @LargeTest
191    public void testPingSupplicant() {
192        assertTrue(mWifiManager.pingSupplicant());
193        mWifiManager.setWifiEnabled(false);
194        sleepAfterWifiEnable();
195
196        assertFalse(mWifiManager.pingSupplicant());
197        mWifiManager.setWifiEnabled(true);
198        sleepAfterWifiEnable();
199    }
200
201    // Test case 4: save config
202    @LargeTest
203    public void testSaveConfig() {
204        WifiConfiguration config = new WifiConfiguration();
205        config.SSID = "\"TestSSID3\"";
206        config.allowedKeyManagement.set(KeyMgmt.NONE);
207
208        //add
209        int netId = mWifiManager.addNetwork(config);
210        assertTrue(netId != -1);
211
212        mWifiManager.saveConfiguration();
213
214        //restart wifi
215        mWifiManager.setWifiEnabled(false);
216        mWifiManager.setWifiEnabled(true);
217
218        sleepAfterWifiEnable();
219
220        //check config list
221        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
222        boolean found = false;
223        for (WifiConfiguration c : configList) {
224            if (c.SSID.equals("TestSSID3")) {
225                found = true;
226            }
227        }
228        assertTrue(found);
229
230        //restore config
231        boolean ret = mWifiManager.removeNetwork(netId);
232        assertTrue(ret);
233        mWifiManager.saveConfiguration();
234    }
235
236    // Test case 5: test wifi state change broadcasts
237    @LargeTest
238    public void testWifiBroadcasts() {
239
240        /* Initialize */
241        mWifiManager.setWifiEnabled(false);
242        sleepAfterWifiEnable();
243        mDisableBroadcastCounter = 0;
244        mEnableBroadcastCounter = 0;
245        mSupplicantConnection = false;
246        mNetworkInfo = null;
247        mSupplicantState = null;
248
249        /* Enable wifi */
250        mWifiManager.setWifiEnabled(true);
251        sleepAfterWifiEnable();
252        assertTrue(mEnableBroadcastCounter == 2);
253        assertTrue(mSupplicantConnection == true);
254        assertTrue(mNetworkInfo.isConnected());
255        assertTrue(mSupplicantState == SupplicantState.COMPLETED);
256
257
258        /* Disable wifi */
259        mWifiManager.setWifiEnabled(false);
260        sleepAfterWifiEnable();
261        assertTrue(mDisableBroadcastCounter == 2);
262        assertTrue(mSupplicantConnection == false);
263        assertTrue(!mNetworkInfo.isConnected());
264        assertTrue(mSupplicantState != SupplicantState.COMPLETED);
265
266    }
267
268    // Test case 6: test configured network status
269    @LargeTest
270    public void testWifiConfiguredNetworkStatus() {
271
272        /* Initialize */
273        mWifiManager.setWifiEnabled(false);
274        sleepAfterWifiEnable();
275
276        /* Ensure no network is CURRENT */
277        List<WifiConfiguration> configList = mWifiManager.getConfiguredNetworks();
278        for (WifiConfiguration c : configList) {
279            assertTrue(c.status != WifiConfiguration.Status.CURRENT);
280        }
281
282        /* Enable wifi */
283        mWifiManager.setWifiEnabled(true);
284        sleepAfterWifiEnable();
285
286        /* Ensure connected network is CURRENT */
287        String connectedSSID = mWifiManager.getConnectionInfo().getSSID();
288        configList = mWifiManager.getConfiguredNetworks();
289        for (WifiConfiguration c : configList) {
290            if (c.SSID.contains(connectedSSID)) {
291                assertTrue(c.status == WifiConfiguration.Status.CURRENT);
292            } else {
293                assertTrue(c.status != WifiConfiguration.Status.CURRENT);
294            }
295        }
296
297        /* Disable wifi */
298        mWifiManager.setWifiEnabled(false);
299        sleepAfterWifiEnable();
300
301        /* Ensure no network is CURRENT */
302        configList = mWifiManager.getConfiguredNetworks();
303        for (WifiConfiguration c : configList) {
304            assertTrue(c.status != WifiConfiguration.Status.CURRENT);
305        }
306    }
307
308
309
310}
311