Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ee223e33 authored by Jack Yu's avatar Jack Yu
Browse files

More CDMA cleanup 

Bug: 379356026
Test: Basic telephony functionality tests
Test: atest FrameworksTelephonyTests
Flag: com.android.internal.telephony.flags.phone_type_cleanup
Change-Id: I41d7c38f0521a66b5f11b46bc4290a21044fcab6
parent c6bf1564

src/java/com/android/internal/telephony/uicc/UiccController.java

+2 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ import android.util.LocalLog; 
import android.util.Log;



import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.hidden_from_bootclasspath.com.android.internal.telephony.flags.Flags;

import com.android.internal.telephony.CarrierServiceBindHelper;

import com.android.internal.telephony.CommandException;

import com.android.internal.telephony.CommandsInterface;
@@ -1661,6 +1662,7 @@ public class UiccController extends Handler { 
     * @return true if CDMA is supported by the device

     */

    public static boolean isCdmaSupported(Context context) {

        if (Flags.phoneTypeCleanup()) return false;

        PackageManager packageManager = context.getPackageManager();

        boolean isCdmaSupported =

                packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY_CDMA);

tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java

+0 −13
Original line number Diff line number Diff line
@@ -49,7 +49,6 @@ import android.content.Context; 
import android.content.Intent;

import android.content.IntentFilter;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageManager;

import android.content.pm.ServiceInfo;

import android.content.res.Resources;

import android.graphics.drawable.Drawable;
@@ -308,9 +307,6 @@ public class ServiceStateTrackerTest extends TelephonyTest { 
        int dds = SubscriptionManager.getDefaultDataSubscriptionId();

        doReturn(dds).when(mPhone).getSubId();



        doReturn(true).when(mPackageManager)

                .hasSystemFeature(PackageManager.FEATURE_TELEPHONY_CDMA);



        // Set cellular radio on after boot by default

        mContextFixture.putBooleanResource(

                R.bool.config_enable_cellular_on_boot_default, true);
@@ -2942,15 +2938,6 @@ public class ServiceStateTrackerTest extends TelephonyTest { 
                sSnetworkRegistrationInfo.getDataSpecificInfo().getVopsSupportInfo());

    }





    @Test

    @SmallTest

    public void testEriLoading() {

        sst.obtainMessage(GsmCdmaPhone.EVENT_CARRIER_CONFIG_CHANGED, null).sendToTarget();

        waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());

        verify(mEriManager, times(1)).loadEriFile();

    }



    @Test

    public void testLastKnownCellIdentity() throws Exception {

        CellIdentityLte cellIdentity =

tests/telephonytests/src/com/android/internal/telephony/cdma/CdmaInboundSmsHandlerTest.java

deleted100644 → 0
+0 −272
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 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 com.android.internal.telephony.cdma;



import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.fail;

import static org.mockito.ArgumentMatchers.anyLong;

import static org.mockito.ArgumentMatchers.nullable;

import static org.mockito.Matchers.any;

import static org.mockito.Mockito.anyBoolean;

import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;



import android.content.Context;

import android.content.Intent;

import android.database.Cursor;

import android.os.AsyncResult;

import android.os.RemoteException;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.Telephony;

import android.test.mock.MockContentResolver;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;



import androidx.test.filters.FlakyTest;

import androidx.test.filters.MediumTest;



import com.android.internal.telephony.FakeSmsContentProvider;

import com.android.internal.telephony.InboundSmsHandler;

import com.android.internal.telephony.InboundSmsTracker;

import com.android.internal.telephony.SmsStorageMonitor;

import com.android.internal.telephony.TelephonyTest;

import com.android.internal.telephony.cdma.sms.SmsEnvelope;

import com.android.internal.util.IState;

import com.android.internal.util.StateMachine;



import org.junit.After;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;



import java.io.PrintWriter;

import java.io.StringWriter;

import java.lang.reflect.Field;

import java.lang.reflect.Method;



@RunWith(AndroidTestingRunner.class)

@TestableLooper.RunWithLooper

public class CdmaInboundSmsHandlerTest extends TelephonyTest {

    // Mocked classes

    private SmsStorageMonitor mSmsStorageMonitor;

    private android.telephony.SmsMessage mSmsMessage;

    private SmsMessage mCdmaSmsMessage;



    private CdmaInboundSmsHandler mCdmaInboundSmsHandler;

    private SmsEnvelope mSmsEnvelope = new SmsEnvelope();

    private FakeSmsContentProvider mContentProvider;

    private InboundSmsTracker mInboundSmsTracker;

    private final byte[] mSmsPdu = new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF};

    private final int mSubId0 = 0;

    private static final UserHandle MOCKED_MAIN_USER = UserHandle.of(10);



    private IState getCurrentState() {

        try {

            Method method = StateMachine.class.getDeclaredMethod("getCurrentState");

            method.setAccessible(true);

            return (IState) method.invoke(mCdmaInboundSmsHandler);

        } catch (Exception e) {

            fail(e.toString());

            return null;

        }

    }



    @Before

    public void setUp() throws Exception {

        super.setUp(getClass().getSimpleName());

        mSmsStorageMonitor = mock(SmsStorageMonitor.class);

        mSmsMessage = mock(android.telephony.SmsMessage.class);

        mCdmaSmsMessage = mock(SmsMessage.class);



        Field field = SmsMessage.class.getDeclaredField("mEnvelope");

        field.setAccessible(true);

        field.set(mCdmaSmsMessage, mSmsEnvelope);



        UserManager userManager = (UserManager) mContextFixture.getTestDouble().

                getSystemService(Context.USER_SERVICE);

        doReturn(MOCKED_MAIN_USER).when(userManager).getMainUser();

        doReturn(true).when(userManager).isUserUnlocked();

        doReturn(true).when(mFeatureFlags).smsMmsDeliverBroadcastsRedirectToMainUser();



        try {

            doReturn(new int[]{0, MOCKED_MAIN_USER.getIdentifier()})

                .when(mIActivityManager).getRunningUserIds();

        } catch (RemoteException re) {

            StringWriter reString = new StringWriter();

            re.printStackTrace(new PrintWriter(reString));

            fail("Unexpected RemoteException: " + reString);

        }



        mSmsMessage.mWrappedSmsMessage = mCdmaSmsMessage;

        doReturn(mSmsPdu).when(mCdmaSmsMessage).getPdu();



        doReturn(true).when(mTelephonyManager).getSmsReceiveCapableForPhone(anyInt(), anyBoolean());

        doReturn(true).when(mSmsStorageMonitor).isStorageAvailable();



        mInboundSmsTracker = new InboundSmsTracker(

                mContext,

                mSmsPdu, /* pdu */

                System.currentTimeMillis(), /* timestamp */

                -1, /* destPort */

                true, /* is3gpp2 */

                false, /* is3gpp2WapPdu */

                "1234567890", /* address */

                "1234567890", /* displayAddress */

                "This is the message body of a single-part message" /* messageBody */,

                false, /* isClass0 */

                mSubId0,

                InboundSmsHandler.SOURCE_NOT_INJECTED);



        doReturn(mInboundSmsTracker).when(mTelephonyComponentFactory)

                .makeInboundSmsTracker(any(Context.class), nullable(byte[].class), anyLong(),

                anyInt(), anyBoolean(),

                anyBoolean(), nullable(String.class), nullable(String.class),

                nullable(String.class), anyBoolean(), anyInt(), anyInt());

        doReturn(mInboundSmsTracker).when(mTelephonyComponentFactory)

                .makeInboundSmsTracker(any(Context.class), nullable(byte[].class), anyLong(),

                anyInt(), anyBoolean(),

                nullable(String.class), nullable(String.class), anyInt(), anyInt(),

                anyInt(), anyBoolean(), nullable(String.class), anyBoolean(), anyInt(),

                anyInt());

        doReturn(mInboundSmsTracker).when(mTelephonyComponentFactory)

                .makeInboundSmsTracker(any(Context.class), nullable(Cursor.class), anyBoolean());



        mContentProvider = new FakeSmsContentProvider();

        ((MockContentResolver)mContext.getContentResolver()).addProvider(

                Telephony.Sms.CONTENT_URI.getAuthority(), mContentProvider);



        mCdmaInboundSmsHandler = CdmaInboundSmsHandler.makeInboundSmsHandler(mContext,

            mSmsStorageMonitor, mPhone, null, mTestableLooper.getLooper(),

                mFeatureFlags);

        monitorTestableLooper(new TestableLooper(mCdmaInboundSmsHandler.getHandler().getLooper()));

        processAllMessages();

    }



    @After

    public void tearDown() throws Exception {

        // wait for wakelock to be released; timeout at 10s

        int i = 0;

        while (mCdmaInboundSmsHandler.getWakeLock().isHeld() && i < 100) {

            processAllMessages();

            waitForMs(100);

            i++;

        }

        assertFalse(mCdmaInboundSmsHandler.getWakeLock().isHeld());

        mCdmaInboundSmsHandler.quit();

        mCdmaInboundSmsHandler = null;

        mContentProvider.shutdown();

        mContentProvider = null;

        mSmsEnvelope = null;

        mInboundSmsTracker = null;

        super.tearDown();

    }



    private void transitionFromStartupToIdle() {

        // verify initially in StartupState

        assertEquals("StartupState", getCurrentState().getName());



        // trigger transition to IdleState

        mCdmaInboundSmsHandler.sendMessage(InboundSmsHandler.EVENT_START_ACCEPTING_SMS);

        processAllMessages();



        assertEquals("IdleState", getCurrentState().getName());

    }



    @FlakyTest

    @Test

    @MediumTest

    @Ignore

    public void testNewSms() {

        transitionFromStartupToIdle();



        // send new SMS to state machine and verify that triggers SMS_DELIVER_ACTION

        doReturn(SmsEnvelope.TELESERVICE_WMT).when(mCdmaSmsMessage).getTeleService();

        mCdmaInboundSmsHandler.sendMessage(InboundSmsHandler.EVENT_NEW_SMS,

                new AsyncResult(null, mSmsMessage, null));

        processAllMessages();



        ArgumentCaptor<Intent> intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class);

        verify(mContext).sendBroadcast(intentArgumentCaptor.capture());

        assertEquals(Telephony.Sms.Intents.SMS_DELIVER_ACTION,

                intentArgumentCaptor.getValue().getAction());



        // verify a message id was created on receive.

        assertNotEquals(0L,

                intentArgumentCaptor.getValue().getLongExtra("messageId", 0L));

        assertEquals("WaitingState", getCurrentState().getName());



        mContextFixture.sendBroadcastToOrderedBroadcastReceivers();



        intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class);

        verify(mContext, times(2)).sendBroadcast(intentArgumentCaptor.capture());

        assertEquals(Telephony.Sms.Intents.SMS_RECEIVED_ACTION,

                intentArgumentCaptor.getAllValues().get(1).getAction());

        assertEquals("WaitingState", getCurrentState().getName());



        mContextFixture.sendBroadcastToOrderedBroadcastReceivers();

        processAllMessages();



        assertEquals("IdleState", getCurrentState().getName());

    }



    @FlakyTest /* flakes 0.43% of the time */

    @Test

    @MediumTest

    public void testNewSmsFromBlockedNumber_noBroadcastsSent() {

        String blockedNumber = "123456789";

        mInboundSmsTracker = new InboundSmsTracker(

                mContext,

                mSmsPdu, /* pdu */

                System.currentTimeMillis(), /* timestamp */

                -1, /* destPort */

                true, /* is3gpp2 */

                false, /* is3gpp2WapPdu */

                "1234567890", /* address */

                blockedNumber, /* displayAddress */

                "This is the message body of a single-part message" /* messageBody */,

                false, /* isClass0 */

                mSubId0,

                InboundSmsHandler.SOURCE_NOT_INJECTED);

        doReturn(mInboundSmsTracker).when(mTelephonyComponentFactory)

                .makeInboundSmsTracker(any(Context.class), nullable(byte[].class), anyLong(),

                anyInt(), anyBoolean(),

                anyBoolean(), nullable(String.class), nullable(String.class),

                nullable(String.class), anyBoolean(), anyInt(), anyInt());

        mFakeBlockedNumberContentProvider.mBlockedNumbers.add(blockedNumber);



        transitionFromStartupToIdle();



        doReturn(SmsEnvelope.TELESERVICE_WMT).when(mCdmaSmsMessage).getTeleService();

        mCdmaInboundSmsHandler.sendMessage(InboundSmsHandler.EVENT_NEW_SMS,

                new AsyncResult(null, mSmsMessage, null));

        processAllMessages();



        verify(mContext, never()).sendBroadcast(any(Intent.class));

        assertEquals("IdleState", getCurrentState().getName());

    }

}