diff --git a/res/xml/mobile_network_settings.xml b/res/xml/mobile_network_settings.xml index c6eb3e76711..16484f38edc 100644 --- a/res/xml/mobile_network_settings.xml +++ b/res/xml/mobile_network_settings.xml @@ -77,7 +77,8 @@ + android:title="@string/call_category" + settings:searchable="false"> m4gLteListeners; - private int mSubId; public Enhanced4gLtePreferenceController(Context context, String key) { super(context, key); mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); m4gLteListeners = new ArrayList<>(); mPhoneStateListener = new PhoneCallStateListener(Looper.getMainLooper()); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { - final boolean isVisible = mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID - && mImsManager != null && mCarrierConfig != null + public int getAvailabilityStatus(int subId) { + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final boolean isVisible = subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + && mImsManager != null && carrierConfig != null && mImsManager.isVolteEnabledByPlatform() && mImsManager.isVolteProvisionedOnDevice() && MobileNetworkUtils.isImsServiceStateReady(mImsManager) - && !mCarrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL); + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL); return isVisible ? (is4gLtePrefEnabled() ? AVAILABLE : AVAILABLE_UNSEARCHABLE) : CONDITIONALLY_UNAVAILABLE; diff --git a/src/com/android/settings/network/telephony/EuiccPreferenceController.java b/src/com/android/settings/network/telephony/EuiccPreferenceController.java index ae207a28636..ecd20edfc57 100644 --- a/src/com/android/settings/network/telephony/EuiccPreferenceController.java +++ b/src/com/android/settings/network/telephony/EuiccPreferenceController.java @@ -18,31 +18,26 @@ package com.android.settings.network.telephony; import android.content.Context; import android.content.Intent; -import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; import android.telephony.euicc.EuiccManager; import android.text.TextUtils; import androidx.preference.Preference; -import com.android.settings.core.BasePreferenceController; - /** * Preference controller for "Euicc preference" */ -public class EuiccPreferenceController extends BasePreferenceController { +public class EuiccPreferenceController extends TelephonyBasePreferenceController { private TelephonyManager mTelephonyManager; - private int mSubId; public EuiccPreferenceController(Context context, String key) { super(context, key); mTelephonyManager = context.getSystemService(TelephonyManager.class); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { + public int getAvailabilityStatus(int subId) { return MobileNetworkUtils.showEuiccSettings(mContext) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; diff --git a/src/com/android/settings/network/telephony/MobileDataPreferenceController.java b/src/com/android/settings/network/telephony/MobileDataPreferenceController.java index 47822b6fce3..7bf01531f85 100644 --- a/src/com/android/settings/network/telephony/MobileDataPreferenceController.java +++ b/src/com/android/settings/network/telephony/MobileDataPreferenceController.java @@ -40,7 +40,7 @@ import com.android.settingslib.core.lifecycle.events.OnStop; /** * Preference controller for "Mobile data" */ -public class MobileDataPreferenceController extends TogglePreferenceController +public class MobileDataPreferenceController extends TelephonyTogglePreferenceController implements LifecycleObserver, OnStart, OnStop { private static final String DIALOG_TAG = "MobileDataDialog"; @@ -50,7 +50,6 @@ public class MobileDataPreferenceController extends TogglePreferenceController private SubscriptionManager mSubscriptionManager; private DataContentObserver mDataContentObserver; private FragmentManager mFragmentManager; - private int mSubId; @VisibleForTesting int mDialogType; @VisibleForTesting @@ -58,15 +57,13 @@ public class MobileDataPreferenceController extends TogglePreferenceController public MobileDataPreferenceController(Context context, String key) { super(context, key); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; mSubscriptionManager = context.getSystemService(SubscriptionManager.class); mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper())); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { - return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + public int getAvailabilityStatus(int subId) { + return subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; } @@ -74,7 +71,7 @@ public class MobileDataPreferenceController extends TogglePreferenceController @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); - mPreference = (SwitchPreference) screen.findPreference(getPreferenceKey()); + mPreference = screen.findPreference(getPreferenceKey()); } @Override diff --git a/src/com/android/settings/network/telephony/MobileNetworkSettings.java b/src/com/android/settings/network/telephony/MobileNetworkSettings.java index e05f185716a..6d29da19af8 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkSettings.java +++ b/src/com/android/settings/network/telephony/MobileNetworkSettings.java @@ -114,7 +114,7 @@ public class MobileNetworkSettings extends RestrictedDashboardFragment { @Override protected List createPreferenceControllers(Context context) { mSubId = getArguments().getInt(Settings.EXTRA_SUB_ID, - SubscriptionManager.INVALID_SUBSCRIPTION_ID); + MobileNetworkUtils.getSearchableSubscriptionId(context)); if (FeatureFlagPersistent.isEnabled(getContext(), FeatureFlags.NETWORK_INTERNET_V2) && mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { @@ -250,11 +250,6 @@ public class MobileNetworkSettings extends RestrictedDashboardFragment { public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider() { - @Override - protected boolean isPageSearchEnabled(Context context) { - return false; - } - @Override public List getXmlResourcesToIndex(Context context, boolean enabled) { diff --git a/src/com/android/settings/network/telephony/MobileNetworkUtils.java b/src/com/android/settings/network/telephony/MobileNetworkUtils.java index c5cdd3a03ef..8e44dd418ff 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java +++ b/src/com/android/settings/network/telephony/MobileNetworkUtils.java @@ -44,6 +44,8 @@ import com.android.ims.ImsException; import com.android.ims.ImsManager; import com.android.internal.telephony.Phone; import com.android.internal.telephony.PhoneConstants; +import com.android.internal.util.ArrayUtils; +import com.android.settings.core.BasePreferenceController; import java.util.Arrays; import java.util.List; @@ -403,4 +405,52 @@ public class MobileNetworkUtils { } return false; } + + + /** + * Return subId that supported by search. If there are more than one, return first one, + * otherwise return {@link SubscriptionManager#INVALID_SUBSCRIPTION_ID} + */ + public static int getSearchableSubscriptionId(Context context) { + final SubscriptionManager subscriptionManager = context.getSystemService( + SubscriptionManager.class); + final int subIds[] = subscriptionManager.getActiveSubscriptionIdList(); + + return subIds.length >= 1 ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + /** + * Return availability for a default subscription id. If subId already been set, use it to + * check, otherwise traverse all active subIds on device to check. + * @param context context + * @param defSubId Default subId get from telephony preference controller + * @param callback Callback to check availability for a specific subId + * @return Availability + * + * @see BasePreferenceController#getAvailabilityStatus() + */ + public static int getAvailability(Context context, int defSubId, + TelephonyAvailabilityCallback callback) { + final SubscriptionManager subscriptionManager = context.getSystemService( + SubscriptionManager.class); + if (defSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + // If subId has been set, return the corresponding status + return callback.getAvailabilityStatus(defSubId); + } else { + // Otherwise, search whether there is one subId in device that support this preference + final int[] subIds = subscriptionManager.getActiveSubscriptionIdList(); + if (ArrayUtils.isEmpty(subIds)) { + return callback.getAvailabilityStatus( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + } else { + for (final int subId : subIds) { + final int status = callback.getAvailabilityStatus(subId); + if (status == BasePreferenceController.AVAILABLE) { + return status; + } + } + return callback.getAvailabilityStatus(subIds[0]); + } + } + } } diff --git a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java index 0326f42d8c6..27a7bce5bb2 100644 --- a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java +++ b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java @@ -35,38 +35,37 @@ import com.android.settings.core.BasePreferenceController; /** * Preference controller for "Preferred network mode" */ -public class PreferredNetworkModePreferenceController extends BasePreferenceController implements - ListPreference.OnPreferenceChangeListener { +public class PreferredNetworkModePreferenceController extends TelephonyBasePreferenceController + implements ListPreference.OnPreferenceChangeListener { private CarrierConfigManager mCarrierConfigManager; private TelephonyManager mTelephonyManager; private PersistableBundle mPersistableBundle; - private int mSubId; private boolean mIsGlobalCdma; public PreferredNetworkModePreferenceController(Context context, String key) { super(context, key); mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { + public int getAvailabilityStatus(int subId) { + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); boolean visible; - if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { visible = false; - } else if (mPersistableBundle == null) { + } else if (carrierConfig == null) { visible = false; - } else if (mPersistableBundle.getBoolean( + } else if (carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { visible = false; - } else if (mPersistableBundle.getBoolean( + } else if (carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) && !mTelephonyManager.getServiceState().getRoaming() && mTelephonyManager.getServiceState().getDataRegState() == ServiceState.STATE_IN_SERVICE) { visible = false; - } else if (mPersistableBundle.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { + } else if (carrierConfig.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { visible = true; } else { visible = false; @@ -100,13 +99,13 @@ public class PreferredNetworkModePreferenceController extends BasePreferenceCont public void init(int subId) { mSubId = subId; - mPersistableBundle = mCarrierConfigManager.getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; mIsGlobalCdma = isLteOnCdma - && mPersistableBundle.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); + && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); } private int getPreferredNetworkMode() { diff --git a/src/com/android/settings/network/telephony/RoamingPreferenceController.java b/src/com/android/settings/network/telephony/RoamingPreferenceController.java index 688268c7887..4140d5d9709 100644 --- a/src/com/android/settings/network/telephony/RoamingPreferenceController.java +++ b/src/com/android/settings/network/telephony/RoamingPreferenceController.java @@ -42,7 +42,7 @@ import com.android.settingslib.core.lifecycle.events.OnStop; /** * Preference controller for "Roaming" */ -public class RoamingPreferenceController extends TogglePreferenceController implements +public class RoamingPreferenceController extends TelephonyTogglePreferenceController implements LifecycleObserver, OnStart, OnStop { private static final String DIALOG_TAG = "MobileDataDialog"; @@ -50,7 +50,6 @@ public class RoamingPreferenceController extends TogglePreferenceController impl private RestrictedSwitchPreference mSwitchPreference; private TelephonyManager mTelephonyManager; private CarrierConfigManager mCarrierConfigManager; - private int mSubId; private DataContentObserver mDataContentObserver; @VisibleForTesting boolean mNeedDialog; @@ -59,10 +58,8 @@ public class RoamingPreferenceController extends TogglePreferenceController impl public RoamingPreferenceController(Context context, String key) { super(context, key); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper())); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override @@ -78,12 +75,12 @@ public class RoamingPreferenceController extends TogglePreferenceController impl @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); - mSwitchPreference = (RestrictedSwitchPreference) screen.findPreference(getPreferenceKey()); + mSwitchPreference = screen.findPreference(getPreferenceKey()); } @Override - public int getAvailabilityStatus() { - return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + public int getAvailabilityStatus(int subId) { + return subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID ? AVAILABLE : AVAILABLE_UNSEARCHABLE; } diff --git a/src/com/android/settings/network/telephony/TelephonyAvailabilityCallback.java b/src/com/android/settings/network/telephony/TelephonyAvailabilityCallback.java new file mode 100644 index 00000000000..d60bccdbc1f --- /dev/null +++ b/src/com/android/settings/network/telephony/TelephonyAvailabilityCallback.java @@ -0,0 +1,30 @@ +/* + * 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; + +/** + * Callback to decide whether preference is available based on subscription id + */ +public interface TelephonyAvailabilityCallback { + /** + * Return availability status for a specific subId + * + * @see TelephonyBasePreferenceController + * @see TelephonyTogglePreferenceController + */ + int getAvailabilityStatus(int subId); +} diff --git a/src/com/android/settings/network/telephony/TelephonyBasePreferenceController.java b/src/com/android/settings/network/telephony/TelephonyBasePreferenceController.java new file mode 100644 index 00000000000..e4ff5c4c78e --- /dev/null +++ b/src/com/android/settings/network/telephony/TelephonyBasePreferenceController.java @@ -0,0 +1,40 @@ +/* + * 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 android.content.Context; +import android.telephony.SubscriptionManager; + +import com.android.settings.core.BasePreferenceController; + +/** + * {@link BasePreferenceController} that used by all preferences that requires subscription id. + */ +public abstract class TelephonyBasePreferenceController extends BasePreferenceController + implements TelephonyAvailabilityCallback { + protected int mSubId; + + public TelephonyBasePreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + return MobileNetworkUtils.getAvailability(mContext, mSubId, this::getAvailabilityStatus); + } +} diff --git a/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java b/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java new file mode 100644 index 00000000000..71efc57fb5a --- /dev/null +++ b/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java @@ -0,0 +1,40 @@ +/* + * 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 android.content.Context; +import android.telephony.SubscriptionManager; + +import com.android.settings.core.TogglePreferenceController; + +/** + * {@link TogglePreferenceController} that used by all preferences that requires subscription id. + */ +public abstract class TelephonyTogglePreferenceController extends TogglePreferenceController + implements TelephonyAvailabilityCallback { + protected int mSubId; + + public TelephonyTogglePreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + return MobileNetworkUtils.getAvailability(mContext, mSubId, this::getAvailabilityStatus); + } +} diff --git a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java index 1007ef8e03a..44984e65dc3 100644 --- a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java +++ b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java @@ -42,7 +42,7 @@ import com.android.settingslib.core.lifecycle.events.OnStop; /** * Preference controller for "Video Calling" */ -public class VideoCallingPreferenceController extends TogglePreferenceController implements +public class VideoCallingPreferenceController extends TelephonyTogglePreferenceController implements LifecycleObserver, OnStart, OnStop, Enhanced4gLtePreferenceController.On4gLteUpdateListener { @@ -54,21 +54,19 @@ public class VideoCallingPreferenceController extends TogglePreferenceController ImsManager mImsManager; private PhoneCallStateListener mPhoneStateListener; private DataContentObserver mDataContentObserver; - private int mSubId; public VideoCallingPreferenceController(Context context, String key) { super(context, key); mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper())); mPhoneStateListener = new PhoneCallStateListener(Looper.getMainLooper()); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { - return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + public int getAvailabilityStatus(int subId) { + return subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && MobileNetworkUtils.isWifiCallingEnabled(mContext, - SubscriptionManager.getPhoneId(mSubId)) + SubscriptionManager.getPhoneId(subId)) && isVideoCallEnabled() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; diff --git a/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java b/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java index ec9a8412b4b..26c4d06d853 100644 --- a/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java +++ b/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java @@ -33,7 +33,6 @@ import androidx.preference.PreferenceScreen; import com.android.ims.ImsConfig; import com.android.ims.ImsManager; -import com.android.settings.core.BasePreferenceController; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnStart; import com.android.settingslib.core.lifecycle.events.OnStop; @@ -43,7 +42,7 @@ import java.util.List; /** * Preference controller for "Wifi Calling" */ -public class WifiCallingPreferenceController extends BasePreferenceController implements +public class WifiCallingPreferenceController extends TelephonyBasePreferenceController implements LifecycleObserver, OnStart, OnStop { @VisibleForTesting @@ -56,19 +55,17 @@ public class WifiCallingPreferenceController extends BasePreferenceController im PhoneAccountHandle mSimCallManager; private PhoneCallStateListener mPhoneStateListener; private Preference mPreference; - private int mSubId; public WifiCallingPreferenceController(Context context, String key) { super(context, key); mTelephonyManager = context.getSystemService(TelephonyManager.class); mSimCallManager = context.getSystemService(TelecomManager.class).getSimCallManager(); mPhoneStateListener = new PhoneCallStateListener(Looper.getMainLooper()); - mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @Override - public int getAvailabilityStatus() { - return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + public int getAvailabilityStatus(int subId) { + return subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && MobileNetworkUtils.isWifiCallingEnabled(mContext, SubscriptionManager.getPhoneId(mSubId)) ? AVAILABLE diff --git a/tests/robotests/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java b/tests/robotests/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java index 34e680e55f2..7dfe520b614 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java @@ -41,7 +41,6 @@ import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; import com.android.internal.telephony.PhoneConstants; -import com.android.settings.R; import org.junit.Before; import org.junit.Test; @@ -184,4 +183,19 @@ public class MobileNetworkUtilsTest { assertThat(MobileNetworkUtils.isCdmaOptions(mContext, SUB_ID_1)).isTrue(); } + + @Test + public void getSearchableSubscriptionId_oneActive_returnValid() { + when(mSubscriptionManager.getActiveSubscriptionIdList()).thenReturn(new int[]{SUB_ID_1}); + + assertThat(MobileNetworkUtils.getSearchableSubscriptionId(mContext)).isEqualTo(SUB_ID_1); + } + + @Test + public void getSearchableSubscriptionId_nonActive_returnInvalid() { + when(mSubscriptionManager.getActiveSubscriptionIdList()).thenReturn(new int[0]); + + assertThat(MobileNetworkUtils.getSearchableSubscriptionId(mContext)) + .isEqualTo(SubscriptionManager.INVALID_SUBSCRIPTION_ID); + } } diff --git a/tests/robotests/src/com/android/settings/network/telephony/TelephonyBasePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/TelephonyBasePreferenceControllerTest.java new file mode 100644 index 00000000000..886ea177d9f --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/TelephonyBasePreferenceControllerTest.java @@ -0,0 +1,93 @@ +/* + * 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 com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.telephony.SubscriptionManager; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class TelephonyBasePreferenceControllerTest { + private static final int VALID_SUB_ID = 1; + + @Mock + private SubscriptionManager mSubscriptionManager; + + private TestPreferenceController mPreferenceController; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + when(mContext.getSystemService(SubscriptionManager.class)) + .thenReturn(mSubscriptionManager); + when(mSubscriptionManager.getActiveSubscriptionIdList()).thenReturn(new int[]{}); + mPreferenceController = new TestPreferenceController(mContext, "prefKey"); + } + + @Test + public void isAvailable_validSubIdSet_returnTrue() { + mPreferenceController.init(VALID_SUB_ID); + + assertThat(mPreferenceController.isAvailable()).isTrue(); + } + + @Test + public void isAvailable_noIdSetHoweverHasDefaultOne_returnTrue() { + when(mSubscriptionManager.getActiveSubscriptionIdList()) + .thenReturn(new int[]{VALID_SUB_ID}); + + assertThat(mPreferenceController.isAvailable()).isTrue(); + } + + @Test + public void isAvailable_noDefaultAndNoSet_returnFalse() { + assertThat(mPreferenceController.isAvailable()).isFalse(); + } + + /** + * Test preference controller for {@link TelephonyBasePreferenceController} + */ + public class TestPreferenceController extends TelephonyBasePreferenceController { + public TestPreferenceController(Context context, String prefKey) { + super(context, prefKey); + } + + public void init(int subId) { + mSubId = subId; + } + + @Override + public int getAvailabilityStatus(int subId) { + return subId == VALID_SUB_ID ? AVAILABLE : UNSUPPORTED_ON_DEVICE; + } + } +}