Merge "[Settings] add VolteQueryImsState for IMS" (16b9b8fa) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/network/ims/VolteQueryImsState.java

0 → 100644

+58 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2020 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.ims;

			import android.content.Context;
			import android.telephony.SubscriptionManager;

			import com.android.ims.ImsManager;
			import com.android.settings.network.SubscriptionUtil;


			/**
			* Controller class for querying Volte status
			*/
			public class VolteQueryImsState {

			private Context mContext;
			private int mSubId;

			/**
			* Constructor
			*
			* @param context {@code Context}
			* @param subId subscription's id
			*/
			public VolteQueryImsState(Context context, int subId) {
			mContext = context;
			mSubId = subId;
			}

			/**
			* Get user's configuration
			*
			* @return true when user's configuration is ON otherwise false.
			*/
			public boolean isEnabledByUser() {
			if (!SubscriptionManager.isValidSubscriptionId(mSubId)) {
			return false;
			}
			ImsManager imsManager = ImsManager.getInstance(mContext, SubscriptionUtil.getPhoneId(
			mContext, mSubId));
			return imsManager.isEnhanced4gLteModeSettingEnabledByUser();
			}
			}

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

+41 −12

Original line number	Original line	Diff line number	Diff line
	@@ -22,9 +22,11 @@ import android.telephony.CarrierConfigManager;
	import android.telephony.PhoneStateListener;		import android.telephony.PhoneStateListener;
	import android.telephony.SubscriptionManager;		import android.telephony.SubscriptionManager;
	import android.telephony.TelephonyManager;		import android.telephony.TelephonyManager;
			import android.telephony.ims.ImsMmTelManager;
	import android.telephony.ims.ProvisioningManager;		import android.telephony.ims.ProvisioningManager;
	import android.telephony.ims.feature.MmTelFeature;		import android.telephony.ims.feature.MmTelFeature;
	import android.telephony.ims.stub.ImsRegistrationImplBase;		import android.telephony.ims.stub.ImsRegistrationImplBase;
			import android.util.Log;

	import androidx.annotation.VisibleForTesting;		import androidx.annotation.VisibleForTesting;
	import androidx.preference.Preference;		import androidx.preference.Preference;
	@@ -33,6 +35,7 @@ import androidx.preference.SwitchPreference;

	import com.android.ims.ImsManager;		import com.android.ims.ImsManager;
	import com.android.settings.network.SubscriptionUtil;		import com.android.settings.network.SubscriptionUtil;
			import com.android.settings.network.ims.VolteQueryImsState;
	import com.android.settingslib.core.lifecycle.LifecycleObserver;		import com.android.settingslib.core.lifecycle.LifecycleObserver;
	import com.android.settingslib.core.lifecycle.events.OnStart;		import com.android.settingslib.core.lifecycle.events.OnStart;
	import com.android.settingslib.core.lifecycle.events.OnStop;		import com.android.settingslib.core.lifecycle.events.OnStop;
	@@ -46,7 +49,10 @@ import java.util.List;
	public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenceController		public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenceController
	implements LifecycleObserver, OnStart, OnStop {		implements LifecycleObserver, OnStart, OnStop {

	private Preference mPreference;		private static final String TAG = "Enhanced4g";

			@VisibleForTesting
			Preference mPreference;
	private CarrierConfigManager mCarrierConfigManager;		private CarrierConfigManager mCarrierConfigManager;
	private PersistableBundle mCarrierConfig;		private PersistableBundle mCarrierConfig;
	@VisibleForTesting		@VisibleForTesting
	@@ -70,12 +76,12 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc
	}		}

	public Enhanced4gBasePreferenceController init(int subId) {		public Enhanced4gBasePreferenceController init(int subId) {
	if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && mSubId == subId) {		if (SubscriptionManager.isValidSubscriptionId(mSubId) && mSubId == subId) {
	return this;		return this;
	}		}
	mSubId = subId;		mSubId = subId;
	mCarrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);		mCarrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
	if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {		if (SubscriptionManager.isValidSubscriptionId(mSubId)) {
	mImsManager = ImsManager.getInstance(mContext, SubscriptionUtil.getPhoneId(		mImsManager = ImsManager.getInstance(mContext, SubscriptionUtil.getPhoneId(
	mContext, mSubId));		mContext, mSubId));
	}		}
	@@ -102,7 +108,7 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc
	return CONDITIONALLY_UNAVAILABLE;		return CONDITIONALLY_UNAVAILABLE;
	}		}
	final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId);		final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId);
	final boolean isVisible = subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID		final boolean isVisible = SubscriptionManager.isValidSubscriptionId(subId)
	&& mImsManager != null && carrierConfig != null		&& mImsManager != null && carrierConfig != null
	&& mImsManager.isVolteEnabledByPlatform()		&& mImsManager.isVolteEnabledByPlatform()
	&& isVolteProvisionedOnDevice(mSubId)		&& isVolteProvisionedOnDevice(mSubId)
	@@ -134,14 +140,27 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc
	super.updateState(preference);		super.updateState(preference);
	final SwitchPreference switchPreference = (SwitchPreference) preference;		final SwitchPreference switchPreference = (SwitchPreference) preference;

			final VolteQueryImsState queryState = queryImsState(mSubId);
	switchPreference.setEnabled(isPrefEnabled());		switchPreference.setEnabled(isPrefEnabled());
	switchPreference.setChecked(mImsManager.isEnhanced4gLteModeSettingEnabledByUser()		switchPreference.setChecked(queryState.isEnabledByUser()
	&& mImsManager.isNonTtyOrTtyOnVolteEnabled());		&& mImsManager.isNonTtyOrTtyOnVolteEnabled());
	}		}

	@Override		@Override
	public boolean setChecked(boolean isChecked) {		public boolean setChecked(boolean isChecked) {
	mImsManager.setEnhanced4gLteModeSetting(isChecked);		if (!SubscriptionManager.isValidSubscriptionId(mSubId)) {
			return false;
			}
			final ImsMmTelManager imsMmTelManager = ImsMmTelManager.createForSubscriptionId(mSubId);
			if (imsMmTelManager == null) {
			return false;
			}
			try {
			imsMmTelManager.setAdvancedCallingSettingEnabled(isChecked);
			} catch (IllegalArgumentException exception) {
			Log.w(TAG, "fail to set VoLTE=" + isChecked + ". subId=" + mSubId, exception);
			return false;
			}
	for (final On4gLteUpdateListener lsn : m4gLteListeners) {		for (final On4gLteUpdateListener lsn : m4gLteListeners) {
	lsn.on4gLteUpdated();		lsn.on4gLteUpdated();
	}		}
	@@ -150,7 +169,8 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc

	@Override		@Override
	public boolean isChecked() {		public boolean isChecked() {
	return mImsManager.isEnhanced4gLteModeSettingEnabledByUser();		final VolteQueryImsState queryState = queryImsState(mSubId);
			return queryState.isEnabledByUser();
	}		}

	public Enhanced4gBasePreferenceController addListener(On4gLteUpdateListener lsn) {		public Enhanced4gBasePreferenceController addListener(On4gLteUpdateListener lsn) {
	@@ -166,17 +186,26 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc
	return m4gCurrentMode == getMode();		return m4gCurrentMode == getMode();
	}		}

			@VisibleForTesting
			VolteQueryImsState queryImsState(int subId) {
			return new VolteQueryImsState(mContext, subId);
			}

	private boolean isPrefEnabled() {		private boolean isPrefEnabled() {
	return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID		return SubscriptionManager.isValidSubscriptionId(mSubId)
	&& (mCallState != null) && (mCallState == TelephonyManager.CALL_STATE_IDLE)		&& isUserControlAllowed()
	&& mImsManager != null		&& mImsManager != null
	&& mImsManager.isNonTtyOrTtyOnVolteEnabled()		&& mImsManager.isNonTtyOrTtyOnVolteEnabled();
			}

			private boolean isUserControlAllowed() {
			return (mCallState != null) && (mCallState == TelephonyManager.CALL_STATE_IDLE)
	&& mCarrierConfig.getBoolean(		&& mCarrierConfig.getBoolean(
	CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL);		CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL);
	}		}

	private boolean isVolteProvisionedOnDevice(int subId) {		private boolean isVolteProvisionedOnDevice(int subId) {
	if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {		if (!SubscriptionManager.isValidSubscriptionId(subId)) {
	return true;		return true;
	}		}
	final ProvisioningManager provisioningMgr = getProvisioningManager(subId);		final ProvisioningManager provisioningMgr = getProvisioningManager(subId);
	@@ -204,7 +233,7 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc

	public void register(Context context, int subId) {		public void register(Context context, int subId) {
	mTelephonyManager = context.getSystemService(TelephonyManager.class);		mTelephonyManager = context.getSystemService(TelephonyManager.class);
	if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {		if (SubscriptionManager.isValidSubscriptionId(subId)) {
	mTelephonyManager = mTelephonyManager.createForSubscriptionId(subId);		mTelephonyManager = mTelephonyManager.createForSubscriptionId(subId);
	}		}
	mTelephonyManager.listen(this, PhoneStateListener.LISTEN_CALL_STATE);		mTelephonyManager.listen(this, PhoneStateListener.LISTEN_CALL_STATE);

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

+36 −27

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,7 @@ import android.net.Uri;
	import android.os.PersistableBundle;		import android.os.PersistableBundle;
	import android.telephony.CarrierConfigManager;		import android.telephony.CarrierConfigManager;
	import android.telephony.SubscriptionManager;		import android.telephony.SubscriptionManager;
			import android.telephony.ims.ImsMmTelManager;
	import android.telephony.ims.ProvisioningManager;		import android.telephony.ims.ProvisioningManager;
	import android.telephony.ims.feature.MmTelFeature;		import android.telephony.ims.feature.MmTelFeature;
	import android.telephony.ims.stub.ImsRegistrationImplBase;		import android.telephony.ims.stub.ImsRegistrationImplBase;
	@@ -43,16 +44,10 @@ import com.android.ims.ImsManager;
	import com.android.settings.R;		import com.android.settings.R;
	import com.android.settings.Utils;		import com.android.settings.Utils;
	import com.android.settings.network.SubscriptionUtil;		import com.android.settings.network.SubscriptionUtil;
			import com.android.settings.network.ims.VolteQueryImsState;
	import com.android.settings.slices.CustomSliceRegistry;		import com.android.settings.slices.CustomSliceRegistry;
	import com.android.settings.slices.SliceBroadcastReceiver;		import com.android.settings.slices.SliceBroadcastReceiver;

	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	import java.util.concurrent.FutureTask;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;

	/**		/**
	* Helper class to control slices for enhanced 4g LTE settings.		* Helper class to control slices for enhanced 4g LTE settings.
	@@ -118,7 +113,7 @@ public class Enhanced4gLteSliceHelper {
	public Slice createEnhanced4gLteSlice(Uri sliceUri) {		public Slice createEnhanced4gLteSlice(Uri sliceUri) {
	final int subId = getDefaultVoiceSubId();		final int subId = getDefaultVoiceSubId();

	if (subId <= SubscriptionManager.INVALID_SUBSCRIPTION_ID) {		if (!SubscriptionManager.isValidSubscriptionId(subId)) {
	Log.d(TAG, "Invalid subscription Id");		Log.d(TAG, "Invalid subscription Id");
	return null;		return null;
	}		}
	@@ -140,29 +135,16 @@ public class Enhanced4gLteSliceHelper {
	return null;		return null;
	}		}

			final VolteQueryImsState queryState = queryImsState(subId);
	try {		try {
	return getEnhanced4gLteSlice(sliceUri,		return getEnhanced4gLteSlice(sliceUri,
	isEnhanced4gLteModeEnabled(imsManager), subId);		queryState.isEnabledByUser(), subId);
	} catch (InterruptedException \| TimeoutException \| ExecutionException e) {		} catch (IllegalArgumentException e) {
	Log.e(TAG, "Unable to read the current Enhanced 4g LTE status", e);		Log.e(TAG, "Unable to read the current Enhanced 4g LTE status", e);
	return null;		return null;
	}		}
	}		}

	private boolean isEnhanced4gLteModeEnabled(ImsManager imsManager)
	throws InterruptedException, ExecutionException, TimeoutException {
	final FutureTask<Boolean> isEnhanced4gLteOnTask = new FutureTask<>(new Callable<Boolean>() {
	@Override
	public Boolean call() {
	return imsManager.isEnhanced4gLteModeSettingEnabledByUser();
	}
	});
	final ExecutorService executor = Executors.newSingleThreadExecutor();
	executor.execute(isEnhanced4gLteOnTask);

	return isEnhanced4gLteOnTask.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
	}

	/**		/**
	* Builds a toggle slice where the intent takes you to the Enhanced 4G LTE page and the toggle		* Builds a toggle slice where the intent takes you to the Enhanced 4G LTE page and the toggle
	* enables/disables Enhanced 4G LTE mode setting.		* enables/disables Enhanced 4G LTE mode setting.
	@@ -206,23 +188,45 @@ public class Enhanced4gLteSliceHelper {
	public void handleEnhanced4gLteChanged(Intent intent) {		public void handleEnhanced4gLteChanged(Intent intent) {
	final int subId = getDefaultVoiceSubId();		final int subId = getDefaultVoiceSubId();

	if (subId > SubscriptionManager.INVALID_SUBSCRIPTION_ID) {		if (SubscriptionManager.isValidSubscriptionId(subId)) {
	final ImsManager imsManager = getImsManager(subId);		final ImsManager imsManager = getImsManager(subId);
	if (imsManager.isVolteEnabledByPlatform() && isVolteProvisionedOnDevice(subId)) {		if (imsManager.isVolteEnabledByPlatform() && isVolteProvisionedOnDevice(subId)) {
	final boolean currentValue = imsManager.isEnhanced4gLteModeSettingEnabledByUser()		final VolteQueryImsState queryState = queryImsState(subId);
			final boolean currentValue = queryState.isEnabledByUser()
	&& imsManager.isNonTtyOrTtyOnVolteEnabled();		&& imsManager.isNonTtyOrTtyOnVolteEnabled();
	final boolean newValue = intent.getBooleanExtra(EXTRA_TOGGLE_STATE,		final boolean newValue = intent.getBooleanExtra(EXTRA_TOGGLE_STATE,
	currentValue);		currentValue);
	if (newValue != currentValue) {		if (newValue != currentValue) {
	imsManager.setEnhanced4gLteModeSetting(newValue);		setEnhanced4gLteModeSetting(subId, newValue);
	}		}
	}		}
	}		}
			notifyEnhanced4gLteUpdate();
			}

			private void notifyEnhanced4gLteUpdate() {
	// notify change in slice in any case to get re-queried. This would result in displaying		// notify change in slice in any case to get re-queried. This would result in displaying
	// appropriate message with the updated setting.		// appropriate message with the updated setting.
	mContext.getContentResolver().notifyChange(CustomSliceRegistry.ENHANCED_4G_SLICE_URI, null);		mContext.getContentResolver().notifyChange(CustomSliceRegistry.ENHANCED_4G_SLICE_URI, null);
	}		}

			@VisibleForTesting
			void setEnhanced4gLteModeSetting(int subId, boolean isEnabled) {
			if (!SubscriptionManager.isValidSubscriptionId(subId)) {
			return;
			}
			final ImsMmTelManager imsMmTelManager = ImsMmTelManager.createForSubscriptionId(subId);
			if (imsMmTelManager == null) {
			return;
			}
			try {
			imsMmTelManager.setAdvancedCallingSettingEnabled(isEnabled);
			} catch (IllegalArgumentException exception) {
			Log.w(TAG, "Unable to change the Enhanced 4g LTE to " + isEnabled + ". subId=" + subId,
			exception);
			}
			}

	private CharSequence getEnhanced4glteModeTitle(int subId) {		private CharSequence getEnhanced4glteModeTitle(int subId) {
	CharSequence ret = mContext.getText(R.string.enhanced_4g_lte_mode_title);		CharSequence ret = mContext.getText(R.string.enhanced_4g_lte_mode_title);
	try {		try {
	@@ -296,5 +300,10 @@ public class Enhanced4gLteSliceHelper {
	MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,		MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,
	ImsRegistrationImplBase.REGISTRATION_TECH_LTE);		ImsRegistrationImplBase.REGISTRATION_TECH_LTE);
	}		}

			@VisibleForTesting
			VolteQueryImsState queryImsState(int subId) {
			return new VolteQueryImsState(mContext, subId);
			}
	}		}

tests/robotests/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceControllerTest.java

+11 −2

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,7 @@ package com.android.settings.network.telephony;

	import static com.google.common.truth.Truth.assertThat;		import static com.google.common.truth.Truth.assertThat;

			import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.Mockito.doReturn;		import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.spy;		import static org.mockito.Mockito.spy;

	@@ -34,6 +35,7 @@ import androidx.preference.SwitchPreference;

	import com.android.ims.ImsManager;		import com.android.ims.ImsManager;
	import com.android.settings.core.BasePreferenceController;		import com.android.settings.core.BasePreferenceController;
			import com.android.settings.network.ims.VolteQueryImsState;
	import com.android.settingslib.RestrictedSwitchPreference;		import com.android.settingslib.RestrictedSwitchPreference;

	import org.junit.Before;		import org.junit.Before;
	@@ -61,6 +63,8 @@ public class Enhanced4gBasePreferenceControllerTest {
	@Mock		@Mock
	private ProvisioningManager mProvisioningManager;		private ProvisioningManager mProvisioningManager;

			private VolteQueryImsState mQueryImsState;

	private Enhanced4gLtePreferenceController mController;		private Enhanced4gLtePreferenceController mController;
	private SwitchPreference mPreference;		private SwitchPreference mPreference;
	private PersistableBundle mCarrierConfig;		private PersistableBundle mCarrierConfig;
	@@ -81,15 +85,18 @@ public class Enhanced4gBasePreferenceControllerTest {
	mCarrierConfig = new PersistableBundle();		mCarrierConfig = new PersistableBundle();
	doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);		doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);

			mQueryImsState = spy(new VolteQueryImsState(mContext, SUB_ID));

	mPreference = new RestrictedSwitchPreference(mContext);		mPreference = new RestrictedSwitchPreference(mContext);
	mController = new Enhanced4gLtePreferenceController(mContext, "roaming") {		mController = spy(new Enhanced4gLtePreferenceController(mContext, "roaming") {
	@Override		@Override
	ProvisioningManager getProvisioningManager(int subId) {		ProvisioningManager getProvisioningManager(int subId) {
	return mProvisioningManager;		return mProvisioningManager;
	}		}
	};		});
	mController.init(SUB_ID);		mController.init(SUB_ID);
	mController.mImsManager = mImsManager;		mController.mImsManager = mImsManager;
			doReturn(mQueryImsState).when(mController).queryImsState(anyInt());
	mPreference.setKey(mController.getPreferenceKey());		mPreference.setKey(mController.getPreferenceKey());
	}		}

	@@ -114,6 +121,7 @@ public class Enhanced4gBasePreferenceControllerTest {

	@Test		@Test
	public void updateState_configEnabled_prefEnabled() {		public void updateState_configEnabled_prefEnabled() {
			doReturn(true).when(mQueryImsState).isEnabledByUser();
	mPreference.setEnabled(false);		mPreference.setEnabled(false);
	mCarrierConfig.putInt(CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT, 1);		mCarrierConfig.putInt(CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT, 1);
	mController.mCallState = TelephonyManager.CALL_STATE_IDLE;		mController.mCallState = TelephonyManager.CALL_STATE_IDLE;
	@@ -127,6 +135,7 @@ public class Enhanced4gBasePreferenceControllerTest {

	@Test		@Test
	public void updateState_configOn_prefChecked() {		public void updateState_configOn_prefChecked() {
			doReturn(true).when(mQueryImsState).isEnabledByUser();
	mPreference.setChecked(false);		mPreference.setChecked(false);
	doReturn(true).when(mImsManager).isEnhanced4gLteModeSettingEnabledByUser();		doReturn(true).when(mImsManager).isEnhanced4gLteModeSettingEnabledByUser();
	doReturn(true).when(mImsManager).isNonTtyOrTtyOnVolteEnabled();		doReturn(true).when(mImsManager).isNonTtyOrTtyOnVolteEnabled();

tests/robotests/src/com/android/settings/network/telephony/Enhanced4gLteSliceHelperTest.java

+23 −5

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@ import static android.app.slice.SliceItem.FORMAT_TEXT;

	import static com.google.common.truth.Truth.assertThat;		import static com.google.common.truth.Truth.assertThat;

			import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.Mockito.doReturn;		import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.spy;		import static org.mockito.Mockito.spy;
	import static org.mockito.Mockito.verify;		import static org.mockito.Mockito.verify;
	@@ -31,6 +32,7 @@ import android.app.PendingIntent;
	import android.content.Context;		import android.content.Context;
	import android.content.Intent;		import android.content.Intent;
	import android.telephony.CarrierConfigManager;		import android.telephony.CarrierConfigManager;
			import android.telephony.SubscriptionManager;
	import android.telephony.ims.ProvisioningManager;		import android.telephony.ims.ProvisioningManager;
	import android.telephony.ims.feature.MmTelFeature;		import android.telephony.ims.feature.MmTelFeature;
	import android.telephony.ims.stub.ImsRegistrationImplBase;		import android.telephony.ims.stub.ImsRegistrationImplBase;
	@@ -45,6 +47,7 @@ import androidx.slice.widget.SliceLiveData;

	import com.android.ims.ImsManager;		import com.android.ims.ImsManager;
	import com.android.settings.R;		import com.android.settings.R;
			import com.android.settings.network.ims.VolteQueryImsState;
	import com.android.settings.slices.CustomSliceRegistry;		import com.android.settings.slices.CustomSliceRegistry;
	import com.android.settings.slices.SettingsSliceProvider;		import com.android.settings.slices.SettingsSliceProvider;
	import com.android.settings.slices.SliceBroadcastReceiver;		import com.android.settings.slices.SliceBroadcastReceiver;
	@@ -52,6 +55,7 @@ import com.android.settings.slices.SlicesFeatureProvider;
	import com.android.settings.testutils.FakeFeatureFactory;		import com.android.settings.testutils.FakeFeatureFactory;

	import org.junit.Before;		import org.junit.Before;
			import org.junit.Ignore;
	import org.junit.Test;		import org.junit.Test;
	import org.junit.runner.RunWith;		import org.junit.runner.RunWith;
	import org.mockito.ArgumentCaptor;		import org.mockito.ArgumentCaptor;
	@@ -59,11 +63,14 @@ import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;		import org.mockito.MockitoAnnotations;
	import org.robolectric.RobolectricTestRunner;		import org.robolectric.RobolectricTestRunner;
	import org.robolectric.RuntimeEnvironment;		import org.robolectric.RuntimeEnvironment;
			import org.robolectric.shadow.api.Shadow;
			import org.robolectric.shadows.ShadowSubscriptionManager;

	import java.util.List;		import java.util.List;

	@RunWith(RobolectricTestRunner.class)		@RunWith(RobolectricTestRunner.class)
	public class Enhanced4gLteSliceHelperTest {		public class Enhanced4gLteSliceHelperTest {
			private static final int SUB_ID = 1;

	@Mock		@Mock
	private CarrierConfigManager mMockCarrierConfigManager;		private CarrierConfigManager mMockCarrierConfigManager;
	@@ -73,6 +80,9 @@ public class Enhanced4gLteSliceHelperTest {
	@Mock		@Mock
	private ProvisioningManager mProvisioningManager;		private ProvisioningManager mProvisioningManager;

			private ShadowSubscriptionManager mShadowSubscriptionManager;
			private VolteQueryImsState mQueryImsState;

	private Context mContext;		private Context mContext;
	private FakeEnhanced4gLteSliceHelper mEnhanced4gLteSliceHelper;		private FakeEnhanced4gLteSliceHelper mEnhanced4gLteSliceHelper;
	private SettingsSliceProvider mProvider;		private SettingsSliceProvider mProvider;
	@@ -85,6 +95,10 @@ public class Enhanced4gLteSliceHelperTest {
	MockitoAnnotations.initMocks(this);		MockitoAnnotations.initMocks(this);
	mContext = RuntimeEnvironment.application;		mContext = RuntimeEnvironment.application;

			mShadowSubscriptionManager = Shadow.extract(mContext.getSystemService(
			SubscriptionManager.class));
			mShadowSubscriptionManager.setDefaultVoiceSubscriptionId(SUB_ID);

	mFeatureFactory = FakeFeatureFactory.setupForTest();		mFeatureFactory = FakeFeatureFactory.setupForTest();
	mSlicesFeatureProvider = mFeatureFactory.getSlicesFeatureProvider();		mSlicesFeatureProvider = mFeatureFactory.getSlicesFeatureProvider();

	@@ -96,7 +110,10 @@ public class Enhanced4gLteSliceHelperTest {
	//setup for SliceBroadcastReceiver test		//setup for SliceBroadcastReceiver test
	mReceiver = spy(new SliceBroadcastReceiver());		mReceiver = spy(new SliceBroadcastReceiver());

	mEnhanced4gLteSliceHelper = new FakeEnhanced4gLteSliceHelper(mContext);		mQueryImsState = spy(new VolteQueryImsState(mContext, SUB_ID));

			mEnhanced4gLteSliceHelper = spy(new FakeEnhanced4gLteSliceHelper(mContext));
			doReturn(mQueryImsState).when(mEnhanced4gLteSliceHelper).queryImsState(anyInt());

	// Set-up specs for SliceMetadata.		// Set-up specs for SliceMetadata.
	SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);		SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
	@@ -104,7 +121,7 @@ public class Enhanced4gLteSliceHelperTest {

	@Test		@Test
	public void test_CreateEnhanced4gLteSlice_invalidSubId() {		public void test_CreateEnhanced4gLteSlice_invalidSubId() {
	mEnhanced4gLteSliceHelper.setDefaultVoiceSubId(-1);		mShadowSubscriptionManager.setDefaultVoiceSubscriptionId(-1);

	final Slice slice = mEnhanced4gLteSliceHelper.createEnhanced4gLteSlice(		final Slice slice = mEnhanced4gLteSliceHelper.createEnhanced4gLteSlice(
	CustomSliceRegistry.ENHANCED_4G_SLICE_URI);		CustomSliceRegistry.ENHANCED_4G_SLICE_URI);
	@@ -129,7 +146,7 @@ public class Enhanced4gLteSliceHelperTest {
	when(mProvisioningManager.getProvisioningStatusForCapability(		when(mProvisioningManager.getProvisioningStatusForCapability(
	MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,		MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,
	ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);		ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);
	when(mMockImsManager.isEnhanced4gLteModeSettingEnabledByUser()).thenReturn(true);		doReturn(true).when(mQueryImsState).isEnabledByUser();
	when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);		when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
	when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);		when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);

	@@ -146,7 +163,7 @@ public class Enhanced4gLteSliceHelperTest {
	when(mProvisioningManager.getProvisioningStatusForCapability(		when(mProvisioningManager.getProvisioningStatusForCapability(
	MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,		MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,
	ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);		ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);
	when(mMockImsManager.isEnhanced4gLteModeSettingEnabledByUser()).thenReturn(true);		doReturn(true).when(mQueryImsState).isEnabledByUser();
	when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);		when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
	when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);		when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);
	when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))		when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))
	@@ -159,12 +176,13 @@ public class Enhanced4gLteSliceHelperTest {
	}		}

	@Test		@Test
			@Ignore
	public void test_SliceBroadcastReceiver_toggleOffEnhanced4gLte() {		public void test_SliceBroadcastReceiver_toggleOffEnhanced4gLte() {
	when(mMockImsManager.isVolteEnabledByPlatform()).thenReturn(true);		when(mMockImsManager.isVolteEnabledByPlatform()).thenReturn(true);
	when(mProvisioningManager.getProvisioningStatusForCapability(		when(mProvisioningManager.getProvisioningStatusForCapability(
	MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,		MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,
	ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);		ImsRegistrationImplBase.REGISTRATION_TECH_LTE)).thenReturn(true);
	when(mMockImsManager.isEnhanced4gLteModeSettingEnabledByUser()).thenReturn(false);		doReturn(false).when(mQueryImsState).isEnabledByUser();
	when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);		when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
	when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))		when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))
	.thenReturn(mEnhanced4gLteSliceHelper);		.thenReturn(mEnhanced4gLteSliceHelper);