From d43fcdaf495a9bdebd20235f16b80bd8b648556c Mon Sep 17 00:00:00 2001 From: Peter_Liang Date: Thu, 20 Aug 2020 21:52:11 +0800 Subject: [PATCH] Fix the Real Time Text option was shown in accessibility settings under active Fi. Root cause: Only using and querying the dialer intent can't be represented for supporting RTT. Next action: Add one checker for carrier config. Bug: 159242323 Test: manual test for AT&T, Google Fi, chunghwa sim & make RunSettingsRoboTests ROBOTEST_FILTER=RTTSettingPreferenceControllerTest Change-Id: I8e85b9fdfc658ea6855a4041691efdbfd07c62d6 --- .../RTTSettingPreferenceController.java | 44 +++++++++- .../RTTSettingPreferenceControllerTest.java | 85 +++++++++++++------ 2 files changed, 101 insertions(+), 28 deletions(-) diff --git a/src/com/android/settings/accessibility/RTTSettingPreferenceController.java b/src/com/android/settings/accessibility/RTTSettingPreferenceController.java index 3b5915d43d7..22c3047d302 100644 --- a/src/com/android/settings/accessibility/RTTSettingPreferenceController.java +++ b/src/com/android/settings/accessibility/RTTSettingPreferenceController.java @@ -20,8 +20,12 @@ import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; +import android.os.PersistableBundle; import android.provider.Settings; import android.telecom.TelecomManager; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; import android.text.TextUtils; import androidx.annotation.VisibleForTesting; @@ -37,7 +41,6 @@ import java.util.List; public class RTTSettingPreferenceController extends BasePreferenceController { private static final String DIALER_RTT_CONFIGURATION = "dialer_rtt_configuration"; - private final Context mContext; private final PackageManager mPackageManager; private final TelecomManager mTelecomManager; @@ -81,8 +84,41 @@ public class RTTSettingPreferenceController extends BasePreferenceController { return mModes[option]; } - @VisibleForTesting - boolean isDialerSupportRTTSetting() { - return TextUtils.equals(mTelecomManager.getDefaultDialerPackage(), mDialerPackage); + private boolean isDialerSupportRTTSetting() { + final TelephonyManager telephonyManager = createTelephonyManagerFromSubId(); + final boolean isCarrierAndRttSupported = telephonyManager.isRttSupported() + && getBooleanCarrierConfig(CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL); + + return isCarrierAndRttSupported + && TextUtils.equals(mTelecomManager.getDefaultDialerPackage(), mDialerPackage); + } + + /** + * Gets the boolean config from carrier config manager. + * + * @param key config key defined in CarrierConfigManager. + * @return boolean value of corresponding key. + */ + private boolean getBooleanCarrierConfig(String key) { + final CarrierConfigManager configManager = + mContext.getSystemService(CarrierConfigManager.class); + if (configManager == null) { + // Return static default defined in CarrierConfigManager. + return CarrierConfigManager.getDefaultConfig().getBoolean(key); + } + + // If an invalid subId is used, this bundle will contain default values. + final int subId = SubscriptionManager.getDefaultVoiceSubscriptionId(); + final PersistableBundle bundle = configManager.getConfigForSubId(subId); + + return bundle != null + ? bundle.getBoolean(key) + : CarrierConfigManager.getDefaultConfig().getBoolean(key); + } + + private TelephonyManager createTelephonyManagerFromSubId() { + final TelephonyManager telephonyManager = mContext.getSystemService(TelephonyManager.class); + final int subId = SubscriptionManager.getDefaultVoiceSubscriptionId(); + return telephonyManager.createForSubscriptionId(subId); } } diff --git a/tests/robotests/src/com/android/settings/accessibility/RTTSettingPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/RTTSettingPreferenceControllerTest.java index 6f3f77d49b4..5a90098ca6f 100644 --- a/tests/robotests/src/com/android/settings/accessibility/RTTSettingPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/RTTSettingPreferenceControllerTest.java @@ -25,67 +25,104 @@ import static org.robolectric.Shadows.shadowOf; import android.content.Context; import android.content.Intent; import android.content.pm.ResolveInfo; +import android.os.PersistableBundle; +import android.telecom.TelecomManager; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import androidx.test.core.app.ApplicationProvider; + +import com.android.settings.R; import com.android.settings.core.BasePreferenceController; import com.android.settings.testutils.ResolveInfoBuilder; 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; import org.robolectric.shadows.ShadowPackageManager; +/** Tests for {@link RTTSettingPreferenceController}. */ @RunWith(RobolectricTestRunner.class) public class RTTSettingPreferenceControllerTest { - private Context mContext; private ShadowPackageManager mShadowPackageManager; private RTTSettingPreferenceController mController; + private TelephonyManager mTelephonyManagerFromSubId; + + @Mock + private PersistableBundle mPersistableBundle; @Before public void setUp() { - mContext = RuntimeEnvironment.application; - mShadowPackageManager = shadowOf(mContext.getPackageManager()); - mController = spy(new RTTSettingPreferenceController(mContext, "rtt_setting")); + MockitoAnnotations.initMocks(this); + + final Context context = spy(ApplicationProvider.getApplicationContext()); + final int subId = SubscriptionManager.getDefaultVoiceSubscriptionId(); + final String rttSettingsPackageName = + context.getString(R.string.config_rtt_setting_package_name); + final CarrierConfigManager configManager = spy(new CarrierConfigManager(context)); + final TelephonyManager telephonyManager = spy(new TelephonyManager(context)); + final TelecomManager telecomManager = spy(new TelecomManager(context)); + mTelephonyManagerFromSubId = spy(new TelephonyManager(context, subId)); + doReturn(telephonyManager).when(context).getSystemService(TelephonyManager.class); + doReturn(mTelephonyManagerFromSubId).when(telephonyManager).createForSubscriptionId(subId); + doReturn(telecomManager).when(context).getSystemService(TelecomManager.class); + doReturn(configManager).when(context).getSystemService(CarrierConfigManager.class); + doReturn(mPersistableBundle).when(configManager).getConfigForSubId(subId); + doReturn(rttSettingsPackageName).when(telecomManager).getDefaultDialerPackage(); + + mShadowPackageManager = shadowOf(context.getPackageManager()); + mController = spy(new RTTSettingPreferenceController(context, "rtt_setting")); mController.mRTTIntent = new Intent("com.android.test.action.example"); } @Test - public void getAvailabilityStatus_defaultDialerIsExpected_intentCanBeHandled_returnAVAILABLE() { - // Default dialer is expected. - doReturn(true).when(mController).isDialerSupportRTTSetting(); - // Intent can be handled. - final ResolveInfo info = new ResolveInfoBuilder("pkg") - .setActivity("pkg", "class").build(); - final Intent intent = new Intent("com.android.test.action.example"); - mShadowPackageManager.addResolveInfoForIntent(intent, info); + public void getStatus_carrierAndRttSupported_settingsIntent_available() { + doReturn(true).when(mTelephonyManagerFromSubId).isRttSupported(); + doReturn(true).when(mPersistableBundle).getBoolean( + CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL); + setupTestIntent(); assertThat(mController.getAvailabilityStatus()) .isEqualTo(BasePreferenceController.AVAILABLE); } @Test - public void getAvailabilityStatus_intentCanNotBeHandled_shouldReturnUNSUPPORTED_ON_DEVICE() { - // Default dialer is expected. - doReturn(true).when(mController).isDialerSupportRTTSetting(); - // Intent can not be handled. + public void getStatus_rttSupported_settingsIntent_unsupported() { + doReturn(true).when(mTelephonyManagerFromSubId).isRttSupported(); + doReturn(false).when(mPersistableBundle).getBoolean( + CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL); + setupTestIntent(); assertThat(mController.getAvailabilityStatus()) .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE); } @Test - public void getAvailabilityStatus_defaultDialerIsNotExpected_returnUNSUPPORTED_ON_DEVICE() { - // Default dialer is not expected. - doReturn(false).when(mController).isDialerSupportRTTSetting(); - // Intent can be handled. + public void getStatus_settingsIntent_unsupported() { + doReturn(false).when(mTelephonyManagerFromSubId).isRttSupported(); + setupTestIntent(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.UNSUPPORTED_ON_DEVICE); + } + + @Test + public void getStatus_unsupported() { + doReturn(false).when(mTelephonyManagerFromSubId).isRttSupported(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.UNSUPPORTED_ON_DEVICE); + } + + private void setupTestIntent() { final ResolveInfo info = new ResolveInfoBuilder("pkg") .setActivity("pkg", "class").build(); final Intent intent = new Intent("com.android.test.action.example"); mShadowPackageManager.addResolveInfoForIntent(intent, info); - - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE); } }