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

Commit 186629aa authored by Chaohui Wang's avatar Chaohui Wang
Browse files

Migrate the "Use this SIM" preference 

This will fix the toggle flicker issue.

Fix: 262179656
Test: manual - on Mobile Settings
Test: unit test
Change-Id: Ided2445034a83a8efc11dc97bab8719686d63712
parent c038d58b

res/xml/mobile_network_settings.xml

+1 −2
Original line number Diff line number Diff line
@@ -18,9 +18,8 @@ 
    xmlns:settings="http://schemas.android.com/apk/res-auto"

    android:key="mobile_network_pref_screen">



    <com.android.settings.widget.SettingsMainSwitchPreference

    <com.android.settings.spa.preference.ComposePreference

        android:key="use_sim_switch"

        android:title="@string/mobile_network_use_sim_on"

        settings:controller="com.android.settings.network.telephony.MobileNetworkSwitchController"/>



    <PreferenceCategory

src/com/android/settings/network/telephony/MobileNetworkSwitchController.java

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

 * Copyright (C) 2019 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.settings.network.telephony;



import static android.telephony.TelephonyManager.CALL_STATE_IDLE;



import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;

import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;



import android.content.Context;

import android.telephony.SubscriptionInfo;

import android.telephony.SubscriptionManager;

import android.telephony.TelephonyCallback;

import android.telephony.TelephonyManager;



import androidx.lifecycle.LifecycleObserver;

import androidx.lifecycle.OnLifecycleEvent;

import androidx.preference.PreferenceScreen;



import com.android.settings.core.BasePreferenceController;

import com.android.settings.network.SubscriptionUtil;

import com.android.settings.network.SubscriptionsChangeListener;

import com.android.settings.widget.SettingsMainSwitchPreference;



/** This controls a switch to allow enabling/disabling a mobile network */

public class MobileNetworkSwitchController extends BasePreferenceController implements

        SubscriptionsChangeListener.SubscriptionsChangeListenerClient, LifecycleObserver {

    private static final String TAG = "MobileNetworkSwitchCtrl";

    private SettingsMainSwitchPreference mSwitchBar;

    private int mSubId;

    private SubscriptionsChangeListener mChangeListener;

    private SubscriptionManager mSubscriptionManager;

    private TelephonyManager mTelephonyManager;

    private CallStateTelephonyCallback mCallStateCallback;



    public MobileNetworkSwitchController(Context context, String preferenceKey) {

        super(context, preferenceKey);

        mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;

        mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class);

        mTelephonyManager = mContext.getSystemService(TelephonyManager.class);

        mChangeListener = new SubscriptionsChangeListener(context, this);

    }



    void init(int subId) {

        mSubId = subId;

        mTelephonyManager = mTelephonyManager.createForSubscriptionId(mSubId);

    }



    @OnLifecycleEvent(ON_RESUME)

    public void onResume() {

        mChangeListener.start();



        if (mCallStateCallback == null) {

            mCallStateCallback = new CallStateTelephonyCallback();

            mTelephonyManager.registerTelephonyCallback(

                    mContext.getMainExecutor(), mCallStateCallback);

        }

        update();

    }



    @OnLifecycleEvent(ON_PAUSE)

    public void onPause() {

        if (mCallStateCallback != null) {

            mTelephonyManager.unregisterTelephonyCallback(mCallStateCallback);

            mCallStateCallback = null;

        }

        mChangeListener.stop();

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mSwitchBar = (SettingsMainSwitchPreference) screen.findPreference(mPreferenceKey);



        mSwitchBar.setOnBeforeCheckedChangeListener((isChecked) -> {

            // TODO b/135222940: re-evaluate whether to use

            // mSubscriptionManager#isSubscriptionEnabled

            if (mSubscriptionManager.isActiveSubscriptionId(mSubId) != isChecked) {

                SubscriptionUtil.startToggleSubscriptionDialogActivity(mContext, mSubId, isChecked);

                return true;

            }

            return false;

        });

        update();

    }



    private void update() {

        if (mSwitchBar == null) {

            return;

        }



        SubscriptionInfo subInfo = null;

        for (SubscriptionInfo info : SubscriptionUtil.getAvailableSubscriptions(mContext)) {

            if (info.getSubscriptionId() == mSubId) {

                subInfo = info;

                break;

            }

        }



        // For eSIM, we always want the toggle. If telephony stack support disabling a pSIM

        // directly, we show the toggle.

        if (subInfo == null || (!subInfo.isEmbedded() && !SubscriptionUtil.showToggleForPhysicalSim(

                mSubscriptionManager))) {

            mSwitchBar.hide();

        } else {

            mSwitchBar.show();

            mSwitchBar.setCheckedInternal(mSubscriptionManager.isActiveSubscriptionId(mSubId));

        }

    }



    @Override

    public int getAvailabilityStatus() {

        return AVAILABLE_UNSEARCHABLE;



    }



    @Override

    public void onAirplaneModeChanged(boolean airplaneModeEnabled) {

    }



    @Override

    public void onSubscriptionsChanged() {

        update();

    }



    private class CallStateTelephonyCallback extends TelephonyCallback implements

            TelephonyCallback.CallStateListener {

        @Override

        public void onCallStateChanged(int state) {

            mSwitchBar.setSwitchBarEnabled(state == CALL_STATE_IDLE);

        }

    }

}

src/com/android/settings/network/telephony/MobileNetworkSwitchController.kt

0 → 100644
+77 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.settings.network.telephony



import android.content.Context

import android.telephony.SubscriptionManager

import android.telephony.TelephonyManager

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.remember

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.res.stringResource

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.android.settings.R

import com.android.settings.network.SubscriptionUtil

import com.android.settings.spa.preference.ComposePreferenceController

import com.android.settingslib.spa.widget.preference.MainSwitchPreference

import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel

import kotlinx.coroutines.flow.map



class MobileNetworkSwitchController @JvmOverloads constructor(

    context: Context,

    preferenceKey: String,

    private val subscriptionRepository: SubscriptionRepository = SubscriptionRepository(context),

) : ComposePreferenceController(context, preferenceKey) {



    private var subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID



    override fun getAvailabilityStatus() = AVAILABLE_UNSEARCHABLE



    fun init(subId: Int) {

        this.subId = subId

    }



    @Composable

    override fun Content() {

        val context = LocalContext.current

        if (remember { !context.isVisible() }) return

        val checked by remember {

            subscriptionRepository.isSubscriptionEnabledFlow(subId)

        }.collectAsStateWithLifecycle(initialValue = null)

        val changeable by remember {

            context.callStateFlow(subId).map { it == TelephonyManager.CALL_STATE_IDLE }

        }.collectAsStateWithLifecycle(initialValue = true)

        MainSwitchPreference(model = object : SwitchPreferenceModel {

            override val title = stringResource(R.string.mobile_network_use_sim_on)

            override val changeable = { changeable }

            override val checked = { checked }

            override val onCheckedChange = { newChecked: Boolean ->

                SubscriptionUtil.startToggleSubscriptionDialogActivity(mContext, subId, newChecked)

            }

        })

    }



    private fun Context.isVisible(): Boolean {

        val subInfo = subscriptionRepository.getSelectableSubscriptionInfoList()

            .firstOrNull { it.subscriptionId == subId }

            ?: return false

        // For eSIM, we always want the toggle. If telephony stack support disabling a pSIM

        // directly, we show the toggle.

        return subInfo.isEmbedded || requireSubscriptionManager().canDisablePhysicalSubscription()

    }

}

src/com/android/settings/network/telephony/SubscriptionRepository.kt

+12 −0
Original line number Diff line number Diff line
@@ -32,6 +32,18 @@ import kotlinx.coroutines.flow.onEach 


private const val TAG = "SubscriptionRepository"



class SubscriptionRepository(private val context: Context) {

    /**

     * Return a list of subscriptions that are available and visible to the user.

     *

     * @return list of user selectable subscriptions.

     */

    fun getSelectableSubscriptionInfoList(): List<SubscriptionInfo> =

        context.getSelectableSubscriptionInfoList()



    fun isSubscriptionEnabledFlow(subId: Int) = context.isSubscriptionEnabledFlow(subId)

}



val Context.subscriptionManager: SubscriptionManager?

    get() = getSystemService(SubscriptionManager::class.java)

tests/spa_unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.kt

0 → 100644
+168 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.settings.network.telephony



import android.content.Context

import android.telephony.SubscriptionInfo

import android.telephony.SubscriptionManager

import androidx.compose.runtime.CompositionLocalProvider

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.test.assertIsDisplayed

import androidx.compose.ui.test.hasText

import androidx.compose.ui.test.isOff

import androidx.compose.ui.test.isOn

import androidx.compose.ui.test.junit4.createComposeRule

import androidx.compose.ui.test.onNodeWithText

import androidx.test.core.app.ApplicationProvider

import androidx.test.ext.junit.runners.AndroidJUnit4

import com.android.settings.R

import com.android.settingslib.spa.testutils.waitUntilExists

import kotlinx.coroutines.flow.flowOf

import org.junit.Rule

import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.kotlin.any

import org.mockito.kotlin.doNothing

import org.mockito.kotlin.doReturn

import org.mockito.kotlin.mock

import org.mockito.kotlin.spy

import org.mockito.kotlin.stub

import org.mockito.kotlin.whenever



@RunWith(AndroidJUnit4::class)

class MobileNetworkSwitchControllerTest {

    @get:Rule

    val composeTestRule = createComposeRule()



    private val mockSubscriptionManager = mock<SubscriptionManager> {

        on { isSubscriptionEnabled(SUB_ID) } doReturn true

    }



    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {

        on { subscriptionManager } doReturn mockSubscriptionManager

        doNothing().whenever(mock).startActivity(any())

    }



    private val mockSubscriptionRepository = mock<SubscriptionRepository> {

        on { getSelectableSubscriptionInfoList() } doReturn listOf(SubInfo)

        on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(false)

    }



    private val controller = MobileNetworkSwitchController(

        context = context,

        preferenceKey = TEST_KEY,

        subscriptionRepository = mockSubscriptionRepository,

    ).apply { init(SUB_ID) }



    @Test

    fun isVisible_pSimAndCanDisablePhysicalSubscription_returnTrue() {

        val pSimSubInfo = SubscriptionInfo.Builder().apply {

            setId(SUB_ID)

            setEmbedded(false)

        }.build()

        mockSubscriptionManager.stub {

            on { canDisablePhysicalSubscription() } doReturn true

        }

        mockSubscriptionRepository.stub {

            on { getSelectableSubscriptionInfoList() } doReturn listOf(pSimSubInfo)

        }



        setContent()



        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))

            .assertIsDisplayed()

    }



    @Test

    fun isVisible_pSimAndCannotDisablePhysicalSubscription_returnFalse() {

        val pSimSubInfo = SubscriptionInfo.Builder().apply {

            setId(SUB_ID)

            setEmbedded(false)

        }.build()

        mockSubscriptionManager.stub {

            on { canDisablePhysicalSubscription() } doReturn false

        }

        mockSubscriptionRepository.stub {

            on { getSelectableSubscriptionInfoList() } doReturn listOf(pSimSubInfo)

        }



        setContent()



        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))

            .assertDoesNotExist()

    }



    @Test

    fun isVisible_eSim_returnTrue() {

        val eSimSubInfo = SubscriptionInfo.Builder().apply {

            setId(SUB_ID)

            setEmbedded(true)

        }.build()

        mockSubscriptionRepository.stub {

            on { getSelectableSubscriptionInfoList() } doReturn listOf(eSimSubInfo)

        }



        setContent()



        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))

            .assertIsDisplayed()

    }



    @Test

    fun isChecked_subscriptionEnabled_switchIsOn() {

        mockSubscriptionRepository.stub {

            on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(true)

        }



        setContent()



        composeTestRule.waitUntilExists(

            hasText(context.getString(R.string.mobile_network_use_sim_on)) and isOn()

        )

    }



    @Test

    fun isChecked_subscriptionNotEnabled_switchIsOff() {

        mockSubscriptionRepository.stub {

            on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(false)

        }



        setContent()



        composeTestRule.waitUntilExists(

            hasText(context.getString(R.string.mobile_network_use_sim_on)) and isOff()

        )

    }



    private fun setContent() {

        composeTestRule.setContent {

            CompositionLocalProvider(LocalContext provides context) {

                controller.Content()

            }

        }

    }



    private companion object {

        const val TEST_KEY = "test_key"

        const val SUB_ID = 123



        val SubInfo: SubscriptionInfo = SubscriptionInfo.Builder().apply {

            setId(SUB_ID)

            setEmbedded(true)

        }.build()

    }

}