1 /* 2 * Copyright (C) 2016 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 17 package com.android.internal.telephony; 18 19 import static com.android.internal.telephony.TelephonyTestUtils.waitForMs; 20 21 import static org.junit.Assert.assertEquals; 22 import static org.junit.Assert.assertFalse; 23 import static org.junit.Assert.assertTrue; 24 import static org.mockito.Matchers.any; 25 import static org.mockito.Matchers.anyLong; 26 import static org.mockito.Matchers.nullable; 27 import static org.mockito.Mockito.anyInt; 28 import static org.mockito.Mockito.anyString; 29 import static org.mockito.Mockito.atLeast; 30 import static org.mockito.Mockito.doReturn; 31 import static org.mockito.Mockito.eq; 32 import static org.mockito.Mockito.mock; 33 import static org.mockito.Mockito.spy; 34 import static org.mockito.Mockito.times; 35 import static org.mockito.Mockito.verify; 36 import static org.mockito.Mockito.when; 37 38 import android.app.IAlarmManager; 39 import android.app.Notification; 40 import android.app.NotificationManager; 41 import android.content.Context; 42 import android.content.Intent; 43 import android.content.IntentFilter; 44 import android.content.pm.ApplicationInfo; 45 import android.content.pm.ServiceInfo; 46 import android.content.res.Resources; 47 import android.graphics.drawable.Drawable; 48 import android.os.AsyncResult; 49 import android.os.Bundle; 50 import android.os.Handler; 51 import android.os.HandlerThread; 52 import android.os.Message; 53 import android.os.Parcel; 54 import android.os.PersistableBundle; 55 import android.os.Process; 56 import android.os.SystemClock; 57 import android.os.UserHandle; 58 import android.os.WorkSource; 59 import android.support.test.filters.FlakyTest; 60 import android.telephony.AccessNetworkConstants.AccessNetworkType; 61 import android.telephony.CarrierConfigManager; 62 import android.telephony.CellIdentityGsm; 63 import android.telephony.CellIdentityLte; 64 import android.telephony.CellInfo; 65 import android.telephony.CellInfoGsm; 66 import android.telephony.NetworkRegistrationState; 67 import android.telephony.NetworkService; 68 import android.telephony.PhysicalChannelConfig; 69 import android.telephony.ServiceState; 70 import android.telephony.SignalStrength; 71 import android.telephony.SubscriptionManager; 72 import android.telephony.TelephonyManager; 73 import android.telephony.gsm.GsmCellLocation; 74 import android.test.suitebuilder.annotation.MediumTest; 75 import android.test.suitebuilder.annotation.SmallTest; 76 import android.util.Pair; 77 78 import com.android.internal.R; 79 import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager; 80 import com.android.internal.telephony.dataconnection.DcTracker; 81 import com.android.internal.telephony.test.SimulatedCommands; 82 import com.android.internal.telephony.uicc.IccCardApplicationStatus; 83 import com.android.internal.telephony.util.TimeStampedValue; 84 85 import org.junit.After; 86 import org.junit.Before; 87 import org.junit.Ignore; 88 import org.junit.Test; 89 import org.mockito.ArgumentCaptor; 90 import org.mockito.Mock; 91 import org.mockito.Mockito; 92 93 import java.util.ArrayList; 94 import java.util.Arrays; 95 import java.util.HashSet; 96 import java.util.List; 97 98 public class ServiceStateTrackerTest extends TelephonyTest { 99 100 @Mock 101 private DcTracker mDct; 102 @Mock 103 private ProxyController mProxyController; 104 @Mock 105 private Handler mTestHandler; 106 @Mock 107 protected IAlarmManager mAlarmManager; 108 109 CellularNetworkService mCellularNetworkService; 110 111 private ServiceStateTracker sst; 112 private ServiceStateTrackerTestHandler mSSTTestHandler; 113 private PersistableBundle mBundle; 114 115 private static final int EVENT_REGISTERED_TO_NETWORK = 1; 116 private static final int EVENT_SUBSCRIPTION_INFO_READY = 2; 117 private static final int EVENT_DATA_ROAMING_ON = 3; 118 private static final int EVENT_DATA_ROAMING_OFF = 4; 119 private static final int EVENT_DATA_CONNECTION_ATTACHED = 5; 120 private static final int EVENT_DATA_CONNECTION_DETACHED = 6; 121 private static final int EVENT_DATA_RAT_CHANGED = 7; 122 private static final int EVENT_PS_RESTRICT_ENABLED = 8; 123 private static final int EVENT_PS_RESTRICT_DISABLED = 9; 124 private static final int EVENT_VOICE_ROAMING_ON = 10; 125 private static final int EVENT_VOICE_ROAMING_OFF = 11; 126 127 private class ServiceStateTrackerTestHandler extends HandlerThread { 128 129 private ServiceStateTrackerTestHandler(String name) { 130 super(name); 131 } 132 133 @Override 134 public void onLooperPrepared() { 135 sst = new ServiceStateTracker(mPhone, mSimulatedCommands); 136 setReady(true); 137 } 138 } 139 140 private void addNetworkService() { 141 mCellularNetworkService = new CellularNetworkService(); 142 ServiceInfo serviceInfo = new ServiceInfo(); 143 serviceInfo.packageName = "com.android.phone"; 144 serviceInfo.permission = "android.permission.BIND_NETWORK_SERVICE"; 145 IntentFilter filter = new IntentFilter(); 146 mContextFixture.addService( 147 NetworkService.NETWORK_SERVICE_INTERFACE, 148 null, 149 "com.android.phone", 150 mCellularNetworkService.mBinder, 151 serviceInfo, 152 filter); 153 } 154 155 @Before 156 public void setUp() throws Exception { 157 158 logd("ServiceStateTrackerTest +Setup!"); 159 super.setUp("ServiceStateTrackerTest"); 160 161 mContextFixture.putResource(R.string.config_wwan_network_service_package, 162 "com.android.phone"); 163 addNetworkService(); 164 165 doReturn(true).when(mDct).isDisconnected(); 166 mPhone.mDcTracker = mDct; 167 168 replaceInstance(ProxyController.class, "sProxyController", null, mProxyController); 169 mBundle = mContextFixture.getCarrierConfigBundle(); 170 mBundle.putStringArray( 171 CarrierConfigManager.KEY_ROAMING_OPERATOR_STRING_ARRAY, new String[]{"123456"}); 172 173 mBundle.putStringArray( 174 CarrierConfigManager.KEY_NON_ROAMING_OPERATOR_STRING_ARRAY, new String[]{"123456"}); 175 176 mBundle.putStringArray(CarrierConfigManager.KEY_RATCHET_RAT_FAMILIES, 177 // UMTS < GPRS < EDGE 178 new String[]{"3,1,2"}); 179 180 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 181 mSimulatedCommands.setVoiceRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA); 182 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 183 mSimulatedCommands.setDataRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA); 184 185 int dds = SubscriptionManager.getDefaultDataSubscriptionId(); 186 doReturn(dds).when(mPhone).getSubId(); 187 188 mSSTTestHandler = new ServiceStateTrackerTestHandler(getClass().getSimpleName()); 189 mSSTTestHandler.start(); 190 waitUntilReady(); 191 waitForMs(600); 192 logd("ServiceStateTrackerTest -Setup!"); 193 } 194 195 @After 196 public void tearDown() throws Exception { 197 sst = null; 198 mSSTTestHandler.quit(); 199 super.tearDown(); 200 } 201 202 @Test 203 @MediumTest 204 public void testSetRadioPower() { 205 boolean oldState = mSimulatedCommands.getRadioState().isOn(); 206 sst.setRadioPower(!oldState); 207 waitForMs(100); 208 assertTrue(oldState != mSimulatedCommands.getRadioState().isOn()); 209 } 210 211 @Test 212 @MediumTest 213 public void testSetRadioPowerFromCarrier() { 214 // Carrier disable radio power 215 sst.setRadioPowerFromCarrier(false); 216 waitForMs(100); 217 assertFalse(mSimulatedCommands.getRadioState().isOn()); 218 assertTrue(sst.getDesiredPowerState()); 219 assertFalse(sst.getPowerStateFromCarrier()); 220 221 // User toggle radio power will not overrides carrier settings 222 sst.setRadioPower(true); 223 waitForMs(100); 224 assertFalse(mSimulatedCommands.getRadioState().isOn()); 225 assertTrue(sst.getDesiredPowerState()); 226 assertFalse(sst.getPowerStateFromCarrier()); 227 228 // Carrier re-enable radio power 229 sst.setRadioPowerFromCarrier(true); 230 waitForMs(100); 231 assertTrue(mSimulatedCommands.getRadioState().isOn()); 232 assertTrue(sst.getDesiredPowerState()); 233 assertTrue(sst.getPowerStateFromCarrier()); 234 235 // User toggle radio power off (airplane mode) and set carrier on 236 sst.setRadioPower(false); 237 sst.setRadioPowerFromCarrier(true); 238 waitForMs(100); 239 assertFalse(mSimulatedCommands.getRadioState().isOn()); 240 assertFalse(sst.getDesiredPowerState()); 241 assertTrue(sst.getPowerStateFromCarrier()); 242 } 243 244 @Test 245 @MediumTest 246 public void testRilTrafficAfterSetRadioPower() { 247 sst.setRadioPower(true); 248 final int getOperatorCallCount = mSimulatedCommands.getGetOperatorCallCount(); 249 final int getDataRegistrationStateCallCount = 250 mSimulatedCommands.getGetDataRegistrationStateCallCount(); 251 final int getVoiceRegistrationStateCallCount = 252 mSimulatedCommands.getGetVoiceRegistrationStateCallCount(); 253 final int getNetworkSelectionModeCallCount = 254 mSimulatedCommands.getGetNetworkSelectionModeCallCount(); 255 sst.setRadioPower(false); 256 257 waitForMs(500); 258 sst.pollState(); 259 waitForMs(250); 260 261 // This test was meant to be for *no* ril traffic. However, RADIO_STATE_CHANGED is 262 // considered a modem triggered action and that causes a pollState() to be done 263 assertEquals(getOperatorCallCount + 1, mSimulatedCommands.getGetOperatorCallCount()); 264 assertEquals(getDataRegistrationStateCallCount + 1, 265 mSimulatedCommands.getGetDataRegistrationStateCallCount()); 266 assertEquals(getVoiceRegistrationStateCallCount + 1, 267 mSimulatedCommands.getGetVoiceRegistrationStateCallCount()); 268 assertEquals(getNetworkSelectionModeCallCount + 1, 269 mSimulatedCommands.getGetNetworkSelectionModeCallCount()); 270 271 // Note that if the poll is triggered by a network change notification 272 // and the modem is supposed to be off, we should still do the poll 273 mSimulatedCommands.notifyNetworkStateChanged(); 274 waitForMs(250); 275 276 assertEquals(getOperatorCallCount + 2 , mSimulatedCommands.getGetOperatorCallCount()); 277 assertEquals(getDataRegistrationStateCallCount + 2, 278 mSimulatedCommands.getGetDataRegistrationStateCallCount()); 279 assertEquals(getVoiceRegistrationStateCallCount + 2, 280 mSimulatedCommands.getGetVoiceRegistrationStateCallCount()); 281 assertEquals(getNetworkSelectionModeCallCount + 2, 282 mSimulatedCommands.getGetNetworkSelectionModeCallCount()); 283 } 284 285 @FlakyTest 286 @Ignore 287 @Test 288 @MediumTest 289 public void testSpnUpdateShowPlmnOnly() { 290 doReturn(0x02).when(mSimRecords).getDisplayRule(new ServiceState()); 291 doReturn(IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN). 292 when(mUiccCardApplication3gpp).getState(); 293 294 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_NETWORK_STATE_CHANGED, null)); 295 296 waitForMs(750); 297 298 ArgumentCaptor<Intent> intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class); 299 verify(mContextFixture.getTestDouble(), times(3)) 300 .sendStickyBroadcastAsUser(intentArgumentCaptor.capture(), eq(UserHandle.ALL)); 301 302 // We only want to verify the intent SPN_STRINGS_UPDATED_ACTION. 303 List<Intent> intents = intentArgumentCaptor.getAllValues(); 304 logd("Total " + intents.size() + " intents"); 305 for (Intent intent : intents) { 306 logd(" " + intent.getAction()); 307 } 308 Intent intent = intents.get(2); 309 assertEquals(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION, intent.getAction()); 310 311 Bundle b = intent.getExtras(); 312 313 // For boolean we need to make sure the key exists first 314 assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_SPN)); 315 assertFalse(b.getBoolean(TelephonyIntents.EXTRA_SHOW_SPN)); 316 317 assertEquals(null, b.getString(TelephonyIntents.EXTRA_SPN)); 318 assertEquals(null, b.getString(TelephonyIntents.EXTRA_DATA_SPN)); 319 320 // For boolean we need to make sure the key exists first 321 assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_PLMN)); 322 assertTrue(b.getBoolean(TelephonyIntents.EXTRA_SHOW_PLMN)); 323 324 assertEquals(SimulatedCommands.FAKE_LONG_NAME, b.getString(TelephonyIntents.EXTRA_PLMN)); 325 326 ArgumentCaptor<Integer> intArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 327 verify(mTelephonyManager).setDataNetworkTypeForPhone(anyInt(), intArgumentCaptor.capture()); 328 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA, 329 intArgumentCaptor.getValue().intValue()); 330 } 331 332 @Test 333 @MediumTest 334 public void testCellInfoList() { 335 Parcel p = Parcel.obtain(); 336 p.writeInt(1); 337 p.writeInt(1); 338 p.writeInt(2); 339 p.writeLong(1453510289108L); 340 p.writeInt(310); 341 p.writeInt(260); 342 p.writeInt(123); 343 p.writeInt(456); 344 p.writeInt(99); 345 p.writeInt(3); 346 p.setDataPosition(0); 347 348 CellInfoGsm cellInfo = CellInfoGsm.CREATOR.createFromParcel(p); 349 350 ArrayList<CellInfo> list = new ArrayList(); 351 list.add(cellInfo); 352 mSimulatedCommands.setCellInfoList(list); 353 354 WorkSource workSource = new WorkSource(Process.myUid(), 355 mContext.getPackageName()); 356 assertEquals(sst.getAllCellInfo(workSource), list); 357 } 358 359 @Test 360 @MediumTest 361 public void testImsRegState() { 362 // Simulate IMS registered 363 mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM}); 364 365 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null)); 366 waitForMs(200); 367 368 assertTrue(sst.isImsRegistered()); 369 370 // Simulate IMS unregistered 371 mSimulatedCommands.setImsRegistrationState(new int[]{0, PhoneConstants.PHONE_TYPE_GSM}); 372 373 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null)); 374 waitForMs(200); 375 376 assertFalse(sst.isImsRegistered()); 377 } 378 379 @Test 380 public void testOnImsServiceStateChanged() { 381 // The service state of GsmCdmaPhone is STATE_OUT_OF_SERVICE, and IMS is unregistered. 382 ServiceState ss = new ServiceState(); 383 ss.setVoiceRegState(ServiceState.STATE_OUT_OF_SERVICE); 384 sst.mSS = ss; 385 386 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_SERVICE_STATE_CHANGED)); 387 waitForMs(200); 388 389 // The listener will be notified that the service state was changed. 390 verify(mPhone).notifyServiceStateChanged(any(ServiceState.class)); 391 392 // The service state of GsmCdmaPhone is STATE_IN_SERVICE, and IMS is registered. 393 ss = new ServiceState(); 394 ss.setVoiceRegState(ServiceState.STATE_IN_SERVICE); 395 sst.mSS = ss; 396 397 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_SERVICE_STATE_CHANGED)); 398 waitForMs(200); 399 400 // Nothing happened because the IMS service state was not affected the merged service state. 401 verify(mPhone, times(1)).notifyServiceStateChanged(any(ServiceState.class)); 402 } 403 404 @Test 405 @MediumTest 406 public void testSignalStrength() { 407 SignalStrength ss = new SignalStrength( 408 30, // gsmSignalStrength 409 0, // gsmBitErrorRate 410 -1, // cdmaDbm 411 -1, // cdmaEcio 412 -1, // evdoDbm 413 -1, // evdoEcio 414 -1, // evdoSnr 415 99, // lteSignalStrength 416 SignalStrength.INVALID, // lteRsrp 417 SignalStrength.INVALID, // lteRsrq 418 SignalStrength.INVALID, // lteRssnr 419 SignalStrength.INVALID, // lteCqi 420 SignalStrength.INVALID // tdScdmaRscp 421 ); 422 423 mSimulatedCommands.setSignalStrength(ss); 424 mSimulatedCommands.notifySignalStrength(); 425 waitForMs(300); 426 assertEquals(sst.getSignalStrength(), ss); 427 assertEquals(sst.getSignalStrength().isGsm(), true); 428 429 // switch to CDMA 430 doReturn(false).when(mPhone).isPhoneTypeGsm(); 431 doReturn(true).when(mPhone).isPhoneTypeCdmaLte(); 432 sst.updatePhoneType(); 433 sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_LTE); 434 435 mSimulatedCommands.notifySignalStrength(); 436 waitForMs(300); 437 assertEquals(sst.getSignalStrength(), ss); 438 assertEquals(sst.getSignalStrength().isGsm(), true); 439 440 // notify signal strength again, but this time data RAT is not LTE 441 sst.mSS.setRilVoiceRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT); 442 sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD); 443 mSimulatedCommands.notifySignalStrength(); 444 waitForMs(300); 445 assertEquals(sst.getSignalStrength(), ss); 446 assertEquals(sst.getSignalStrength().isGsm(), false); 447 } 448 449 @Test 450 public void testSetsNewSignalStrengthReportingCriteria() { 451 int[] wcdmaThresholds = { 452 -110, /* SIGNAL_STRENGTH_POOR */ 453 -100, /* SIGNAL_STRENGTH_MODERATE */ 454 -90, /* SIGNAL_STRENGTH_GOOD */ 455 -80 /* SIGNAL_STRENGTH_GREAT */ 456 }; 457 mBundle.putIntArray(CarrierConfigManager.KEY_WCDMA_RSCP_THRESHOLDS_INT_ARRAY, 458 wcdmaThresholds); 459 460 int[] lteThresholds = { 461 -130, /* SIGNAL_STRENGTH_POOR */ 462 -120, /* SIGNAL_STRENGTH_MODERATE */ 463 -110, /* SIGNAL_STRENGTH_GOOD */ 464 -100, /* SIGNAL_STRENGTH_GREAT */ 465 }; 466 mBundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY, 467 lteThresholds); 468 469 CarrierConfigManager mockConfigManager = Mockito.mock(CarrierConfigManager.class); 470 when(mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE)) 471 .thenReturn(mockConfigManager); 472 when(mockConfigManager.getConfigForSubId(anyInt())).thenReturn(mBundle); 473 474 Intent intent = new Intent().setAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED); 475 mContext.sendBroadcast(intent); 476 waitForMs(300); 477 478 verify(mPhone).setSignalStrengthReportingCriteria(eq(wcdmaThresholds), 479 eq(AccessNetworkType.UTRAN)); 480 verify(mPhone).setSignalStrengthReportingCriteria(eq(lteThresholds), 481 eq(AccessNetworkType.EUTRAN)); 482 } 483 484 @Test 485 @MediumTest 486 public void testSignalLevelWithWcdmaRscpThresholds() { 487 mBundle.putIntArray(CarrierConfigManager.KEY_WCDMA_RSCP_THRESHOLDS_INT_ARRAY, 488 new int[] { 489 -110, /* SIGNAL_STRENGTH_POOR */ 490 -100, /* SIGNAL_STRENGTH_MODERATE */ 491 -90, /* SIGNAL_STRENGTH_GOOD */ 492 -80 /* SIGNAL_STRENGTH_GREAT */ 493 }); 494 mBundle.putString( 495 CarrierConfigManager.KEY_WCDMA_DEFAULT_SIGNAL_STRENGTH_MEASUREMENT_STRING, 496 "rscp"); 497 498 SignalStrength ss = new SignalStrength( 499 30, // gsmSignalStrength 500 0, // gsmBitErrorRate 501 -1, // cdmaDbm 502 -1, // cdmaEcio 503 -1, // evdoDbm 504 -1, // evdoEcio 505 -1, // evdoSnr 506 99, // lteSignalStrength 507 SignalStrength.INVALID, // lteRsrp 508 SignalStrength.INVALID, // lteRsrq 509 SignalStrength.INVALID, // lteRssnr 510 SignalStrength.INVALID, // lteCqi 511 SignalStrength.INVALID, // tdScdmaRscp 512 99, // wcdmaSignalStrength 513 45 // wcdmaRscpAsu 514 ); 515 mSimulatedCommands.setSignalStrength(ss); 516 mSimulatedCommands.notifySignalStrength(); 517 waitForMs(300); 518 assertEquals(sst.getSignalStrength(), ss); 519 assertEquals(sst.getSignalStrength().getWcdmaLevel(), SignalStrength.SIGNAL_STRENGTH_GREAT); 520 assertEquals(sst.getSignalStrength().getWcdmaAsuLevel(), 45); 521 assertEquals(sst.getSignalStrength().getWcdmaDbm(), -75); 522 523 ss = new SignalStrength( 524 30, // gsmSignalStrength 525 0, // gsmBitErrorRate 526 -1, // cdmaDbm 527 -1, // cdmaEcio 528 -1, // evdoDbm 529 -1, // evdoEcio 530 -1, // evdoSnr 531 99, // lteSignalStrength 532 SignalStrength.INVALID, // lteRsrp 533 SignalStrength.INVALID, // lteRsrq 534 SignalStrength.INVALID, // lteRssnr 535 SignalStrength.INVALID, // lteCqi 536 SignalStrength.INVALID, // tdScdmaRscp 537 99, // wcdmaSignalStrength 538 35 // wcdmaRscpAsu 539 ); 540 mSimulatedCommands.setSignalStrength(ss); 541 mSimulatedCommands.notifySignalStrength(); 542 waitForMs(300); 543 assertEquals(sst.getSignalStrength(), ss); 544 assertEquals(sst.getSignalStrength().getWcdmaLevel(), SignalStrength.SIGNAL_STRENGTH_GOOD); 545 assertEquals(sst.getSignalStrength().getWcdmaAsuLevel(), 35); 546 assertEquals(sst.getSignalStrength().getWcdmaDbm(), -85); 547 548 ss = new SignalStrength( 549 30, // gsmSignalStrength 550 0, // gsmBitErrorRate 551 -1, // cdmaDbm 552 -1, // cdmaEcio 553 -1, // evdoDbm 554 -1, // evdoEcio 555 -1, // evdoSnr 556 99, // lteSignalStrength 557 SignalStrength.INVALID, // lteRsrp 558 SignalStrength.INVALID, // lteRsrq 559 SignalStrength.INVALID, // lteRssnr 560 SignalStrength.INVALID, // lteCqi 561 SignalStrength.INVALID, // tdScdmaRscp 562 99, // wcdmaSignalStrength 563 25 // wcdmaRscpAsu 564 ); 565 mSimulatedCommands.setSignalStrength(ss); 566 mSimulatedCommands.notifySignalStrength(); 567 waitForMs(300); 568 assertEquals(sst.getSignalStrength(), ss); 569 assertEquals(sst.getSignalStrength().getWcdmaLevel(), 570 SignalStrength.SIGNAL_STRENGTH_MODERATE); 571 assertEquals(sst.getSignalStrength().getWcdmaAsuLevel(), 25); 572 assertEquals(sst.getSignalStrength().getWcdmaDbm(), -95); 573 574 ss = new SignalStrength( 575 30, // gsmSignalStrength 576 0, // gsmBitErrorRate 577 -1, // cdmaDbm 578 -1, // cdmaEcio 579 -1, // evdoDbm 580 -1, // evdoEcio 581 -1, // evdoSnr 582 99, // lteSignalStrength 583 SignalStrength.INVALID, // lteRsrp 584 SignalStrength.INVALID, // lteRsrq 585 SignalStrength.INVALID, // lteRssnr 586 SignalStrength.INVALID, // lteCqi 587 SignalStrength.INVALID, // tdScdmaRscp 588 99, // wcdmaSignalStrength 589 15 // wcdmaRscpAsu 590 ); 591 mSimulatedCommands.setSignalStrength(ss); 592 mSimulatedCommands.notifySignalStrength(); 593 waitForMs(300); 594 assertEquals(sst.getSignalStrength(), ss); 595 assertEquals(sst.getSignalStrength().getWcdmaLevel(), SignalStrength.SIGNAL_STRENGTH_POOR); 596 assertEquals(sst.getSignalStrength().getWcdmaAsuLevel(), 15); 597 assertEquals(sst.getSignalStrength().getWcdmaDbm(), -105); 598 599 ss = new SignalStrength( 600 30, // gsmSignalStrength 601 0, // gsmBitErrorRate 602 -1, // cdmaDbm 603 -1, // cdmaEcio 604 -1, // evdoDbm 605 -1, // evdoEcio 606 -1, // evdoSnr 607 99, // lteSignalStrength 608 SignalStrength.INVALID, // lteRsrp 609 SignalStrength.INVALID, // lteRsrq 610 SignalStrength.INVALID, // lteRssnr 611 SignalStrength.INVALID, // lteCqi 612 SignalStrength.INVALID, // tdScdmaRscp 613 99, // wcdmaSignalStrength 614 5 // wcdmaRscpAsu 615 ); 616 mSimulatedCommands.setSignalStrength(ss); 617 mSimulatedCommands.notifySignalStrength(); 618 waitForMs(300); 619 assertEquals(sst.getSignalStrength(), ss); 620 assertEquals(sst.getSignalStrength().getWcdmaLevel(), 621 SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN); 622 assertEquals(sst.getSignalStrength().getWcdmaAsuLevel(), 5); 623 assertEquals(sst.getSignalStrength().getWcdmaDbm(), -115); 624 } 625 626 @Test 627 @MediumTest 628 public void testGsmCellLocation() { 629 CellIdentityGsm cellIdentityGsm = new CellIdentityGsm(0, 0, 2, 3); 630 NetworkRegistrationState result = new NetworkRegistrationState( 631 0, 0, 0, 0, 0, false, null, cellIdentityGsm); 632 633 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_GET_LOC_DONE, 634 new AsyncResult(null, result, null))); 635 636 waitForMs(200); 637 WorkSource workSource = new WorkSource(Process.myUid(), mContext.getPackageName()); 638 GsmCellLocation cl = (GsmCellLocation) sst.getCellLocation(workSource); 639 assertEquals(2, cl.getLac()); 640 assertEquals(3, cl.getCid()); 641 } 642 643 @Test 644 @MediumTest 645 public void testUpdatePhoneType() { 646 doReturn(false).when(mPhone).isPhoneTypeGsm(); 647 doReturn(true).when(mPhone).isPhoneTypeCdmaLte(); 648 doReturn(CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM).when(mCdmaSSM). 649 getCdmaSubscriptionSource(); 650 651 logd("Calling updatePhoneType"); 652 // switch to CDMA 653 sst.updatePhoneType(); 654 655 ArgumentCaptor<Integer> integerArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 656 verify(mRuimRecords).registerForRecordsLoaded(eq(sst), integerArgumentCaptor.capture(), 657 nullable(Object.class)); 658 659 // response for mRuimRecords.registerForRecordsLoaded() 660 Message msg = Message.obtain(); 661 msg.what = integerArgumentCaptor.getValue(); 662 msg.obj = new AsyncResult(null, null, null); 663 sst.sendMessage(msg); 664 waitForMs(100); 665 666 // on RUIM_RECORDS_LOADED, sst is expected to call following apis 667 verify(mRuimRecords, times(1)).isProvisioned(); 668 669 // switch back to GSM 670 doReturn(true).when(mPhone).isPhoneTypeGsm(); 671 doReturn(false).when(mPhone).isPhoneTypeCdmaLte(); 672 673 // response for mRuimRecords.registerForRecordsLoaded() can be sent after switching to GSM 674 msg = Message.obtain(); 675 msg.what = integerArgumentCaptor.getValue(); 676 msg.obj = new AsyncResult(null, null, null); 677 sst.sendMessage(msg); 678 679 // There's no easy way to check if the msg was handled or discarded. Wait to make sure sst 680 // did not crash, and then verify that the functions called records loaded are not called 681 // again 682 waitForMs(200); 683 684 verify(mRuimRecords, times(1)).isProvisioned(); 685 } 686 687 @Test 688 @MediumTest 689 public void testRegAndUnregForVoiceRoamingOn() throws Exception { 690 sst.registerForVoiceRoamingOn(mTestHandler, EVENT_DATA_ROAMING_ON, null); 691 692 // Enable roaming and trigger events to notify handler registered 693 doReturn(true).when(mPhone).isPhoneTypeGsm(); 694 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 695 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 696 mSimulatedCommands.notifyNetworkStateChanged(); 697 698 waitForMs(200); 699 700 // verify if registered handler has message posted to it 701 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 702 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 703 assertEquals(EVENT_DATA_ROAMING_ON, messageArgumentCaptor.getValue().what); 704 705 // Disable roaming 706 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 707 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 708 mSimulatedCommands.notifyNetworkStateChanged(); 709 710 waitForMs(100); 711 712 // Unregister registrant 713 sst.unregisterForVoiceRoamingOn(mTestHandler); 714 715 // Enable roaming 716 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 717 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 718 mSimulatedCommands.notifyNetworkStateChanged(); 719 720 waitForMs(200); 721 722 // verify that no new message posted to handler 723 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 724 } 725 726 @Test 727 @MediumTest 728 public void testRegAndUnregForVoiceRoamingOff() throws Exception { 729 // Enable roaming 730 doReturn(true).when(mPhone).isPhoneTypeGsm(); 731 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 732 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 733 mSimulatedCommands.notifyNetworkStateChanged(); 734 735 waitForMs(100); 736 737 sst.registerForVoiceRoamingOff(mTestHandler, EVENT_DATA_ROAMING_OFF, null); 738 739 // Disable roaming 740 doReturn(true).when(mPhone).isPhoneTypeGsm(); 741 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 742 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 743 mSimulatedCommands.notifyNetworkStateChanged(); 744 745 waitForMs(200); 746 747 // verify if registered handler has message posted to it 748 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 749 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 750 assertEquals(EVENT_DATA_ROAMING_OFF, messageArgumentCaptor.getValue().what); 751 752 // Enable roaming 753 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 754 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 755 mSimulatedCommands.notifyNetworkStateChanged(); 756 757 waitForMs(100); 758 759 // Unregister registrant 760 sst.unregisterForVoiceRoamingOff(mTestHandler); 761 762 // Disable roaming 763 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 764 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 765 mSimulatedCommands.notifyNetworkStateChanged(); 766 767 waitForMs(100); 768 769 // verify that no new message posted to handler 770 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 771 } 772 773 @Test 774 @MediumTest 775 public void testRegAndUnregForDataRoamingOn() throws Exception { 776 sst.registerForDataRoamingOn(mTestHandler, EVENT_DATA_ROAMING_ON, null); 777 778 // Enable roaming and trigger events to notify handler registered 779 doReturn(true).when(mPhone).isPhoneTypeGsm(); 780 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 781 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 782 mSimulatedCommands.notifyNetworkStateChanged(); 783 784 waitForMs(200); 785 786 // verify if registered handler has message posted to it 787 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 788 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 789 assertEquals(EVENT_DATA_ROAMING_ON, messageArgumentCaptor.getValue().what); 790 791 // Disable roaming 792 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 793 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 794 mSimulatedCommands.notifyNetworkStateChanged(); 795 796 waitForMs(100); 797 798 // Unregister registrant 799 sst.unregisterForDataRoamingOn(mTestHandler); 800 801 // Enable roaming 802 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 803 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 804 mSimulatedCommands.notifyNetworkStateChanged(); 805 806 waitForMs(200); 807 808 // verify that no new message posted to handler 809 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 810 } 811 812 @Test 813 @MediumTest 814 public void testRegAndUnregForDataRoamingOff() throws Exception { 815 // Enable roaming 816 doReturn(true).when(mPhone).isPhoneTypeGsm(); 817 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 818 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 819 mSimulatedCommands.notifyNetworkStateChanged(); 820 821 waitForMs(100); 822 823 sst.registerForDataRoamingOff(mTestHandler, EVENT_DATA_ROAMING_OFF, null, true); 824 825 // Disable roaming 826 doReturn(true).when(mPhone).isPhoneTypeGsm(); 827 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 828 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 829 mSimulatedCommands.notifyNetworkStateChanged(); 830 831 waitForMs(100); 832 833 // verify if registered handler has message posted to it 834 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 835 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 836 assertEquals(EVENT_DATA_ROAMING_OFF, messageArgumentCaptor.getValue().what); 837 838 // Enable roaming 839 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 840 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 841 mSimulatedCommands.notifyNetworkStateChanged(); 842 843 waitForMs(100); 844 845 // Unregister registrant 846 sst.unregisterForDataRoamingOff(mTestHandler); 847 848 // Disable roaming 849 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_HOME); 850 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_HOME); 851 mSimulatedCommands.notifyNetworkStateChanged(); 852 853 waitForMs(100); 854 855 // verify that no new message posted to handler 856 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 857 } 858 859 @Test 860 @MediumTest 861 public void testRegAndInvalidregForDataConnAttach() throws Exception { 862 // Initially set service state out of service 863 doReturn(true).when(mPhone).isPhoneTypeGsm(); 864 mSimulatedCommands.setVoiceRegState(23); 865 mSimulatedCommands.setDataRegState(23); 866 mSimulatedCommands.notifyNetworkStateChanged(); 867 868 waitForMs(100); 869 870 sst.registerForDataConnectionAttached(mTestHandler, EVENT_DATA_CONNECTION_ATTACHED, null); 871 872 // set service state in service and trigger events to post message on handler 873 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 874 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 875 mSimulatedCommands.notifyNetworkStateChanged(); 876 877 waitForMs(200); 878 879 // verify if registered handler has message posted to it 880 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 881 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 882 assertEquals(EVENT_DATA_CONNECTION_ATTACHED, messageArgumentCaptor.getValue().what); 883 884 // set service state out of service 885 mSimulatedCommands.setVoiceRegState(-1); 886 mSimulatedCommands.setDataRegState(-1); 887 mSimulatedCommands.notifyNetworkStateChanged(); 888 889 waitForMs(100); 890 891 // Unregister registrant 892 sst.unregisterForDataConnectionAttached(mTestHandler); 893 894 // set service state in service 895 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 896 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 897 mSimulatedCommands.notifyNetworkStateChanged(); 898 899 waitForMs(100); 900 901 // verify that no new message posted to handler 902 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 903 } 904 905 @Test 906 @MediumTest 907 public void testRegAndUnregForDataConnAttach() throws Exception { 908 // Initially set service state out of service 909 doReturn(true).when(mPhone).isPhoneTypeGsm(); 910 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 911 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 912 mSimulatedCommands.notifyNetworkStateChanged(); 913 914 waitForMs(100); 915 916 sst.registerForDataConnectionAttached(mTestHandler, EVENT_DATA_CONNECTION_ATTACHED, null); 917 918 // set service state in service and trigger events to post message on handler 919 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 920 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 921 mSimulatedCommands.notifyNetworkStateChanged(); 922 923 waitForMs(200); 924 925 // verify if registered handler has message posted to it 926 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 927 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 928 assertEquals(EVENT_DATA_CONNECTION_ATTACHED, messageArgumentCaptor.getValue().what); 929 930 // set service state out of service 931 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 932 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 933 mSimulatedCommands.notifyNetworkStateChanged(); 934 935 waitForMs(100); 936 937 // Unregister registrant 938 sst.unregisterForDataConnectionAttached(mTestHandler); 939 940 // set service state in service 941 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 942 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 943 mSimulatedCommands.notifyNetworkStateChanged(); 944 945 waitForMs(100); 946 947 // verify that no new message posted to handler 948 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 949 } 950 951 @Test 952 @MediumTest 953 public void testRegAndUnregForDataConnDetach() throws Exception { 954 // Initially set service state in service 955 doReturn(true).when(mPhone).isPhoneTypeGsm(); 956 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 957 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 958 mSimulatedCommands.notifyNetworkStateChanged(); 959 960 sst.registerForDataConnectionDetached(mTestHandler, EVENT_DATA_CONNECTION_DETACHED, null); 961 962 // set service state out of service and trigger events to post message on handler 963 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 964 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 965 mSimulatedCommands.notifyNetworkStateChanged(); 966 967 waitForMs(200); 968 969 // verify if registered handler has message posted to it 970 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 971 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 972 assertEquals(EVENT_DATA_CONNECTION_DETACHED, messageArgumentCaptor.getValue().what); 973 974 // set service state in service 975 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 976 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 977 mSimulatedCommands.notifyNetworkStateChanged(); 978 979 waitForMs(100); 980 981 // Unregister registrant 982 sst.unregisterForDataConnectionDetached(mTestHandler); 983 984 // set service state out of service 985 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 986 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 987 mSimulatedCommands.notifyNetworkStateChanged(); 988 989 waitForMs(100); 990 991 // verify that no new message posted to handler 992 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 993 } 994 995 @Test 996 @MediumTest 997 public void testRegisterForDataRegStateOrRatChange() { 998 int drs = NetworkRegistrationState.REG_STATE_HOME; 999 int rat = sst.mSS.RIL_RADIO_TECHNOLOGY_LTE; 1000 sst.mSS.setRilDataRadioTechnology(rat); 1001 sst.mSS.setDataRegState(drs); 1002 sst.registerForDataRegStateOrRatChanged(mTestHandler, EVENT_DATA_RAT_CHANGED, null); 1003 1004 waitForMs(100); 1005 1006 // Verify if message was posted to handler and value of result 1007 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1008 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1009 assertEquals(EVENT_DATA_RAT_CHANGED, messageArgumentCaptor.getValue().what); 1010 assertEquals(new Pair<Integer, Integer>(drs, rat), 1011 ((AsyncResult)messageArgumentCaptor.getValue().obj).result); 1012 } 1013 1014 @Test 1015 @MediumTest 1016 public void testRegAndUnregForNetworkAttached() throws Exception { 1017 // Initially set service state out of service 1018 doReturn(true).when(mPhone).isPhoneTypeGsm(); 1019 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 1020 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 1021 mSimulatedCommands.notifyNetworkStateChanged(); 1022 1023 waitForMs(100); 1024 1025 sst.registerForNetworkAttached(mTestHandler, EVENT_REGISTERED_TO_NETWORK, null); 1026 1027 // set service state in service and trigger events to post message on handler 1028 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1029 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1030 mSimulatedCommands.notifyNetworkStateChanged(); 1031 1032 waitForMs(100); 1033 1034 // verify if registered handler has message posted to it 1035 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1036 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1037 assertEquals(EVENT_REGISTERED_TO_NETWORK, messageArgumentCaptor.getValue().what); 1038 1039 // set service state out of service 1040 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 1041 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_UNKNOWN); 1042 mSimulatedCommands.notifyNetworkStateChanged(); 1043 1044 waitForMs(100); 1045 1046 // Unregister registrant 1047 sst.unregisterForNetworkAttached(mTestHandler); 1048 1049 // set service state in service 1050 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1051 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1052 mSimulatedCommands.notifyNetworkStateChanged(); 1053 1054 waitForMs(100); 1055 1056 // verify that no new message posted to handler 1057 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 1058 } 1059 1060 @Test 1061 @MediumTest 1062 public void testRegAndInvalidRegForNetworkAttached() throws Exception { 1063 // Initially set service state out of service 1064 doReturn(true).when(mPhone).isPhoneTypeGsm(); 1065 mSimulatedCommands.setVoiceRegState(23); 1066 mSimulatedCommands.setDataRegState(23); 1067 mSimulatedCommands.notifyNetworkStateChanged(); 1068 1069 waitForMs(100); 1070 1071 sst.registerForNetworkAttached(mTestHandler, EVENT_REGISTERED_TO_NETWORK, null); 1072 1073 // set service state in service and trigger events to post message on handler 1074 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1075 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1076 mSimulatedCommands.notifyNetworkStateChanged(); 1077 1078 waitForMs(100); 1079 1080 // verify if registered handler has message posted to it 1081 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1082 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1083 assertEquals(EVENT_REGISTERED_TO_NETWORK, messageArgumentCaptor.getValue().what); 1084 1085 // set service state out of service 1086 mSimulatedCommands.setVoiceRegState(-1); 1087 mSimulatedCommands.setDataRegState(-1); 1088 mSimulatedCommands.notifyNetworkStateChanged(); 1089 1090 waitForMs(100); 1091 1092 // Unregister registrant 1093 sst.unregisterForNetworkAttached(mTestHandler); 1094 1095 1096 waitForMs(100); 1097 1098 sst.registerForNetworkAttached(mTestHandler, EVENT_REGISTERED_TO_NETWORK, null); 1099 1100 // set service state in service 1101 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1102 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1103 mSimulatedCommands.notifyNetworkStateChanged(); 1104 1105 waitForMs(100); 1106 1107 // verify if registered handler has message posted to it 1108 messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1109 verify(mTestHandler, times(2)).sendMessageAtTime(messageArgumentCaptor.capture(), 1110 anyLong()); 1111 assertEquals(EVENT_REGISTERED_TO_NETWORK, messageArgumentCaptor.getValue().what); 1112 } 1113 1114 @Test 1115 @MediumTest 1116 public void testRegisterForPsRestrictedEnabled() throws Exception { 1117 sst.mRestrictedState.setPsRestricted(true); 1118 // Since PsRestricted is set to true, registerForPsRestrictedEnabled will 1119 // also post message to handler 1120 sst.registerForPsRestrictedEnabled(mTestHandler, EVENT_PS_RESTRICT_ENABLED, null); 1121 1122 waitForMs(100); 1123 1124 // verify posted message 1125 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1126 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1127 assertEquals(EVENT_PS_RESTRICT_ENABLED, messageArgumentCaptor.getValue().what); 1128 } 1129 1130 @Test 1131 @MediumTest 1132 public void testRegisterForPsRestrictedDisabled() throws Exception { 1133 sst.mRestrictedState.setPsRestricted(true); 1134 // Since PsRestricted is set to true, registerForPsRestrictedDisabled will 1135 // also post message to handler 1136 sst.registerForPsRestrictedDisabled(mTestHandler, EVENT_PS_RESTRICT_DISABLED, null); 1137 1138 waitForMs(100); 1139 1140 // verify posted message 1141 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1142 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1143 assertEquals(EVENT_PS_RESTRICT_DISABLED, messageArgumentCaptor.getValue().what); 1144 } 1145 1146 @Test 1147 @MediumTest 1148 public void testOnRestrictedStateChanged() throws Exception { 1149 ServiceStateTracker spySst = spy(sst); 1150 doReturn(true).when(mPhone).isPhoneTypeGsm(); 1151 doReturn(IccCardApplicationStatus.AppState.APPSTATE_READY).when( 1152 mUiccCardApplication3gpp).getState(); 1153 1154 ArgumentCaptor<Integer> intArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 1155 verify(mSimulatedCommandsVerifier).setOnRestrictedStateChanged(any(Handler.class), 1156 intArgumentCaptor.capture(), eq(null)); 1157 // Since spy() creates a copy of sst object we need to call 1158 // setOnRestrictedStateChanged() explicitly. 1159 mSimulatedCommands.setOnRestrictedStateChanged(spySst, 1160 intArgumentCaptor.getValue().intValue(), null); 1161 1162 // Combination of restricted state and expected notification type. 1163 final int CS_ALL[] = {RILConstants.RIL_RESTRICTED_STATE_CS_ALL, 1164 ServiceStateTracker.CS_ENABLED}; 1165 final int CS_NOR[] = {RILConstants.RIL_RESTRICTED_STATE_CS_NORMAL, 1166 ServiceStateTracker.CS_NORMAL_ENABLED}; 1167 final int CS_EME[] = {RILConstants.RIL_RESTRICTED_STATE_CS_EMERGENCY, 1168 ServiceStateTracker.CS_EMERGENCY_ENABLED}; 1169 final int CS_NON[] = {RILConstants.RIL_RESTRICTED_STATE_NONE, 1170 ServiceStateTracker.CS_DISABLED}; 1171 final int PS_ALL[] = {RILConstants.RIL_RESTRICTED_STATE_PS_ALL, 1172 ServiceStateTracker.PS_ENABLED}; 1173 final int PS_NON[] = {RILConstants.RIL_RESTRICTED_STATE_NONE, 1174 ServiceStateTracker.PS_DISABLED}; 1175 1176 int notifyCount = 0; 1177 // cs not restricted -> cs emergency/normal restricted 1178 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_ALL); 1179 // cs emergency/normal restricted -> cs normal restricted 1180 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NOR); 1181 // cs normal restricted -> cs emergency restricted 1182 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_EME); 1183 // cs emergency restricted -> cs not restricted 1184 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NON); 1185 // cs not restricted -> cs normal restricted 1186 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NOR); 1187 // cs normal restricted -> cs emergency/normal restricted 1188 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_ALL); 1189 // cs emergency/normal restricted -> cs emergency restricted 1190 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_EME); 1191 // cs emergency restricted -> cs emergency/normal restricted 1192 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_ALL); 1193 // cs emergency/normal restricted -> cs not restricted 1194 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NON); 1195 // cs not restricted -> cs emergency restricted 1196 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_EME); 1197 // cs emergency restricted -> cs normal restricted 1198 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NOR); 1199 // cs normal restricted -> cs not restricted 1200 internalCheckForRestrictedStateChange(spySst, ++notifyCount, CS_NON); 1201 1202 // ps not restricted -> ps restricted 1203 internalCheckForRestrictedStateChange(spySst, ++notifyCount, PS_ALL); 1204 // ps restricted -> ps not restricted 1205 internalCheckForRestrictedStateChange(spySst, ++notifyCount, PS_NON); 1206 } 1207 1208 private void internalCheckForRestrictedStateChange(ServiceStateTracker serviceStateTracker, 1209 int times, int[] restrictedState) { 1210 mSimulatedCommands.triggerRestrictedStateChanged(restrictedState[0]); 1211 waitForMs(100); 1212 ArgumentCaptor<Integer> intArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 1213 verify(serviceStateTracker, times(times)).setNotification(intArgumentCaptor.capture()); 1214 assertEquals(intArgumentCaptor.getValue().intValue(), restrictedState[1]); 1215 } 1216 1217 private boolean notificationHasTitleSet(Notification n) { 1218 // Notification has no methods to check the actual title, but #toString() includes the 1219 // word "tick" if the title is set so we check this as a workaround 1220 return n.toString().contains("tick"); 1221 } 1222 1223 private String getNotificationTitle(Notification n) { 1224 return n.extras.getString(Notification.EXTRA_TITLE); 1225 } 1226 1227 @Test 1228 @SmallTest 1229 public void testSetPsNotifications() { 1230 sst.mSubId = 1; 1231 final NotificationManager nm = (NotificationManager) 1232 mContext.getSystemService(Context.NOTIFICATION_SERVICE); 1233 mContextFixture.putBooleanResource( 1234 R.bool.config_user_notification_of_restrictied_mobile_access, true); 1235 doReturn(new ApplicationInfo()).when(mContext).getApplicationInfo(); 1236 Drawable mockDrawable = mock(Drawable.class); 1237 Resources mockResources = mContext.getResources(); 1238 when(mockResources.getDrawable(anyInt(), any())).thenReturn(mockDrawable); 1239 1240 mContextFixture.putResource(com.android.internal.R.string.RestrictedOnDataTitle, "test1"); 1241 sst.setNotification(ServiceStateTracker.PS_ENABLED); 1242 ArgumentCaptor<Notification> notificationArgumentCaptor = 1243 ArgumentCaptor.forClass(Notification.class); 1244 verify(nm).notify(anyString(), anyInt(), notificationArgumentCaptor.capture()); 1245 // if the postedNotification has title set then it must have been the correct notification 1246 Notification postedNotification = notificationArgumentCaptor.getValue(); 1247 assertTrue(notificationHasTitleSet(postedNotification)); 1248 assertEquals("test1", getNotificationTitle(postedNotification)); 1249 1250 sst.setNotification(ServiceStateTracker.PS_DISABLED); 1251 verify(nm).cancel(anyString(), anyInt()); 1252 } 1253 1254 @Test 1255 @SmallTest 1256 public void testSetCsNotifications() { 1257 sst.mSubId = 1; 1258 final NotificationManager nm = (NotificationManager) 1259 mContext.getSystemService(Context.NOTIFICATION_SERVICE); 1260 mContextFixture.putBooleanResource( 1261 R.bool.config_user_notification_of_restrictied_mobile_access, true); 1262 doReturn(new ApplicationInfo()).when(mContext).getApplicationInfo(); 1263 Drawable mockDrawable = mock(Drawable.class); 1264 Resources mockResources = mContext.getResources(); 1265 when(mockResources.getDrawable(anyInt(), any())).thenReturn(mockDrawable); 1266 1267 mContextFixture.putResource(com.android.internal.R.string.RestrictedOnAllVoiceTitle, 1268 "test2"); 1269 sst.setNotification(ServiceStateTracker.CS_ENABLED); 1270 ArgumentCaptor<Notification> notificationArgumentCaptor = 1271 ArgumentCaptor.forClass(Notification.class); 1272 verify(nm).notify(anyString(), anyInt(), notificationArgumentCaptor.capture()); 1273 // if the postedNotification has title set then it must have been the correct notification 1274 Notification postedNotification = notificationArgumentCaptor.getValue(); 1275 assertTrue(notificationHasTitleSet(postedNotification)); 1276 assertEquals("test2", getNotificationTitle(postedNotification)); 1277 1278 sst.setNotification(ServiceStateTracker.CS_DISABLED); 1279 verify(nm).cancel(anyString(), anyInt()); 1280 } 1281 1282 @Test 1283 @SmallTest 1284 public void testSetCsNormalNotifications() { 1285 sst.mSubId = 1; 1286 final NotificationManager nm = (NotificationManager) 1287 mContext.getSystemService(Context.NOTIFICATION_SERVICE); 1288 mContextFixture.putBooleanResource( 1289 R.bool.config_user_notification_of_restrictied_mobile_access, true); 1290 doReturn(new ApplicationInfo()).when(mContext).getApplicationInfo(); 1291 Drawable mockDrawable = mock(Drawable.class); 1292 Resources mockResources = mContext.getResources(); 1293 when(mockResources.getDrawable(anyInt(), any())).thenReturn(mockDrawable); 1294 1295 mContextFixture.putResource(com.android.internal.R.string.RestrictedOnNormalTitle, "test3"); 1296 sst.setNotification(ServiceStateTracker.CS_NORMAL_ENABLED); 1297 ArgumentCaptor<Notification> notificationArgumentCaptor = 1298 ArgumentCaptor.forClass(Notification.class); 1299 verify(nm).notify(anyString(), anyInt(), notificationArgumentCaptor.capture()); 1300 // if the postedNotification has title set then it must have been the correct notification 1301 Notification postedNotification = notificationArgumentCaptor.getValue(); 1302 assertTrue(notificationHasTitleSet(postedNotification)); 1303 assertEquals("test3", getNotificationTitle(postedNotification)); 1304 1305 sst.setNotification(ServiceStateTracker.CS_DISABLED); 1306 verify(nm).cancel(anyString(), anyInt()); 1307 } 1308 1309 @Test 1310 @SmallTest 1311 public void testSetCsEmergencyNotifications() { 1312 sst.mSubId = 1; 1313 final NotificationManager nm = (NotificationManager) 1314 mContext.getSystemService(Context.NOTIFICATION_SERVICE); 1315 mContextFixture.putBooleanResource( 1316 R.bool.config_user_notification_of_restrictied_mobile_access, true); 1317 doReturn(new ApplicationInfo()).when(mContext).getApplicationInfo(); 1318 Drawable mockDrawable = mock(Drawable.class); 1319 Resources mockResources = mContext.getResources(); 1320 when(mockResources.getDrawable(anyInt(), any())).thenReturn(mockDrawable); 1321 1322 mContextFixture.putResource(com.android.internal.R.string.RestrictedOnEmergencyTitle, 1323 "test4"); 1324 sst.setNotification(ServiceStateTracker.CS_EMERGENCY_ENABLED); 1325 ArgumentCaptor<Notification> notificationArgumentCaptor = 1326 ArgumentCaptor.forClass(Notification.class); 1327 verify(nm).notify(anyString(), anyInt(), notificationArgumentCaptor.capture()); 1328 // if the postedNotification has title set then it must have been the correct notification 1329 Notification postedNotification = notificationArgumentCaptor.getValue(); 1330 assertTrue(notificationHasTitleSet(postedNotification)); 1331 assertEquals("test4", getNotificationTitle(postedNotification)); 1332 1333 sst.setNotification(ServiceStateTracker.CS_DISABLED); 1334 verify(nm).cancel(anyString(), anyInt()); 1335 sst.setNotification(ServiceStateTracker.CS_REJECT_CAUSE_ENABLED); 1336 } 1337 1338 @Test 1339 @MediumTest 1340 public void testRegisterForSubscriptionInfoReady() { 1341 sst.registerForSubscriptionInfoReady(mTestHandler, EVENT_SUBSCRIPTION_INFO_READY, null); 1342 1343 // Call functions which would trigger posting of message on test handler 1344 doReturn(false).when(mPhone).isPhoneTypeGsm(); 1345 sst.updatePhoneType(); 1346 mSimulatedCommands.notifyOtaProvisionStatusChanged(); 1347 1348 waitForMs(200); 1349 1350 // verify posted message 1351 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1352 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 1353 assertEquals(EVENT_SUBSCRIPTION_INFO_READY, messageArgumentCaptor.getValue().what); 1354 } 1355 1356 @Test 1357 @MediumTest 1358 public void testRoamingPhoneTypeSwitch() { 1359 // Enable roaming 1360 doReturn(true).when(mPhone).isPhoneTypeGsm(); 1361 1362 mSimulatedCommands.setVoiceRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1363 mSimulatedCommands.setDataRegState(NetworkRegistrationState.REG_STATE_ROAMING); 1364 mSimulatedCommands.notifyNetworkStateChanged(); 1365 1366 waitForMs(200); 1367 1368 sst.registerForDataRoamingOff(mTestHandler, EVENT_DATA_ROAMING_OFF, null, true); 1369 sst.registerForVoiceRoamingOff(mTestHandler, EVENT_VOICE_ROAMING_OFF, null); 1370 sst.registerForDataConnectionDetached(mTestHandler, EVENT_DATA_CONNECTION_DETACHED, null); 1371 1372 // Call functions which would trigger posting of message on test handler 1373 doReturn(false).when(mPhone).isPhoneTypeGsm(); 1374 sst.updatePhoneType(); 1375 1376 // verify if registered handler has message posted to it 1377 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 1378 verify(mTestHandler, atLeast(3)).sendMessageAtTime( 1379 messageArgumentCaptor.capture(), anyLong()); 1380 HashSet<Integer> messageSet = new HashSet<>(); 1381 for (Message m : messageArgumentCaptor.getAllValues()) { 1382 messageSet.add(m.what); 1383 } 1384 1385 assertTrue(messageSet.contains(EVENT_DATA_ROAMING_OFF)); 1386 assertTrue(messageSet.contains(EVENT_VOICE_ROAMING_OFF)); 1387 assertTrue(messageSet.contains(EVENT_DATA_CONNECTION_DETACHED)); 1388 } 1389 1390 @Test 1391 @SmallTest 1392 public void testGetDesiredPowerState() { 1393 sst.setRadioPower(true); 1394 assertEquals(sst.getDesiredPowerState(), true); 1395 } 1396 1397 @Test 1398 @MediumTest 1399 public void testEnableLocationUpdates() throws Exception { 1400 sst.enableLocationUpdates(); 1401 verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(true), 1402 any(Message.class)); 1403 } 1404 1405 @Test 1406 @SmallTest 1407 public void testDisableLocationUpdates() throws Exception { 1408 sst.disableLocationUpdates(); 1409 verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(false), 1410 nullable(Message.class)); 1411 } 1412 1413 @Test 1414 @SmallTest 1415 public void testGetCurrentDataRegState() throws Exception { 1416 sst.mSS.setDataRegState(ServiceState.STATE_OUT_OF_SERVICE); 1417 assertEquals(sst.getCurrentDataConnectionState(), ServiceState.STATE_OUT_OF_SERVICE); 1418 } 1419 1420 @Test 1421 @SmallTest 1422 public void testIsConcurrentVoiceAndDataAllowed() { 1423 doReturn(false).when(mPhone).isPhoneTypeGsm(); 1424 sst.mSS.setCssIndicator(1); 1425 assertEquals(true, sst.isConcurrentVoiceAndDataAllowed()); 1426 sst.mSS.setCssIndicator(0); 1427 assertEquals(false, sst.isConcurrentVoiceAndDataAllowed()); 1428 1429 doReturn(true).when(mPhone).isPhoneTypeGsm(); 1430 sst.mSS.setRilDataRadioTechnology(sst.mSS.RIL_RADIO_TECHNOLOGY_HSPA); 1431 assertEquals(true, sst.isConcurrentVoiceAndDataAllowed()); 1432 sst.mSS.setRilDataRadioTechnology(sst.mSS.RIL_RADIO_TECHNOLOGY_GPRS); 1433 assertEquals(false, sst.isConcurrentVoiceAndDataAllowed()); 1434 sst.mSS.setCssIndicator(1); 1435 assertEquals(true, sst.isConcurrentVoiceAndDataAllowed()); 1436 } 1437 1438 @Test 1439 @MediumTest 1440 public void testIsImsRegistered() throws Exception { 1441 mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM}); 1442 mSimulatedCommands.notifyImsNetworkStateChanged(); 1443 waitForMs(200); 1444 assertEquals(sst.isImsRegistered(), true); 1445 } 1446 1447 @Test 1448 @SmallTest 1449 public void testIsDeviceShuttingDown() throws Exception { 1450 sst.requestShutdown(); 1451 assertEquals(true, sst.isDeviceShuttingDown()); 1452 } 1453 1454 @Test 1455 @SmallTest 1456 public void testShuttingDownRequest() throws Exception { 1457 sst.setRadioPower(true); 1458 waitForMs(100); 1459 1460 sst.requestShutdown(); 1461 waitForMs(100); 1462 assertFalse(mSimulatedCommands.getRadioState().isAvailable()); 1463 } 1464 1465 @Test 1466 @SmallTest 1467 public void testShuttingDownRequestWithRadioPowerFailResponse() throws Exception { 1468 sst.setRadioPower(true); 1469 waitForMs(100); 1470 1471 // Simulate RIL fails the radio power settings. 1472 mSimulatedCommands.setRadioPowerFailResponse(true); 1473 sst.setRadioPower(false); 1474 waitForMs(100); 1475 assertTrue(mSimulatedCommands.getRadioState().isOn()); 1476 sst.requestShutdown(); 1477 waitForMs(100); 1478 assertFalse(mSimulatedCommands.getRadioState().isAvailable()); 1479 } 1480 1481 @Test 1482 @SmallTest 1483 public void testSetTimeFromNITZStr() throws Exception { 1484 { 1485 // Mock sending incorrect nitz str from RIL 1486 mSimulatedCommands.triggerNITZupdate("38/06/20,00:00:00+0"); 1487 waitForMs(200); 1488 verify(mNitzStateMachine, times(0)).handleNitzReceived(any()); 1489 } 1490 { 1491 // Mock sending correct nitz str from RIL 1492 String nitzStr = "15/06/20,00:00:00+0"; 1493 NitzData expectedNitzData = NitzData.parse(nitzStr); 1494 mSimulatedCommands.triggerNITZupdate(nitzStr); 1495 waitForMs(200); 1496 1497 ArgumentCaptor<TimeStampedValue<NitzData>> argumentsCaptor = 1498 ArgumentCaptor.forClass(TimeStampedValue.class); 1499 verify(mNitzStateMachine, times(1)) 1500 .handleNitzReceived(argumentsCaptor.capture()); 1501 1502 // Confirm the argument was what we expected. 1503 TimeStampedValue<NitzData> actualNitzSignal = argumentsCaptor.getValue(); 1504 assertEquals(expectedNitzData, actualNitzSignal.mValue); 1505 assertTrue(actualNitzSignal.mElapsedRealtime <= SystemClock.elapsedRealtime()); 1506 } 1507 } 1508 1509 // Edge and GPRS are grouped under the same family and Edge has higher rate than GPRS. 1510 // Expect no rat update when move from E to G. 1511 @Test 1512 public void testRatRatchet() throws Exception { 1513 CellIdentityGsm cellIdentity = new CellIdentityGsm(-1, -1, -1, -1, -1, -1); 1514 NetworkRegistrationState dataResult = new NetworkRegistrationState( 1515 0, 0, 1, 2, 0, false, null, cellIdentity, 1); 1516 sst.mPollingContext[0] = 2; 1517 // update data reg state to be in service 1518 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1519 new AsyncResult(sst.mPollingContext, dataResult, null))); 1520 waitForMs(200); 1521 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1522 1523 NetworkRegistrationState voiceResult = new NetworkRegistrationState( 1524 0, 0, 1, 2, 0, false, null, cellIdentity, false, 0, 0, 0); 1525 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1526 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1527 waitForMs(200); 1528 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_EDGE, sst.mSS.getRilVoiceRadioTechnology()); 1529 1530 // EDGE -> GPRS 1531 voiceResult = new NetworkRegistrationState( 1532 0, 0, 1, 1, 0, false, null, 1533 cellIdentity, false, 0, 0, 0); 1534 sst.mPollingContext[0] = 2; 1535 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1536 new AsyncResult(sst.mPollingContext, dataResult, null))); 1537 waitForMs(200); 1538 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1539 1540 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1541 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1542 waitForMs(200); 1543 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_EDGE, sst.mSS.getRilVoiceRadioTechnology()); 1544 } 1545 1546 // Edge and GPRS are grouped under the same family and Edge has higher rate than GPRS. 1547 // Bypass rat rachet when cell id changed. Expect rat update from E to G 1548 @Test 1549 public void testRatRatchetWithCellChange() throws Exception { 1550 CellIdentityGsm cellIdentity = new CellIdentityGsm(-1, -1, -1, -1, -1, -1); 1551 NetworkRegistrationState dataResult = new NetworkRegistrationState( 1552 0, 0, 1, 2, 0, false, null, cellIdentity, 1); 1553 sst.mPollingContext[0] = 2; 1554 // update data reg state to be in service 1555 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1556 new AsyncResult(sst.mPollingContext, dataResult, null))); 1557 waitForMs(200); 1558 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1559 1560 NetworkRegistrationState voiceResult = new NetworkRegistrationState( 1561 0, 0, 1, 2, 0, false, null, cellIdentity, false, 0, 0, 0); 1562 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1563 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1564 waitForMs(200); 1565 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_EDGE, sst.mSS.getRilVoiceRadioTechnology()); 1566 1567 // RAT: EDGE -> GPRS cell ID: -1 -> 5 1568 cellIdentity = new CellIdentityGsm(-1, -1, -1, 5, -1, -1); 1569 voiceResult = new NetworkRegistrationState( 1570 0, 0, 1, 1, 0, false, null, cellIdentity, false, 0, 0, 0); 1571 sst.mPollingContext[0] = 2; 1572 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1573 new AsyncResult(sst.mPollingContext, dataResult, null))); 1574 waitForMs(200); 1575 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1576 1577 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1578 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1579 waitForMs(200); 1580 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_GPRS, sst.mSS.getRilVoiceRadioTechnology()); 1581 } 1582 1583 // Edge, GPRS and UMTS are grouped under the same family where Edge > GPRS > UMTS . 1584 // Expect no rat update from E to G immediately following cell id change. 1585 // Expect ratratchet (from G to UMTS) for the following rat update within the cell location. 1586 @Test 1587 public void testRatRatchetWithCellChangeBeforeRatChange() throws Exception { 1588 // cell ID update 1589 CellIdentityGsm cellIdentity = new CellIdentityGsm(-1, -1, -1, 5, -1, -1); 1590 NetworkRegistrationState dataResult = new NetworkRegistrationState( 1591 0, 0, 1, 2, 0, false, null, cellIdentity, 1); 1592 sst.mPollingContext[0] = 2; 1593 // update data reg state to be in service 1594 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1595 new AsyncResult(sst.mPollingContext, dataResult, null))); 1596 waitForMs(200); 1597 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1598 1599 NetworkRegistrationState voiceResult = new NetworkRegistrationState( 1600 0, 0, 1, 2, 0, false, null, cellIdentity, false, 0, 0, 0); 1601 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1602 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1603 waitForMs(200); 1604 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_EDGE, sst.mSS.getRilVoiceRadioTechnology()); 1605 1606 // RAT: EDGE -> GPRS, cell ID unchanged. Expect no rat ratchet following cell Id change. 1607 voiceResult = new NetworkRegistrationState( 1608 0, 0, 1, 1, 0, false, null, cellIdentity, false, 0, 0, 0); 1609 sst.mPollingContext[0] = 2; 1610 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1611 new AsyncResult(sst.mPollingContext, dataResult, null))); 1612 waitForMs(200); 1613 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1614 1615 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1616 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1617 waitForMs(200); 1618 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_GPRS, sst.mSS.getRilVoiceRadioTechnology()); 1619 1620 // RAT: GPRS -> UMTS 1621 voiceResult = new NetworkRegistrationState( 1622 0, 0, 1, 3, 0, false, null, cellIdentity, false, 0, 0, 0); 1623 sst.mPollingContext[0] = 2; 1624 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1625 new AsyncResult(sst.mPollingContext, dataResult, null))); 1626 waitForMs(200); 1627 assertEquals(ServiceState.STATE_IN_SERVICE, mSST.getCurrentDataConnectionState()); 1628 1629 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1630 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1631 waitForMs(200); 1632 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_GPRS, sst.mSS.getRilVoiceRadioTechnology()); 1633 } 1634 1635 private void sendPhyChanConfigChange(int[] bandwidths) { 1636 ArrayList<PhysicalChannelConfig> pc = new ArrayList<>(); 1637 int ssType = PhysicalChannelConfig.CONNECTION_PRIMARY_SERVING; 1638 for (int bw : bandwidths) { 1639 pc.add(new PhysicalChannelConfig(ssType, bw)); 1640 1641 // All cells after the first are secondary serving cells. 1642 ssType = PhysicalChannelConfig.CONNECTION_SECONDARY_SERVING; 1643 } 1644 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_PHYSICAL_CHANNEL_CONFIG, 1645 new AsyncResult(null, pc, null))); 1646 waitForMs(100); 1647 } 1648 1649 private void sendRegStateUpdateForLteCellId(CellIdentityLte cellId) { 1650 NetworkRegistrationState dataResult = new NetworkRegistrationState( 1651 1, 2, 1, TelephonyManager.NETWORK_TYPE_LTE, 0, false, null, cellId, 1); 1652 NetworkRegistrationState voiceResult = new NetworkRegistrationState( 1653 1, 1, 1, TelephonyManager.NETWORK_TYPE_LTE, 0, false, null, cellId, 1654 false, 0, 0, 0); 1655 sst.mPollingContext[0] = 2; 1656 // update data reg state to be in service 1657 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1658 new AsyncResult(sst.mPollingContext, dataResult, null))); 1659 waitForMs(200); 1660 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1661 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1662 waitForMs(200); 1663 } 1664 1665 @Test 1666 public void testPhyChanBandwidthUpdatedOnDataRegState() throws Exception { 1667 // Cell ID change should trigger hasLocationChanged. 1668 CellIdentityLte cellIdentity5 = 1669 new CellIdentityLte(1, 1, 5, 1, 5000, "001", "01", "test", "tst"); 1670 1671 sendPhyChanConfigChange(new int[] {10000}); 1672 sendRegStateUpdateForLteCellId(cellIdentity5); 1673 assertTrue(Arrays.equals(new int[] {5000}, sst.mSS.getCellBandwidths())); 1674 } 1675 1676 @Test 1677 public void testPhyChanBandwidthNotUpdatedWhenInvalidInCellIdentity() throws Exception { 1678 // Cell ID change should trigger hasLocationChanged. 1679 CellIdentityLte cellIdentityInv = 1680 new CellIdentityLte(1, 1, 5, 1, 12345, "001", "01", "test", "tst"); 1681 1682 sendPhyChanConfigChange(new int[] {10000}); 1683 sendRegStateUpdateForLteCellId(cellIdentityInv); 1684 assertTrue(Arrays.equals(new int[] {10000}, sst.mSS.getCellBandwidths())); 1685 } 1686 1687 @Test 1688 public void testPhyChanBandwidthPrefersCarrierAggregationReport() throws Exception { 1689 // Cell ID change should trigger hasLocationChanged. 1690 CellIdentityLte cellIdentity10 = 1691 new CellIdentityLte(1, 1, 5, 1, 10000, "001", "01", "test", "tst"); 1692 1693 sendPhyChanConfigChange(new int[] {10000, 5000}); 1694 sendRegStateUpdateForLteCellId(cellIdentity10); 1695 assertTrue(Arrays.equals(new int[] {10000, 5000}, sst.mSS.getCellBandwidths())); 1696 } 1697 1698 @Test 1699 public void testPhyChanBandwidthRatchetedOnPhyChanBandwidth() throws Exception { 1700 // LTE Cell with bandwidth = 10000 1701 CellIdentityLte cellIdentity10 = 1702 new CellIdentityLte(1, 1, 1, 1, 10000, "1", "1", "test", "tst"); 1703 1704 sendRegStateUpdateForLteCellId(cellIdentity10); 1705 assertTrue(Arrays.equals(new int[] {10000}, sst.mSS.getCellBandwidths())); 1706 sendPhyChanConfigChange(new int[] {10000, 5000}); 1707 assertTrue(Arrays.equals(new int[] {10000, 5000}, sst.mSS.getCellBandwidths())); 1708 } 1709 1710 @Test 1711 public void testPhyChanBandwidthResetsOnOos() throws Exception { 1712 testPhyChanBandwidthRatchetedOnPhyChanBandwidth(); 1713 NetworkRegistrationState dataResult = new NetworkRegistrationState( 1714 1, 2, 0, TelephonyManager.NETWORK_TYPE_UNKNOWN, 0, false, null, null, 1); 1715 NetworkRegistrationState voiceResult = new NetworkRegistrationState( 1716 1, 1, 0, TelephonyManager.NETWORK_TYPE_UNKNOWN, 0, false, null, null, 1717 false, 0, 0, 0); 1718 sst.mPollingContext[0] = 2; 1719 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_GPRS, 1720 new AsyncResult(sst.mPollingContext, dataResult, null))); 1721 waitForMs(200); 1722 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_POLL_STATE_REGISTRATION, 1723 new AsyncResult(sst.mPollingContext, voiceResult, null))); 1724 waitForMs(200); 1725 assertTrue(Arrays.equals(new int[0], sst.mSS.getCellBandwidths())); 1726 } 1727 } 1728
