diff --git a/res/layout/wifi_add_network_view.xml b/res/layout/wifi_add_network_view.xml index 8c23020fcb8..d698adfc06c 100644 --- a/res/layout/wifi_add_network_view.xml +++ b/res/layout/wifi_add_network_view.xml @@ -15,36 +15,16 @@ limitations under the License. --> - - + - - + android:orientation="vertical"> + - - - - - \ No newline at end of file + + + diff --git a/res/layout/wifi_dialog.xml b/res/layout/wifi_dialog.xml index b2cdbc9b048..95299932d66 100644 --- a/res/layout/wifi_dialog.xml +++ b/res/layout/wifi_dialog.xml @@ -15,694 +15,10 @@ --> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + diff --git a/res/layout/wifi_network_config.xml b/res/layout/wifi_network_config.xml new file mode 100644 index 00000000000..f91f7385c17 --- /dev/null +++ b/res/layout/wifi_network_config.xml @@ -0,0 +1,699 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/res/values/strings.xml b/res/values/strings.xml index 68a035f4f16..c732dd8a0e3 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -1291,11 +1291,9 @@ In addition to unlocking your phone, you can also use your fingerprint to authorize purchases and app access. Learn more - - The screen lock option is disabled. To learn more, contact your organization\'s admin. - More details\n\nYou can still use your - fingerprint to authorize purchases and app access. - Learn more + The screen lock option is disabled. To learn more, contact your organization\u2019s admin. + + You can still use your fingerprint to authorize purchases and app access. Lift finger, then touch sensor again @@ -1622,6 +1620,13 @@ Must contain at least %d character Must be at least %d characters + + + {count, plural, + =1 {If using only numbers, must be at least 1 digit} + other {If using only numbers, must be at least # digits} + } + PIN must contain at least %d digit diff --git a/res/xml/accessibility_settings_for_setup_wizard.xml b/res/xml/accessibility_settings_for_setup_wizard.xml index 6929d544a87..0926d2d3008 100644 --- a/res/xml/accessibility_settings_for_setup_wizard.xml +++ b/res/xml/accessibility_settings_for_setup_wizard.xml @@ -48,12 +48,4 @@ android:persistent="true" android:summary="@string/talkback_summary"/> - - diff --git a/src/com/android/settings/applications/appinfo/AppBatteryPreferenceController.java b/src/com/android/settings/applications/appinfo/AppBatteryPreferenceController.java index 3cb22e07b61..d69c2c880cc 100644 --- a/src/com/android/settings/applications/appinfo/AppBatteryPreferenceController.java +++ b/src/com/android/settings/applications/appinfo/AppBatteryPreferenceController.java @@ -45,6 +45,7 @@ import com.android.settings.fuelgauge.BatteryUsageStatsLoader; import com.android.settings.fuelgauge.BatteryUtils; import com.android.settings.fuelgauge.PowerUsageFeatureProvider; import com.android.settings.overlay.FeatureFactory; +import com.android.settingslib.applications.AppUtils; import com.android.settingslib.core.lifecycle.Lifecycle; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnPause; @@ -71,9 +72,10 @@ public class AppBatteryPreferenceController extends BasePreferenceController BatteryDiffEntry mBatteryDiffEntry; @VisibleForTesting boolean mIsChartGraphEnabled; + @VisibleForTesting + final AppInfoDashboardFragment mParent; private Preference mPreference; - private final AppInfoDashboardFragment mParent; private String mBatteryPercent; private final String mPackageName; private final int mUid; @@ -107,6 +109,11 @@ public class AppBatteryPreferenceController extends BasePreferenceController super.displayPreference(screen); mPreference = screen.findPreference(getPreferenceKey()); mPreference.setEnabled(false); + if (!AppUtils.isAppInstalled(mParent.getAppEntry())) { + mPreference.setSummary(""); + return; + } + loadBatteryDiffEntries(); } diff --git a/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceController.java b/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceController.java index 6a254cbd8c2..e82732551c0 100644 --- a/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceController.java +++ b/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceController.java @@ -20,6 +20,7 @@ import android.content.Context; import android.net.NetworkStats; import android.net.NetworkTemplate; import android.os.Bundle; +import android.os.Process; import android.text.format.DateUtils; import android.text.format.Formatter; @@ -35,6 +36,7 @@ import com.android.settings.Utils; import com.android.settings.datausage.AppDataUsage; import com.android.settings.datausage.DataUsageUtils; import com.android.settingslib.AppItem; +import com.android.settingslib.applications.AppUtils; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnPause; import com.android.settingslib.core.lifecycle.events.OnResume; @@ -61,6 +63,7 @@ public class AppDataUsagePreferenceController extends AppInfoPreferenceControlle @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); + mPreference.setEnabled(AppUtils.isAppInstalled(mAppEntry)); } @Override @@ -89,11 +92,19 @@ public class AppDataUsagePreferenceController extends AppInfoPreferenceControlle @Override public Loader> onCreateLoader(int id, Bundle args) { final NetworkTemplate template = getTemplate(mContext); - return NetworkCycleDataForUidLoader.builder(mContext) - .addUid(mParent.getAppEntry().info.uid) - .setRetrieveDetail(false) - .setNetworkTemplate(template) - .build(); + final int uid = mParent.getAppEntry().info.uid; + + final NetworkCycleDataForUidLoader.Builder builder = + NetworkCycleDataForUidLoader.builder(mContext); + builder.setRetrieveDetail(false) + .setNetworkTemplate(template); + + builder.addUid(uid); + if (Process.isApplicationUid(uid)) { + // Also add in network usage for the app's SDK sandbox + builder.addUid(Process.toSdkSandboxUid(uid)); + } + return builder.build(); } @Override diff --git a/src/com/android/settings/applications/appinfo/AppInfoDashboardFragment.java b/src/com/android/settings/applications/appinfo/AppInfoDashboardFragment.java index 4cf591125a3..18cb4b3b80b 100755 --- a/src/com/android/settings/applications/appinfo/AppInfoDashboardFragment.java +++ b/src/com/android/settings/applications/appinfo/AppInfoDashboardFragment.java @@ -154,6 +154,7 @@ public class AppInfoDashboardFragment extends DashboardFragment final TimeSpentInAppPreferenceController timeSpentInAppPreferenceController = use( TimeSpentInAppPreferenceController.class); timeSpentInAppPreferenceController.setPackageName(packageName); + timeSpentInAppPreferenceController.setParentFragment(this); timeSpentInAppPreferenceController.initLifeCycleOwner(this); use(AppDataUsagePreferenceController.class).setParentFragment(this); diff --git a/src/com/android/settings/applications/appinfo/AppInfoPreferenceControllerBase.java b/src/com/android/settings/applications/appinfo/AppInfoPreferenceControllerBase.java index c495cbc50c8..718ddb8490b 100644 --- a/src/com/android/settings/applications/appinfo/AppInfoPreferenceControllerBase.java +++ b/src/com/android/settings/applications/appinfo/AppInfoPreferenceControllerBase.java @@ -25,6 +25,7 @@ import androidx.preference.PreferenceScreen; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.applications.ApplicationsState; /* * Abstract base controller for the app detail preferences that refresh the state when the app state @@ -35,6 +36,7 @@ public abstract class AppInfoPreferenceControllerBase extends BasePreferenceCont protected AppInfoDashboardFragment mParent; protected Preference mPreference; + protected ApplicationsState.AppEntry mAppEntry; private final Class mDetailFragmentClass; @@ -72,10 +74,12 @@ public abstract class AppInfoPreferenceControllerBase extends BasePreferenceCont public void setParentFragment(AppInfoDashboardFragment parent) { mParent = parent; parent.addToCallbackList(this); + mAppEntry = mParent.getAppEntry(); } /** * Gets the fragment class to be launched when the preference is clicked. + * * @return the fragment to launch */ protected Class getDetailFragmentClass() { @@ -84,10 +88,10 @@ public abstract class AppInfoPreferenceControllerBase extends BasePreferenceCont /** * Gets any extras that should be passed to the fragment class when the preference is clicked. + * * @return a bundle of extras to include in the launch intent */ protected Bundle getArguments() { return null; } - } diff --git a/src/com/android/settings/applications/appinfo/AppNotificationPreferenceController.java b/src/com/android/settings/applications/appinfo/AppNotificationPreferenceController.java index bc87b44a69c..a32205bdfdb 100644 --- a/src/com/android/settings/applications/appinfo/AppNotificationPreferenceController.java +++ b/src/com/android/settings/applications/appinfo/AppNotificationPreferenceController.java @@ -22,11 +22,13 @@ import android.content.Context; import android.os.Bundle; import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; -import com.android.settings.notification.app.AppNotificationSettings; import com.android.settings.notification.NotificationBackend; +import com.android.settings.notification.app.AppNotificationSettings; +import com.android.settingslib.applications.AppUtils; import com.android.settingslib.applications.ApplicationsState; public class AppNotificationPreferenceController extends AppInfoPreferenceControllerBase { @@ -49,6 +51,12 @@ public class AppNotificationPreferenceController extends AppInfoPreferenceContro } } + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference.setEnabled(AppUtils.isAppInstalled(mAppEntry)); + } + @Override public void updateState(Preference preference) { preference.setSummary(getNotificationSummary(mParent.getAppEntry(), mContext, mBackend)); diff --git a/src/com/android/settings/applications/appinfo/AppStoragePreferenceController.java b/src/com/android/settings/applications/appinfo/AppStoragePreferenceController.java index 4e6bf4e1428..490fa0e87b2 100644 --- a/src/com/android/settings/applications/appinfo/AppStoragePreferenceController.java +++ b/src/com/android/settings/applications/appinfo/AppStoragePreferenceController.java @@ -26,12 +26,13 @@ import androidx.annotation.VisibleForTesting; import androidx.loader.app.LoaderManager; import androidx.loader.content.Loader; import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.applications.AppStorageSettings; import com.android.settings.applications.FetchPackageStorageAsyncLoader; -import com.android.settingslib.applications.ApplicationsState; +import com.android.settingslib.applications.AppUtils; import com.android.settingslib.applications.StorageStatsSource; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnPause; @@ -47,14 +48,22 @@ public class AppStoragePreferenceController extends AppInfoPreferenceControllerB super(context, key); } + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference.setEnabled(AppUtils.isAppInstalled(mAppEntry)); + } + @Override public void updateState(Preference preference) { - final ApplicationsState.AppEntry entry = mParent.getAppEntry(); - if (entry != null && entry.info != null) { - final boolean isExternal = - (entry.info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; - preference.setSummary(getStorageSummary(mLastResult, isExternal)); + if (!AppUtils.isAppInstalled(mAppEntry)) { + preference.setSummary(""); + return; } + + final boolean isExternal = + (mAppEntry.info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; + preference.setSummary(getStorageSummary(mLastResult, isExternal)); } @Override @@ -102,5 +111,4 @@ public class AppStoragePreferenceController extends AppInfoPreferenceControllerB @Override public void onLoaderReset(Loader loader) { } - } diff --git a/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceController.java b/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceController.java index 27d90269e3f..3682af27f2f 100644 --- a/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceController.java +++ b/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceController.java @@ -31,6 +31,8 @@ import androidx.preference.PreferenceScreen; import com.android.settings.applications.ApplicationFeatureProvider; import com.android.settings.core.LiveDataController; import com.android.settings.overlay.FeatureFactory; +import com.android.settingslib.applications.AppUtils; +import com.android.settingslib.applications.ApplicationsState; import java.util.List; @@ -45,6 +47,8 @@ public class TimeSpentInAppPreferenceController extends LiveDataController { private final ApplicationFeatureProvider mAppFeatureProvider; private Intent mIntent; private String mPackageName; + protected AppInfoDashboardFragment mParent; + protected ApplicationsState.AppEntry mAppEntry; public TimeSpentInAppPreferenceController(Context context, String preferenceKey) { super(context, preferenceKey); @@ -59,6 +63,14 @@ public class TimeSpentInAppPreferenceController extends LiveDataController { .putExtra(Intent.EXTRA_PACKAGE_NAME, mPackageName); } + /** + * Set a parent fragment for this controller. + */ + public void setParentFragment(AppInfoDashboardFragment parent) { + mParent = parent; + mAppEntry = mParent.getAppEntry(); + } + @Override public int getAvailabilityStatus() { if (TextUtils.isEmpty(mPackageName)) { @@ -84,6 +96,7 @@ public class TimeSpentInAppPreferenceController extends LiveDataController { if (pref != null) { pref.setIntent(mIntent); } + pref.setEnabled(AppUtils.isAppInstalled(mAppEntry)); } @Override diff --git a/src/com/android/settings/applications/manageapplications/ResetAppsHelper.java b/src/com/android/settings/applications/manageapplications/ResetAppsHelper.java index 670b5a8ffd4..9cb5a3f851a 100644 --- a/src/com/android/settings/applications/manageapplications/ResetAppsHelper.java +++ b/src/com/android/settings/applications/manageapplications/ResetAppsHelper.java @@ -32,6 +32,8 @@ import android.os.Bundle; import android.os.RemoteException; import android.os.ServiceManager; import android.os.UserHandle; +import android.os.UserManager; +import android.util.Log; import androidx.appcompat.app.AlertDialog; @@ -44,6 +46,7 @@ public class ResetAppsHelper implements DialogInterface.OnClickListener, DialogInterface.OnDismissListener { private static final String EXTRA_RESET_DIALOG = "resetDialog"; + private static final String TAG = "ResetAppsHelper"; private final PackageManager mPm; private final IPackageManager mIPm; @@ -51,6 +54,7 @@ public class ResetAppsHelper implements DialogInterface.OnClickListener, private final NetworkPolicyManager mNpm; private final AppOpsManager mAom; private final Context mContext; + private final UserManager mUm; private AlertDialog mResetDialog; @@ -62,6 +66,7 @@ public class ResetAppsHelper implements DialogInterface.OnClickListener, ServiceManager.getService(Context.NOTIFICATION_SERVICE)); mNpm = NetworkPolicyManager.from(context); mAom = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE); + mUm = (UserManager) context.getSystemService(Context.USER_SERVICE); } public void onRestoreInstanceState(Bundle savedInstanceState) { @@ -110,27 +115,35 @@ public class ResetAppsHelper implements DialogInterface.OnClickListener, AsyncTask.execute(new Runnable() { @Override public void run() { - final List apps = mPm.getInstalledApplications( - PackageManager.GET_DISABLED_COMPONENTS); final List allowList = Arrays.asList( mContext.getResources().getStringArray( R.array.config_skip_reset_apps_package_name)); - - for (int i = 0; i < apps.size(); i++) { - ApplicationInfo app = apps.get(i); - if (allowList.contains(app.packageName)) { - continue; - } - try { - mNm.clearData(app.packageName, app.uid, false); - } catch (android.os.RemoteException ex) { - } - if (!app.enabled) { - if (mPm.getApplicationEnabledSetting(app.packageName) - == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) { - mPm.setApplicationEnabledSetting(app.packageName, - PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, - PackageManager.DONT_KILL_APP); + for (UserHandle userHandle : mUm.getEnabledProfiles()) { + final int userId = userHandle.getIdentifier(); + final List apps = mPm.getInstalledApplicationsAsUser( + PackageManager.GET_DISABLED_COMPONENTS, userId); + for (int i = 0; i < apps.size(); i++) { + ApplicationInfo app = apps.get(i); + if (allowList.contains(app.packageName)) { + continue; + } + try { + mNm.clearData(app.packageName, app.uid, false); + } catch (android.os.RemoteException ex) { + } + if (!app.enabled) { + try { + if (mIPm.getApplicationEnabledSetting(app.packageName, userId) + == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) { + mIPm.setApplicationEnabledSetting(app.packageName, + PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, + PackageManager.DONT_KILL_APP, + userId, + mContext.getPackageName()); + } + } catch (RemoteException e) { + Log.e(TAG, "Error during reset disabled apps.", e); + } } } } diff --git a/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java b/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java index 408f8596aac..e42574f7b6b 100644 --- a/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java +++ b/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java @@ -65,7 +65,6 @@ import com.android.settings.biometrics.BiometricUtils; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; import com.android.settings.password.ChooseLockGeneric; import com.android.settings.password.ChooseLockSettingsHelper; -import com.android.settings.utils.AnnotationSpan; import com.android.settingslib.HelpUtils; import com.android.settingslib.RestrictedLockUtils; import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; @@ -73,6 +72,7 @@ import com.android.settingslib.RestrictedLockUtilsInternal; import com.android.settingslib.widget.FooterPreference; import com.android.settingslib.widget.TwoTargetPreference; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -114,6 +114,13 @@ public class FingerprintSettings extends SubSettings { public static class FingerprintSettingsFragment extends SettingsPreferenceFragment implements OnPreferenceChangeListener, FingerprintPreference.OnDeleteClickListener { + + private static class FooterColumn { + CharSequence mTitle = null; + CharSequence mLearnMoreOverrideText = null; + View.OnClickListener mLearnMoreClickListener = null; + } + private static final int RESET_HIGHLIGHT_DELAY_MS = 500; private static final String TAG = "FingerprintSettings"; @@ -144,8 +151,7 @@ public class FingerprintSettings extends SubSettings { private boolean mLaunchedConfirm; private Drawable mHighlightDrawable; private int mUserId; - private CharSequence mFooterTitle; - private View.OnClickListener mLearnMoreListener = null; + private final List mFooterColumns = new ArrayList<>(); private boolean mEnrollClicked; private long mChallenge; @@ -352,32 +358,45 @@ public class FingerprintSettings extends SubSettings { mLaunchedConfirm = true; launchChooseOrConfirmLock(); } + updateFooterColumns(activity); + } + private void updateFooterColumns(@NonNull Activity activity) { final EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfKeyguardFeaturesDisabled( activity, DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT, mUserId); - final AnnotationSpan.LinkInfo adminLinkInfo = new AnnotationSpan.LinkInfo( - ANNOTATION_ADMIN_DETAILS, (view) -> { - RestrictedLockUtils.sendShowAdminSupportDetailsIntent(activity, admin); - }); final Intent helpIntent = HelpUtils.getHelpIntent( activity, getString(getHelpResource()), activity.getClass().getName()); - final AnnotationSpan.LinkInfo linkInfo = new AnnotationSpan.LinkInfo( - activity, ANNOTATION_URL, helpIntent); + final View.OnClickListener learnMoreClickListener = (v) -> + activity.startActivityForResult(helpIntent, 0); + mFooterColumns.clear(); if (admin != null) { - DevicePolicyManager devicePolicyManager = + final DevicePolicyManager devicePolicyManager = getSystemService(DevicePolicyManager.class); - String footerText = devicePolicyManager.getResources().getString( + final FooterColumn column1 = new FooterColumn(); + column1.mTitle = devicePolicyManager.getResources().getString( FINGERPRINT_UNLOCK_DISABLED_EXPLANATION, - () -> getString(R.string.security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled)); + () -> getString( + R.string.security_fingerprint_disclaimer_lockscreen_disabled_1 + ) + ); + column1.mLearnMoreClickListener = (v) -> RestrictedLockUtils + .sendShowAdminSupportDetailsIntent(activity, admin); + column1.mLearnMoreOverrideText = getText(R.string.admin_support_more_info); + mFooterColumns.add(column1); - mFooterTitle = AnnotationSpan.linkify(footerText, linkInfo, adminLinkInfo); + final FooterColumn column2 = new FooterColumn(); + column2.mTitle = getText( + R.string.security_fingerprint_disclaimer_lockscreen_disabled_2 + ); + column2.mLearnMoreClickListener = learnMoreClickListener; + mFooterColumns.add(column2); } else { - mFooterTitle = getText(R.string.security_settings_fingerprint_v2_home_screen_text); - mLearnMoreListener = (v) -> activity.startActivityForResult(helpIntent, 0); + final FooterColumn column = new FooterColumn(); + column.mTitle = getText(R.string.security_settings_fingerprint_v2_home_screen_text); + column.mLearnMoreClickListener = learnMoreClickListener; + mFooterColumns.add(column); } - - } private boolean isUdfps() { @@ -474,12 +493,21 @@ public class FingerprintSettings extends SubSettings { if (context == null) { return; } - final FooterPreference footer = new FooterPreference.Builder(context) - .setTitle(mFooterTitle).build(); - if (mLearnMoreListener != null) { - footer.setLearnMoreAction(mLearnMoreListener); + for (int i = 0; i < mFooterColumns.size(); ++i) { + final FooterColumn column = mFooterColumns.get(i); + final FooterPreference footer = new FooterPreference.Builder(context) + .setTitle(column.mTitle).build(); + if (i > 0) { + footer.setIconVisibility(View.GONE); + } + if (column.mLearnMoreClickListener != null) { + footer.setLearnMoreAction(column.mLearnMoreClickListener); + if (!TextUtils.isEmpty(column.mLearnMoreOverrideText)) { + footer.setLearnMoreText(column.mLearnMoreOverrideText); + } + } + root.addPreference(footer); } - root.addPreference(footer); } private static String genKey(int id) { diff --git a/src/com/android/settings/bluetooth/BluetoothPairingDialogFragment.java b/src/com/android/settings/bluetooth/BluetoothPairingDialogFragment.java index 9e3624732d0..14b4a7a5a7e 100644 --- a/src/com/android/settings/bluetooth/BluetoothPairingDialogFragment.java +++ b/src/com/android/settings/bluetooth/BluetoothPairingDialogFragment.java @@ -82,6 +82,12 @@ public class BluetoothPairingDialogFragment extends InstrumentedDialogFragment i return mDialog; } + @Override + public void onDestroy() { + super.onDestroy(); + mPairingController.onCancel(); + } + @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } diff --git a/src/com/android/settings/datausage/AppDataUsage.java b/src/com/android/settings/datausage/AppDataUsage.java index 531a341c95a..f0d27997ff8 100644 --- a/src/com/android/settings/datausage/AppDataUsage.java +++ b/src/com/android/settings/datausage/AppDataUsage.java @@ -25,6 +25,7 @@ import android.content.pm.PackageManager; import android.graphics.drawable.Drawable; import android.net.NetworkTemplate; import android.os.Bundle; +import android.os.Process; import android.os.UserHandle; import android.telephony.SubscriptionManager; import android.util.ArraySet; @@ -140,6 +141,14 @@ public class AppDataUsage extends DataUsageBaseFragment implements OnPreferenceC } } + if (mAppItem.key > 0 && UserHandle.isApp(mAppItem.key)) { + // In case we've been asked data usage for an app, automatically + // include data usage of the corresponding SDK sandbox + final int appSandboxUid = Process.toSdkSandboxUid(mAppItem.key); + if (!mAppItem.uids.get(appSandboxUid)) { + mAppItem.addUid(appSandboxUid); + } + } mTotalUsage = findPreference(KEY_TOTAL_USAGE); mForegroundUsage = findPreference(KEY_FOREGROUND_USAGE); mBackgroundUsage = findPreference(KEY_BACKGROUND_USAGE); @@ -307,6 +316,10 @@ public class AppDataUsage extends DataUsageBaseFragment implements OnPreferenceC } private void addUid(int uid) { + if (Process.isSdkSandboxUid(uid)) { + // For a sandbox process, get the associated app UID + uid = Process.getAppUidForSdkSandboxUid(uid); + } String[] packages = mPackageManager.getPackagesForUid(uid); if (packages != null) { for (int i = 0; i < packages.length; i++) { @@ -404,12 +417,8 @@ public class AppDataUsage extends DataUsageBaseFragment implements OnPreferenceC = NetworkCycleDataForUidLoader.builder(mContext); builder.setRetrieveDetail(true) .setNetworkTemplate(mTemplate); - if (mAppItem.category == AppItem.CATEGORY_USER) { - for (int i = 0; i < mAppItem.uids.size(); i++) { - builder.addUid(mAppItem.uids.keyAt(i)); - } - } else { - builder.addUid(mAppItem.key); + for (int i = 0; i < mAppItem.uids.size(); i++) { + builder.addUid(mAppItem.uids.keyAt(i)); } if (mCycles != null) { builder.setCycles(mCycles); diff --git a/src/com/android/settings/datausage/BillingCyclePreferenceController.java b/src/com/android/settings/datausage/BillingCyclePreferenceController.java index 9592c5e4775..73216ab72f4 100644 --- a/src/com/android/settings/datausage/BillingCyclePreferenceController.java +++ b/src/com/android/settings/datausage/BillingCyclePreferenceController.java @@ -28,6 +28,7 @@ import android.telephony.TelephonyManager; import androidx.preference.PreferenceScreen; import com.android.settings.core.BasePreferenceController; +import com.android.settings.datausage.DataUsageUtils; import com.android.settings.datausage.lib.DataUsageLib; import com.android.settingslib.NetworkPolicyEditor; @@ -63,6 +64,6 @@ public class BillingCyclePreferenceController extends BasePreferenceController { @Override public int getAvailabilityStatus() { - return AVAILABLE; + return DataUsageUtils.hasMobileData(mContext) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; } } diff --git a/src/com/android/settings/datausage/DataUsageList.java b/src/com/android/settings/datausage/DataUsageList.java index 4ee653017e4..4a44a1674e0 100644 --- a/src/com/android/settings/datausage/DataUsageList.java +++ b/src/com/android/settings/datausage/DataUsageList.java @@ -369,7 +369,7 @@ public class DataUsageList extends DataUsageBaseFragment final int collapseKey; final int category; final int userId = UserHandle.getUserId(uid); - if (UserHandle.isApp(uid)) { + if (UserHandle.isApp(uid) || Process.isSdkSandboxUid(uid)) { if (profiles.contains(new UserHandle(userId))) { if (userId != currentUserId) { // Add to a managed user item. @@ -377,8 +377,12 @@ public class DataUsageList extends DataUsageBaseFragment largest = accumulate(managedKey, knownItems, bucket, AppItem.CATEGORY_USER, items, largest); } - // Add to app item. - collapseKey = uid; + // Map SDK sandbox back to its corresponding app + if (Process.isSdkSandboxUid(uid)) { + collapseKey = Process.getAppUidForSdkSandboxUid(uid); + } else { + collapseKey = uid; + } category = AppItem.CATEGORY_APP; } else { // If it is a removed user add it to the removed users' key @@ -416,6 +420,7 @@ public class DataUsageList extends DataUsageBaseFragment if (item == null) { item = new AppItem(uid); item.total = -1; + item.addUid(uid); items.add(item); knownItems.put(item.key, item); } diff --git a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java index 34edf987104..a00b036239d 100644 --- a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java +++ b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java @@ -525,20 +525,24 @@ public class AdvancedPowerUsageDetail extends DashboardFragment implements final long foregroundTimeMs = bundle.getLong(EXTRA_FOREGROUND_TIME); final long backgroundTimeMs = bundle.getLong(EXTRA_BACKGROUND_TIME); final int consumedPower = bundle.getInt(EXTRA_POWER_USAGE_AMOUNT); + final int uid = bundle.getInt(EXTRA_UID, 0); final String slotTime = bundle.getString(EXTRA_SLOT_TIME, null); final long totalTimeMs = foregroundTimeMs + backgroundTimeMs; final CharSequence usageTimeSummary; - final PowerUsageFeatureProvider powerFeatureProvider = - FeatureFactory.getFactory(getContext()).getPowerUsageFeatureProvider(getContext()); + final boolean isChartGraphEnabled = FeatureFactory.getFactory(getContext()) + .getPowerUsageFeatureProvider(getContext()).isChartGraphEnabled(getContext()); + if (!isChartGraphEnabled && BatteryEntry.isSystemUid(uid)) { + return null; + } if (totalTimeMs == 0) { final int batteryWithoutUsageTime = consumedPower > 0 ? R.string.battery_usage_without_time : R.string.battery_not_usage_24hr; - usageTimeSummary = getText(powerFeatureProvider.isChartGraphEnabled(getContext()) + usageTimeSummary = getText(isChartGraphEnabled ? batteryWithoutUsageTime : R.string.battery_not_usage); } else if (slotTime == null) { // Shows summary text with past 24 hr or full charge if slot time is null. - usageTimeSummary = powerFeatureProvider.isChartGraphEnabled(getContext()) + usageTimeSummary = isChartGraphEnabled ? getAppPast24HrActiveSummary(foregroundTimeMs, backgroundTimeMs, totalTimeMs) : getAppFullChargeActiveSummary( foregroundTimeMs, backgroundTimeMs, totalTimeMs); diff --git a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java index 9e1bbb3cb06..9731ab7c708 100644 --- a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java +++ b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java @@ -434,7 +434,7 @@ public class BatteryAppListPreferenceController extends AbstractPreferenceContro @VisibleForTesting void setUsageSummary(Preference preference, BatteryEntry entry) { - if (entry.getUid() == Process.SYSTEM_UID) { + if (BatteryEntry.isSystemUid(entry.getUid())) { return; } String packageName = entry.getDefaultPackageName(); diff --git a/src/com/android/settings/fuelgauge/BatteryEntry.java b/src/com/android/settings/fuelgauge/BatteryEntry.java index ef200a4daf5..9dcbd05564e 100644 --- a/src/com/android/settings/fuelgauge/BatteryEntry.java +++ b/src/com/android/settings/fuelgauge/BatteryEntry.java @@ -612,7 +612,7 @@ public class BatteryEntry { return new NameAndIcon(name, null /* icon */, iconId); } - private static boolean isSystemUid(int uid) { + static boolean isSystemUid(int uid) { return uid == Process.SYSTEM_UID; } } diff --git a/src/com/android/settings/network/SwitchToEuiccSubscriptionSidecar.java b/src/com/android/settings/network/SwitchToEuiccSubscriptionSidecar.java index 0b39d6ac0b7..935e235aeaf 100644 --- a/src/com/android/settings/network/SwitchToEuiccSubscriptionSidecar.java +++ b/src/com/android/settings/network/SwitchToEuiccSubscriptionSidecar.java @@ -21,12 +21,14 @@ import android.app.PendingIntent; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; import android.telephony.UiccCardInfo; +import android.telephony.UiccSlotMapping; import android.telephony.euicc.EuiccManager; import android.util.Log; import com.android.settings.SidecarFragment; import com.android.settings.network.telephony.EuiccOperationSidecar; +import java.util.Collection; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; @@ -94,7 +96,7 @@ public class SwitchToEuiccSubscriptionSidecar extends EuiccOperationSidecar { // To check whether the esim slot's port is active. If yes, skip setSlotMapping. If no, // set this slot+port into setSimSlotMapping. - mPort = (port < 0) ? getTargetPortId(removedSubInfo) : port; + mPort = (port < 0) ? getTargetPortId(targetSlot, removedSubInfo) : port; mRemovedSubInfo = removedSubInfo; Log.d(TAG, String.format("set esim into the SubId%d Slot%d:Port%d", @@ -114,12 +116,24 @@ public class SwitchToEuiccSubscriptionSidecar extends EuiccOperationSidecar { } } - private int getTargetPortId(SubscriptionInfo removedSubInfo) { - if (!mTelephonyManager.isMultiSimEnabled() || !isMultipleEnabledProfilesSupported()) { - // In the 'SS mode' or 'DSDS+no MEP', the port is 0. + private int getTargetPortId(int physicalEsimSlotIndex, SubscriptionInfo removedSubInfo) { + if (!isMultipleEnabledProfilesSupported()) { + Log.d(TAG, "The device is no MEP, port is 0"); return 0; } + if (!mTelephonyManager.isMultiSimEnabled()) { + // In the 'SS mode' + // If there is the esim slot is active, the port is from the current esim slot. + // If there is no esim slot in device, then the esim's port is 0. + Collection uiccSlotMappings = mTelephonyManager.getSimSlotMapping(); + Log.d(TAG, "In SS mode, the UiccSlotMapping: " + uiccSlotMappings); + return uiccSlotMappings.stream() + .filter(i -> i.getPhysicalSlotIndex() == physicalEsimSlotIndex) + .mapToInt(i -> i.getPortIndex()) + .findFirst().orElse(0); + } + // In the 'DSDS+MEP', if the removedSubInfo is esim, then the port is // removedSubInfo's port. if (removedSubInfo != null && removedSubInfo.isEmbedded()) { diff --git a/src/com/android/settings/network/UiccSlotUtil.java b/src/com/android/settings/network/UiccSlotUtil.java index 8fdc3700dd6..813b9d6826d 100644 --- a/src/com/android/settings/network/UiccSlotUtil.java +++ b/src/com/android/settings/network/UiccSlotUtil.java @@ -282,6 +282,21 @@ public class UiccSlotUtil { // 1. pSIM's logical slots always is [RIL 0]. // 2. assign the new active port to the same stack that will be de-activated // For example: mode#3->mode#4 + // 3. Add an eSIM carrier or enable eSIM carrier. The cases are at the below. + // 1) 1 => 2 / 2.1 / 3 / 3.1 + // 2) 2 => 1 / 3 / 3.2 + // 3) 2.1 => 3.1 / 4 + // 4) 3 => 4 + // 5) 3.1 => 3.2 + // Note: + // 1) 2 <=> 2.1 blocked by LPA (reason: existing active port in SS so just re-use) + // 2) 3 <=> 3.1 blocked by LPA (reason: if pSIM+an active port, re-use the active port) + // 4. pSIM insertion or enabling + // 1) 2 => 1 / 3 + // 2) 2.1 => 1 / 3.1 + // 3) 3.2 => 3 / 3.1 + // 4) 4 => 3 / 3.1 + @VisibleForTesting static Collection prepareUiccSlotMappings( diff --git a/src/com/android/settings/network/telephony/DataDuringCallsPreferenceController.java b/src/com/android/settings/network/telephony/DataDuringCallsPreferenceController.java index 110c5823de3..2bbb1cab049 100644 --- a/src/com/android/settings/network/telephony/DataDuringCallsPreferenceController.java +++ b/src/com/android/settings/network/telephony/DataDuringCallsPreferenceController.java @@ -33,6 +33,7 @@ import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; import com.android.internal.annotations.VisibleForTesting; +import com.android.settings.datausage.DataUsageUtils; import com.android.settings.network.MobileDataContentObserver; import com.android.settings.network.SubscriptionsChangeListener; @@ -102,10 +103,16 @@ public class DataDuringCallsPreferenceController extends TelephonyTogglePreferen return true; } + @VisibleForTesting + protected boolean hasMobileData() { + return DataUsageUtils.hasMobileData(mContext); + } + @Override public int getAvailabilityStatus(int subId) { if (!SubscriptionManager.isValidSubscriptionId(subId) - || SubscriptionManager.getDefaultDataSubscriptionId() == subId) { + || SubscriptionManager.getDefaultDataSubscriptionId() == subId + || (!hasMobileData())) { return CONDITIONALLY_UNAVAILABLE; } return AVAILABLE; diff --git a/src/com/android/settings/network/telephony/DataUsagePreferenceController.java b/src/com/android/settings/network/telephony/DataUsagePreferenceController.java index 40eb549308c..a536c1da96b 100644 --- a/src/com/android/settings/network/telephony/DataUsagePreferenceController.java +++ b/src/com/android/settings/network/telephony/DataUsagePreferenceController.java @@ -56,6 +56,7 @@ public class DataUsagePreferenceController extends TelephonyBasePreferenceContro @Override public int getAvailabilityStatus(int subId) { return (SubscriptionManager.isValidSubscriptionId(subId)) + && DataUsageUtils.hasMobileData(mContext) ? AVAILABLE : AVAILABLE_UNSEARCHABLE; } diff --git a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java index 698f6e1258b..40641812133 100644 --- a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java +++ b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java @@ -17,6 +17,7 @@ package com.android.settings.network.telephony; import android.content.Context; +import android.content.pm.PackageManager; import android.os.PersistableBundle; import android.telephony.CarrierConfigManager; import android.telephony.SubscriptionManager; @@ -129,6 +130,12 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC return queryImsState(mSubId).isEnabledByUser(); } + @VisibleForTesting + protected boolean isImsSupported() { + return mContext.getPackageManager().hasSystemFeature( + PackageManager.FEATURE_TELEPHONY_IMS); + } + public VideoCallingPreferenceController init(int subId) { mSubId = subId; @@ -154,7 +161,7 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC return false; } - return queryImsState(subId).isReadyToVideoCall(); + return isImsSupported() && queryImsState(subId).isReadyToVideoCall(); } @Override diff --git a/src/com/android/settings/password/ChooseLockPassword.java b/src/com/android/settings/password/ChooseLockPassword.java index 7b0955e13d2..199d584cc5c 100644 --- a/src/com/android/settings/password/ChooseLockPassword.java +++ b/src/com/android/settings/password/ChooseLockPassword.java @@ -39,6 +39,7 @@ import static com.android.internal.widget.PasswordValidationError.NOT_ENOUGH_UPP import static com.android.internal.widget.PasswordValidationError.RECENTLY_USED; import static com.android.internal.widget.PasswordValidationError.TOO_LONG; import static com.android.internal.widget.PasswordValidationError.TOO_SHORT; +import static com.android.internal.widget.PasswordValidationError.TOO_SHORT_WHEN_ALL_NUMERIC; import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_CREDENTIAL; import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_ID; @@ -91,6 +92,7 @@ import com.android.settings.SetupWizardUtils; import com.android.settings.Utils; import com.android.settings.core.InstrumentedFragment; import com.android.settings.notification.RedactionInterstitial; +import com.android.settingslib.utils.StringUtil; import com.google.android.setupcompat.template.FooterBarMixin; import com.google.android.setupcompat.template.FooterButton; @@ -834,6 +836,11 @@ public class ChooseLockPassword extends SettingsActivity { : R.plurals.lockpassword_pin_too_short, error.requirement, error.requirement)); break; + case TOO_SHORT_WHEN_ALL_NUMERIC: + messages.add( + StringUtil.getIcuPluralsString(getContext(), error.requirement, + R.string.lockpassword_password_too_short_all_numeric)); + break; case TOO_LONG: messages.add(getResources().getQuantityString( mIsAlphaMode diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/AppBatteryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/AppBatteryPreferenceControllerTest.java index bcca0f20b6f..03b3a479895 100644 --- a/tests/robotests/src/com/android/settings/applications/appinfo/AppBatteryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/appinfo/AppBatteryPreferenceControllerTest.java @@ -28,6 +28,7 @@ import static org.mockito.Mockito.when; import android.app.AppOpsManager; import android.content.Context; +import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; import android.os.BatteryUsageStats; @@ -41,6 +42,7 @@ import androidx.preference.PreferenceScreen; import com.android.settings.SettingsActivity; import com.android.settings.fuelgauge.BatteryDiffEntry; import com.android.settings.fuelgauge.BatteryUtils; +import com.android.settingslib.applications.ApplicationsState; import org.junit.Before; import org.junit.Test; @@ -176,6 +178,26 @@ public class AppBatteryPreferenceControllerTest { assertThat(mBatteryPreference.getSummary()).isEqualTo("60% use for past 24 hours"); } + @Test + public void displayPreference_noEntry_preferenceShouldSetEmptySummary() { + mController.mParent.setAppEntry(null); + + mController.displayPreference(mScreen); + + assertThat(mBatteryPreference.getSummary()).isEqualTo(""); + } + + @Test + public void displayPreference_appIsNotInstalled_preferenceShouldSetEmptySummary() { + final ApplicationsState.AppEntry appEntry = mock(ApplicationsState.AppEntry.class); + appEntry.info = new ApplicationInfo(); + mController.mParent.setAppEntry(appEntry); + + mController.displayPreference(mScreen); + + assertThat(mBatteryPreference.getSummary()).isEqualTo(""); + } + @Test public void isBatteryStatsAvailable_hasBatteryStatsHelperAndSipper_returnTrue() { mController.mBatteryUsageStats = mBatteryUsageStats; diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceControllerTest.java index 472bf221c57..aa7d6bc9492 100644 --- a/tests/robotests/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/appinfo/AppDataUsagePreferenceControllerTest.java @@ -34,6 +34,7 @@ import android.os.Bundle; import androidx.loader.app.LoaderManager; import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; import com.android.settings.core.BasePreferenceController; import com.android.settings.datausage.AppDataUsage; @@ -54,6 +55,8 @@ public class AppDataUsagePreferenceControllerTest { private LoaderManager mLoaderManager; @Mock private AppInfoDashboardFragment mFragment; + @Mock + private PreferenceScreen mScreen; private Context mContext; private AppDataUsagePreferenceController mController; @@ -71,7 +74,7 @@ public class AppDataUsagePreferenceControllerTest { doReturn(true).when(mController).isBandwidthControlEnabled(); assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.AVAILABLE); + .isEqualTo(BasePreferenceController.AVAILABLE); } @Test @@ -79,13 +82,14 @@ public class AppDataUsagePreferenceControllerTest { doReturn(false).when(mController).isBandwidthControlEnabled(); assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); + .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); } @Test public void onResume_notAvailable_shouldNotRestartDataLoader() { doReturn(mLoaderManager).when(mFragment).getLoaderManager(); - doReturn(BasePreferenceController.CONDITIONALLY_UNAVAILABLE).when(mController).getAvailabilityStatus(); + doReturn(BasePreferenceController.CONDITIONALLY_UNAVAILABLE).when( + mController).getAvailabilityStatus(); mController.onResume(); @@ -130,4 +134,45 @@ public class AppDataUsagePreferenceControllerTest { verify(preference).setSummary(any()); } + + @Test + public void displayPreference_noEntry_preferenceShouldNotEnable() { + mController.mAppEntry = null; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + doReturn(true).when(mController).isBandwidthControlEnabled(); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } + + @Test + public void displayPreference_appIsInstalled_preferenceShouldEnable() { + final AppEntry appEntry = mock(AppEntry.class); + appEntry.info = new ApplicationInfo(); + appEntry.info.flags = ApplicationInfo.FLAG_INSTALLED; + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + doReturn(true).when(mController).isBandwidthControlEnabled(); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isTrue(); + } + + @Test + public void displayPreference_appIsNotInstalled_preferenceShouldDisable() { + final AppEntry appEntry = mock(AppEntry.class); + appEntry.info = new ApplicationInfo(); + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + doReturn(true).when(mController).isBandwidthControlEnabled(); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } } diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/AppStoragePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/AppStoragePreferenceControllerTest.java index 065544b2f68..27e5db7a2ed 100644 --- a/tests/robotests/src/com/android/settings/applications/appinfo/AppStoragePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/appinfo/AppStoragePreferenceControllerTest.java @@ -21,7 +21,6 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -32,6 +31,7 @@ import android.os.Bundle; import androidx.loader.app.LoaderManager; import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; import com.android.settings.applications.AppStorageSettings; import com.android.settingslib.applications.ApplicationsState.AppEntry; @@ -52,6 +52,8 @@ public class AppStoragePreferenceControllerTest { private LoaderManager mLoaderManager; @Mock private AppInfoDashboardFragment mFragment; + @Mock + private PreferenceScreen mScreen; private Context mContext; private AppStoragePreferenceController mController; @@ -89,10 +91,48 @@ public class AppStoragePreferenceControllerTest { } @Test - public void updateState_shouldUpdatePreferenceSummary() { + public void displayPreference_noEntry_preferenceShouldNotEnable() { + mController.mAppEntry = null; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } + + @Test + public void displayPreference_appIsInstalled_preferenceShouldEnable() { final AppEntry appEntry = mock(AppEntry.class); appEntry.info = new ApplicationInfo(); - when(mFragment.getAppEntry()).thenReturn(appEntry); + appEntry.info.flags = ApplicationInfo.FLAG_INSTALLED; + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isTrue(); + } + + @Test + public void displayPreference_appIsNotInstalled_preferenceShouldDisable() { + final AppEntry appEntry = mock(AppEntry.class); + appEntry.info = new ApplicationInfo(); + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } + + @Test + public void updateState_hasAppEntry_shouldUpdatePreferenceSummary() { + final AppEntry appEntry = mock(AppEntry.class); + appEntry.info = new ApplicationInfo(); + mController.mAppEntry = appEntry; Preference preference = mock(Preference.class); mController.updateState(preference); @@ -102,12 +142,12 @@ public class AppStoragePreferenceControllerTest { @Test public void updateState_entryIsNull_shouldNotUpdatePreferenceSummary() { - when(mFragment.getAppEntry()).thenReturn(null); - Preference preference = mock(Preference.class); + mController.mAppEntry = null; + Preference preference = new Preference(mContext); mController.updateState(preference); - verify(preference, never()).setSummary(any()); + assertThat(preference.getSummary()).isEqualTo(""); } @Test diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceControllerTest.java index 775025616ba..0f3e7469ba3 100644 --- a/tests/robotests/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/appinfo/TimeSpentInAppPreferenceControllerTest.java @@ -20,7 +20,9 @@ import static android.content.Intent.EXTRA_PACKAGE_NAME; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -35,6 +37,7 @@ import androidx.preference.PreferenceScreen; import com.android.settings.core.BasePreferenceController; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settingslib.applications.ApplicationsState; import org.junit.Before; import org.junit.Test; @@ -125,4 +128,42 @@ public class TimeSpentInAppPreferenceControllerTest { verify(mFeatureFactory.applicationFeatureProvider).getTimeSpentInApp( nullable(String.class)); } + + @Test + public void displayPreference_noEntry_preferenceShouldNotEnable() { + mController.mAppEntry = null; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } + + @Test + public void displayPreference_appIsInstalled_preferenceShouldEnable() { + final ApplicationsState.AppEntry appEntry = mock(ApplicationsState.AppEntry.class); + appEntry.info = new ApplicationInfo(); + appEntry.info.flags = ApplicationInfo.FLAG_INSTALLED; + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isTrue(); + } + + @Test + public void displayPreference_appIsNotInstalled_preferenceShouldDisable() { + final ApplicationsState.AppEntry appEntry = mock(ApplicationsState.AppEntry.class); + appEntry.info = new ApplicationInfo(); + mController.mAppEntry = appEntry; + Preference preference = new Preference(mContext); + when(mScreen.findPreference(any())).thenReturn(preference); + + mController.displayPreference(mScreen); + + assertThat(preference.isEnabled()).isFalse(); + } } diff --git a/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java b/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java index f043ec737e3..14431ee5e69 100644 --- a/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java +++ b/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java @@ -302,6 +302,7 @@ public class AppDataUsageTest { final Context context = RuntimeEnvironment.application; final int testUid = 123123; final AppItem appItem = new AppItem(testUid); + appItem.addUid(testUid); appItem.category = AppItem.CATEGORY_APP; ReflectionHelpers.setField(mFragment, "mContext", context); ReflectionHelpers.setField(mFragment, "mAppItem", appItem); diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java index aaa14874cbe..269c810f852 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java @@ -43,6 +43,7 @@ import android.content.pm.PackageManager; import android.graphics.drawable.Drawable; import android.os.BatteryStats; import android.os.Bundle; +import android.os.Process; import android.os.UserHandle; import android.util.Pair; @@ -548,6 +549,7 @@ public class AdvancedPowerUsageDetailTest { bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeFourMinute); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes); when(mFragment.getArguments()).thenReturn(bundle); + mFragment.initHeader(); ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); @@ -560,7 +562,7 @@ public class AdvancedPowerUsageDetailTest { public void testInitHeader_totalUsageLessThanAMinWithSlotTime_hasCorrectSummary() { final long backgroundTimeLessThanHalfMinute = 20000; final long foregroundTimeLessThanHalfMinute = 20000; - Bundle bundle = new Bundle(2); + Bundle bundle = new Bundle(3); bundle.putLong( AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanHalfMinute); bundle.putLong( @@ -580,7 +582,7 @@ public class AdvancedPowerUsageDetailTest { public void testInitHeader_TotalAMinBackgroundLessThanAMinWithSlotTime_hasCorrectSummary() { final long backgroundTimeZero = 59999; final long foregroundTimeTwoMinutes = 1; - Bundle bundle = new Bundle(2); + Bundle bundle = new Bundle(3); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeZero); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes); bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME); @@ -598,7 +600,7 @@ public class AdvancedPowerUsageDetailTest { public void testInitHeader_TotalAMinBackgroundZeroWithSlotTime_hasCorrectSummary() { final long backgroundTimeZero = 0; final long foregroundTimeAMinutes = 60000; - Bundle bundle = new Bundle(2); + Bundle bundle = new Bundle(3); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeZero); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeAMinutes); bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME); @@ -616,11 +618,12 @@ public class AdvancedPowerUsageDetailTest { public void testInitHeader_foregroundTwoMinBackgroundFourMinWithSlotTime_hasCorrectSummary() { final long backgroundTimeFourMinute = 240000; final long foregroundTimeTwoMinutes = 120000; - Bundle bundle = new Bundle(2); + Bundle bundle = new Bundle(3); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeFourMinute); bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes); bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME); when(mFragment.getArguments()).thenReturn(bundle); + mFragment.initHeader(); ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); @@ -629,6 +632,38 @@ public class AdvancedPowerUsageDetailTest { .isEqualTo("6 min total • 4 min background\nfor 12 am-2 am"); } + @Test + public void testInitHeader_systemUidWithChartIsDisabled_nullSummary() { + Bundle bundle = new Bundle(3); + bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, 240000); + bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, 120000); + bundle.putInt(AdvancedPowerUsageDetail.EXTRA_UID, Process.SYSTEM_UID); + when(mFragment.getArguments()).thenReturn(bundle); + when(mFeatureFactory.powerUsageFeatureProvider.isChartGraphEnabled(mContext)) + .thenReturn(false); + + mFragment.initHeader(); + + ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); + verify(mEntityHeaderController).setSummary(captor.capture()); + assertThat(captor.getValue()).isNull(); + } + + @Test + public void testInitHeader_systemUidWithChartIsEnabled_notNullSummary() { + Bundle bundle = new Bundle(3); + bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, 240000); + bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, 120000); + bundle.putInt(AdvancedPowerUsageDetail.EXTRA_UID, Process.SYSTEM_UID); + when(mFragment.getArguments()).thenReturn(bundle); + + mFragment.initHeader(); + + ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); + verify(mEntityHeaderController).setSummary(captor.capture()); + assertThat(captor.getValue()).isNotNull(); + } + @Test public void testStartBatteryDetailPage_hasBasicData() { AdvancedPowerUsageDetail.startBatteryDetailPage(mActivity, mFragment, diff --git a/tests/robotests/src/com/android/settings/network/DataDuringCallsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/DataDuringCallsPreferenceControllerTest.java similarity index 97% rename from tests/robotests/src/com/android/settings/network/DataDuringCallsPreferenceControllerTest.java rename to tests/robotests/src/com/android/settings/network/telephony/DataDuringCallsPreferenceControllerTest.java index d366dfd9d0a..62d9974c59e 100644 --- a/tests/robotests/src/com/android/settings/network/DataDuringCallsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/DataDuringCallsPreferenceControllerTest.java @@ -14,7 +14,7 @@ * limitations under the License */ -package com.android.settings.network; +package com.android.settings.network.telephony; import static android.telephony.SubscriptionManager.INVALID_SUBSCRIPTION_ID; @@ -74,7 +74,10 @@ public class DataDuringCallsPreferenceControllerTest { when(mTelephonyManager.createForSubscriptionId(anyInt())).thenReturn(mTelephonyManager); mSwitchPreference = new SwitchPreference(mContext); when(mPreferenceScreen.findPreference(PREF_KEY)).thenReturn(mSwitchPreference); - mController = new DataDuringCallsPreferenceController(mContext, PREF_KEY); + mController = new DataDuringCallsPreferenceController(mContext, PREF_KEY) { + @Override + protected boolean hasMobileData() { return true; } + }; mController.init(mLifecycle, SUB_ID_1); } diff --git a/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java index 668d7f37981..9b44faa9295 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java @@ -89,6 +89,7 @@ public class VideoCallingPreferenceControllerTest { mController.init(SUB_ID); doReturn(mQueryImsState).when(mController).queryImsState(anyInt()); doReturn(mQueryVoLteState).when(mController).queryVoLteState(anyInt()); + doReturn(true).when(mController).isImsSupported(); mPreference.setKey(mController.getPreferenceKey()); mQueryImsState.setIsEnabledByPlatform(true); diff --git a/tests/robotests/src/com/android/settings/password/ChooseLockPasswordTest.java b/tests/robotests/src/com/android/settings/password/ChooseLockPasswordTest.java index e789b61f188..3c50c6bf2f4 100644 --- a/tests/robotests/src/com/android/settings/password/ChooseLockPasswordTest.java +++ b/tests/robotests/src/com/android/settings/password/ChooseLockPasswordTest.java @@ -56,7 +56,6 @@ import com.google.android.setupdesign.GlifLayout; import org.junit.After; import org.junit.Before; -import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.robolectric.Robolectric; @@ -74,13 +73,10 @@ import org.robolectric.shadows.ShadowDrawable; }) public class ChooseLockPasswordTest { - private ShadowDevicePolicyManager mShadowDpm; - @Before public void setUp() { SettingsShadowResources.overrideResource( com.android.internal.R.string.config_headlineFontFamily, ""); - mShadowDpm = ShadowDevicePolicyManager.getShadow(); } @After @@ -191,7 +187,6 @@ public class ChooseLockPasswordTest { } @Test - @Ignore public void processAndValidatePasswordRequirements_minPasswordComplexityStricter_password() { PasswordPolicy policy = new PasswordPolicy(); policy.quality = PASSWORD_QUALITY_SOMETHING; @@ -201,7 +196,6 @@ public class ChooseLockPasswordTest { /* minComplexity= */ PASSWORD_COMPLEXITY_MEDIUM, /* passwordType= */ PASSWORD_QUALITY_ALPHABETIC, /* userEnteredPassword= */ LockscreenCredential.createNone(), - "Must contain at least 1 non-numerical character", "Must be at least 4 characters"); } @@ -323,7 +317,6 @@ public class ChooseLockPasswordTest { } @Test - @Ignore public void processAndValidatePasswordRequirements_requirementsUpdateAccordingToMinComplexityAndUserInput_empty() { PasswordPolicy policy = new PasswordPolicy(); policy.quality = PASSWORD_QUALITY_UNSPECIFIED; @@ -334,11 +327,10 @@ public class ChooseLockPasswordTest { /* passwordType= */ PASSWORD_QUALITY_ALPHABETIC, /* userEnteredPassword= */ LockscreenCredential.createNone(), "Must be at least 6 characters", - "Must contain at least 1 non-numerical character"); + "If using only numbers, must be at least 8 digits"); } @Test - @Ignore public void processAndValidatePasswordRequirements_requirementsUpdateAccordingToMinComplexityAndUserInput_numeric() { PasswordPolicy policy = new PasswordPolicy(); policy.quality = PASSWORD_QUALITY_UNSPECIFIED; @@ -349,7 +341,7 @@ public class ChooseLockPasswordTest { /* passwordType= */ PASSWORD_QUALITY_ALPHABETIC, /* userEnteredPassword= */ LockscreenCredential.createPassword("1"), "Must be at least 6 characters", - "Must contain at least 1 non-numerical character"); + "If using only numbers, must be at least 8 digits"); } @Test diff --git a/tests/unit/src/com/android/settings/deviceinfo/simstatus/SimStatusDialogControllerTest.java b/tests/unit/src/com/android/settings/deviceinfo/simstatus/SimStatusDialogControllerTest.java index 9cd6f2d29fc..428c575e4a9 100644 --- a/tests/unit/src/com/android/settings/deviceinfo/simstatus/SimStatusDialogControllerTest.java +++ b/tests/unit/src/com/android/settings/deviceinfo/simstatus/SimStatusDialogControllerTest.java @@ -156,6 +156,9 @@ public class SimStatusDialogControllerTest { return mTelephonyManager; } + @Override + protected void requestForUpdateEid() {} + @Override public AtomicReference getEid(int slotIndex) { return mEuiccEnabled.get() ? mEid : null; @@ -202,6 +205,7 @@ public class SimStatusDialogControllerTest { doReturn(carrierName).when(mSubscriptionInfo).getCarrierName(); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(NETWORK_PROVIDER_VALUE_ID, carrierName); } @@ -209,6 +213,7 @@ public class SimStatusDialogControllerTest { @Test public void initialize_shouldUpdatePhoneNumber() { mController.initialize(); + mController.updateEid(mController.getEid(0)); assertTrue(mUpdatePhoneNumberCount.get() > 0); } @@ -218,6 +223,7 @@ public class SimStatusDialogControllerTest { when(mTelephonyManager.getPhoneType()).thenReturn(TelephonyManager.PHONE_TYPE_CDMA); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).removeSettingFromScreen(OPERATOR_INFO_LABEL_ID); verify(mDialog).removeSettingFromScreen(OPERATOR_INFO_VALUE_ID); @@ -228,6 +234,7 @@ public class SimStatusDialogControllerTest { when(mServiceState.getState()).thenReturn(ServiceState.STATE_IN_SERVICE); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String inServiceText = ResourcesUtils.getResourcesString( mContext, "radioInfo_service_in"); @@ -239,6 +246,7 @@ public class SimStatusDialogControllerTest { when(mServiceState.getState()).thenReturn(ServiceState.STATE_POWER_OFF); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String offServiceText = ResourcesUtils.getResourcesString( mContext, "radioInfo_service_off"); @@ -253,6 +261,7 @@ public class SimStatusDialogControllerTest { ServiceState.STATE_OUT_OF_SERVICE); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String offServiceText = ResourcesUtils.getResourcesString( mContext, "radioInfo_service_out"); @@ -266,6 +275,7 @@ public class SimStatusDialogControllerTest { when(mServiceState.getDataRegistrationState()).thenReturn(ServiceState.STATE_IN_SERVICE); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String inServiceText = ResourcesUtils.getResourcesString( mContext, "radioInfo_service_in"); @@ -281,6 +291,7 @@ public class SimStatusDialogControllerTest { setupCellSignalStrength_lteWcdma(lteDbm, lteAsu, wcdmaDbm, wcdmaAsu); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String signalStrengthString = ResourcesUtils.getResourcesString( mContext, "sim_signal_strength", lteDbm, lteAsu); @@ -296,6 +307,7 @@ public class SimStatusDialogControllerTest { setupCellSignalStrength_lteCdma(lteDbm, lteAsu, cdmaDbm, cdmaAsu); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String signalStrengthString = ResourcesUtils.getResourcesString( mContext, "sim_signal_strength", lteDbm, lteAsu); @@ -312,6 +324,7 @@ public class SimStatusDialogControllerTest { setupCellSignalStrength_lteOnly(lteDbm, lteAsu); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String signalStrengthString = ResourcesUtils.getResourcesString( mContext, "sim_signal_strength", lteDbm, lteAsu); @@ -324,6 +337,7 @@ public class SimStatusDialogControllerTest { TelephonyManager.NETWORK_TYPE_EDGE); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(CELL_VOICE_NETWORK_TYPE_VALUE_ID, SimStatusDialogController.getNetworkTypeName(TelephonyManager.NETWORK_TYPE_EDGE)); @@ -335,6 +349,7 @@ public class SimStatusDialogControllerTest { TelephonyManager.NETWORK_TYPE_EDGE); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(CELL_DATA_NETWORK_TYPE_VALUE_ID, SimStatusDialogController.getNetworkTypeName(TelephonyManager.NETWORK_TYPE_EDGE)); @@ -345,6 +360,7 @@ public class SimStatusDialogControllerTest { when(mServiceState.getRoaming()).thenReturn(true); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String roamingOnString = ResourcesUtils.getResourcesString( mContext, "radioInfo_roaming_in"); @@ -356,6 +372,7 @@ public class SimStatusDialogControllerTest { when(mServiceState.getRoaming()).thenReturn(false); mController.initialize(); + mController.updateEid(mController.getEid(0)); final String roamingOffString = ResourcesUtils.getResourcesString( mContext, "radioInfo_roaming_not"); @@ -368,6 +385,7 @@ public class SimStatusDialogControllerTest { CarrierConfigManager.KEY_SHOW_ICCID_IN_SIM_STATUS_BOOL, false); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).removeSettingFromScreen(ICCID_INFO_LABEL_ID); verify(mDialog).removeSettingFromScreen(ICCID_INFO_VALUE_ID); @@ -379,6 +397,7 @@ public class SimStatusDialogControllerTest { CarrierConfigManager.KEY_SHOW_SIGNAL_STRENGTH_IN_SIM_STATUS_BOOL, false); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog, times(2)).removeSettingFromScreen(SIGNAL_STRENGTH_LABEL_ID); verify(mDialog, times(2)).removeSettingFromScreen(SIGNAL_STRENGTH_VALUE_ID); @@ -390,6 +409,7 @@ public class SimStatusDialogControllerTest { when(mCarrierConfigManager.getConfigForSubId(anyInt())).thenReturn(null); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog, times(2)).setText(eq(SIGNAL_STRENGTH_VALUE_ID), any()); verify(mDialog).removeSettingFromScreen(ICCID_INFO_LABEL_ID); @@ -403,6 +423,7 @@ public class SimStatusDialogControllerTest { doReturn(iccid).when(mTelephonyManager).getSimSerialNumber(); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(ICCID_INFO_VALUE_ID, iccid); } @@ -457,6 +478,7 @@ public class SimStatusDialogControllerTest { mEid.set(null); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Keep 'Not available' if neither the card nor the associated manager can provide EID. verify(mDialog, never()).setText(eq(EID_INFO_VALUE_ID), any()); @@ -511,6 +533,7 @@ public class SimStatusDialogControllerTest { when(mEuiccManager.createForCardId(0)).thenReturn(mEuiccManager); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Set EID retrieved from the card. verify(mDialog).setText(EID_INFO_VALUE_ID, TEST_EID_FROM_CARD); @@ -570,14 +593,15 @@ public class SimStatusDialogControllerTest { when(mEuiccManager.createForCardId(1)).thenReturn(mEuiccManager); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Set EID retrieved from the manager associated with the card which cannot provide EID. verify(mDialog).setText(EID_INFO_VALUE_ID, TEST_EID_FROM_MANAGER); verify(mDialog, never()).removeSettingFromScreen(eq(EID_INFO_VALUE_ID)); } - @Ignore @Test + @Ignore public void initialize_updateEid_shouldRemoveEid() { when(mTelephonyManager.getActiveModemCount()).thenReturn(MAX_PHONE_COUNT_DUAL_SIM); @@ -623,10 +647,10 @@ public class SimStatusDialogControllerTest { when(mEuiccManager.isEnabled()).thenReturn(true); mEuiccEnabled.set(true); - mEid.set(TEST_EID_FROM_MANAGER); + mEid.set(null); - mController.updateEid(mController.getEid(0)); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Remove EID if the card is not eUICC. verify(mDialog, never()).setText(eq(EID_INFO_VALUE_ID), any()); @@ -666,6 +690,7 @@ public class SimStatusDialogControllerTest { mEid.set(null); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Keep 'Not available' if the default eUICC manager cannot provide EID in Single SIM mode. verify(mDialog, never()).setText(eq(EID_INFO_VALUE_ID), any()); @@ -707,6 +732,7 @@ public class SimStatusDialogControllerTest { new RuntimeException("EID shall be retrieved from the default eUICC manager")); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Set EID retrieved from the default eUICC manager in Single SIM mode. verify(mDialog).setText(EID_INFO_VALUE_ID, TEST_EID_FROM_MANAGER); @@ -748,6 +774,7 @@ public class SimStatusDialogControllerTest { new RuntimeException("EID shall be retrieved from the default eUICC manager")); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Set EID retrieved from the default eUICC manager in Single SIM mode. verify(mDialog).setText(EID_INFO_VALUE_ID, TEST_EID_FROM_MANAGER); @@ -786,6 +813,7 @@ public class SimStatusDialogControllerTest { mEid.set(null); mController.initialize(); + mController.updateEid(mController.getEid(0)); // Remove EID if the default eUICC manager indicates that eSIM is not enabled. verify(mDialog).removeSettingFromScreen(eq(EID_INFO_LABEL_ID)); @@ -800,6 +828,7 @@ public class SimStatusDialogControllerTest { when(mTelephonyManager.isImsRegistered(anyInt())).thenReturn(true); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(IMS_REGISTRATION_STATE_VALUE_ID, mContext.getString(R.string.ims_reg_status_registered)); @@ -813,6 +842,7 @@ public class SimStatusDialogControllerTest { when(mTelephonyManager.isImsRegistered(anyInt())).thenReturn(false); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).setText(IMS_REGISTRATION_STATE_VALUE_ID, mContext.getString(R.string.ims_reg_status_not_registered)); @@ -825,6 +855,7 @@ public class SimStatusDialogControllerTest { CarrierConfigManager.KEY_SHOW_IMS_REGISTRATION_STATUS_BOOL, true); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog, never()).removeSettingFromScreen(IMS_REGISTRATION_STATE_VALUE_ID); } @@ -836,6 +867,7 @@ public class SimStatusDialogControllerTest { CarrierConfigManager.KEY_SHOW_IMS_REGISTRATION_STATUS_BOOL, false); mController.initialize(); + mController.updateEid(mController.getEid(0)); verify(mDialog).removeSettingFromScreen(IMS_REGISTRATION_STATE_LABEL_ID); verify(mDialog).removeSettingFromScreen(IMS_REGISTRATION_STATE_VALUE_ID); @@ -846,6 +878,7 @@ public class SimStatusDialogControllerTest { doReturn(null).when(mTelephonyManager).getSignalStrength(); // we should not crash when running the following line mController.initialize(); + mController.updateEid(mController.getEid(0)); } private void setupCellSignalStrength_lteWcdma(int lteDbm, int lteAsu, int wcdmaDbm,