ConnectivityManagerMobileTest.java revision 8f076ec3c3133c70b67cdb9f5ae0907fd20492dd 
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.functional;
18
19import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
20
21import android.content.Intent;
22import android.content.Context;
23import android.os.PowerManager;
24import android.os.PowerManager.WakeLock;
25import android.app.Instrumentation;
26import android.os.Handler;
27import android.os.Message;
28import android.net.ConnectivityManager;
29import android.net.NetworkInfo;
30import android.net.NetworkInfo.State;
31import android.net.NetworkInfo.DetailedState;
32import android.net.wifi.WifiManager;
33
34import android.test.suitebuilder.annotation.LargeTest;
35import android.test.ActivityInstrumentationTestCase2;
36import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
37import com.android.connectivitymanagertest.NetworkState;
38import android.util.Log;
39
40public class ConnectivityManagerMobileTest
41    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
42    private static final String LOG_TAG = "ConnectivityManagerMobileTest";
43    private static final String PKG_NAME = "com.android.connectivitymanagertest";
44    private static final long STATE_TRANSITION_SHORT_TIMEOUT = 5 * 1000;
45    private static final long STATE_TRANSITION_LONG_TIMEOUT = 30 * 1000;
46
47    private String TEST_ACCESS_POINT;
48    private ConnectivityManagerTestActivity cmActivity;
49    private WakeLock wl;
50
51    public ConnectivityManagerMobileTest() {
52        super(PKG_NAME, ConnectivityManagerTestActivity.class);
53    }
54
55    @Override
56    public void setUp() throws Exception {
57        super.setUp();
58        cmActivity = getActivity();
59        ConnectivityManagerTestRunner mRunner =
60                (ConnectivityManagerTestRunner)getInstrumentation();
61        TEST_ACCESS_POINT = mRunner.TEST_SSID;
62        PowerManager pm = (PowerManager)getInstrumentation().
63                getContext().getSystemService(Context.POWER_SERVICE);
64        wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "CMWakeLock");
65        wl.acquire();
66        // Each test case will start with cellular connection
67        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
68                STATE_TRANSITION_LONG_TIMEOUT);
69        verifyCellularConnection();
70    }
71
72    @Override
73    public void tearDown() throws Exception {
74        cmActivity.finish();
75        Log.v(LOG_TAG, "tear down ConnectivityManagerTestActivity");
76        wl.release();
77        cmActivity.clearWifi();
78        super.tearDown();
79    }
80
81    // help function to verify 3G connection
82    public void verifyCellularConnection() {
83        NetworkInfo extraNetInfo = cmActivity.mNetworkInfo;
84        assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE,
85            extraNetInfo.getType());
86        assertTrue("not connected to cellular network", extraNetInfo.isConnected());
87        assertTrue("no data connection", cmActivity.mState.equals(State.CONNECTED));
88    }
89
90    // Wait for network connectivity state: CONNECTING, CONNECTED, SUSPENDED,
91    //                                      DISCONNECTING, DISCONNECTED, UNKNOWN
92    private void waitForNetworkState(int networkType, State expectedState, long timeout) {
93        long startTime = System.currentTimeMillis();
94        while (true) {
95            if ((System.currentTimeMillis() - startTime) > timeout) {
96                if (cmActivity.mCM.getNetworkInfo(networkType).getState() != expectedState) {
97                    assertFalse("Wait for network state timeout", true);
98                } else {
99                    // the broadcast has been sent out. the state has been changed.
100                    return;
101                }
102            }
103            Log.v(LOG_TAG, "Wait for the connectivity state for network: " + networkType +
104                    " to be " + expectedState.toString());
105            synchronized (cmActivity.connectivityObject) {
106                try {
107                    cmActivity.connectivityObject.wait(STATE_TRANSITION_SHORT_TIMEOUT);
108                } catch (InterruptedException e) {
109                    e.printStackTrace();
110                }
111                if ((cmActivity.mNetworkInfo.getType() != networkType) ||
112                    (cmActivity.mNetworkInfo.getState() != expectedState)) {
113                    Log.v(LOG_TAG, "network state for " + cmActivity.mNetworkInfo.getType() +
114                            "is: " + cmActivity.mNetworkInfo.getState());
115                    continue;
116                }
117                break;
118            }
119        }
120    }
121
122    // Wait for Wifi state: WIFI_STATE_DISABLED, WIFI_STATE_DISABLING, WIFI_STATE_ENABLED,
123    //                      WIFI_STATE_ENALBING, WIFI_STATE_UNKNOWN
124    private void waitForWifiState(int expectedState, long timeout) {
125        long startTime = System.currentTimeMillis();
126        while (true) {
127            if ((System.currentTimeMillis() - startTime) > timeout) {
128                if (cmActivity.mWifiState != expectedState) {
129                    assertFalse("Wait for Wifi state timeout", true);
130                } else {
131                    return;
132                }
133            }
134            Log.v(LOG_TAG, "Wait for wifi state to be: " + expectedState);
135            synchronized (cmActivity.wifiObject) {
136                try {
137                    cmActivity.wifiObject.wait(5*1000);
138                } catch (InterruptedException e) {
139                    e.printStackTrace();
140                }
141                if (cmActivity.mWifiState != expectedState) {
142                    Log.v(LOG_TAG, "Wifi state is: " + cmActivity.mWifiNetworkInfo.getState());
143                    continue;
144                }
145                break;
146            }
147        }
148    }
149
150    // Test case 1: Test enabling Wifi without associating with any AP
151    @LargeTest
152    public void test3GToWifiNotification() {
153        // To avoid UNKNOWN state when device boots up
154        cmActivity.enableWifi();
155        try {
156            Thread.sleep(2 * STATE_TRANSITION_SHORT_TIMEOUT);
157        } catch (Exception e) {
158            Log.v(LOG_TAG, "exception: " + e.toString());
159        }
160
161        cmActivity.disableWifi();
162        // As Wifi stays in DISCONNECTED, the connectivity manager will not broadcast
163        // any network connectivity event for Wifi
164        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
165        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, networkInfo.getState(),
166                NetworkState.DO_NOTHING, State.CONNECTED);
167        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
168        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
169                NetworkState.DO_NOTHING, State.DISCONNECTED);
170        // Eanble Wifi
171        cmActivity.enableWifi();
172        try {
173            Thread.sleep(2 * STATE_TRANSITION_SHORT_TIMEOUT);
174        } catch (Exception e) {
175            Log.v(LOG_TAG, "exception: " + e.toString());
176        }
177
178        // validate state and broadcast
179        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
180            Log.v(LOG_TAG, "the state for WIFI is changed");
181            Log.v(LOG_TAG, "reason: " +
182                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
183            assertTrue("state validation fail", false);
184        }
185        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
186            Log.v(LOG_TAG, "the state for MOBILE is changed");
187            Log.v(LOG_TAG, "reason: " +
188                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
189            assertTrue("state validation fail", false);
190        }
191        // Verify that the device is still connected to MOBILE
192        verifyCellularConnection();
193    }
194
195    // Test case 2: test connection to a given AP
196    @LargeTest
197    public void testConnectToWifi() {
198        assertNotNull("SSID is null", TEST_ACCESS_POINT);
199        //Prepare for connectivity verification
200        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
201        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, networkInfo.getState(),
202                NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
203        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
204        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
205                NetworkState.TO_CONNECTION, State.CONNECTED);
206
207        // Enable Wifi and connect to a test access point
208        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
209                cmActivity.connectToWifi(TEST_ACCESS_POINT));
210
211        waitForWifiState(WifiManager.WIFI_STATE_ENABLED, STATE_TRANSITION_LONG_TIMEOUT);
212        Log.v(LOG_TAG, "wifi state is enabled");
213        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
214                STATE_TRANSITION_LONG_TIMEOUT);
215        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
216                STATE_TRANSITION_LONG_TIMEOUT);
217
218        // validate states
219        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
220            Log.v(LOG_TAG, "Wifi state transition validation failed.");
221            Log.v(LOG_TAG, "reason: " +
222                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
223            assertTrue(false);
224        }
225        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
226            Log.v(LOG_TAG, "Mobile state transition validation failed.");
227            Log.v(LOG_TAG, "reason: " +
228                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
229            assertTrue(false);
230        }
231    }
232
233    // Test case 3: connect to Wifi with known AP
234    @LargeTest
235    public void testConnectToWifWithKnownAP() {
236        assertNotNull("SSID is null", TEST_ACCESS_POINT);
237        // Connect to TEST_ACCESS_POINT
238        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
239                cmActivity.connectToWifi(TEST_ACCESS_POINT));
240        waitForWifiState(WifiManager.WIFI_STATE_ENABLED, STATE_TRANSITION_LONG_TIMEOUT);
241        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
242                STATE_TRANSITION_LONG_TIMEOUT);
243
244        try {
245            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
246        } catch (Exception e) {
247            Log.v(LOG_TAG, "exception: " + e.toString());
248        }
249
250        // Disable Wifi
251        Log.v(LOG_TAG, "Disable Wifi");
252        if (!cmActivity.disableWifi()) {
253            Log.v(LOG_TAG, "disable Wifi failed");
254            return;
255        }
256
257        // Wait for the Wifi state to be DISABLED
258        waitForWifiState(WifiManager.WIFI_STATE_DISABLED, STATE_TRANSITION_LONG_TIMEOUT);
259        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
260                STATE_TRANSITION_LONG_TIMEOUT);
261        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
262                STATE_TRANSITION_LONG_TIMEOUT);
263
264        //Prepare for connectivity state verification
265        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
266        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
267                                              networkInfo.getState(), NetworkState.DO_NOTHING,
268                                              State.DISCONNECTED);
269        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
270        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
271                NetworkState.TO_CONNECTION, State.CONNECTED);
272
273        // Enable Wifi again
274        Log.v(LOG_TAG, "Enable Wifi again");
275        cmActivity.enableWifi();
276
277        // Wait for Wifi to be connected and mobile to be disconnected
278        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
279                STATE_TRANSITION_LONG_TIMEOUT);
280        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
281                STATE_TRANSITION_LONG_TIMEOUT);
282
283        // validate wifi states
284        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
285            Log.v(LOG_TAG, "Wifi state transition validation failed.");
286            Log.v(LOG_TAG, "reason: " +
287                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
288            assertTrue(false);
289        }
290    }
291
292    // Test case 4:  test disconnect Wifi
293    @LargeTest
294    public void testDisconnectWifi() {
295        assertNotNull("SSID is null", TEST_ACCESS_POINT);
296
297        // connect to Wifi
298        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
299                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
300
301        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
302            STATE_TRANSITION_LONG_TIMEOUT);
303
304        // Wait for a few seconds to avoid the state that both Mobile and Wifi is connected
305        try {
306            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
307        } catch (Exception e) {
308            Log.v(LOG_TAG, "exception: " + e.toString());
309        }
310
311        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
312        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
313                                              networkInfo.getState(),
314                                              NetworkState.TO_CONNECTION,
315                                              State.CONNECTED);
316        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
317        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
318                NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
319
320        // clear Wifi
321        cmActivity.clearWifi();
322
323        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
324                STATE_TRANSITION_LONG_TIMEOUT);
325        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
326                STATE_TRANSITION_LONG_TIMEOUT);
327
328        // validate states
329        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
330            Log.v(LOG_TAG, "Wifi state transition validation failed.");
331            Log.v(LOG_TAG, "reason: " +
332                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
333            assertTrue(false);
334        }
335        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
336            Log.v(LOG_TAG, "Mobile state transition validation failed.");
337            Log.v(LOG_TAG, "reason: " +
338                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
339            assertTrue(false);
340        }
341    }
342
343    // Test case 5: test connectivity from 3G to airplane mode, then to 3G again
344    @LargeTest
345    public void testDataConnectionWith3GToAmTo3G() {
346        //Prepare for state verification
347        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
348        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
349                                              networkInfo.getState(),
350                                              NetworkState.TO_DISCONNECTION,
351                                              State.DISCONNECTED);
352        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
353        assertEquals(State.DISCONNECTED, networkInfo.getState());
354        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
355                NetworkState.DO_NOTHING, State.DISCONNECTED);
356
357        // Enable airplane mode
358        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
359        try {
360            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
361        } catch (Exception e) {
362            Log.v(LOG_TAG, "exception: " + e.toString());
363        }
364
365        // Validate the state transition
366        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
367            Log.v(LOG_TAG, "Wifi state transition validation failed.");
368            Log.v(LOG_TAG, "reason: " +
369                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
370            assertTrue(false);
371        }
372        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
373            Log.v(LOG_TAG, "Mobile state transition validation failed.");
374            Log.v(LOG_TAG, "reason: " +
375                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
376            assertTrue(false);
377        }
378
379        // reset state recorder
380        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
381        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
382                                              networkInfo.getState(),
383                                              NetworkState.TO_CONNECTION,
384                                              State.CONNECTED);
385        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
386        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
387                NetworkState.DO_NOTHING, State.DISCONNECTED);
388
389        // disable airplane mode
390        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
391
392        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
393                STATE_TRANSITION_LONG_TIMEOUT);
394
395        // Validate the state transition
396        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
397            Log.v(LOG_TAG, "Mobile state transition validation failed.");
398            Log.v(LOG_TAG, "reason: " +
399                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
400            assertTrue(false);
401        }
402        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
403          Log.v(LOG_TAG, "Wifi state transition validation failed.");
404          Log.v(LOG_TAG, "reason: " +
405                  cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
406          assertTrue(false);
407        }
408    }
409
410    // Test case 6: test connectivity with airplane mode Wifi connected
411    @LargeTest
412    public void testDataConnectionOverAMWithWifi() {
413        assertNotNull("SSID is null", TEST_ACCESS_POINT);
414        // Eanble airplane mode
415        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
416
417        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
418                STATE_TRANSITION_LONG_TIMEOUT);
419
420        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
421        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
422                                              networkInfo.getState(),
423                                              NetworkState.DO_NOTHING,
424                                              State.DISCONNECTED);
425        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
426        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
427                                              NetworkState.TO_CONNECTION, State.CONNECTED);
428
429        // Connect to Wifi
430        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
431                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
432        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
433                            STATE_TRANSITION_LONG_TIMEOUT);
434
435        // validate state and broadcast
436        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
437            Log.v(LOG_TAG, "state validate for Wifi failed");
438            Log.v(LOG_TAG, "reason: " +
439                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
440            assertTrue("State validation failed", false);
441        }
442        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
443            Log.v(LOG_TAG, "state validation for Mobile failed");
444            Log.v(LOG_TAG, "reason: " +
445                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
446            assertTrue("state validation failed", false);
447        }
448        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
449    }
450
451    // Test case 7: test connectivity while transit from Wifi->AM->Wifi
452    @LargeTest
453    public void testDataConnectionWithWifiToAMToWifi () {
454        // Connect to TEST_ACCESS_POINT
455        assertNotNull("SSID is null", TEST_ACCESS_POINT);
456        // Connect to Wifi
457        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
458                cmActivity.connectToWifi(TEST_ACCESS_POINT));
459
460        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
461                STATE_TRANSITION_LONG_TIMEOUT);
462
463        try {
464            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
465        } catch (Exception e) {
466            Log.v(LOG_TAG, "exception: " + e.toString());
467        }
468
469        // Enable airplane mode without clearing Wifi
470        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
471
472        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
473                STATE_TRANSITION_LONG_TIMEOUT);
474
475        try {
476            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
477        } catch (Exception e) {
478            Log.v(LOG_TAG, "exception: " + e.toString());
479        }
480
481        // Prepare for state validation
482        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
483        assertEquals(State.DISCONNECTED, networkInfo.getState());
484        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI,
485                networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED);
486
487        // Disable airplane mode
488        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
489
490        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
491                            STATE_TRANSITION_LONG_TIMEOUT);
492        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
493                            STATE_TRANSITION_LONG_TIMEOUT);
494
495        // validate the state transition
496        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
497            Log.v(LOG_TAG, "Wifi state transition validation failed.");
498            Log.v(LOG_TAG, "reason: " +
499                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
500            assertTrue(false);
501        }
502    }
503
504    // Test case 8: test wifi state change while connecting/disconnecting to/from an AP
505    @LargeTest
506    public void testWifiStateChange () {
507        assertNotNull("SSID is null", TEST_ACCESS_POINT);
508        //Connect to TEST_ACCESS_POINT
509        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
510                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
511        waitForWifiState(WifiManager.WIFI_STATE_ENABLED, STATE_TRANSITION_LONG_TIMEOUT);
512        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
513                            STATE_TRANSITION_LONG_TIMEOUT);
514        assertNotNull("Not associated with any AP",
515                      cmActivity.mWifiManager.getConnectionInfo().getBSSID());
516
517        try {
518            Thread.sleep(STATE_TRANSITION_SHORT_TIMEOUT);
519        } catch (Exception e) {
520            Log.v(LOG_TAG, "exception: " + e.toString());
521        }
522
523        // Disconnect from the current AP
524        Log.v(LOG_TAG, "disconnect from the AP");
525        if (!cmActivity.disconnectAP()) {
526            Log.v(LOG_TAG, "failed to disconnect from " + TEST_ACCESS_POINT);
527        }
528
529        // Verify the connectivity state for Wifi is DISCONNECTED
530        waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
531                STATE_TRANSITION_LONG_TIMEOUT);
532
533        if (!cmActivity.disableWifi()) {
534            Log.v(LOG_TAG, "disable Wifi failed");
535            return;
536        }
537        waitForWifiState(WifiManager.WIFI_STATE_DISABLED, STATE_TRANSITION_LONG_TIMEOUT);
538    }
539}
540