PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Align with the visibility logic from Dialer" into sc-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2021-07-02 16:17:09 +00:00
committed by Android (Google) Code Review
parent d5f9f65390 770f064d36
commit 6d06f9bcad
3 changed files with 158 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/com/android/settings/accessibility/RTTSettingPreferenceController.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 The Android Open Source Project
* 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.
@@ -22,28 +22,32 @@ import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.PersistableBundle;
import android.provider.Settings;
import android.telecom.TelecomManager;
import android.telecom.PhoneAccount;
import android.telecom.PhoneAccountHandle;
import android.telephony.CarrierConfigManager;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.accessibility.rtt.TelecomUtil;
import com.android.settings.core.BasePreferenceController;
import java.util.List;
/** A controller to control the status for RTT setting in Accessibility screen.*/
/** A controller to control the status for RTT setting in Accessibility screen. */
public class RTTSettingPreferenceController extends BasePreferenceController {
private static final String TAG = "RTTSettingsCtr";
private static final String DIALER_RTT_CONFIGURATION = "dialer_rtt_configuration";
private final Context mContext;
private final PackageManager mPackageManager;
private final TelecomManager mTelecomManager;
private final CarrierConfigManager mCarrierConfigManager;
private final CharSequence[] mModes;
private final String mDialerPackage;
@@ -55,17 +59,17 @@ public class RTTSettingPreferenceController extends BasePreferenceController {
mContext = context;
mModes = mContext.getResources().getTextArray(R.array.rtt_setting_mode);
mDialerPackage = mContext.getString(R.string.config_rtt_setting_package_name);
mPackageManager = context.getPackageManager();
mTelecomManager = context.getSystemService(TelecomManager.class);
mPackageManager = mContext.getPackageManager();
mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class);
mRTTIntent = new Intent(context.getString(R.string.config_rtt_setting_intent_action));
Log.d(TAG, "init controller");
}
@Override
public int getAvailabilityStatus() {
final List<ResolveInfo> resolved =
mPackageManager.queryIntentActivities(mRTTIntent, 0 /* flags */);
return resolved != null && !resolved.isEmpty() && isDialerSupportRTTSetting()
return resolved != null && !resolved.isEmpty() && isRttSettingSupported()
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@@ -80,17 +84,55 @@ public class RTTSettingPreferenceController extends BasePreferenceController {
@Override
public CharSequence getSummary() {
final int option = Settings.Secure.getInt(mContext.getContentResolver(),
DIALER_RTT_CONFIGURATION, 1 /* not visible */);
DIALER_RTT_CONFIGURATION, 0 /* Invalid value */);
Log.d(TAG, "DIALER_RTT_CONFIGURATION value = " + option);
return mModes[option];
}
private boolean isDialerSupportRTTSetting() {
final TelephonyManager telephonyManager = createTelephonyManagerFromSubId();
final boolean isCarrierAndRttSupported = telephonyManager.isRttSupported()
&& getBooleanCarrierConfig(CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL);
@VisibleForTesting
boolean isRttSettingSupported() {
Log.d(TAG, "isRttSettingSupported [start]");
if (!isDefaultDialerSupportedRTT(mContext)) {
Log.d(TAG, "Dialer doesn't support RTT.");
return false;
}
// At least one PhoneAccount must have both isRttSupported and
// ignore_rtt_mode_setting_bool being true
for (PhoneAccountHandle phoneAccountHandle :
TelecomUtil.getCallCapablePhoneAccounts(mContext)) {
final int subId =
TelecomUtil.getSubIdForPhoneAccountHandle(mContext, phoneAccountHandle);
Log.d(TAG, "subscription id for the device: " + subId);
return isCarrierAndRttSupported
&& TextUtils.equals(mTelecomManager.getDefaultDialerPackage(), mDialerPackage);
final boolean isRttCallingSupported = isRttSupportedByTelecom(phoneAccountHandle);
Log.d(TAG, "rtt calling supported by telecom:: " + isRttCallingSupported);
if (isRttCallingSupported) {
PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId);
// If IGNORE_RTT_MODE_SETTING_BOOL=true, RTT visibility is not supported because
// this means we must use the legacy Telecom setting, which does not support RTT
// visibility.
if (carrierConfig != null
&& getBooleanCarrierConfig(
CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL)) {
Log.d(TAG, "RTT visibility setting is supported.");
return true;
}
Log.d(TAG, "IGNORE_RTT_MODE_SETTING_BOOL is false.");
}
}
Log.d(TAG, "isRttSettingSupported [Not support]");
return false;
}
private boolean isRttSupportedByTelecom(PhoneAccountHandle phoneAccountHandle) {
PhoneAccount phoneAccount =
TelecomUtil.getTelecomManager(mContext).getPhoneAccount(phoneAccountHandle);
if (phoneAccount != null && phoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_RTT)) {
Log.d(TAG, "Phone account has RTT capability.");
return true;
}
return false;
}
/**
@@ -100,25 +142,24 @@ public class RTTSettingPreferenceController extends BasePreferenceController {
* @return boolean value of corresponding key.
*/
private boolean getBooleanCarrierConfig(String key) {
final CarrierConfigManager configManager =
mContext.getSystemService(CarrierConfigManager.class);
if (configManager == null) {
if (mCarrierConfigManager == 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);
final PersistableBundle bundle = mCarrierConfigManager.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);
/** Returns whether is a correct default dialer which supports RTT. */
private static boolean isDefaultDialerSupportedRTT(Context context) {
return TextUtils.equals(
context.getString(R.string.config_rtt_setting_package_name),
TelecomUtil.getTelecomManager(context).getDefaultDialerPackage());
}
}

81
src/com/android/settings/accessibility/rtt/TelecomUtil.java Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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.accessibility.rtt;
import android.content.Context;
import android.telecom.PhoneAccountHandle;
import android.telecom.TelecomManager;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.text.TextUtils;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
/**
* A util class checks some SIM card information and permissions.
*/
public abstract class TelecomUtil {
private static final String TAG = "TelecomUtil";
/** Get a list of phone accounts which are call capable. */
public static List<PhoneAccountHandle> getCallCapablePhoneAccounts(Context context) {
return Optional.ofNullable(getTelecomManager(context).getCallCapablePhoneAccounts())
.orElse(new ArrayList<>());
}
/** Returns a {@link TelecomManager} instance. */
public static TelecomManager getTelecomManager(Context context) {
return context.getApplicationContext().getSystemService(TelecomManager.class);
}
/** Returns a subscription id of the SIM. */
public static int getSubIdForPhoneAccountHandle(
Context context, PhoneAccountHandle phoneAccountHandle) {
Optional<SubscriptionInfo> info = getSubscriptionInfo(context, phoneAccountHandle);
return info.map(SubscriptionInfo::getSubscriptionId)
.orElse(SubscriptionManager.INVALID_SUBSCRIPTION_ID);
}
/**
* @return the {@link SubscriptionInfo} of the SIM if {@code phoneAccountHandle} corresponds
* to a valid SIM. Absent otherwise.
*/
private static Optional<SubscriptionInfo> getSubscriptionInfo(
Context context, PhoneAccountHandle phoneAccountHandle) {
if (TextUtils.isEmpty(phoneAccountHandle.getId())) {
return Optional.empty();
}
SubscriptionManager subscriptionManager = context.getSystemService(
SubscriptionManager.class);
List<SubscriptionInfo> subscriptionInfos =
subscriptionManager.getActiveSubscriptionInfoList();
if (subscriptionInfos == null) {
return Optional.empty();
}
for (SubscriptionInfo info : subscriptionInfos) {
if (phoneAccountHandle.getId().startsWith(info.getIccId())) {
return Optional.of(info);
}
}
Log.d(TAG, "Failed to find SubscriptionInfo for phoneAccountHandle");
return Optional.empty();
}
}

63
tests/robotests/src/com/android/settings/accessibility/RTTSettingPreferenceControllerTest.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 The Android Open Source Project
* 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.
@@ -25,22 +25,15 @@ 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.shadows.ShadowPackageManager;
@@ -51,72 +44,40 @@ public class RTTSettingPreferenceControllerTest {
private ShadowPackageManager mShadowPackageManager;
private RTTSettingPreferenceController mController;
private TelephonyManager mTelephonyManagerFromSubId;
@Mock
private PersistableBundle mPersistableBundle;
@Before
public void setUp() {
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 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 getStatus_rttSupported_settingsIntent_unsupported() {
doReturn(true).when(mTelephonyManagerFromSubId).isRttSupported();
doReturn(false).when(mPersistableBundle).getBoolean(
CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL);
setupTestIntent();
public void getAvailabilityStatus_resolvedIsEmpty_shouldReturnUNSUPPORTED_ON_DEVICE() {
doReturn(true).when(mController).isRttSettingSupported();
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getStatus_settingsIntent_unsupported() {
doReturn(false).when(mTelephonyManagerFromSubId).isRttSupported();
public void getAvailabilityStatus_intentIsHandledButRttSettingNotSupported_returnAVAILABLE() {
setupTestIntent();
doReturn(false).when(mController).isRttSettingSupported();
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getStatus_unsupported() {
doReturn(false).when(mTelephonyManagerFromSubId).isRttSupported();
public void getAvailabilityStatus_intentCanBeHandledAndRttSettingSupported_returnAVAILABLE() {
setupTestIntent();
doReturn(true).when(mController).isRttSettingSupported();
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
private void setupTestIntent() {