ConnectivityManagerMobileTest.java revision 4672203ea119f38786f55ac866f38da307671a49
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 // In case the broadcast is already sent out, no need to wait 95 if (cmActivity.mCM.getNetworkInfo(networkType).getState() == expectedState) { 96 return; 97 } else { 98 while (true) { 99 if ((System.currentTimeMillis() - startTime) > timeout) { 100 assertFalse("Wait for network state timeout", true); 101 } 102 Log.v(LOG_TAG, "Wait for the connectivity state for network: " + networkType + 103 " to be " + expectedState.toString()); 104 synchronized (cmActivity.connectivityObject) { 105 try { 106 cmActivity.connectivityObject.wait(STATE_TRANSITION_SHORT_TIMEOUT); 107 } catch (InterruptedException e) { 108 e.printStackTrace(); 109 } 110 if ((cmActivity.mNetworkInfo.getType() != networkType) || 111 (cmActivity.mNetworkInfo.getState() != expectedState)) { 112 Log.v(LOG_TAG, "network state for " + cmActivity.mNetworkInfo.getType() + 113 "is: " + cmActivity.mNetworkInfo.getState()); 114 continue; 115 } 116 break; 117 } 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 if (cmActivity.mWifiState == expectedState) { 127 return; 128 } else { 129 while (true) { 130 if ((System.currentTimeMillis() - startTime) > timeout) { 131 assertFalse("Wait for Wifi state timeout", true); 132 } 133 Log.v(LOG_TAG, "Wait for wifi state to be: " + expectedState); 134 synchronized (cmActivity.wifiObject) { 135 try { 136 cmActivity.wifiObject.wait(5*1000); 137 } catch (InterruptedException e) { 138 e.printStackTrace(); 139 } 140 if (cmActivity.mWifiState != expectedState) { 141 Log.v(LOG_TAG, "Wifi state is: " + cmActivity.mWifiNetworkInfo.getState()); 142 continue; 143 } 144 break; 145 } 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