| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package android.telephony.cts; |
| |
| import static androidx.test.InstrumentationRegistry.getContext; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assume.assumeTrue; |
| |
| import android.content.Context; |
| import android.content.pm.PackageManager; |
| import android.net.ConnectivityManager; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.telephony.Annotation.RadioPowerState; |
| import android.telephony.Annotation.SimActivationState; |
| import android.telephony.BarringInfo; |
| import android.telephony.CellIdentity; |
| import android.telephony.CellInfo; |
| import android.telephony.CellLocation; |
| import android.telephony.PhoneStateListener; |
| import android.telephony.PreciseCallState; |
| import android.telephony.PreciseDataConnectionState; |
| import android.telephony.ServiceState; |
| import android.telephony.SignalStrength; |
| import android.telephony.SmsManager; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyDisplayInfo; |
| import android.telephony.TelephonyManager; |
| import android.telephony.cts.util.TelephonyUtils; |
| import android.telephony.emergency.EmergencyNumber; |
| import android.telephony.ims.ImsReasonInfo; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import androidx.test.InstrumentationRegistry; |
| |
| import com.android.compatibility.common.util.ShellIdentityUtils; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.LinkedBlockingQueue; |
| import java.util.concurrent.TimeUnit; |
| |
| public class PhoneStateListenerTest { |
| |
| public static final long WAIT_TIME = 1000; |
| |
| private static final String TEST_EMERGENCY_NUMBER = "998877665544332211"; |
| |
| private boolean mOnActiveDataSubscriptionIdChanged; |
| private boolean mOnCallForwardingIndicatorChangedCalled; |
| private boolean mOnCallStateChangedCalled; |
| private boolean mOnCellLocationChangedCalled; |
| private boolean mOnUserMobileDataStateChanged; |
| private boolean mOnDataActivityCalled; |
| private boolean mOnDataConnectionStateChangedCalled; |
| private boolean mOnDataConnectionStateChangedWithNetworkTypeCalled; |
| private boolean mOnMessageWaitingIndicatorChangedCalled; |
| private boolean mOnCellInfoChangedCalled; |
| private boolean mOnServiceStateChangedCalled; |
| private boolean mOnSignalStrengthChangedCalled; |
| private boolean mOnPreciseCallStateChangedCalled; |
| private boolean mOnCallDisconnectCauseChangedCalled; |
| private boolean mOnImsCallDisconnectCauseChangedCalled; |
| private ImsReasonInfo mImsReasonInfo; |
| private boolean mOnPreciseDataConnectionStateChanged; |
| private boolean mOnRadioPowerStateChangedCalled; |
| private boolean mVoiceActivationStateChangedCalled; |
| private boolean mSrvccStateChangedCalled; |
| private boolean mOnBarringInfoChangedCalled; |
| private boolean mOnRegistrationFailedCalled; |
| private boolean mOnTelephonyDisplayInfoChanged; |
| @RadioPowerState |
| private int mRadioPowerState; |
| @SimActivationState |
| private int mVoiceActivationState; |
| private BarringInfo mBarringInfo; |
| private PreciseDataConnectionState mPreciseDataConnectionState; |
| private PreciseCallState mPreciseCallState; |
| private SignalStrength mSignalStrength; |
| private TelephonyManager mTelephonyManager; |
| private PhoneStateListener mListener; |
| private final Object mLock = new Object(); |
| private static final String TAG = "android.telephony.cts.PhoneStateListenerTest"; |
| private static ConnectivityManager mCm; |
| private HandlerThread mHandlerThread; |
| private Handler mHandler; |
| private PackageManager mPackageManager; |
| private static final List<Integer> DATA_CONNECTION_STATE = Arrays.asList( |
| TelephonyManager.DATA_CONNECTED, |
| TelephonyManager.DATA_DISCONNECTED, |
| TelephonyManager.DATA_CONNECTING, |
| TelephonyManager.DATA_UNKNOWN, |
| TelephonyManager.DATA_SUSPENDED |
| ); |
| private static final List<Integer> PRECISE_CALL_STATE = Arrays.asList( |
| PreciseCallState.PRECISE_CALL_STATE_ACTIVE, |
| PreciseCallState.PRECISE_CALL_STATE_ALERTING, |
| PreciseCallState.PRECISE_CALL_STATE_DIALING, |
| PreciseCallState.PRECISE_CALL_STATE_DISCONNECTED, |
| PreciseCallState.PRECISE_CALL_STATE_DISCONNECTING, |
| PreciseCallState.PRECISE_CALL_STATE_HOLDING, |
| PreciseCallState.PRECISE_CALL_STATE_IDLE, |
| PreciseCallState.PRECISE_CALL_STATE_INCOMING, |
| PreciseCallState.PRECISE_CALL_STATE_NOT_VALID, |
| PreciseCallState.PRECISE_CALL_STATE_WAITING |
| ); |
| |
| private Executor mSimpleExecutor = new Executor() { |
| @Override |
| public void execute(Runnable r) { |
| r.run(); |
| } |
| }; |
| |
| @Before |
| public void setUp() throws Exception { |
| mPackageManager = getContext().getPackageManager(); |
| assumeTrue("Skipping test that requires FEATURE_TELEPHONY", |
| mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)); |
| |
| mTelephonyManager = |
| (TelephonyManager) getContext().getSystemService(Context.TELEPHONY_SERVICE); |
| mCm = (ConnectivityManager) getContext().getSystemService(Context.CONNECTIVITY_SERVICE); |
| mHandlerThread = new HandlerThread("PhoneStateListenerTest"); |
| mHandlerThread.start(); |
| mHandler = new Handler(mHandlerThread.getLooper()); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| if (mListener != null) { |
| // unregister the listener |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_NONE); |
| } |
| if (mHandlerThread != null) { |
| mHandlerThread.quitSafely(); |
| } |
| } |
| |
| @Test |
| public void testPhoneStateListener() { |
| |
| Looper.prepare(); |
| new PhoneStateListener(); |
| } |
| |
| @Test |
| public void testOnServiceStateChanged() throws Throwable { |
| |
| assertFalse(mOnServiceStateChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onServiceStateChanged(ServiceState serviceState) { |
| synchronized (mLock) { |
| mOnServiceStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SERVICE_STATE); |
| }); |
| synchronized (mLock) { |
| if (!mOnServiceStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnServiceStateChangedCalled); |
| } |
| |
| @Test |
| public void testOnUnRegisterFollowedByRegister() throws Throwable { |
| |
| assertFalse(mOnServiceStateChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onServiceStateChanged(ServiceState serviceState) { |
| synchronized (mLock) { |
| mOnServiceStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SERVICE_STATE); |
| }); |
| synchronized (mLock) { |
| if (!mOnServiceStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnServiceStateChangedCalled); |
| |
| // reset and un-register |
| mOnServiceStateChangedCalled = false; |
| if (mListener != null) { |
| // un-register the listener |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_NONE); |
| } |
| synchronized (mLock) { |
| if (!mOnServiceStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| assertFalse(mOnServiceStateChangedCalled); |
| |
| // re-register the listener |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SERVICE_STATE); |
| synchronized (mLock) { |
| if (!mOnServiceStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnServiceStateChangedCalled); |
| } |
| |
| @Test |
| public void testOnSignalStrengthChanged() throws Throwable { |
| |
| assertFalse(mOnSignalStrengthChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onSignalStrengthChanged(int asu) { |
| synchronized (mLock) { |
| mOnSignalStrengthChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTH); |
| }); |
| synchronized (mLock) { |
| if (!mOnSignalStrengthChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnSignalStrengthChangedCalled); |
| } |
| |
| /** |
| * Due to the corresponding API is hidden in R and will be public in S, this test |
| * is commented and will be un-commented in Android S. |
| * |
| @Test |
| public void testOnAlwaysReportedSignalStrengthChanged() throws Throwable { |
| |
| assertTrue(mSignalStrength == null); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onSignalStrengthsChanged(SignalStrength signalStrength) { |
| synchronized (mLock) { |
| mSignalStrength = signalStrength; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH)); |
| }); |
| synchronized (mLock) { |
| if (mSignalStrength == null) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mSignalStrength != null); |
| // Call SignalStrength methods to make sure they do not throw any exceptions |
| mSignalStrength.getCdmaDbm(); |
| mSignalStrength.getCdmaEcio(); |
| mSignalStrength.getEvdoDbm(); |
| mSignalStrength.getEvdoEcio(); |
| mSignalStrength.getEvdoSnr(); |
| mSignalStrength.getGsmBitErrorRate(); |
| mSignalStrength.getGsmSignalStrength(); |
| mSignalStrength.isGsm(); |
| mSignalStrength.getLevel(); |
| } |
| */ |
| |
| @Test |
| public void testOnSignalStrengthsChanged() throws Throwable { |
| assertTrue(mSignalStrength == null); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onSignalStrengthsChanged(SignalStrength signalStrength) { |
| synchronized (mLock) { |
| mSignalStrength = signalStrength; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS); |
| }); |
| synchronized (mLock) { |
| if (mSignalStrength == null) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mSignalStrength != null); |
| // Call SignalStrength methods to make sure they do not throw any exceptions |
| mSignalStrength.getCdmaDbm(); |
| mSignalStrength.getCdmaEcio(); |
| mSignalStrength.getEvdoDbm(); |
| mSignalStrength.getEvdoEcio(); |
| mSignalStrength.getEvdoSnr(); |
| mSignalStrength.getGsmBitErrorRate(); |
| mSignalStrength.getGsmSignalStrength(); |
| mSignalStrength.isGsm(); |
| mSignalStrength.getLevel(); |
| } |
| |
| /** |
| * Due to the corresponding API is hidden in R and will be public in S, this test |
| * is commented and will be un-commented in Android S. |
| * |
| * Validate that SecurityException should be thrown when listen |
| * with LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH without LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH |
| * permission. |
| * |
| @Test |
| public void testOnAlwaysReportedSignalStrengthChangedWithoutPermission() throws Throwable { |
| |
| assertTrue(mSignalStrength == null); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onSignalStrengthsChanged(SignalStrength signalStrength) { |
| synchronized (mLock) { |
| mSignalStrength = signalStrength; |
| mLock.notify(); |
| } |
| } |
| }; |
| try { |
| mTelephonyManager.listen(mListener, |
| PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH); |
| } catch (SecurityException se) { |
| synchronized (mLock) { |
| mSecurityExceptionThrown = true; |
| mLock.notify(); |
| } |
| } |
| }); |
| synchronized (mLock) { |
| if (!mSecurityExceptionThrown) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertThat(mSecurityExceptionThrown).isTrue(); |
| assertTrue(mSignalStrength == null); |
| } |
| */ |
| |
| @Test |
| public void testOnMessageWaitingIndicatorChanged() throws Throwable { |
| assertFalse(mOnMessageWaitingIndicatorChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onMessageWaitingIndicatorChanged(boolean mwi) { |
| synchronized (mLock) { |
| mOnMessageWaitingIndicatorChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen( |
| mListener, PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR); |
| }); |
| synchronized (mLock) { |
| if (!mOnMessageWaitingIndicatorChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnMessageWaitingIndicatorChangedCalled); |
| } |
| |
| @Test |
| public void testOnPreciseCallStateChanged() throws Throwable { |
| assertThat(mOnPreciseCallStateChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onPreciseCallStateChanged(PreciseCallState preciseCallState) { |
| synchronized (mLock) { |
| mOnPreciseCallStateChangedCalled = true; |
| mPreciseCallState = preciseCallState; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, PhoneStateListener.LISTEN_PRECISE_CALL_STATE)); |
| }); |
| synchronized (mLock) { |
| if (!mOnPreciseCallStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| Log.d(TAG, "testOnPreciseCallStateChanged: " + mOnPreciseCallStateChangedCalled); |
| |
| assertThat(mOnPreciseCallStateChangedCalled).isTrue(); |
| assertThat(mPreciseCallState.getForegroundCallState()).isIn(PRECISE_CALL_STATE); |
| assertThat(mPreciseCallState.getBackgroundCallState()).isIn(PRECISE_CALL_STATE); |
| assertThat(mPreciseCallState.getRingingCallState()).isIn(PRECISE_CALL_STATE); |
| } |
| |
| @Test |
| public void testOnCallDisconnectCauseChanged() throws Throwable { |
| assertThat(mOnCallDisconnectCauseChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onCallDisconnectCauseChanged(int disconnectCause, |
| int preciseDisconnectCause) { |
| synchronized (mLock) { |
| mOnCallDisconnectCauseChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_CALL_DISCONNECT_CAUSES)); |
| }); |
| synchronized (mLock) { |
| if (!mOnCallDisconnectCauseChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertThat(mOnCallDisconnectCauseChangedCalled).isTrue(); |
| } |
| |
| @Test |
| public void testOnImsCallDisconnectCauseChanged() throws Throwable { |
| assertThat(mOnImsCallDisconnectCauseChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onImsCallDisconnectCauseChanged(ImsReasonInfo imsReason) { |
| synchronized (mLock) { |
| mOnImsCallDisconnectCauseChangedCalled = true; |
| mImsReasonInfo = imsReason; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_IMS_CALL_DISCONNECT_CAUSES)); |
| }); |
| synchronized (mLock) { |
| if (!mOnImsCallDisconnectCauseChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertThat(mOnImsCallDisconnectCauseChangedCalled).isTrue(); |
| assertNotNull(mImsReasonInfo); |
| } |
| |
| @Test |
| public void testOnPhoneStateListenerExecutorWithSrvccChanged() throws Throwable { |
| assertThat(mSrvccStateChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener(mSimpleExecutor) { |
| @Override |
| public void onSrvccStateChanged(int state) { |
| synchronized (mLock) { |
| mSrvccStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_SRVCC_STATE_CHANGED)); |
| }); |
| synchronized (mLock) { |
| if (!mSrvccStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| Log.d(TAG, "testOnPhoneStateListenerExecutorWithSrvccChanged"); |
| |
| assertThat(mSrvccStateChangedCalled).isTrue(); |
| } |
| |
| @Test |
| public void testOnRadioPowerStateChanged() throws Throwable { |
| assertThat(mOnRadioPowerStateChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onRadioPowerStateChanged(int state) { |
| synchronized (mLock) { |
| mRadioPowerState = state; |
| mOnRadioPowerStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_RADIO_POWER_STATE_CHANGED)); |
| }); |
| synchronized (mLock) { |
| if (!mOnRadioPowerStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| Log.d(TAG, "testOnRadioPowerStateChanged: " + mRadioPowerState); |
| |
| assertThat(mTelephonyManager.getRadioPowerState()).isEqualTo(mRadioPowerState); |
| } |
| |
| @Test |
| public void testOnVoiceActivationStateChanged() throws Throwable { |
| assertThat(mVoiceActivationStateChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onVoiceActivationStateChanged(int state) { |
| synchronized (mLock) { |
| mVoiceActivationState = state; |
| mVoiceActivationStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_VOICE_ACTIVATION_STATE)); |
| }); |
| synchronized (mLock) { |
| if (!mVoiceActivationStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| Log.d(TAG, "onVoiceActivationStateChanged: " + mVoiceActivationState); |
| int state = ShellIdentityUtils.invokeMethodWithShellPermissions(mTelephonyManager, |
| (tm) -> tm.getVoiceActivationState()); |
| |
| assertEquals(state, mVoiceActivationState); |
| } |
| |
| @Test |
| public void testOnPreciseDataConnectionStateChanged() throws Throwable { |
| assertThat(mOnCallDisconnectCauseChangedCalled).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onPreciseDataConnectionStateChanged( |
| PreciseDataConnectionState state) { |
| synchronized (mLock) { |
| mOnPreciseDataConnectionStateChanged = true; |
| mPreciseDataConnectionState = state; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE)); |
| }); |
| synchronized (mLock) { |
| if (!mOnPreciseDataConnectionStateChanged) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertThat(mOnPreciseDataConnectionStateChanged).isTrue(); |
| assertThat(mPreciseDataConnectionState.getState()) |
| .isIn(DATA_CONNECTION_STATE); |
| |
| // Ensure that no exceptions are thrown |
| mPreciseDataConnectionState.getNetworkType(); |
| mPreciseDataConnectionState.getLinkProperties(); |
| mPreciseDataConnectionState.getLastCauseCode(); |
| mPreciseDataConnectionState.getLinkProperties(); |
| mPreciseDataConnectionState.getApnSetting(); |
| mPreciseDataConnectionState.getTransportType(); |
| mPreciseDataConnectionState.getId(); |
| |
| // Deprecated in R |
| assertEquals(mPreciseDataConnectionState.getDataConnectionState(), |
| mPreciseDataConnectionState.getState()); |
| assertEquals(mPreciseDataConnectionState.getDataConnectionFailCause(), |
| mPreciseDataConnectionState.getLastCauseCode()); |
| |
| // Superseded in R by getApnSetting() |
| mPreciseDataConnectionState.getDataConnectionApnTypeBitMask(); |
| mPreciseDataConnectionState.getDataConnectionApn(); |
| } |
| |
| @Test |
| public void testOnDisplayInfoChanged() throws Exception { |
| assertThat(mOnTelephonyDisplayInfoChanged).isFalse(); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onDisplayInfoChanged(TelephonyDisplayInfo displayInfo) { |
| synchronized (mLock) { |
| mOnTelephonyDisplayInfoChanged = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_DISPLAY_INFO_CHANGED)); |
| }); |
| |
| synchronized (mLock) { |
| if (!mOnTelephonyDisplayInfoChanged) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| assertTrue(mOnTelephonyDisplayInfoChanged); |
| } |
| |
| @Test |
| public void testOnCallForwardingIndicatorChanged() throws Throwable { |
| assertFalse(mOnCallForwardingIndicatorChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onCallForwardingIndicatorChanged(boolean cfi) { |
| synchronized (mLock) { |
| mOnCallForwardingIndicatorChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen( |
| mListener, PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR); |
| }); |
| synchronized (mLock) { |
| if (!mOnCallForwardingIndicatorChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnCallForwardingIndicatorChangedCalled); |
| } |
| |
| @Test |
| public void testOnCellLocationChanged() throws Throwable { |
| assertFalse(mOnCellLocationChangedCalled); |
| |
| TelephonyManagerTest.grantLocationPermissions(); |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onCellLocationChanged(CellLocation location) { |
| synchronized (mLock) { |
| mOnCellLocationChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_CELL_LOCATION); |
| }); |
| synchronized (mLock) { |
| if (!mOnCellLocationChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnCellLocationChangedCalled); |
| } |
| |
| @Test |
| public void testOnCallStateChanged() throws Throwable { |
| assertFalse(mOnCallStateChangedCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onCallStateChanged(int state, String incomingNumber) { |
| synchronized (mLock) { |
| mOnCallStateChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_CALL_STATE); |
| }); |
| synchronized (mLock) { |
| if (!mOnCallStateChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnCallStateChangedCalled); |
| } |
| |
| @Test |
| public void testOnDataConnectionStateChanged() throws Throwable { |
| assertFalse(mOnDataConnectionStateChangedCalled); |
| assertFalse(mOnDataConnectionStateChangedWithNetworkTypeCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onDataConnectionStateChanged(int state) { |
| synchronized (mLock) { |
| mOnDataConnectionStateChangedCalled = true; |
| if (mOnDataConnectionStateChangedCalled |
| && mOnDataConnectionStateChangedWithNetworkTypeCalled) { |
| mLock.notify(); |
| } |
| } |
| } |
| |
| @Override |
| public void onDataConnectionStateChanged(int state, int networkType) { |
| synchronized (mLock) { |
| mOnDataConnectionStateChangedWithNetworkTypeCalled = true; |
| if (mOnDataConnectionStateChangedCalled |
| && mOnDataConnectionStateChangedWithNetworkTypeCalled) { |
| mLock.notify(); |
| } |
| } |
| } |
| }; |
| mTelephonyManager.listen( |
| mListener, PhoneStateListener.LISTEN_DATA_CONNECTION_STATE); |
| }); |
| synchronized (mLock) { |
| if (!mOnDataConnectionStateChangedCalled || |
| !mOnDataConnectionStateChangedWithNetworkTypeCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnDataConnectionStateChangedCalled); |
| assertTrue(mOnDataConnectionStateChangedWithNetworkTypeCalled); |
| } |
| |
| @Test |
| public void testOnDataActivity() throws Throwable { |
| assertFalse(mOnDataActivityCalled); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onDataActivity(int direction) { |
| synchronized (mLock) { |
| mOnDataActivityCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_DATA_ACTIVITY); |
| }); |
| synchronized (mLock) { |
| if (!mOnDataActivityCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnDataActivityCalled); |
| } |
| |
| @Test |
| public void testOnCellInfoChanged() throws Throwable { |
| assertFalse(mOnDataActivityCalled); |
| |
| TelephonyManagerTest.grantLocationPermissions(); |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onCellInfoChanged(List<CellInfo> cellInfo) { |
| synchronized (mLock) { |
| mOnCellInfoChangedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_CELL_INFO); |
| }); |
| synchronized (mLock) { |
| if (!mOnCellInfoChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnCellInfoChangedCalled); |
| } |
| |
| @Test |
| public void testOnUserMobileDataStateChanged() throws Throwable { |
| assertFalse(mOnUserMobileDataStateChanged); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onUserMobileDataStateChanged(boolean state) { |
| synchronized (mLock) { |
| mOnUserMobileDataStateChanged = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen( |
| mListener, PhoneStateListener.LISTEN_USER_MOBILE_DATA_STATE); |
| }); |
| synchronized (mLock) { |
| if (!mOnUserMobileDataStateChanged) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnUserMobileDataStateChanged); |
| } |
| |
| @Test |
| public void testOnOutgoingSmsEmergencyNumberChanged() throws Throwable { |
| TelephonyUtils.addTestEmergencyNumber( |
| InstrumentationRegistry.getInstrumentation(), TEST_EMERGENCY_NUMBER); |
| |
| LinkedBlockingQueue<Pair<EmergencyNumber, Integer>> smsCallbackQueue = |
| new LinkedBlockingQueue<>(1); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onOutgoingEmergencySms(EmergencyNumber emergencyNumber, |
| int subscriptionId) { |
| synchronized (mLock) { |
| Log.i(TAG, "onOutgoingEmergencySms: emergencyNumber=" + emergencyNumber); |
| smsCallbackQueue.offer(Pair.create(emergencyNumber, subscriptionId)); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_OUTGOING_EMERGENCY_SMS)); |
| |
| SmsManager smsManager = SmsManager.getDefault(); |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(smsManager, |
| (sm) -> sm.sendTextMessage(TEST_EMERGENCY_NUMBER, null, |
| "testOutgoingSmsListenerCts", null, null)); |
| }); |
| |
| |
| try { |
| Pair<EmergencyNumber, Integer> emergencySmsInfo = |
| smsCallbackQueue.poll(WAIT_TIME, TimeUnit.MILLISECONDS); |
| assertNotNull("Never got emergency sms callback", emergencySmsInfo); |
| assertEquals(TEST_EMERGENCY_NUMBER, emergencySmsInfo.first.getNumber()); |
| assertEquals(SubscriptionManager.getDefaultSmsSubscriptionId(), |
| emergencySmsInfo.second.intValue()); |
| } catch (InterruptedException e) { |
| Log.e(TAG, "Operation interrupted."); |
| } finally { |
| TelephonyUtils.removeTestEmergencyNumber( |
| InstrumentationRegistry.getInstrumentation(), TEST_EMERGENCY_NUMBER); |
| } |
| |
| // Disable suppressing blocking. |
| TelephonyUtils.endBlockSuppression(InstrumentationRegistry.getInstrumentation()); |
| } |
| |
| @Test |
| public void testOnActiveDataSubscriptionIdChanged() throws Throwable { |
| assertFalse(mOnActiveDataSubscriptionIdChanged); |
| |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onActiveDataSubscriptionIdChanged(int subId) { |
| synchronized (mLock) { |
| mOnActiveDataSubscriptionIdChanged = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| mTelephonyManager.listen( |
| mListener, PhoneStateListener.LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE); |
| }); |
| synchronized (mLock) { |
| if (!mOnActiveDataSubscriptionIdChanged) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| assertTrue(mOnActiveDataSubscriptionIdChanged); |
| } |
| |
| @Test |
| public void testOnBarringInfoChanged() throws Throwable { |
| |
| assertFalse(mOnBarringInfoChangedCalled); |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onBarringInfoChanged(BarringInfo barringInfo) { |
| synchronized (mLock) { |
| mOnBarringInfoChangedCalled = true; |
| mBarringInfo = barringInfo; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, PhoneStateListener.LISTEN_BARRING_INFO)); |
| }); |
| |
| synchronized (mLock) { |
| if (!mOnBarringInfoChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| assertTrue(mOnBarringInfoChangedCalled); |
| |
| assertBarringInfoSane(mBarringInfo); |
| } |
| |
| private static final int[] sBarringServiceInfoTypes = new int[]{ |
| BarringInfo.BARRING_SERVICE_TYPE_CS_SERVICE, |
| BarringInfo.BARRING_SERVICE_TYPE_PS_SERVICE, |
| BarringInfo.BARRING_SERVICE_TYPE_CS_VOICE, |
| BarringInfo.BARRING_SERVICE_TYPE_MO_SIGNALLING, |
| BarringInfo.BARRING_SERVICE_TYPE_MO_DATA, |
| BarringInfo.BARRING_SERVICE_TYPE_CS_FALLBACK, |
| BarringInfo.BARRING_SERVICE_TYPE_MMTEL_VOICE, |
| BarringInfo.BARRING_SERVICE_TYPE_MMTEL_VIDEO, |
| BarringInfo.BARRING_SERVICE_TYPE_EMERGENCY, |
| BarringInfo.BARRING_SERVICE_TYPE_SMS |
| }; |
| |
| private static void assertBarringInfoSane(BarringInfo barringInfo) { |
| assertNotNull(barringInfo); |
| |
| // Flags to track whether we have had unknown and known barring types reported |
| boolean hasBarringTypeUnknown = false; |
| boolean hasBarringTypeKnown = false; |
| |
| for (int bsiType : sBarringServiceInfoTypes) { |
| BarringInfo.BarringServiceInfo bsi = barringInfo.getBarringServiceInfo(bsiType); |
| assertNotNull(bsi); |
| switch (bsi.getBarringType()) { |
| case BarringInfo.BarringServiceInfo.BARRING_TYPE_UNKNOWN: |
| hasBarringTypeUnknown = true; |
| assertFalse(bsi.isConditionallyBarred()); |
| assertEquals(0, bsi.getConditionalBarringFactor()); |
| assertEquals(0, bsi.getConditionalBarringTimeSeconds()); |
| assertFalse(bsi.isBarred()); |
| break; |
| |
| case BarringInfo.BarringServiceInfo.BARRING_TYPE_NONE: |
| hasBarringTypeKnown = true; |
| // Unless conditional barring is active, all conditional barring fields |
| // should be "unset". |
| assertFalse(bsi.isConditionallyBarred()); |
| assertEquals(0, bsi.getConditionalBarringFactor()); |
| assertEquals(0, bsi.getConditionalBarringTimeSeconds()); |
| assertFalse(bsi.isBarred()); |
| break; |
| |
| case BarringInfo.BarringServiceInfo.BARRING_TYPE_UNCONDITIONAL: |
| hasBarringTypeKnown = true; |
| // Unless conditional barring is active, all conditional barring fields |
| // should be "unset". |
| assertFalse(bsi.isConditionallyBarred()); |
| assertEquals(0, bsi.getConditionalBarringFactor()); |
| assertEquals(0, bsi.getConditionalBarringTimeSeconds()); |
| assertTrue(bsi.isBarred()); |
| break; |
| |
| case BarringInfo.BarringServiceInfo.BARRING_TYPE_CONDITIONAL: |
| hasBarringTypeKnown = true; |
| // If conditional barring is active, then the barring time and factor must |
| // be known (set), but the device may or may not be barred at the moment, |
| // so isConditionallyBarred() can be either true or false (hence not checked). |
| assertNotEquals(0, bsi.getConditionalBarringFactor()); |
| assertNotEquals(0, bsi.getConditionalBarringTimeSeconds()); |
| assertEquals(bsi.isBarred(), bsi.isConditionallyBarred()); |
| break; |
| } |
| } |
| // If any barring type is unknown, then barring is not supported so all must be |
| // unknown. If any type is known, then all that are not reported are assumed to |
| // be not barred. |
| assertNotEquals(hasBarringTypeUnknown, hasBarringTypeKnown); |
| } |
| |
| @Test |
| public void testOnRegistrationFailed() throws Throwable { |
| |
| assertFalse(mOnBarringInfoChangedCalled); |
| mHandler.post(() -> { |
| mListener = new PhoneStateListener() { |
| @Override |
| public void onRegistrationFailed(CellIdentity cid, String chosenPlmn, |
| int domain, int causeCode, |
| int additionalCauseCode) { |
| synchronized (mLock) { |
| mOnRegistrationFailedCalled = true; |
| mLock.notify(); |
| } |
| } |
| }; |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyManager, |
| (tm) -> tm.listen(mListener, |
| PhoneStateListener.LISTEN_REGISTRATION_FAILURE)); |
| }); |
| |
| synchronized (mLock) { |
| if (!mOnBarringInfoChangedCalled) { |
| mLock.wait(WAIT_TIME); |
| } |
| } |
| |
| // Assert that in the WAIT_TIME interval, the listener wasn't invoked. While this is |
| // **technically** a flaky test, in practice this flake should happen approximately never |
| // as it would mean that a registered phone is failing to reselect during CTS at this |
| // exact moment. |
| // |
| // What the test is verifying is that there is no "auto" callback for registration |
| // failure because unlike other PSL registrants, this one is not called upon registration. |
| assertFalse(mOnRegistrationFailedCalled); |
| } |
| } |
