Merge "[BackupCall] The toggle doesn't work when try to disable/enable it."... (b1bd0b6d) · Commits · e / os / android_packages_apps_Settings

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

0 → 100644

+289 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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 androidx.lifecycle.Lifecycle.Event;

		import android.content.Context;
		import android.os.PersistableBundle;
		import android.telephony.CarrierConfigManager;
		import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;
		import android.telephony.TelephonyManager;
		import android.telephony.ims.ImsException;
		import android.telephony.ims.ImsManager;
		import android.telephony.ims.ImsMmTelManager;
		import android.util.ArrayMap;
		import android.util.Log;

		import androidx.annotation.VisibleForTesting;
		import androidx.lifecycle.LifecycleObserver;
		import androidx.lifecycle.OnLifecycleEvent;
		import androidx.preference.Preference;
		import androidx.preference.PreferenceGroup;
		import androidx.preference.PreferenceScreen;
		import androidx.preference.SwitchPreference;

		import com.android.settings.R;
		import com.android.settings.network.SubscriptionUtil;
		import com.android.settings.network.SubscriptionsChangeListener;
		import com.android.settings.network.ims.WifiCallingQueryImsState;
		import com.android.settingslib.core.lifecycle.Lifecycle;

		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;

		/**
		* Preference controller for "Backup Calling"
		**/
		public class NetworkProviderBackupCallingGroup extends
		TelephonyTogglePreferenceController implements LifecycleObserver,
		SubscriptionsChangeListener.SubscriptionsChangeListenerClient {
		private static final String TAG = "NetworkProviderBackupCallingGroup";
		private static final String KEY_PREFERENCE_BACKUPCALLING_GROUP =
		"provider_model_backup_call_group";
		private static final int PREF_START_ORDER = 10;

		private String mPreferenceGroupKey;
		private PreferenceGroup mPreferenceGroup;
		private Map<Integer, SwitchPreference> mBackupCallingForSubPreferences;
		private List<SubscriptionInfo> mSubInfoListForBackupCall;
		private Map<Integer, TelephonyManager> mTelephonyManagerList = new HashMap<>();
		private SubscriptionsChangeListener mSubscriptionsChangeListener;

		public NetworkProviderBackupCallingGroup(Context context, Lifecycle lifecycle,
		List<SubscriptionInfo> subscriptionList, String preferenceGroupKey) {
		super(context, preferenceGroupKey);
		mPreferenceGroupKey = preferenceGroupKey;
		mSubInfoListForBackupCall = subscriptionList;
		mBackupCallingForSubPreferences = new ArrayMap<>();
		setSubscriptionInfoList(context);
		lifecycle.addObserver(this);
		}

		@OnLifecycleEvent(Event.ON_RESUME)
		public void onResume() {
		if (mSubscriptionsChangeListener == null) {
		mSubscriptionsChangeListener = new SubscriptionsChangeListener(mContext, this);
		}
		mSubscriptionsChangeListener.start();
		}

		@OnLifecycleEvent(Event.ON_PAUSE)
		public void onPause() {
		if (mSubscriptionsChangeListener != null) {
		mSubscriptionsChangeListener.stop();
		}
		}

		@Override
		public int getAvailabilityStatus(int subId) {
		if (mSubInfoListForBackupCall == null
		\|\| getSubscriptionInfoFromList(mSubInfoListForBackupCall, subId) == null) {
		return CONDITIONALLY_UNAVAILABLE;
		}

		return (mSubInfoListForBackupCall.size() > 1) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
		}

		private boolean setCrossSimCallingEnabled(int subId, boolean checked) {
		ImsMmTelManager imsMmTelMgr = getImsMmTelManager(subId);
		if (imsMmTelMgr == null) {
		Log.d(TAG, "setCrossSimCallingEnabled(), ImsMmTelManager is null");
		return false;
		}

		try {
		imsMmTelMgr.setCrossSimCallingEnabled(checked);
		} catch (ImsException exception) {
		Log.w(TAG, "fail to get cross SIM calling configuration", exception);
		return false;
		}
		return true;
		}

		@Override
		public boolean setChecked(boolean checked) {
		return false;
		}

		private boolean isCrossSimCallingEnabled(int subId) {
		ImsMmTelManager imsMmTelMgr = getImsMmTelManager(subId);
		if (imsMmTelMgr == null) {
		Log.d(TAG, "isCrossSimCallingEnabled(), ImsMmTelManager is null");
		return false;
		}
		try {
		return imsMmTelMgr.isCrossSimCallingEnabled();
		} catch (ImsException exception) {
		Log.w(TAG, "fail to get cross SIM calling configuration", exception);
		}
		return false;
		}

		@Override
		public boolean isChecked() {
		return false;
		}

		@Override
		public void displayPreference(PreferenceScreen screen) {
		mPreferenceGroup = screen.findPreference(mPreferenceGroupKey);
		update();
		}

		@Override
		public void updateState(Preference preference) {
		super.updateState(preference);
		// Do nothing in this case since preference is invisible
		if (preference == null) {
		return;
		}
		update();
		}

		private void update() {
		if (mPreferenceGroup == null) {
		return;
		}

		setSubscriptionInfoList(mContext);
		if (mSubInfoListForBackupCall == null \|\| mSubInfoListForBackupCall.size() < 2) {
		for (SwitchPreference pref : mBackupCallingForSubPreferences.values()) {
		mPreferenceGroup.removePreference(pref);
		}
		mBackupCallingForSubPreferences.clear();
		return;
		}

		Map<Integer, SwitchPreference> toRemovePreferences = mBackupCallingForSubPreferences;
		mBackupCallingForSubPreferences = new ArrayMap<>();
		setSubscriptionInfoForPreference(toRemovePreferences);
		}

		private void setSubscriptionInfoForPreference(
		Map<Integer, SwitchPreference> toRemovePreferences) {
		int order = PREF_START_ORDER;
		for (SubscriptionInfo subInfo : mSubInfoListForBackupCall) {
		final int subId = subInfo.getSubscriptionId();

		SwitchPreference pref = toRemovePreferences.remove(subId);
		if (pref == null) {
		pref = new SwitchPreference(mPreferenceGroup.getContext());
		mPreferenceGroup.addPreference(pref);
		}

		CharSequence displayName = (subInfo == null) ? ""
		: SubscriptionUtil.getUniqueSubscriptionDisplayName(subInfo, mContext);
		pref.setTitle(displayName);
		pref.setOrder(order++);
		pref.setSummary(getSummary(displayName));
		boolean enabled = isCrossSimCallingEnabled(subId);
		pref.setChecked(enabled);
		pref.setOnPreferenceClickListener(clickedPref -> {
		setCrossSimCallingEnabled(subId, !enabled);
		return true;
		});
		mBackupCallingForSubPreferences.put(subId, pref);
		}
		}

		private String getSummary(CharSequence displayName) {
		String summary = String.format(
		getResourcesForSubId().getString(R.string.backup_calling_setting_summary),
		displayName)
		.toString();
		return summary;
		}

		private void setSubscriptionInfoList(Context context) {
		if (mSubInfoListForBackupCall != null) {
		mSubInfoListForBackupCall.removeIf(info -> {
		int subId = info.getSubscriptionId();
		setTelephonyManagerForSubscriptionId(context, subId);
		if (!hasBackupCallingFeature(subId) && mSubInfoListForBackupCall.contains(info)) {
		return true;
		}
		return false;
		});
		} else {
		Log.d(TAG, "No active subscriptions");
		}
		}

		private void setTelephonyManagerForSubscriptionId(Context context, int subId) {
		TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
		.createForSubscriptionId(subId);
		mTelephonyManagerList.put(subId, telephonyManager);
		}

		@VisibleForTesting
		protected boolean hasBackupCallingFeature(int subscriptionId) {
		return isCrossSimEnabledByPlatform(mContext, subscriptionId);
		}

		/**
		* Copied from {@link BackupCallingPreferenceController}
		**/
		@VisibleForTesting
		protected boolean isCrossSimEnabledByPlatform(Context context, int subscriptionId) {
		// TODO : Change into API which created for accessing
		// com.android.ims.ImsManager#isCrossSimEnabledByPlatform()
		if ((new WifiCallingQueryImsState(context, subscriptionId)).isWifiCallingSupported()) {
		PersistableBundle bundle = getCarrierConfigForSubId(subscriptionId);
		return (bundle != null) && bundle.getBoolean(
		CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL,
		false /default/);
		}
		Log.d(TAG, "WifiCalling is not supported by framework. subId = " + subscriptionId);
		return false;
		}

		private ImsMmTelManager getImsMmTelManager(int subId) {
		if (!SubscriptionManager.isUsableSubscriptionId(subId)) {
		return null;
		}
		ImsManager imsMgr = mContext.getSystemService(ImsManager.class);
		return (imsMgr == null) ? null : imsMgr.getImsMmTelManager(subId);
		}

		private SubscriptionInfo getSubscriptionInfoFromList(
		List<SubscriptionInfo> subInfoList, int subId) {
		for (SubscriptionInfo subInfo : subInfoList) {
		if ((subInfo != null) && (subInfo.getSubscriptionId() == subId)) {
		return subInfo;
		}
		}
		return null;
		}

		@Override
		public String getPreferenceKey() {
		return KEY_PREFERENCE_BACKUPCALLING_GROUP;
		}

		@Override
		public void onAirplaneModeChanged(boolean airplaneModeEnabled) {}

		@Override
		public void onSubscriptionsChanged() {
		SubscriptionManager subscriptionManager =
		mContext.getSystemService(SubscriptionManager.class);
		mSubInfoListForBackupCall = SubscriptionUtil.getActiveSubscriptions(subscriptionManager);
		update();
		}
		}

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

+28 −63

Original line number	Diff line number	Diff line
		@@ -20,10 +20,8 @@ import android.content.Context;
		import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;

		import androidx.preference.Preference;
		import androidx.preference.PreferenceCategory;
		import androidx.preference.PreferenceScreen;
		import androidx.preference.SwitchPreference;

		import com.android.settings.core.BasePreferenceController;
		import com.android.settings.network.SubscriptionUtil;
		@@ -31,8 +29,6 @@ import com.android.settingslib.core.lifecycle.Lifecycle;
		import com.android.settingslib.core.lifecycle.LifecycleObserver;

		import java.util.List;
		import java.util.Objects;
		import java.util.stream.Collectors;

		/**
		* Preference controller for "Backup Calling" summary list
		@@ -41,16 +37,24 @@ public class NetworkProviderBackupCallingPreferenceController extends
		BasePreferenceController implements LifecycleObserver {

		private static final String TAG = "NetProvBackupCallingCtrl";
		private static final String KEY_PREFERENCE_CATEGORY = "provider_model_backup_calling_category";

		private Context mContext;
		private PreferenceCategory mPreferenceCategory;
		private PreferenceScreen mPreferenceScreen;
		private NetworkProviderBackupCallingGroup mNetworkProviderBackupCallingGroup;
		private List<SubscriptionInfo> mSubscriptionList;

		/**
		* Preference controller for "Backup Calling" summary list
		*/
		public NetworkProviderBackupCallingPreferenceController(Context context, String key) {
		super(context, key);
		mContext = context;
		}

		protected NetworkProviderBackupCallingGroup createBackupCallingControllerForSub(
		Lifecycle lifecycle, List<SubscriptionInfo> subscriptionList) {
		return new NetworkProviderBackupCallingGroup(mContext, lifecycle, subscriptionList,
		KEY_PREFERENCE_CATEGORY);
		}

		/**
		@@ -59,73 +63,34 @@ public class NetworkProviderBackupCallingPreferenceController extends
		* @param lifecycle Lifecycle of UI which owns this Preference
		*/
		public void init(Lifecycle lifecycle) {
		lifecycle.addObserver(this);
		mSubscriptionList = getActiveSubscriptionList();
		mNetworkProviderBackupCallingGroup = createBackupCallingControllerForSub(lifecycle,
		mSubscriptionList);
		}

		private List<SubscriptionInfo> getActiveSubscriptionList() {
		SubscriptionManager subscriptionManager =
		mContext.getSystemService(SubscriptionManager.class);
		return SubscriptionUtil.getActiveSubscriptions(subscriptionManager);
		}

		@Override
		public int getAvailabilityStatus() {
		List<SubscriptionInfo> subList = getActiveSubscriptions();
		if (subList.size() < 2) {
		if (mNetworkProviderBackupCallingGroup == null
		\|\| mSubscriptionList == null
		\|\| mSubscriptionList.size() < 2) {
		return CONDITIONALLY_UNAVAILABLE;
		} else {
		return AVAILABLE;
		}
		return (getPreferences(subList).size() >= 1) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
		}

		@Override
		public void displayPreference(PreferenceScreen screen) {
		super.displayPreference(screen);

		PreferenceCategory prefCategory = screen.findPreference(getPreferenceKey());
		updatePreferenceList(prefCategory);
		prefCategory.setVisible(isAvailable());
		}

		@Override
		public void updateState(Preference preference) {
		super.updateState(preference);
		// Do nothing in this case since preference is invisible
		if (preference == null) {
		return;
		}
		updatePreferenceList((PreferenceCategory) preference);
		}

		private String getPreferenceKey(int subscriptionId) {
		return getPreferenceKey() + "_subId_" + subscriptionId;
		}

		private SwitchPreference getPreference(SubscriptionInfo subInfo) {
		int subId = subInfo.getSubscriptionId();
		BackupCallingPreferenceController prefCtrl =
		new BackupCallingPreferenceController(mContext, getPreferenceKey(subId));
		prefCtrl.init(subId);
		if (prefCtrl.getAvailabilityStatus(subId) != BasePreferenceController.AVAILABLE) {
		return null;
		}
		SwitchPreference pref = new SwitchPreference(mContext);
		prefCtrl.updateState(pref);
		pref.setTitle(SubscriptionUtil.getUniqueSubscriptionDisplayName(subInfo, mContext));
		return pref;
		}

		private List<SwitchPreference> getPreferences(List<SubscriptionInfo> subList) {
		return subList.stream()
		.map(subInfo -> getPreference(subInfo))
		.filter(Objects::nonNull)
		.collect(Collectors.toList());
		}

		private List<SubscriptionInfo> getActiveSubscriptions() {
		return SubscriptionUtil.getActiveSubscriptions(
		mContext.getSystemService(SubscriptionManager.class));
		}

		private void updatePreferenceList(PreferenceCategory prefCategory) {
		List<SwitchPreference> prefList = getPreferences(getActiveSubscriptions());

		prefCategory.removeAll();
		for (SwitchPreference pref : prefList) {
		prefCategory.addPreference(pref);
		}
		mPreferenceScreen = screen;
		mPreferenceCategory = screen.findPreference(KEY_PREFERENCE_CATEGORY);
		mPreferenceCategory.setVisible(isAvailable());
		mNetworkProviderBackupCallingGroup.displayPreference(screen);
		}
		}

tests/unit/src/com/android/settings/network/telephony/NetworkProviderBackupCallingGroupTest.java

0 → 100644

+173 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.doReturn;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.when;

		import android.content.Context;
		import android.os.Looper;
		import android.os.PersistableBundle;
		import android.telephony.CarrierConfigManager;
		import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;
		import android.telephony.TelephonyManager;
		import android.util.FeatureFlagUtils;
		import android.util.Log;

		import androidx.preference.Preference;
		import androidx.preference.PreferenceGroup;
		import androidx.preference.PreferenceManager;
		import androidx.preference.PreferenceScreen;
		import androidx.preference.SwitchPreference;
		import androidx.test.core.app.ApplicationProvider;
		import androidx.test.ext.junit.runners.AndroidJUnit4;

		import com.android.settings.network.CarrierWifiTogglePreferenceController;
		import com.android.settings.testutils.ResourcesUtils;
		import com.android.settingslib.core.lifecycle.Lifecycle;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		import java.util.List;

		@RunWith(AndroidJUnit4.class)
		public class NetworkProviderBackupCallingGroupTest {

		private static final int SUB_ID_1 = 1;
		private static final int SUB_ID_2 = 2;

		private static final String KEY_PREFERENCE_CATEGORY_BACKUP_CALLING =
		"provider_model_backup_calling_category";
		private static final String DISPLAY_NAME_1 = "Test Display Name 1";
		private static final String DISPLAY_NAME_2 = "Test Display Name 2";

		@Mock
		private PreferenceGroup mPreferenceGroup;
		@Mock
		private CarrierConfigManager mCarrierConfigManager;
		@Mock
		private Lifecycle mLifecycle;
		@Mock
		private SubscriptionManager mSubscriptionManager;
		@Mock
		private SubscriptionInfo mSubscriptionInfo1;
		@Mock
		private SubscriptionInfo mSubscriptionInfo2;
		@Mock
		private List<SubscriptionInfo> mSubscriptionInfoList;
		@Mock
		private TelephonyManager mTelephonyManager1;
		@Mock
		private TelephonyManager mTelephonyManager2;

		@Mock
		private NetworkProviderBackupCallingGroup mNetworkProviderBackupCallingGroup;
		private Context mContext;
		private PersistableBundle mCarrierConfig;
		private PreferenceManager mPreferenceManager;
		private PreferenceScreen mPreferenceScreen;
		private SwitchPreference mSwitchPreference1;
		private SwitchPreference mSwitchPreference2;

		@Before
		public void setUp() throws Exception {
		MockitoAnnotations.initMocks(this);
		mContext = spy(ApplicationProvider.getApplicationContext());
		when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager1);
		when(mTelephonyManager1.createForSubscriptionId(SUB_ID_1)).thenReturn(mTelephonyManager1);
		when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager2);
		when(mTelephonyManager2.createForSubscriptionId(SUB_ID_2)).thenReturn(mTelephonyManager2);
		when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager);
		when(mSubscriptionInfo1.getSubscriptionId()).thenReturn(SUB_ID_1);
		when(mSubscriptionInfo1.getDisplayName()).thenReturn(DISPLAY_NAME_1);
		doReturn(true).when(mNetworkProviderBackupCallingGroup).isCrossSimEnabledByPlatform(
		mContext, SUB_ID_1);
		mSubscriptionInfoList.add(mSubscriptionInfo1);
		when(mSubscriptionInfo2.getSubscriptionId()).thenReturn(SUB_ID_2);
		when(mSubscriptionInfo2.getDisplayName()).thenReturn(DISPLAY_NAME_2);
		doReturn(true).when(mNetworkProviderBackupCallingGroup).isCrossSimEnabledByPlatform(
		mContext, SUB_ID_2);
		mSubscriptionInfoList.add(mSubscriptionInfo2);
		when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(
		mSubscriptionInfoList);

		mCarrierConfig = new PersistableBundle();
		doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID_1);
		mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL,
		true);
		doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID_2);
		mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL,
		true);

		if (Looper.myLooper() == null) {
		Looper.prepare();
		}

		mPreferenceManager = new PreferenceManager(mContext);
		mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext);
		when(mPreferenceGroup.getKey()).thenReturn(KEY_PREFERENCE_CATEGORY_BACKUP_CALLING);
		when(mPreferenceGroup.getPreferenceCount()).thenReturn(2);
		mPreferenceScreen.addPreference(mPreferenceGroup);

		mNetworkProviderBackupCallingGroup = spy(new NetworkProviderBackupCallingGroup(
		mContext, mLifecycle, mSubscriptionInfoList,
		KEY_PREFERENCE_CATEGORY_BACKUP_CALLING));
		}

		@Test
		public void shouldShowBackupCallingForSub_invalidSubId_returnFalse() {
		assertThat(mNetworkProviderBackupCallingGroup.hasBackupCallingFeature(
		SubscriptionManager.INVALID_SUBSCRIPTION_ID)).isEqualTo(false);
		}

		@Test
		public void shouldShowBackupCallingForSub_carrierConfigIsUnavailable_returnFalse() {
		mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL,
		false);

		assertThat(mNetworkProviderBackupCallingGroup.hasBackupCallingFeature(SUB_ID_1))
		.isEqualTo(false);
		}

		@Test
		public void
		shouldShowBackupCallingForSub_crossSimDisabled_returnFalse() {
		FeatureFlagUtils.setEnabled(mContext, FeatureFlagUtils.SETTINGS_PROVIDER_MODEL, true);
		doReturn(false).when(mNetworkProviderBackupCallingGroup).isCrossSimEnabledByPlatform(
		mContext, SUB_ID_1);

		assertThat(mNetworkProviderBackupCallingGroup.hasBackupCallingFeature(SUB_ID_1))
		.isEqualTo(false);
		}

		@Test
		public void shouldBackupCallingForSub_crossSimEnabled_returnTrue() {
		FeatureFlagUtils.setEnabled(mContext, FeatureFlagUtils.SETTINGS_PROVIDER_MODEL, true);
		doReturn(true).when(mNetworkProviderBackupCallingGroup).isCrossSimEnabledByPlatform(
		mContext, SUB_ID_1);

		assertThat(mNetworkProviderBackupCallingGroup.hasBackupCallingFeature(SUB_ID_1))
		.isEqualTo(true);
		}
		}