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.TelephonyStatsLog.CELLULAR_SERVICE_STATE__FOLD_STATE__STATE_UNKNOWN; 20 21 import static org.junit.Assert.assertTrue; 22 import static org.junit.Assert.fail; 23 import static org.mockito.ArgumentMatchers.anyString; 24 import static org.mockito.Matchers.anyBoolean; 25 import static org.mockito.Matchers.nullable; 26 import static org.mockito.Mockito.any; 27 import static org.mockito.Mockito.anyInt; 28 import static org.mockito.Mockito.doAnswer; 29 import static org.mockito.Mockito.doReturn; 30 import static org.mockito.Mockito.eq; 31 import static org.mockito.Mockito.spy; 32 33 import android.app.ActivityManager; 34 import android.app.AppOpsManager; 35 import android.app.IActivityManager; 36 import android.app.KeyguardManager; 37 import android.app.PropertyInvalidatedCache; 38 import android.app.admin.DevicePolicyManager; 39 import android.app.usage.NetworkStatsManager; 40 import android.content.ContentProvider; 41 import android.content.ContentResolver; 42 import android.content.Context; 43 import android.content.IIntentSender; 44 import android.content.Intent; 45 import android.content.SharedPreferences; 46 import android.content.pm.ApplicationInfo; 47 import android.content.pm.IPackageManager; 48 import android.content.pm.PackageInfo; 49 import android.content.pm.PackageManager; 50 import android.location.LocationManager; 51 import android.net.ConnectivityManager; 52 import android.net.NetworkCapabilities; 53 import android.net.NetworkPolicyManager; 54 import android.net.vcn.VcnManager; 55 import android.net.vcn.VcnNetworkPolicyResult; 56 import android.net.wifi.WifiInfo; 57 import android.net.wifi.WifiManager; 58 import android.os.Build; 59 import android.os.Bundle; 60 import android.os.Handler; 61 import android.os.IBinder; 62 import android.os.Looper; 63 import android.os.Message; 64 import android.os.MessageQueue; 65 import android.os.RegistrantList; 66 import android.os.ServiceManager; 67 import android.os.StrictMode; 68 import android.os.SystemClock; 69 import android.os.UserManager; 70 import android.permission.LegacyPermissionManager; 71 import android.provider.BlockedNumberContract; 72 import android.provider.DeviceConfig; 73 import android.provider.Settings; 74 import android.provider.Telephony; 75 import android.telecom.TelecomManager; 76 import android.telephony.AccessNetworkConstants; 77 import android.telephony.CarrierConfigManager; 78 import android.telephony.CellIdentity; 79 import android.telephony.CellLocation; 80 import android.telephony.NetworkRegistrationInfo; 81 import android.telephony.ServiceState; 82 import android.telephony.SignalStrength; 83 import android.telephony.SubscriptionManager; 84 import android.telephony.TelephonyDisplayInfo; 85 import android.telephony.TelephonyManager; 86 import android.telephony.TelephonyRegistryManager; 87 import android.telephony.emergency.EmergencyNumber; 88 import android.telephony.euicc.EuiccManager; 89 import android.telephony.ims.ImsCallProfile; 90 import android.test.mock.MockContentProvider; 91 import android.test.mock.MockContentResolver; 92 import android.testing.TestableLooper; 93 import android.util.Log; 94 import android.util.Singleton; 95 96 import com.android.ims.ImsCall; 97 import com.android.ims.ImsEcbm; 98 import com.android.ims.ImsManager; 99 import com.android.internal.telephony.analytics.TelephonyAnalytics; 100 import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager; 101 import com.android.internal.telephony.cdma.EriManager; 102 import com.android.internal.telephony.data.AccessNetworksManager; 103 import com.android.internal.telephony.data.CellularNetworkValidator; 104 import com.android.internal.telephony.data.DataConfigManager; 105 import com.android.internal.telephony.data.DataNetworkController; 106 import com.android.internal.telephony.data.DataProfileManager; 107 import com.android.internal.telephony.data.DataRetryManager; 108 import com.android.internal.telephony.data.DataServiceManager; 109 import com.android.internal.telephony.data.DataSettingsManager; 110 import com.android.internal.telephony.data.LinkBandwidthEstimator; 111 import com.android.internal.telephony.data.PhoneSwitcher; 112 import com.android.internal.telephony.domainselection.DomainSelectionResolver; 113 import com.android.internal.telephony.emergency.EmergencyNumberTracker; 114 import com.android.internal.telephony.flags.FeatureFlags; 115 import com.android.internal.telephony.imsphone.ImsExternalCallTracker; 116 import com.android.internal.telephony.imsphone.ImsNrSaModeHandler; 117 import com.android.internal.telephony.imsphone.ImsPhone; 118 import com.android.internal.telephony.imsphone.ImsPhoneCallTracker; 119 import com.android.internal.telephony.metrics.DefaultNetworkMonitor; 120 import com.android.internal.telephony.metrics.DeviceStateHelper; 121 import com.android.internal.telephony.metrics.ImsStats; 122 import com.android.internal.telephony.metrics.MetricsCollector; 123 import com.android.internal.telephony.metrics.PersistAtomsStorage; 124 import com.android.internal.telephony.metrics.ServiceStateStats; 125 import com.android.internal.telephony.metrics.SmsStats; 126 import com.android.internal.telephony.metrics.VoiceCallSessionStats; 127 import com.android.internal.telephony.satellite.SatelliteController; 128 import com.android.internal.telephony.security.CellularIdentifierDisclosureNotifier; 129 import com.android.internal.telephony.security.CellularNetworkSecuritySafetySource; 130 import com.android.internal.telephony.security.NullCipherNotifier; 131 import com.android.internal.telephony.subscription.SubscriptionManagerService; 132 import com.android.internal.telephony.test.SimulatedCommands; 133 import com.android.internal.telephony.test.SimulatedCommandsVerifier; 134 import com.android.internal.telephony.uicc.IccCardStatus; 135 import com.android.internal.telephony.uicc.IccRecords; 136 import com.android.internal.telephony.uicc.IsimUiccRecords; 137 import com.android.internal.telephony.uicc.PinStorage; 138 import com.android.internal.telephony.uicc.RuimRecords; 139 import com.android.internal.telephony.uicc.SIMRecords; 140 import com.android.internal.telephony.uicc.UiccCard; 141 import com.android.internal.telephony.uicc.UiccCardApplication; 142 import com.android.internal.telephony.uicc.UiccController; 143 import com.android.internal.telephony.uicc.UiccPort; 144 import com.android.internal.telephony.uicc.UiccProfile; 145 import com.android.internal.telephony.uicc.UiccSlot; 146 import com.android.server.pm.permission.LegacyPermissionManagerService; 147 148 import org.mockito.Mockito; 149 import org.mockito.invocation.InvocationOnMock; 150 import org.mockito.stubbing.Answer; 151 152 import java.lang.reflect.Field; 153 import java.lang.reflect.InvocationTargetException; 154 import java.lang.reflect.Method; 155 import java.util.ArrayList; 156 import java.util.HashMap; 157 import java.util.HashSet; 158 import java.util.List; 159 import java.util.Set; 160 import java.util.concurrent.CountDownLatch; 161 import java.util.concurrent.Semaphore; 162 import java.util.concurrent.TimeUnit; 163 import java.util.function.Consumer; 164 165 public abstract class TelephonyTest { 166 protected static String TAG; 167 168 private static final int MAX_INIT_WAIT_MS = 30000; // 30 seconds 169 170 private static final EmergencyNumber SAMPLE_EMERGENCY_NUMBER = 171 new EmergencyNumber("911", "us", "30", 172 EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED, 173 new ArrayList<String>(), EmergencyNumber.EMERGENCY_NUMBER_SOURCE_NETWORK_SIGNALING, 174 EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL); 175 176 private static final Field MESSAGE_QUEUE_FIELD; 177 private static final Field MESSAGE_WHEN_FIELD; 178 private static final Field MESSAGE_NEXT_FIELD; 179 180 static { 181 try { 182 MESSAGE_QUEUE_FIELD = MessageQueue.class.getDeclaredField("mMessages"); 183 MESSAGE_QUEUE_FIELD.setAccessible(true); 184 MESSAGE_WHEN_FIELD = Message.class.getDeclaredField("when"); 185 MESSAGE_WHEN_FIELD.setAccessible(true); 186 MESSAGE_NEXT_FIELD = Message.class.getDeclaredField("next"); 187 MESSAGE_NEXT_FIELD.setAccessible(true); 188 } catch (NoSuchFieldException e) { 189 throw new RuntimeException("Failed to initialize TelephonyTest", e); 190 } 191 } 192 193 // Mocked classes 194 protected FeatureFlags mFeatureFlags; 195 protected GsmCdmaPhone mPhone; 196 protected GsmCdmaPhone mPhone2; 197 protected ImsPhone mImsPhone; 198 protected ServiceStateTracker mSST; 199 protected EmergencyNumberTracker mEmergencyNumberTracker; 200 protected GsmCdmaCallTracker mCT; 201 protected ImsPhoneCallTracker mImsCT; 202 protected UiccController mUiccController; 203 protected UiccProfile mUiccProfile; 204 protected UiccSlot mUiccSlot; 205 protected CallManager mCallManager; 206 protected PhoneNotifier mNotifier; 207 protected TelephonyComponentFactory mTelephonyComponentFactory; 208 protected CdmaSubscriptionSourceManager mCdmaSSM; 209 protected RegistrantList mRegistrantList; 210 protected IccPhoneBookInterfaceManager mIccPhoneBookIntManager; 211 protected ImsManager mImsManager; 212 protected DataNetworkController mDataNetworkController; 213 protected DataRetryManager mDataRetryManager; 214 protected DataSettingsManager mDataSettingsManager; 215 protected DataConfigManager mDataConfigManager; 216 protected DataProfileManager mDataProfileManager; 217 protected DisplayInfoController mDisplayInfoController; 218 protected GsmCdmaCall mGsmCdmaCall; 219 protected ImsCall mImsCall; 220 protected ImsEcbm mImsEcbm; 221 protected SubscriptionManagerService mSubscriptionManagerService; 222 protected ServiceState mServiceState; 223 protected IPackageManager.Stub mMockPackageManager; 224 protected LegacyPermissionManagerService mMockLegacyPermissionManager; 225 protected SimulatedCommandsVerifier mSimulatedCommandsVerifier; 226 protected InboundSmsHandler mInboundSmsHandler; 227 protected WspTypeDecoder mWspTypeDecoder; 228 protected UiccCardApplication mUiccCardApplication3gpp; 229 protected UiccCardApplication mUiccCardApplication3gpp2; 230 protected UiccCardApplication mUiccCardApplicationIms; 231 protected SIMRecords mSimRecords; 232 protected SignalStrengthController mSignalStrengthController; 233 protected RuimRecords mRuimRecords; 234 protected IsimUiccRecords mIsimUiccRecords; 235 protected ProxyController mProxyController; 236 protected PhoneSwitcher mPhoneSwitcher; 237 protected Singleton<IActivityManager> mIActivityManagerSingleton; 238 protected IActivityManager mIActivityManager; 239 protected IIntentSender mIIntentSender; 240 protected IBinder mIBinder; 241 protected SmsStorageMonitor mSmsStorageMonitor; 242 protected SmsUsageMonitor mSmsUsageMonitor; 243 protected PackageInfo mPackageInfo; 244 protected ApplicationInfo mApplicationInfo; 245 protected EriManager mEriManager; 246 protected IBinder mConnMetLoggerBinder; 247 protected CarrierSignalAgent mCarrierSignalAgent; 248 protected CarrierActionAgent mCarrierActionAgent; 249 protected ImsExternalCallTracker mImsExternalCallTracker; 250 protected ImsNrSaModeHandler mImsNrSaModeHandler; 251 protected AppSmsManager mAppSmsManager; 252 protected IccSmsInterfaceManager mIccSmsInterfaceManager; 253 protected SmsDispatchersController mSmsDispatchersController; 254 protected DeviceStateMonitor mDeviceStateMonitor; 255 protected AccessNetworksManager mAccessNetworksManager; 256 protected IntentBroadcaster mIntentBroadcaster; 257 protected NitzStateMachine mNitzStateMachine; 258 protected RadioConfig mMockRadioConfig; 259 protected RadioConfigProxy mMockRadioConfigProxy; 260 protected LocaleTracker mLocaleTracker; 261 protected RestrictedState mRestrictedState; 262 protected PhoneConfigurationManager mPhoneConfigurationManager; 263 protected CellularNetworkValidator mCellularNetworkValidator; 264 protected UiccCard mUiccCard; 265 protected UiccPort mUiccPort; 266 protected MultiSimSettingController mMultiSimSettingController; 267 protected IccCard mIccCard; 268 protected NetworkStatsManager mStatsManager; 269 protected CarrierPrivilegesTracker mCarrierPrivilegesTracker; 270 protected VoiceCallSessionStats mVoiceCallSessionStats; 271 protected PersistAtomsStorage mPersistAtomsStorage; 272 protected DefaultNetworkMonitor mDefaultNetworkMonitor; 273 protected MetricsCollector mMetricsCollector; 274 protected SmsStats mSmsStats; 275 protected TelephonyAnalytics mTelephonyAnalytics; 276 protected SignalStrength mSignalStrength; 277 protected WifiManager mWifiManager; 278 protected WifiInfo mWifiInfo; 279 protected ImsStats mImsStats; 280 protected LinkBandwidthEstimator mLinkBandwidthEstimator; 281 protected PinStorage mPinStorage; 282 protected LocationManager mLocationManager; 283 protected CellIdentity mCellIdentity; 284 protected CellLocation mCellLocation; 285 protected DataServiceManager mMockedWwanDataServiceManager; 286 protected DataServiceManager mMockedWlanDataServiceManager; 287 protected ServiceStateStats mServiceStateStats; 288 protected SatelliteController mSatelliteController; 289 protected DeviceStateHelper mDeviceStateHelper; 290 protected CellularNetworkSecuritySafetySource mSafetySource; 291 protected CellularIdentifierDisclosureNotifier mIdentifierDisclosureNotifier; 292 protected DomainSelectionResolver mDomainSelectionResolver; 293 protected NullCipherNotifier mNullCipherNotifier; 294 295 // Initialized classes 296 protected ActivityManager mActivityManager; 297 protected ImsCallProfile mImsCallProfile; 298 protected TelephonyManager mTelephonyManager; 299 protected TelecomManager mTelecomManager; 300 protected TelephonyRegistryManager mTelephonyRegistryManager; 301 protected SubscriptionManager mSubscriptionManager; 302 protected EuiccManager mEuiccManager; 303 protected PackageManager mPackageManager; 304 protected ConnectivityManager mConnectivityManager; 305 protected AppOpsManager mAppOpsManager; 306 protected CarrierConfigManager mCarrierConfigManager; 307 protected UserManager mUserManager; 308 protected DevicePolicyManager mDevicePolicyManager; 309 protected KeyguardManager mKeyguardManager; 310 protected VcnManager mVcnManager; 311 protected NetworkPolicyManager mNetworkPolicyManager; 312 protected SimulatedCommands mSimulatedCommands; 313 protected ContextFixture mContextFixture; 314 protected Context mContext; 315 protected FakeBlockedNumberContentProvider mFakeBlockedNumberContentProvider; 316 private final ContentProvider mContentProvider = spy(new ContextFixture.FakeContentProvider()); 317 private final Object mLock = new Object(); 318 private boolean mReady; 319 protected HashMap<String, IBinder> mServiceManagerMockedServices = new HashMap<>(); 320 protected Phone[] mPhones; 321 protected NetworkRegistrationInfo mNetworkRegistrationInfo = 322 new NetworkRegistrationInfo.Builder() 323 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 324 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 325 .build(); 326 protected List<TestableLooper> mTestableLoopers = new ArrayList<>(); 327 protected TestableLooper mTestableLooper; 328 329 private final HashMap<InstanceKey, Object> mOldInstances = new HashMap<>(); 330 331 private final List<InstanceKey> mInstanceKeys = new ArrayList<>(); 332 333 protected int mIntegerConsumerResult; 334 protected Semaphore mIntegerConsumerSemaphore = new Semaphore(0); 335 protected Consumer<Integer> mIntegerConsumer = new Consumer<Integer>() { 336 @Override 337 public void accept(Integer integer) { 338 logd("mIIntegerConsumer: result=" + integer); 339 mIntegerConsumerResult = integer; 340 try { 341 mIntegerConsumerSemaphore.release(); 342 } catch (Exception ex) { 343 logd("mIIntegerConsumer: Got exception in releasing semaphore, ex=" + ex); 344 } 345 } 346 }; 347 waitForIntegerConsumerResponse(int expectedNumberOfEvents)348 protected boolean waitForIntegerConsumerResponse(int expectedNumberOfEvents) { 349 for (int i = 0; i < expectedNumberOfEvents; i++) { 350 try { 351 if (!mIntegerConsumerSemaphore.tryAcquire(500 /*Timeout*/, TimeUnit.MILLISECONDS)) { 352 logd("Timeout to receive IIntegerConsumer() callback"); 353 return false; 354 } 355 } catch (Exception ex) { 356 logd("waitForIIntegerConsumerResult: Got exception=" + ex); 357 return false; 358 } 359 } 360 return true; 361 } 362 363 private class InstanceKey { 364 public final Class mClass; 365 public final String mInstName; 366 public final Object mObj; InstanceKey(final Class c, final String instName, final Object obj)367 InstanceKey(final Class c, final String instName, final Object obj) { 368 mClass = c; 369 mInstName = instName; 370 mObj = obj; 371 } 372 373 @Override hashCode()374 public int hashCode() { 375 return (mClass.getName().hashCode() * 31 + mInstName.hashCode()) * 31; 376 } 377 378 @Override equals(Object obj)379 public boolean equals(Object obj) { 380 if (obj == null || !(obj instanceof InstanceKey)) { 381 return false; 382 } 383 384 InstanceKey other = (InstanceKey) obj; 385 return (other.mClass == mClass && other.mInstName.equals(mInstName) 386 && other.mObj == mObj); 387 } 388 } 389 waitUntilReady()390 protected void waitUntilReady() { 391 synchronized (mLock) { 392 long now = SystemClock.elapsedRealtime(); 393 long deadline = now + MAX_INIT_WAIT_MS; 394 while (!mReady && now < deadline) { 395 try { 396 mLock.wait(MAX_INIT_WAIT_MS); 397 } catch (Exception e) { 398 fail("Telephony tests failed to initialize: e=" + e); 399 } 400 now = SystemClock.elapsedRealtime(); 401 } 402 if (!mReady) { 403 fail("Telephony tests failed to initialize"); 404 } 405 } 406 } 407 setReady(boolean ready)408 protected void setReady(boolean ready) { 409 synchronized (mLock) { 410 mReady = ready; 411 mLock.notifyAll(); 412 } 413 } 414 replaceInstance(final Class c, final String instanceName, final Object obj, final Object newValue)415 protected synchronized void replaceInstance(final Class c, final String instanceName, 416 final Object obj, final Object newValue) 417 throws Exception { 418 Field field = c.getDeclaredField(instanceName); 419 field.setAccessible(true); 420 421 InstanceKey key = new InstanceKey(c, instanceName, obj); 422 if (!mOldInstances.containsKey(key)) { 423 mOldInstances.put(key, field.get(obj)); 424 mInstanceKeys.add(key); 425 } 426 field.set(obj, newValue); 427 } 428 getPrivateField(Object object, String fieldName, Class<T> fieldType)429 protected static <T> T getPrivateField(Object object, String fieldName, Class<T> fieldType) 430 throws Exception { 431 432 Class<?> clazz = object.getClass(); 433 Field field = clazz.getDeclaredField(fieldName); 434 field.setAccessible(true); 435 436 return fieldType.cast(field.get(object)); 437 } 438 restoreInstance(final Class c, final String instanceName, final Object obj)439 protected synchronized void restoreInstance(final Class c, final String instanceName, 440 final Object obj) throws Exception { 441 InstanceKey key = new InstanceKey(c, instanceName, obj); 442 if (mOldInstances.containsKey(key)) { 443 Field field = c.getDeclaredField(instanceName); 444 field.setAccessible(true); 445 field.set(obj, mOldInstances.get(key)); 446 mOldInstances.remove(key); 447 mInstanceKeys.remove(key); 448 } 449 } 450 restoreInstances()451 protected synchronized void restoreInstances() throws Exception { 452 for (int i = mInstanceKeys.size() - 1; i >= 0; i--) { 453 InstanceKey key = mInstanceKeys.get(i); 454 Field field = key.mClass.getDeclaredField(key.mInstName); 455 field.setAccessible(true); 456 field.set(key.mObj, mOldInstances.get(key)); 457 } 458 459 mInstanceKeys.clear(); 460 mOldInstances.clear(); 461 } 462 463 // TODO: Unit tests that do not extend TelephonyTest or ImsTestBase should enable strict mode 464 // by calling this method. enableStrictMode()465 public static void enableStrictMode() { 466 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder() 467 .detectLeakedSqlLiteObjects() 468 .detectLeakedClosableObjects() 469 .detectIncorrectContextUse() 470 .detectLeakedRegistrationObjects() 471 .detectUnsafeIntentLaunch() 472 .detectActivityLeaks() 473 .penaltyLog() 474 .penaltyDeath() 475 .build()); 476 } 477 setUp(String tag)478 protected void setUp(String tag) throws Exception { 479 TAG = tag; 480 enableStrictMode(); 481 mFeatureFlags = Mockito.mock(FeatureFlags.class); 482 mPhone = Mockito.mock(GsmCdmaPhone.class); 483 mPhone2 = Mockito.mock(GsmCdmaPhone.class); 484 mImsPhone = Mockito.mock(ImsPhone.class); 485 mSST = Mockito.mock(ServiceStateTracker.class); 486 mEmergencyNumberTracker = Mockito.mock(EmergencyNumberTracker.class); 487 mCT = Mockito.mock(GsmCdmaCallTracker.class); 488 mImsCT = Mockito.mock(ImsPhoneCallTracker.class); 489 mUiccController = Mockito.mock(UiccController.class); 490 mUiccProfile = Mockito.mock(UiccProfile.class); 491 mUiccSlot = Mockito.mock(UiccSlot.class); 492 mCallManager = Mockito.mock(CallManager.class); 493 mNotifier = Mockito.mock(PhoneNotifier.class); 494 mTelephonyComponentFactory = Mockito.mock(TelephonyComponentFactory.class); 495 mCdmaSSM = Mockito.mock(CdmaSubscriptionSourceManager.class); 496 mRegistrantList = Mockito.mock(RegistrantList.class); 497 mIccPhoneBookIntManager = Mockito.mock(IccPhoneBookInterfaceManager.class); 498 mImsManager = Mockito.mock(ImsManager.class); 499 mDataNetworkController = Mockito.mock(DataNetworkController.class); 500 mDataRetryManager = Mockito.mock(DataRetryManager.class); 501 mDataSettingsManager = Mockito.mock(DataSettingsManager.class); 502 mDataConfigManager = Mockito.mock(DataConfigManager.class); 503 mDataProfileManager = Mockito.mock(DataProfileManager.class); 504 mDisplayInfoController = Mockito.mock(DisplayInfoController.class); 505 mGsmCdmaCall = Mockito.mock(GsmCdmaCall.class); 506 mImsCall = Mockito.mock(ImsCall.class); 507 mImsEcbm = Mockito.mock(ImsEcbm.class); 508 mSubscriptionManagerService = Mockito.mock(SubscriptionManagerService.class); 509 mServiceState = Mockito.mock(ServiceState.class); 510 mMockPackageManager = Mockito.mock(IPackageManager.Stub.class); 511 mMockLegacyPermissionManager = Mockito.mock(LegacyPermissionManagerService.class); 512 mSimulatedCommandsVerifier = Mockito.mock(SimulatedCommandsVerifier.class); 513 mInboundSmsHandler = Mockito.mock(InboundSmsHandler.class); 514 mWspTypeDecoder = Mockito.mock(WspTypeDecoder.class); 515 mUiccCardApplication3gpp = Mockito.mock(UiccCardApplication.class); 516 mUiccCardApplication3gpp2 = Mockito.mock(UiccCardApplication.class); 517 mUiccCardApplicationIms = Mockito.mock(UiccCardApplication.class); 518 mSimRecords = Mockito.mock(SIMRecords.class); 519 mSignalStrengthController = Mockito.mock(SignalStrengthController.class); 520 mRuimRecords = Mockito.mock(RuimRecords.class); 521 mIsimUiccRecords = Mockito.mock(IsimUiccRecords.class); 522 mProxyController = Mockito.mock(ProxyController.class); 523 mPhoneSwitcher = Mockito.mock(PhoneSwitcher.class); 524 mIActivityManagerSingleton = Mockito.mock(Singleton.class); 525 mIActivityManager = Mockito.mock(IActivityManager.class); 526 mIIntentSender = Mockito.mock(IIntentSender.class); 527 mIBinder = Mockito.mock(IBinder.class); 528 mSmsStorageMonitor = Mockito.mock(SmsStorageMonitor.class); 529 mSmsUsageMonitor = Mockito.mock(SmsUsageMonitor.class); 530 mPackageInfo = Mockito.mock(PackageInfo.class); 531 mApplicationInfo = Mockito.mock(ApplicationInfo.class); 532 mEriManager = Mockito.mock(EriManager.class); 533 mConnMetLoggerBinder = Mockito.mock(IBinder.class); 534 mCarrierSignalAgent = Mockito.mock(CarrierSignalAgent.class); 535 mCarrierActionAgent = Mockito.mock(CarrierActionAgent.class); 536 mImsExternalCallTracker = Mockito.mock(ImsExternalCallTracker.class); 537 mImsNrSaModeHandler = Mockito.mock(ImsNrSaModeHandler.class); 538 mAppSmsManager = Mockito.mock(AppSmsManager.class); 539 mIccSmsInterfaceManager = Mockito.mock(IccSmsInterfaceManager.class); 540 mSmsDispatchersController = Mockito.mock(SmsDispatchersController.class); 541 mDeviceStateMonitor = Mockito.mock(DeviceStateMonitor.class); 542 mAccessNetworksManager = Mockito.mock(AccessNetworksManager.class); 543 mIntentBroadcaster = Mockito.mock(IntentBroadcaster.class); 544 mNitzStateMachine = Mockito.mock(NitzStateMachine.class); 545 mMockRadioConfig = Mockito.mock(RadioConfig.class); 546 mMockRadioConfigProxy = Mockito.mock(RadioConfigProxy.class); 547 mLocaleTracker = Mockito.mock(LocaleTracker.class); 548 mRestrictedState = Mockito.mock(RestrictedState.class); 549 mPhoneConfigurationManager = Mockito.mock(PhoneConfigurationManager.class); 550 mCellularNetworkValidator = Mockito.mock(CellularNetworkValidator.class); 551 mUiccCard = Mockito.mock(UiccCard.class); 552 mUiccPort = Mockito.mock(UiccPort.class); 553 mMultiSimSettingController = Mockito.mock(MultiSimSettingController.class); 554 mIccCard = Mockito.mock(IccCard.class); 555 mStatsManager = Mockito.mock(NetworkStatsManager.class); 556 mCarrierPrivilegesTracker = Mockito.mock(CarrierPrivilegesTracker.class); 557 mVoiceCallSessionStats = Mockito.mock(VoiceCallSessionStats.class); 558 mPersistAtomsStorage = Mockito.mock(PersistAtomsStorage.class); 559 mDefaultNetworkMonitor = Mockito.mock(DefaultNetworkMonitor.class); 560 mMetricsCollector = Mockito.mock(MetricsCollector.class); 561 mSmsStats = Mockito.mock(SmsStats.class); 562 mTelephonyAnalytics = Mockito.mock(TelephonyAnalytics.class); 563 mSignalStrength = Mockito.mock(SignalStrength.class); 564 mWifiManager = Mockito.mock(WifiManager.class); 565 mWifiInfo = Mockito.mock(WifiInfo.class); 566 mImsStats = Mockito.mock(ImsStats.class); 567 mLinkBandwidthEstimator = Mockito.mock(LinkBandwidthEstimator.class); 568 mPinStorage = Mockito.mock(PinStorage.class); 569 mLocationManager = Mockito.mock(LocationManager.class); 570 mCellIdentity = Mockito.mock(CellIdentity.class); 571 mCellLocation = Mockito.mock(CellLocation.class); 572 mMockedWwanDataServiceManager = Mockito.mock(DataServiceManager.class); 573 mMockedWlanDataServiceManager = Mockito.mock(DataServiceManager.class); 574 mServiceStateStats = Mockito.mock(ServiceStateStats.class); 575 mSatelliteController = Mockito.mock(SatelliteController.class); 576 mDeviceStateHelper = Mockito.mock(DeviceStateHelper.class); 577 mSafetySource = Mockito.mock(CellularNetworkSecuritySafetySource.class); 578 mIdentifierDisclosureNotifier = Mockito.mock(CellularIdentifierDisclosureNotifier.class); 579 mDomainSelectionResolver = Mockito.mock(DomainSelectionResolver.class); 580 mNullCipherNotifier = Mockito.mock(NullCipherNotifier.class); 581 582 doReturn(true).when(mFeatureFlags).minimalTelephonyCdmCheck(); 583 doReturn(true).when(mFeatureFlags).supportNetworkProvider(); 584 doReturn(true).when(mFeatureFlags).hsumBroadcast(); 585 doReturn(true).when(mFeatureFlags).hsumPackageManager(); 586 587 TelephonyManager.disableServiceHandleCaching(); 588 PropertyInvalidatedCache.disableForTestMode(); 589 // For testing do not allow Log.WTF as it can cause test process to crash 590 Log.setWtfHandler((tagString, what, system) -> Log.d(TAG, "WTF captured, ignoring. Tag: " 591 + tagString + ", exception: " + what)); 592 593 mPhones = new Phone[] {mPhone}; 594 mImsCallProfile = new ImsCallProfile(); 595 mImsCallProfile.setCallerNumberVerificationStatus( 596 ImsCallProfile.VERIFICATION_STATUS_PASSED); 597 mSimulatedCommands = new SimulatedCommands(); 598 mContextFixture = new ContextFixture(); 599 mContext = mContextFixture.getTestDouble(); 600 mFakeBlockedNumberContentProvider = new FakeBlockedNumberContentProvider(); 601 ((MockContentResolver)mContext.getContentResolver()).addProvider( 602 BlockedNumberContract.AUTHORITY, mFakeBlockedNumberContentProvider); 603 ((MockContentResolver) mContext.getContentResolver()).addProvider( 604 Settings.AUTHORITY, mContentProvider); 605 ((MockContentResolver) mContext.getContentResolver()).addProvider( 606 Telephony.ServiceStateTable.AUTHORITY, mContentProvider); 607 replaceContentProvider(mContentProvider); 608 609 Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 0); 610 611 mServiceManagerMockedServices.put("isub", mSubscriptionManagerService); 612 doReturn(mSubscriptionManagerService).when(mSubscriptionManagerService) 613 .queryLocalInterface(anyString()); 614 615 mPhone.mCi = mSimulatedCommands; 616 mCT.mCi = mSimulatedCommands; 617 doReturn(mUiccCard).when(mPhone).getUiccCard(); 618 doReturn(mUiccCard).when(mUiccSlot).getUiccCard(); 619 doReturn(mUiccCard).when(mUiccController).getUiccCardForPhone(anyInt()); 620 doReturn(mUiccPort).when(mPhone).getUiccPort(); 621 doReturn(mUiccProfile).when(mUiccPort).getUiccProfile(); 622 623 mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 624 mTelecomManager = mContext.getSystemService(TelecomManager.class); 625 mActivityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 626 mTelephonyRegistryManager = (TelephonyRegistryManager) mContext.getSystemService( 627 Context.TELEPHONY_REGISTRY_SERVICE); 628 mSubscriptionManager = (SubscriptionManager) mContext.getSystemService( 629 Context.TELEPHONY_SUBSCRIPTION_SERVICE); 630 mEuiccManager = (EuiccManager) mContext.getSystemService(Context.EUICC_SERVICE); 631 mConnectivityManager = (ConnectivityManager) 632 mContext.getSystemService(Context.CONNECTIVITY_SERVICE); 633 mPackageManager = mContext.getPackageManager(); 634 mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE); 635 mCarrierConfigManager = 636 (CarrierConfigManager) mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE); 637 mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); 638 mDevicePolicyManager = (DevicePolicyManager) mContext.getSystemService( 639 Context.DEVICE_POLICY_SERVICE); 640 mKeyguardManager = (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE); 641 mVcnManager = mContext.getSystemService(VcnManager.class); 642 mNetworkPolicyManager = mContext.getSystemService(NetworkPolicyManager.class); 643 mLocationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE); 644 645 //mTelephonyComponentFactory 646 doReturn(mTelephonyComponentFactory).when(mTelephonyComponentFactory).inject(anyString()); 647 doReturn(mSST).when(mTelephonyComponentFactory) 648 .makeServiceStateTracker(nullable(GsmCdmaPhone.class), 649 nullable(CommandsInterface.class), nullable(FeatureFlags.class)); 650 doReturn(mEmergencyNumberTracker).when(mTelephonyComponentFactory) 651 .makeEmergencyNumberTracker(nullable(Phone.class), 652 nullable(CommandsInterface.class), any(FeatureFlags.class)); 653 doReturn(getTestEmergencyNumber()).when(mEmergencyNumberTracker) 654 .getEmergencyNumber(any()); 655 doReturn(mUiccProfile).when(mTelephonyComponentFactory) 656 .makeUiccProfile(nullable(Context.class), nullable(CommandsInterface.class), 657 nullable(IccCardStatus.class), anyInt(), nullable(UiccCard.class), 658 nullable(Object.class), any(FeatureFlags.class)); 659 doReturn(mCT).when(mTelephonyComponentFactory) 660 .makeGsmCdmaCallTracker(nullable(GsmCdmaPhone.class), any(FeatureFlags.class)); 661 doReturn(mIccPhoneBookIntManager).when(mTelephonyComponentFactory) 662 .makeIccPhoneBookInterfaceManager(nullable(Phone.class)); 663 doReturn(mDisplayInfoController).when(mTelephonyComponentFactory) 664 .makeDisplayInfoController(nullable(Phone.class), any(FeatureFlags.class)); 665 doReturn(mWspTypeDecoder).when(mTelephonyComponentFactory) 666 .makeWspTypeDecoder(nullable(byte[].class)); 667 doReturn(mImsCT).when(mTelephonyComponentFactory) 668 .makeImsPhoneCallTracker(nullable(ImsPhone.class), any(FeatureFlags.class)); 669 doReturn(mCdmaSSM).when(mTelephonyComponentFactory) 670 .getCdmaSubscriptionSourceManagerInstance(nullable(Context.class), 671 nullable(CommandsInterface.class), nullable(Handler.class), 672 anyInt(), nullable(Object.class)); 673 doReturn(mImsExternalCallTracker).when(mTelephonyComponentFactory) 674 .makeImsExternalCallTracker(nullable(ImsPhone.class)); 675 doReturn(mImsNrSaModeHandler).when(mTelephonyComponentFactory) 676 .makeImsNrSaModeHandler(nullable(ImsPhone.class)); 677 doReturn(mAppSmsManager).when(mTelephonyComponentFactory) 678 .makeAppSmsManager(nullable(Context.class)); 679 doReturn(mCarrierSignalAgent).when(mTelephonyComponentFactory) 680 .makeCarrierSignalAgent(nullable(Phone.class)); 681 doReturn(mCarrierActionAgent).when(mTelephonyComponentFactory) 682 .makeCarrierActionAgent(nullable(Phone.class)); 683 doReturn(mDeviceStateMonitor).when(mTelephonyComponentFactory) 684 .makeDeviceStateMonitor(nullable(Phone.class), any(FeatureFlags.class)); 685 doReturn(mAccessNetworksManager).when(mTelephonyComponentFactory) 686 .makeAccessNetworksManager(nullable(Phone.class), any(Looper.class)); 687 doReturn(mNitzStateMachine).when(mTelephonyComponentFactory) 688 .makeNitzStateMachine(nullable(GsmCdmaPhone.class)); 689 doReturn(mLocaleTracker).when(mTelephonyComponentFactory) 690 .makeLocaleTracker(nullable(Phone.class), nullable(NitzStateMachine.class), 691 nullable(Looper.class), any(FeatureFlags.class)); 692 doReturn(mEriManager).when(mTelephonyComponentFactory) 693 .makeEriManager(nullable(Phone.class), anyInt()); 694 doReturn(mLinkBandwidthEstimator).when(mTelephonyComponentFactory) 695 .makeLinkBandwidthEstimator(nullable(Phone.class), any(Looper.class)); 696 doReturn(mDataProfileManager).when(mTelephonyComponentFactory) 697 .makeDataProfileManager(any(Phone.class), any(DataNetworkController.class), 698 any(DataServiceManager.class), any(Looper.class), 699 any(FeatureFlags.class), 700 any(DataProfileManager.DataProfileManagerCallback.class)); 701 doReturn(mSafetySource).when(mTelephonyComponentFactory) 702 .makeCellularNetworkSecuritySafetySource(any(Context.class)); 703 doReturn(mIdentifierDisclosureNotifier) 704 .when(mTelephonyComponentFactory) 705 .makeIdentifierDisclosureNotifier(any(CellularNetworkSecuritySafetySource.class)); 706 doReturn(mNullCipherNotifier) 707 .when(mTelephonyComponentFactory) 708 .makeNullCipherNotifier(any(CellularNetworkSecuritySafetySource.class)); 709 710 //mPhone 711 doReturn(mContext).when(mPhone).getContext(); 712 doReturn(mContext).when(mImsPhone).getContext(); 713 doReturn(true).when(mPhone).getUnitTestMode(); 714 doReturn(mUiccProfile).when(mPhone).getIccCard(); 715 doReturn(mServiceState).when(mPhone).getServiceState(); 716 doReturn(mServiceState).when(mImsPhone).getServiceState(); 717 doReturn(mPhone).when(mImsPhone).getDefaultPhone(); 718 doReturn(true).when(mPhone).isPhoneTypeGsm(); 719 doReturn(PhoneConstants.PHONE_TYPE_GSM).when(mPhone).getPhoneType(); 720 doReturn(mCT).when(mPhone).getCallTracker(); 721 doReturn(mSST).when(mPhone).getServiceStateTracker(); 722 doReturn(mDeviceStateMonitor).when(mPhone).getDeviceStateMonitor(); 723 doReturn(mDisplayInfoController).when(mPhone).getDisplayInfoController(); 724 doReturn(mSignalStrengthController).when(mPhone).getSignalStrengthController(); 725 doReturn(mEmergencyNumberTracker).when(mPhone).getEmergencyNumberTracker(); 726 doReturn(mCarrierSignalAgent).when(mPhone).getCarrierSignalAgent(); 727 doReturn(mCarrierActionAgent).when(mPhone).getCarrierActionAgent(); 728 doReturn(mAppSmsManager).when(mPhone).getAppSmsManager(); 729 doReturn(mIccSmsInterfaceManager).when(mPhone).getIccSmsInterfaceManager(); 730 doReturn(mAccessNetworksManager).when(mPhone).getAccessNetworksManager(); 731 doReturn(mDataSettingsManager).when(mDataNetworkController).getDataSettingsManager(); 732 doReturn(mDataNetworkController).when(mPhone).getDataNetworkController(); 733 doReturn(mDataSettingsManager).when(mPhone).getDataSettingsManager(); 734 doReturn(mCarrierPrivilegesTracker).when(mPhone).getCarrierPrivilegesTracker(); 735 doReturn(mSignalStrength).when(mPhone).getSignalStrength(); 736 doReturn(mVoiceCallSessionStats).when(mPhone).getVoiceCallSessionStats(); 737 doReturn(mVoiceCallSessionStats).when(mImsPhone).getVoiceCallSessionStats(); 738 doReturn(mSmsStats).when(mPhone).getSmsStats(); 739 doReturn(mTelephonyAnalytics).when(mPhone).getTelephonyAnalytics(); 740 doReturn(mImsStats).when(mImsPhone).getImsStats(); 741 mIccSmsInterfaceManager.mDispatchersController = mSmsDispatchersController; 742 doReturn(mLinkBandwidthEstimator).when(mPhone).getLinkBandwidthEstimator(); 743 doReturn(mCellIdentity).when(mPhone).getCurrentCellIdentity(); 744 doReturn(mCellLocation).when(mCellIdentity).asCellLocation(); 745 doReturn(mDataConfigManager).when(mDataNetworkController).getDataConfigManager(); 746 doReturn(mDataProfileManager).when(mDataNetworkController).getDataProfileManager(); 747 doReturn(mDataRetryManager).when(mDataNetworkController).getDataRetryManager(); 748 doReturn(mCarrierPrivilegesTracker).when(mPhone).getCarrierPrivilegesTracker(); 749 doReturn(0).when(mPhone).getPhoneId(); 750 doReturn(true).when(mPhone).hasCalling(); 751 doReturn(true).when(mPhone2).hasCalling(); 752 753 //mUiccController 754 doReturn(mUiccCardApplication3gpp).when(mUiccController).getUiccCardApplication(anyInt(), 755 eq(UiccController.APP_FAM_3GPP)); 756 doReturn(mUiccCardApplication3gpp2).when(mUiccController).getUiccCardApplication(anyInt(), 757 eq(UiccController.APP_FAM_3GPP2)); 758 doReturn(mUiccCardApplicationIms).when(mUiccController).getUiccCardApplication(anyInt(), 759 eq(UiccController.APP_FAM_IMS)); 760 doReturn(mUiccCard).when(mUiccController).getUiccCard(anyInt()); 761 doReturn(mUiccPort).when(mUiccController).getUiccPort(anyInt()); 762 763 doAnswer(new Answer<IccRecords>() { 764 public IccRecords answer(InvocationOnMock invocation) { 765 switch ((Integer) invocation.getArguments()[1]) { 766 case UiccController.APP_FAM_3GPP: 767 return mSimRecords; 768 case UiccController.APP_FAM_3GPP2: 769 return mRuimRecords; 770 case UiccController.APP_FAM_IMS: 771 return mIsimUiccRecords; 772 default: 773 logd("Unrecognized family " + invocation.getArguments()[1]); 774 return null; 775 } 776 } 777 }).when(mUiccController).getIccRecords(anyInt(), anyInt()); 778 doReturn(new UiccSlot[] {mUiccSlot}).when(mUiccController).getUiccSlots(); 779 doReturn(mUiccSlot).when(mUiccController).getUiccSlotForPhone(anyInt()); 780 doReturn(mPinStorage).when(mUiccController).getPinStorage(); 781 782 //UiccCardApplication 783 doReturn(mSimRecords).when(mUiccCardApplication3gpp).getIccRecords(); 784 doReturn(mRuimRecords).when(mUiccCardApplication3gpp2).getIccRecords(); 785 doReturn(mIsimUiccRecords).when(mUiccCardApplicationIms).getIccRecords(); 786 787 //mUiccProfile 788 doReturn(mSimRecords).when(mUiccProfile).getIccRecords(); 789 doAnswer(new Answer<IccRecords>() { 790 public IccRecords answer(InvocationOnMock invocation) { 791 return mSimRecords; 792 } 793 }).when(mUiccProfile).getIccRecords(); 794 795 //mUiccProfile 796 doReturn(mUiccCardApplication3gpp).when(mUiccProfile).getApplication( 797 eq(UiccController.APP_FAM_3GPP)); 798 doReturn(mUiccCardApplication3gpp2).when(mUiccProfile).getApplication( 799 eq(UiccController.APP_FAM_3GPP2)); 800 doReturn(mUiccCardApplicationIms).when(mUiccProfile).getApplication( 801 eq(UiccController.APP_FAM_IMS)); 802 803 //SMS 804 doReturn(true).when(mSmsStorageMonitor).isStorageAvailable(); 805 doReturn(true).when(mSmsUsageMonitor).check(nullable(String.class), anyInt()); 806 doReturn(true).when(mTelephonyManager).getSmsReceiveCapableForPhone(anyInt(), anyBoolean()); 807 doReturn(true).when(mTelephonyManager).getSmsSendCapableForPhone( 808 anyInt(), anyBoolean()); 809 810 //Misc 811 doReturn(ServiceState.RIL_RADIO_TECHNOLOGY_LTE).when(mServiceState) 812 .getRilDataRadioTechnology(); 813 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_LTE, 814 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE, false, false, false)) 815 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 816 doReturn(mPhone).when(mCT).getPhone(); 817 doReturn(mImsEcbm).when(mImsManager).getEcbmInterface(); 818 doReturn(mPhone).when(mInboundSmsHandler).getPhone(); 819 doReturn(mImsCallProfile).when(mImsCall).getCallProfile(); 820 doReturn(mIBinder).when(mIIntentSender).asBinder(); 821 doAnswer(invocation -> { 822 Intent[] intents = invocation.getArgument(6); 823 if (intents != null && intents.length > 0) { 824 doReturn(intents[0]).when(mIActivityManager) 825 .getIntentForIntentSender(mIIntentSender); 826 } 827 return mIIntentSender; 828 }).when(mIActivityManager).getIntentSenderWithFeature(anyInt(), 829 nullable(String.class), nullable(String.class), nullable(IBinder.class), 830 nullable(String.class), anyInt(), nullable(Intent[].class), 831 nullable(String[].class), anyInt(), nullable(Bundle.class), anyInt()); 832 doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt()); 833 doReturn(true).when(mTelephonyManager).isDataCapable(); 834 835 mContextFixture.addSystemFeature(PackageManager.FEATURE_TELECOM); 836 mContextFixture.addSystemFeature(PackageManager.FEATURE_TELEPHONY_CALLING); 837 mContextFixture.addSystemFeature(PackageManager.FEATURE_TELEPHONY_DATA); 838 mContextFixture.addSystemFeature(PackageManager.FEATURE_TELEPHONY_EUICC); 839 mContextFixture.addSystemFeature(PackageManager.FEATURE_TELEPHONY_MESSAGING); 840 841 doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); 842 doReturn(mServiceState).when(mSST).getServiceState(); 843 doReturn(mServiceStateStats).when(mSST).getServiceStateStats(); 844 mSST.mSS = mServiceState; 845 mSST.mRestrictedState = mRestrictedState; 846 mServiceManagerMockedServices.put("connectivity_metrics_logger", mConnMetLoggerBinder); 847 mServiceManagerMockedServices.put("package", mMockPackageManager); 848 mServiceManagerMockedServices.put("legacy_permission", mMockLegacyPermissionManager); 849 logd("mMockLegacyPermissionManager replaced"); 850 doReturn(new int[]{AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 851 AccessNetworkConstants.TRANSPORT_TYPE_WLAN}) 852 .when(mAccessNetworksManager).getAvailableTransports(); 853 doReturn(true).when(mDataSettingsManager).isDataEnabled(); 854 doReturn(mNetworkRegistrationInfo).when(mServiceState).getNetworkRegistrationInfo( 855 anyInt(), anyInt()); 856 doReturn(RIL.RADIO_HAL_VERSION_2_0).when(mPhone).getHalVersion(anyInt()); 857 doReturn(2).when(mSignalStrength).getLevel(); 858 doReturn(mMockRadioConfigProxy).when(mMockRadioConfig).getRadioConfigProxy(any()); 859 860 // WiFi 861 doReturn(mWifiInfo).when(mWifiManager).getConnectionInfo(); 862 doReturn(2).when(mWifiManager).calculateSignalLevel(anyInt()); 863 doReturn(4).when(mWifiManager).getMaxSignalLevel(); 864 865 doAnswer(invocation -> { 866 NetworkCapabilities nc = invocation.getArgument(0); 867 return new VcnNetworkPolicyResult( 868 false /* isTearDownRequested */, nc); 869 }).when(mVcnManager).applyVcnNetworkPolicy(any(), any()); 870 871 //SIM 872 doReturn(1).when(mTelephonyManager).getSimCount(); 873 doReturn(1).when(mTelephonyManager).getPhoneCount(); 874 doReturn(1).when(mTelephonyManager).getActiveModemCount(); 875 // Have getMaxPhoneCount always return the same value with getPhoneCount by default. 876 doAnswer((invocation)->Math.max(mTelephonyManager.getActiveModemCount(), 877 mTelephonyManager.getPhoneCount())) 878 .when(mTelephonyManager).getSupportedModemCount(); 879 doReturn(mStatsManager).when(mContext).getSystemService(eq(Context.NETWORK_STATS_SERVICE)); 880 881 //Data 882 //Initial state is: userData enabled, provisioned. 883 ContentResolver resolver = mContext.getContentResolver(); 884 Settings.Global.putInt(resolver, Settings.Global.MOBILE_DATA, 1); 885 Settings.Global.putInt(resolver, Settings.Global.DEVICE_PROVISIONED, 1); 886 Settings.Global.putInt(resolver, 887 Settings.Global.DEVICE_PROVISIONING_MOBILE_DATA_ENABLED, 1); 888 Settings.Global.putInt(resolver, Settings.Global.DATA_ROAMING, 0); 889 890 doReturn(90).when(mDataConfigManager).getNetworkCapabilityPriority( 891 eq(NetworkCapabilities.NET_CAPABILITY_EIMS)); 892 doReturn(80).when(mDataConfigManager).getNetworkCapabilityPriority( 893 eq(NetworkCapabilities.NET_CAPABILITY_SUPL)); 894 doReturn(70).when(mDataConfigManager).getNetworkCapabilityPriority( 895 eq(NetworkCapabilities.NET_CAPABILITY_MMS)); 896 doReturn(70).when(mDataConfigManager).getNetworkCapabilityPriority( 897 eq(NetworkCapabilities.NET_CAPABILITY_XCAP)); 898 doReturn(50).when(mDataConfigManager).getNetworkCapabilityPriority( 899 eq(NetworkCapabilities.NET_CAPABILITY_CBS)); 900 doReturn(50).when(mDataConfigManager).getNetworkCapabilityPriority( 901 eq(NetworkCapabilities.NET_CAPABILITY_MCX)); 902 doReturn(50).when(mDataConfigManager).getNetworkCapabilityPriority( 903 eq(NetworkCapabilities.NET_CAPABILITY_FOTA)); 904 doReturn(40).when(mDataConfigManager).getNetworkCapabilityPriority( 905 eq(NetworkCapabilities.NET_CAPABILITY_IMS)); 906 doReturn(30).when(mDataConfigManager).getNetworkCapabilityPriority( 907 eq(NetworkCapabilities.NET_CAPABILITY_DUN)); 908 doReturn(20).when(mDataConfigManager).getNetworkCapabilityPriority( 909 eq(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 910 doReturn(20).when(mDataConfigManager).getNetworkCapabilityPriority( 911 eq(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 912 doReturn(60000).when(mDataConfigManager).getAnomalyNetworkConnectingTimeoutMs(); 913 doReturn(60000).when(mDataConfigManager) 914 .getAnomalyNetworkDisconnectingTimeoutMs(); 915 doReturn(60000).when(mDataConfigManager).getNetworkHandoverTimeoutMs(); 916 doReturn(new DataConfigManager.EventFrequency(300000, 12)) 917 .when(mDataConfigManager).getAnomalySetupDataCallThreshold(); 918 doReturn(new DataConfigManager.EventFrequency(0, 2)) 919 .when(mDataConfigManager).getAnomalyImsReleaseRequestThreshold(); 920 doReturn(new DataConfigManager.EventFrequency(300000, 12)) 921 .when(mDataConfigManager).getAnomalyNetworkUnwantedThreshold(); 922 923 // CellularNetworkValidator 924 doReturn(SubscriptionManager.INVALID_PHONE_INDEX) 925 .when(mCellularNetworkValidator).getSubIdInValidation(); 926 doReturn(true).when(mCellularNetworkValidator).isValidationFeatureSupported(); 927 928 // Metrics 929 doReturn(null).when(mContext).getFileStreamPath(anyString()); 930 doReturn(mPersistAtomsStorage).when(mMetricsCollector).getAtomsStorage(); 931 doReturn(mDefaultNetworkMonitor).when(mMetricsCollector).getDefaultNetworkMonitor(); 932 doReturn(mWifiManager).when(mContext).getSystemService(eq(Context.WIFI_SERVICE)); 933 doReturn(mDeviceStateHelper).when(mMetricsCollector).getDeviceStateHelper(); 934 doReturn(CELLULAR_SERVICE_STATE__FOLD_STATE__STATE_UNKNOWN) 935 .when(mDeviceStateHelper) 936 .getFoldState(); 937 doReturn(null).when(mContext).getSystemService(eq(Context.DEVICE_STATE_SERVICE)); 938 939 doReturn(false).when(mDomainSelectionResolver).isDomainSelectionSupported(); 940 DomainSelectionResolver.setDomainSelectionResolver(mDomainSelectionResolver); 941 942 //Use reflection to mock singletons 943 replaceInstance(CallManager.class, "INSTANCE", null, mCallManager); 944 replaceInstance(TelephonyComponentFactory.class, "sInstance", null, 945 mTelephonyComponentFactory); 946 replaceInstance(UiccController.class, "mInstance", null, mUiccController); 947 replaceInstance(CdmaSubscriptionSourceManager.class, "sInstance", null, mCdmaSSM); 948 replaceInstance(SubscriptionManagerService.class, "sInstance", null, 949 mSubscriptionManagerService); 950 replaceInstance(ProxyController.class, "sProxyController", null, mProxyController); 951 replaceInstance(PhoneSwitcher.class, "sPhoneSwitcher", null, mPhoneSwitcher); 952 replaceInstance(ActivityManager.class, "IActivityManagerSingleton", null, 953 mIActivityManagerSingleton); 954 replaceInstance(CdmaSubscriptionSourceManager.class, 955 "mCdmaSubscriptionSourceChangedRegistrants", mCdmaSSM, mRegistrantList); 956 replaceInstance(SimulatedCommandsVerifier.class, "sInstance", null, 957 mSimulatedCommandsVerifier); 958 replaceInstance(Singleton.class, "mInstance", mIActivityManagerSingleton, 959 mIActivityManager); 960 replaceInstance(ServiceManager.class, "sCache", null, mServiceManagerMockedServices); 961 replaceInstance(IntentBroadcaster.class, "sIntentBroadcaster", null, mIntentBroadcaster); 962 replaceInstance(TelephonyManager.class, "sInstance", null, 963 mContext.getSystemService(Context.TELEPHONY_SERVICE)); 964 replaceInstance(TelephonyManager.class, "sServiceHandleCacheEnabled", null, false); 965 replaceInstance(PhoneFactory.class, "sMadeDefaults", null, true); 966 replaceInstance(PhoneFactory.class, "sPhone", null, mPhone); 967 replaceInstance(PhoneFactory.class, "sPhones", null, mPhones); 968 replaceInstance(RadioConfig.class, "sRadioConfig", null, mMockRadioConfig); 969 replaceInstance(PhoneConfigurationManager.class, "sInstance", null, 970 mPhoneConfigurationManager); 971 replaceInstance(CellularNetworkValidator.class, "sInstance", null, 972 mCellularNetworkValidator); 973 replaceInstance(MultiSimSettingController.class, "sInstance", null, 974 mMultiSimSettingController); 975 replaceInstance(PhoneFactory.class, "sCommandsInterfaces", null, 976 new CommandsInterface[] {mSimulatedCommands}); 977 replaceInstance(PhoneFactory.class, "sMetricsCollector", null, mMetricsCollector); 978 replaceInstance(SatelliteController.class, "sInstance", null, mSatelliteController); 979 980 setReady(false); 981 // create default TestableLooper for test and add to list of monitored loopers 982 mTestableLooper = TestableLooper.get(TelephonyTest.this); 983 if (mTestableLooper != null) { 984 monitorTestableLooper(mTestableLooper); 985 } 986 } 987 tearDown()988 protected void tearDown() throws Exception { 989 // Clear all remaining messages 990 if (!mTestableLoopers.isEmpty()) { 991 for (TestableLooper looper : mTestableLoopers) { 992 looper.getLooper().quit(); 993 } 994 } 995 // Ensure there are no references to handlers between tests. 996 PhoneConfigurationManager.unregisterAllMultiSimConfigChangeRegistrants(); 997 // unmonitor TestableLooper for TelephonyTest class 998 if (mTestableLooper != null) { 999 unmonitorTestableLooper(mTestableLooper); 1000 } 1001 // destroy all newly created TestableLoopers so they can be reused 1002 for (TestableLooper looper : mTestableLoopers) { 1003 looper.destroy(); 1004 } 1005 TestableLooper.remove(TelephonyTest.this); 1006 1007 if (mSimulatedCommands != null) { 1008 mSimulatedCommands.dispose(); 1009 } 1010 if (mContext != null) { 1011 SharedPreferences sharedPreferences = mContext.getSharedPreferences((String) null, 0); 1012 if (sharedPreferences != null) { 1013 sharedPreferences.edit().clear().commit(); 1014 } 1015 } 1016 restoreInstances(); 1017 TelephonyManager.enableServiceHandleCaching(); 1018 1019 mNetworkRegistrationInfo = null; 1020 mActivityManager = null; 1021 mImsCallProfile = null; 1022 mTelephonyManager = null; 1023 mTelephonyRegistryManager = null; 1024 mSubscriptionManager = null; 1025 mEuiccManager = null; 1026 mPackageManager = null; 1027 mConnectivityManager = null; 1028 mAppOpsManager = null; 1029 mCarrierConfigManager = null; 1030 mUserManager = null; 1031 mKeyguardManager = null; 1032 mVcnManager = null; 1033 mNetworkPolicyManager = null; 1034 mSimulatedCommands = null; 1035 mContextFixture = null; 1036 mContext = null; 1037 mFakeBlockedNumberContentProvider = null; 1038 mServiceManagerMockedServices.clear(); 1039 mServiceManagerMockedServices = null; 1040 mPhone = null; 1041 mTestableLoopers.clear(); 1042 mTestableLoopers = null; 1043 mTestableLooper = null; 1044 DomainSelectionResolver.setDomainSelectionResolver(null); 1045 } 1046 logd(String s)1047 protected static void logd(String s) { 1048 Log.d(TAG, s); 1049 } 1050 1051 public static class FakeBlockedNumberContentProvider extends MockContentProvider { 1052 public Set<String> mBlockedNumbers = new HashSet<>(); 1053 public int mNumEmergencyContactNotifications = 0; 1054 1055 @Override call(String method, String arg, Bundle extras)1056 public Bundle call(String method, String arg, Bundle extras) { 1057 switch (method) { 1058 case BlockedNumberContract.SystemContract.METHOD_SHOULD_SYSTEM_BLOCK_NUMBER: 1059 Bundle bundle = new Bundle(); 1060 int blockStatus = mBlockedNumbers.contains(arg) 1061 ? BlockedNumberContract.STATUS_BLOCKED_IN_LIST 1062 : BlockedNumberContract.STATUS_NOT_BLOCKED; 1063 bundle.putInt(BlockedNumberContract.RES_BLOCK_STATUS, blockStatus); 1064 return bundle; 1065 case BlockedNumberContract.SystemContract.METHOD_NOTIFY_EMERGENCY_CONTACT: 1066 mNumEmergencyContactNotifications++; 1067 return new Bundle(); 1068 default: 1069 fail("Method not expected: " + method); 1070 } 1071 return null; 1072 } 1073 } 1074 1075 public static class FakeSettingsConfigProvider extends MockContentProvider { 1076 private static final String PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED = 1077 DeviceConfig.NAMESPACE_PRIVACY + "/" 1078 + "device_identifier_access_restrictions_disabled"; 1079 private HashMap<String, String> mFlags = new HashMap<>(); 1080 1081 @Override call(String method, String arg, Bundle extras)1082 public Bundle call(String method, String arg, Bundle extras) { 1083 logd("FakeSettingsConfigProvider: call called, method: " + method + 1084 " request: " + arg + ", args=" + extras); 1085 Bundle bundle = new Bundle(); 1086 switch (method) { 1087 case Settings.CALL_METHOD_GET_CONFIG: { 1088 switch (arg) { 1089 case PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED: { 1090 bundle.putString( 1091 PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED, 1092 "0"); 1093 return bundle; 1094 } 1095 default: { 1096 fail("arg not expected: " + arg); 1097 } 1098 } 1099 break; 1100 } 1101 case Settings.CALL_METHOD_LIST_CONFIG: 1102 logd("LIST_config: " + mFlags); 1103 Bundle result = new Bundle(); 1104 result.putSerializable(Settings.NameValueTable.VALUE, mFlags); 1105 return result; 1106 case Settings.CALL_METHOD_SET_ALL_CONFIG: 1107 mFlags = (extras != null) 1108 ? (HashMap) extras.getSerializable(Settings.CALL_METHOD_FLAGS_KEY) 1109 : new HashMap<>(); 1110 bundle.putInt(Settings.KEY_CONFIG_SET_ALL_RETURN, 1111 Settings.SET_ALL_RESULT_SUCCESS); 1112 return bundle; 1113 default: 1114 fail("Method not expected: " + method); 1115 } 1116 return null; 1117 } 1118 } 1119 setupMockPackagePermissionChecks()1120 protected void setupMockPackagePermissionChecks() throws Exception { 1121 doReturn(new String[]{TAG}).when(mPackageManager).getPackagesForUid(anyInt()); 1122 doReturn(mPackageInfo).when(mPackageManager).getPackageInfo(eq(TAG), anyInt()); 1123 } 1124 setupMocksForTelephonyPermissions()1125 protected void setupMocksForTelephonyPermissions() throws Exception { 1126 setupMocksForTelephonyPermissions(Build.VERSION_CODES.Q); 1127 } 1128 setupMocksForTelephonyPermissions(int targetSdkVersion)1129 protected void setupMocksForTelephonyPermissions(int targetSdkVersion) 1130 throws Exception { 1131 // If the calling package does not meet the new requirements for device identifier access 1132 // TelephonyPermissions will query the PackageManager for the ApplicationInfo of the package 1133 // to determine the target SDK. For apps targeting Q a SecurityException is thrown 1134 // regardless of if the package satisfies the previous requirements for device ID access. 1135 1136 // Any tests that query for SubscriptionInfo objects will trigger a phone number access 1137 // check that will first query the ApplicationInfo as apps targeting R+ can no longer 1138 // access the phone number with the READ_PHONE_STATE permission and instead must meet one of 1139 // the other requirements. This ApplicationInfo is generalized to any package name since 1140 // some tests will simulate invocation from other packages. 1141 mApplicationInfo.targetSdkVersion = targetSdkVersion; 1142 doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfoAsUser(anyString(), 1143 anyInt(), any()); 1144 1145 // TelephonyPermissions uses a SystemAPI to check if the calling package meets any of the 1146 // generic requirements for device identifier access (currently READ_PRIVILEGED_PHONE_STATE, 1147 // appop, and device / profile owner checks). This sets up the PermissionManager to return 1148 // that access requirements are met. 1149 setIdentifierAccess(true); 1150 LegacyPermissionManager legacyPermissionManager = 1151 new LegacyPermissionManager(mMockLegacyPermissionManager); 1152 doReturn(legacyPermissionManager).when(mContext) 1153 .getSystemService(Context.LEGACY_PERMISSION_SERVICE); 1154 // Also make sure all appop checks fails, to not interfere tests. Tests should explicitly 1155 // mock AppOpManager to return allowed/default mode. Note by default a mock returns 0 which 1156 // is MODE_ALLOWED, hence this setup is necessary. 1157 doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManager).noteOpNoThrow( 1158 /* op= */ anyString(), /* uid= */ anyInt(), 1159 /* packageName= */ nullable(String.class), 1160 /* attributionTag= */ nullable(String.class), 1161 /* message= */ nullable(String.class)); 1162 1163 // TelephonyPermissions queries DeviceConfig to determine if the identifier access 1164 // restrictions should be enabled; this results in a NPE when DeviceConfig uses 1165 // Activity.currentActivity.getContentResolver as the resolver for Settings.Config.getString 1166 // since the IContentProvider in the NameValueCache's provider holder is null. 1167 replaceContentProvider(new FakeSettingsConfigProvider()); 1168 } 1169 replaceContentProvider(ContentProvider contentProvider)1170 private void replaceContentProvider(ContentProvider contentProvider) throws Exception { 1171 Class c = Class.forName("android.provider.Settings$Config"); 1172 Field field = c.getDeclaredField("sNameValueCache"); 1173 field.setAccessible(true); 1174 Object cache = field.get(null); 1175 1176 c = Class.forName("android.provider.Settings$NameValueCache"); 1177 field = c.getDeclaredField("mProviderHolder"); 1178 field.setAccessible(true); 1179 Object providerHolder = field.get(cache); 1180 1181 field = MockContentProvider.class.getDeclaredField("mIContentProvider"); 1182 field.setAccessible(true); 1183 Object iContentProvider = field.get(contentProvider); 1184 1185 replaceInstance(Class.forName("android.provider.Settings$ContentProviderHolder"), 1186 "mContentProvider", providerHolder, iContentProvider); 1187 } 1188 setIdentifierAccess(boolean hasAccess)1189 protected void setIdentifierAccess(boolean hasAccess) { 1190 doReturn(hasAccess ? PackageManager.PERMISSION_GRANTED 1191 : PackageManager.PERMISSION_DENIED).when(mMockLegacyPermissionManager) 1192 .checkDeviceIdentifierAccess(any(), any(), any(), anyInt(), anyInt()); 1193 } 1194 setPhoneNumberAccess(int value)1195 protected void setPhoneNumberAccess(int value) { 1196 doReturn(value).when(mMockLegacyPermissionManager).checkPhoneNumberAccess(any(), any(), 1197 any(), anyInt(), anyInt()); 1198 } 1199 setCarrierPrivileges(boolean hasCarrierPrivileges)1200 protected void setCarrierPrivileges(boolean hasCarrierPrivileges) { 1201 doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt()); 1202 doReturn(hasCarrierPrivileges ? TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS 1203 : TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS).when( 1204 mTelephonyManager).getCarrierPrivilegeStatus(anyInt()); 1205 } 1206 setCarrierPrivilegesForSubId(boolean hasCarrierPrivileges, int subId)1207 protected void setCarrierPrivilegesForSubId(boolean hasCarrierPrivileges, int subId) { 1208 TelephonyManager mockTelephonyManager = Mockito.mock(TelephonyManager.class); 1209 doReturn(mockTelephonyManager).when(mTelephonyManager).createForSubscriptionId(subId); 1210 doReturn(hasCarrierPrivileges ? TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS 1211 : TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS).when( 1212 mockTelephonyManager).getCarrierPrivilegeStatus(anyInt()); 1213 } 1214 waitForDelayedHandlerAction(Handler h, long delayMillis, long timeoutMillis)1215 protected final void waitForDelayedHandlerAction(Handler h, long delayMillis, 1216 long timeoutMillis) { 1217 final CountDownLatch lock = new CountDownLatch(1); 1218 h.postDelayed(lock::countDown, delayMillis); 1219 while (lock.getCount() > 0) { 1220 try { 1221 lock.await(delayMillis + timeoutMillis, TimeUnit.MILLISECONDS); 1222 } catch (InterruptedException e) { 1223 // do nothing 1224 } 1225 } 1226 } 1227 waitForHandlerAction(Handler h, long timeoutMillis)1228 protected final void waitForHandlerAction(Handler h, long timeoutMillis) { 1229 final CountDownLatch lock = new CountDownLatch(1); 1230 h.post(lock::countDown); 1231 while (lock.getCount() > 0) { 1232 try { 1233 lock.await(timeoutMillis, TimeUnit.MILLISECONDS); 1234 } catch (InterruptedException e) { 1235 // do nothing 1236 } 1237 } 1238 } 1239 1240 /** 1241 * Wait for up to 1 second for the handler message queue to clear. 1242 */ waitForLastHandlerAction(Handler h)1243 protected final void waitForLastHandlerAction(Handler h) { 1244 CountDownLatch lock = new CountDownLatch(1); 1245 // Allow the handler to start work on stuff. 1246 h.postDelayed(lock::countDown, 100); 1247 int timeoutCount = 0; 1248 while (timeoutCount < 5) { 1249 try { 1250 if (lock.await(200, TimeUnit.MILLISECONDS)) { 1251 // no messages in queue, stop waiting. 1252 if (!h.hasMessagesOrCallbacks()) break; 1253 lock = new CountDownLatch(1); 1254 // Delay to allow the handler thread to start work on stuff. 1255 h.postDelayed(lock::countDown, 100); 1256 } 1257 1258 } catch (InterruptedException e) { 1259 // do nothing 1260 } 1261 timeoutCount++; 1262 } 1263 assertTrue("Handler was not empty before timeout elapsed", timeoutCount < 5); 1264 } 1265 getTestEmergencyNumber()1266 protected final EmergencyNumber getTestEmergencyNumber() { 1267 return SAMPLE_EMERGENCY_NUMBER; 1268 } 1269 invokeMethod( Object instance, String methodName, Class<?>[] parameterClasses, Object[] parameters)1270 public static Object invokeMethod( 1271 Object instance, String methodName, Class<?>[] parameterClasses, Object[] parameters) { 1272 try { 1273 Method method = instance.getClass().getDeclaredMethod(methodName, parameterClasses); 1274 method.setAccessible(true); 1275 return method.invoke(instance, parameters); 1276 } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 1277 fail(instance.getClass() + " " + methodName + " " + e.getClass().getName()); 1278 } 1279 return null; 1280 } 1281 1282 /** 1283 * Add a TestableLooper to the list of monitored loopers 1284 * @param looper added if it doesn't already exist 1285 */ monitorTestableLooper(TestableLooper looper)1286 public void monitorTestableLooper(TestableLooper looper) { 1287 if (!mTestableLoopers.contains(looper)) { 1288 mTestableLoopers.add(looper); 1289 } 1290 } 1291 1292 /** 1293 * Remove a TestableLooper from the list of monitored loopers 1294 * @param looper removed if it does exist 1295 */ unmonitorTestableLooper(TestableLooper looper)1296 private void unmonitorTestableLooper(TestableLooper looper) { 1297 if (mTestableLoopers.contains(looper)) { 1298 mTestableLoopers.remove(looper); 1299 } 1300 } 1301 1302 /** 1303 * Handle all messages that can be processed at the current time 1304 * for all monitored TestableLoopers 1305 */ processAllMessages()1306 public void processAllMessages() { 1307 if (mTestableLoopers.isEmpty()) { 1308 fail("mTestableLoopers is empty. Please make sure to add @RunWithLooper annotation"); 1309 } 1310 while (!areAllTestableLoopersIdle()) { 1311 for (TestableLooper looper : mTestableLoopers) looper.processAllMessages(); 1312 } 1313 } 1314 1315 /** 1316 * @return The longest delay from all the message queues. 1317 */ getLongestDelay()1318 private long getLongestDelay() { 1319 long delay = 0; 1320 for (TestableLooper looper : mTestableLoopers) { 1321 MessageQueue queue = looper.getLooper().getQueue(); 1322 try { 1323 Message msg = (Message) MESSAGE_QUEUE_FIELD.get(queue); 1324 while (msg != null) { 1325 delay = Math.max(msg.getWhen(), delay); 1326 msg = (Message) MESSAGE_NEXT_FIELD.get(msg); 1327 } 1328 } catch (IllegalAccessException e) { 1329 throw new RuntimeException("Access failed in TelephonyTest", e); 1330 } 1331 } 1332 return delay; 1333 } 1334 1335 /** 1336 * @return {@code true} if there are any messages in the queue. 1337 */ messagesExist()1338 private boolean messagesExist() { 1339 for (TestableLooper looper : mTestableLoopers) { 1340 MessageQueue queue = looper.getLooper().getQueue(); 1341 try { 1342 Message msg = (Message) MESSAGE_QUEUE_FIELD.get(queue); 1343 if (msg != null) return true; 1344 } catch (IllegalAccessException e) { 1345 throw new RuntimeException("Access failed in TelephonyTest", e); 1346 } 1347 } 1348 return false; 1349 } 1350 1351 /** 1352 * Handle all messages including the delayed messages. 1353 */ processAllFutureMessages()1354 public void processAllFutureMessages() { 1355 while (messagesExist()) { 1356 moveTimeForward(getLongestDelay()); 1357 processAllMessages(); 1358 } 1359 } 1360 1361 /** 1362 * Check if there are any messages to be processed in any monitored TestableLooper 1363 * Delayed messages to be handled at a later time will be ignored 1364 * @return true if there are no messages that can be handled at the current time 1365 * across all monitored TestableLoopers 1366 */ areAllTestableLoopersIdle()1367 private boolean areAllTestableLoopersIdle() { 1368 for (TestableLooper looper : mTestableLoopers) { 1369 if (!looper.getLooper().getQueue().isIdle()) return false; 1370 } 1371 return true; 1372 } 1373 1374 /** 1375 * Effectively moves time forward by reducing the time of all messages 1376 * for all monitored TestableLoopers 1377 * @param milliSeconds number of milliseconds to move time forward by 1378 */ moveTimeForward(long milliSeconds)1379 public void moveTimeForward(long milliSeconds) { 1380 for (TestableLooper looper : mTestableLoopers) { 1381 MessageQueue queue = looper.getLooper().getQueue(); 1382 try { 1383 Message msg = (Message) MESSAGE_QUEUE_FIELD.get(queue); 1384 while (msg != null) { 1385 long updatedWhen = msg.getWhen() - milliSeconds; 1386 if (updatedWhen < 0) { 1387 updatedWhen = 0; 1388 } 1389 MESSAGE_WHEN_FIELD.set(msg, updatedWhen); 1390 msg = (Message) MESSAGE_NEXT_FIELD.get(msg); 1391 } 1392 } catch (IllegalAccessException e) { 1393 throw new RuntimeException("Access failed in TelephonyTest", e); 1394 } 1395 } 1396 } 1397 } 1398