[Settings] Allow disabled SIM to be controlled in UI

Disabled SIM are hidden from UI due to the API only check if there's a
SIM with mobile data capability active within device.

Right now, the UI design has been changed. The UI here should be
accessible no mater with or without the support of mobile data.

Bug: 193820245
Bug: 194761536
Test: local
Change-Id: I9c8b8fa16e74cd0fe4419966cc97ad55b5b87b17
(cherry picked from commit 847f326cd4)
(cherry picked from commit a8ce9abde7)

src/com/android/settings/network/MobileNetworkSummaryController.java

@@ -23,7 +23,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.UserManager;
 import android.provider.Settings;
-import android.telephony.SubscriptionInfo;
 import android.telephony.SubscriptionManager;
 import android.telephony.euicc.EuiccManager;
 
@@ -36,8 +35,9 @@ import androidx.preference.PreferenceScreen;
 import com.android.settings.R;
 import com.android.settings.core.PreferenceControllerMixin;
 import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.network.helper.SelectableSubscriptions;
+import com.android.settings.network.helper.SubscriptionAnnotation;
 import com.android.settings.network.telephony.MobileNetworkActivity;
-import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.widget.AddPreference;
 import com.android.settingslib.Utils;
@@ -61,6 +61,8 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
     private SubscriptionsChangeListener mChangeListener;
     private AddPreference mPreference;
 
+    private MobileNetworkSummaryStatus mStatusCache = new MobileNetworkSummaryStatus();
+
     /**
      * This controls the summary text and click behavior of the "Mobile network" item on the
      * Network & internet page. There are 3 separate cases depending on the number of mobile network
@@ -82,8 +84,8 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
         mSubscriptionManager = context.getSystemService(SubscriptionManager.class);
         mUserManager = context.getSystemService(UserManager.class);
         if (lifecycle != null) {
-          mChangeListener = new SubscriptionsChangeListener(context, this);
+            mChangeListener = new SubscriptionsChangeListener(context, this);
-          lifecycle.addObserver(this);
+            lifecycle.addObserver(this);
         }
     }
 
@@ -106,25 +108,24 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
 
     @Override
     public CharSequence getSummary() {
-        final List<SubscriptionInfo> subs = SubscriptionUtil.getAvailableSubscriptions(
+        mStatusCache.update(mContext, null);
-                mContext);
+        List<SubscriptionAnnotation> subs = mStatusCache.getSubscriptionList();
+
         if (subs.isEmpty()) {
-            if (MobileNetworkUtils.showEuiccSettings(mContext)) {
+            if (mStatusCache.isEuiccConfigSupport()) {
                 return mContext.getResources().getString(
                         R.string.mobile_network_summary_add_a_network);
             }
-            return null;
+            // set empty string to override previous text for carrier when SIM available
+            return "";
         } else if (subs.size() == 1) {
-            final SubscriptionInfo info = subs.get(0);
+            SubscriptionAnnotation info = subs.get(0);
-            final CharSequence displayName = SubscriptionUtil.getUniqueSubscriptionDisplayName(
+            CharSequence displayName = mStatusCache.getDisplayName(info.getSubscriptionId());
-                    info, mContext);
+            if (info.getSubInfo().isEmbedded() || info.isActive()
-            final int subId = info.getSubscriptionId();
+                    || mStatusCache.isPhysicalSimDisableSupport()) {
-            if (!info.isEmbedded() && !mSubscriptionManager.isActiveSubscriptionId(subId)
-                    && !SubscriptionUtil.showToggleForPhysicalSim(mSubscriptionManager)) {
-                return mContext.getString(R.string.mobile_network_tap_to_activate, displayName);
-            } else {
                 return displayName;
             }
+            return mContext.getString(R.string.mobile_network_tap_to_activate, displayName);
         } else {
             if (com.android.settings.Utils.isProviderModelEnabled(mContext)) {
                 return getSummaryForProviderModel(subs);
@@ -135,10 +136,16 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
         }
     }
 
-    private CharSequence getSummaryForProviderModel(List<SubscriptionInfo> subs) {
+    private CharSequence getSummaryForProviderModel(List<SubscriptionAnnotation> subs) {
-        return String.join(", ", subs.stream().map(subInfo -> {
+        return subs.stream()
-            return SubscriptionUtil.getUniqueSubscriptionDisplayName(subInfo, mContext);
+                .mapToInt(SubscriptionAnnotation::getSubscriptionId)
-        }).collect(Collectors.toList()));
+                .mapToObj(subId -> mStatusCache.getDisplayName(subId))
+                .collect(Collectors.joining(", "));
+    }
+
+    private void logPreferenceClick(Preference preference) {
+        mMetricsFeatureProvider.logClickedPreference(preference,
+                preference.getExtras().getInt(DashboardFragment.CATEGORY));
     }
 
     private void startAddSimFlow() {
@@ -147,62 +154,64 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
         mContext.startActivity(intent);
     }
 
-    private void update() {
+    private void initPreference() {
-        if (mPreference == null || mPreference.isDisabledByAdmin()) {
-            return;
-        }
         refreshSummary(mPreference);
         mPreference.setOnPreferenceClickListener(null);
         mPreference.setOnAddClickListener(null);
         mPreference.setFragment(null);
         mPreference.setEnabled(!mChangeListener.isAirplaneModeOn());
+    }
 
-        final List<SubscriptionInfo> subs = SubscriptionUtil.getAvailableSubscriptions(
+    private void update() {
-                mContext);
+        if (mPreference == null || mPreference.isDisabledByAdmin()) {
+            return;
+        }
 
+        mStatusCache.update(mContext, statusCache -> initPreference());
+
+        List<SubscriptionAnnotation> subs = mStatusCache.getSubscriptionList();
         if (subs.isEmpty()) {
-            if (MobileNetworkUtils.showEuiccSettings(mContext)) {
+            if (mStatusCache.isEuiccConfigSupport()) {
                 mPreference.setOnPreferenceClickListener((Preference pref) -> {
-                    mMetricsFeatureProvider.logClickedPreference(pref,
+                    logPreferenceClick(pref);
-                            pref.getExtras().getInt(DashboardFragment.CATEGORY));
                     startAddSimFlow();
                     return true;
                 });
             } else {
                 mPreference.setEnabled(false);
             }
-        } else {
+            return;
-            // We have one or more existing subscriptions, so we want the plus button if eSIM is
+        }
-            // supported.
-            if (MobileNetworkUtils.showEuiccSettings(mContext)) {
-                mPreference.setAddWidgetEnabled(!mChangeListener.isAirplaneModeOn());
-                mPreference.setOnAddClickListener(p -> {
-                    mMetricsFeatureProvider.logClickedPreference(p,
-                            p.getExtras().getInt(DashboardFragment.CATEGORY));
-                    startAddSimFlow();
-                });
-            }
 
-            if (subs.size() == 1) {
+        // We have one or more existing subscriptions, so we want the plus button if eSIM is
-                mPreference.setOnPreferenceClickListener((Preference pref) -> {
+        // supported.
-                    mMetricsFeatureProvider.logClickedPreference(pref,
+        if (mStatusCache.isEuiccConfigSupport()) {
-                            pref.getExtras().getInt(DashboardFragment.CATEGORY));
+            mPreference.setAddWidgetEnabled(!mChangeListener.isAirplaneModeOn());
-                    final SubscriptionInfo info = subs.get(0);
+            mPreference.setOnAddClickListener(p -> {
-                    final int subId = info.getSubscriptionId();
+                logPreferenceClick(p);
-                    if (!info.isEmbedded() && !mSubscriptionManager.isActiveSubscriptionId(subId)
+                startAddSimFlow();
-                            && !SubscriptionUtil.showToggleForPhysicalSim(mSubscriptionManager)) {
+            });
-                        SubscriptionUtil.startToggleSubscriptionDialogActivity(
+        }
-                                mContext, subId, true);
+
-                    } else {
+        if (subs.size() == 1) {
-                        final Intent intent = new Intent(mContext, MobileNetworkActivity.class);
+            mPreference.setOnPreferenceClickListener((Preference pref) -> {
-                        intent.putExtra(Settings.EXTRA_SUB_ID, subs.get(0).getSubscriptionId());
+                logPreferenceClick(pref);
-                        mContext.startActivity(intent);
+
-                    }
+                SubscriptionAnnotation info = subs.get(0);
+                if (info.getSubInfo().isEmbedded() || info.isActive()
+                        || mStatusCache.isPhysicalSimDisableSupport()) {
+                    final Intent intent = new Intent(mContext, MobileNetworkActivity.class);
+                    intent.putExtra(Settings.EXTRA_SUB_ID, info.getSubscriptionId());
+                    mContext.startActivity(intent);
                     return true;
-                });
+                }
-            } else {
+
-                mPreference.setFragment(MobileNetworkListFragment.class.getCanonicalName());
+                SubscriptionUtil.startToggleSubscriptionDialogActivity(
-            }
+                        mContext, info.getSubscriptionId(), true);
+                return true;
+            });
+        } else {
+            mPreference.setFragment(MobileNetworkListFragment.class.getCanonicalName());
         }
     }
 
@@ -218,12 +227,14 @@ public class MobileNetworkSummaryController extends AbstractPreferenceController
 
     @Override
     public void onAirplaneModeChanged(boolean airplaneModeEnabled) {
-        update();
+        mStatusCache.update(mContext, statusCache -> update());
     }
 
     @Override
     public void onSubscriptionsChanged() {
-        refreshSummary(mPreference);
+        mStatusCache.update(mContext, statusCache -> {
-        update();
+            refreshSummary(mPreference);
+            update();
+        });
     }
 }

src/com/android/settings/network/MobileNetworkSummaryStatus.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.network;
+
+import android.content.Context;
+import android.telephony.SubscriptionManager;
+import android.util.Log;
+
+import com.android.settings.network.SubscriptionUtil;
+import com.android.settings.network.helper.SelectableSubscriptions;
+import com.android.settings.network.helper.SubscriptionAnnotation;
+import com.android.settings.network.helper.SubscriptionGrouping;
+import com.android.settings.network.telephony.MobileNetworkUtils;
+import com.android.settingslib.utils.ThreadUtils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+/**
+ * This one keeps the information required by MobileNetworkSummaryController.
+ */
+public class MobileNetworkSummaryStatus {
+    private static final String LOG_TAG = "MobileNetworkSummaryStatus";
+
+    private Future<Map<Integer, CharSequence>> mUniqueNameMapping;
+    private Map<Integer, CharSequence> mUniqueNameMappingCache;
+
+    private Future<Boolean> mIsEuiccConfiguable;
+    private Boolean mIsEuiccConfiguableCache;
+
+    private Future<Boolean> mIsPsimDisableSupported;
+    private Boolean mIsPsimDisableSupportedCache;
+
+    private List<SubscriptionAnnotation> mSubscriptionList;
+
+    private boolean mDisableReEntranceUpdate;
+
+    // Constructor
+    public MobileNetworkSummaryStatus() {}
+
+    /**
+     * Update the status
+     * @param context
+     * @param andThen Consumer which always performed by the end of #update()
+     *                and avoid from repeated queries.
+     */
+    public void update(Context context, Consumer<MobileNetworkSummaryStatus> andThen) {
+        if (mDisableReEntranceUpdate) {
+            Log.d(LOG_TAG, "network summary query ignored");
+            if (andThen != null) {
+                andThen.accept(this);
+            }
+            return;
+        }
+        mDisableReEntranceUpdate = true;
+        Log.d(LOG_TAG, "network summary query");
+
+        // Query Euicc in background
+        mIsEuiccConfiguable = (Future<Boolean>)
+                ThreadUtils.postOnBackgroundThread(() -> isEuiccConfiguable(context));
+
+        // Query display name in background
+        mUniqueNameMapping = (Future<Map<Integer, CharSequence>>)
+                ThreadUtils.postOnBackgroundThread(() -> getUniqueNameForDisplay(context));
+
+        // Query support status of pSIM disable feature
+        mIsPsimDisableSupported = (Future<Boolean>) ThreadUtils.postOnBackgroundThread(()
+                -> isPhysicalSimDisableSupported(context));
+
+        // Query subscription
+        mSubscriptionList = getSubscriptions(context);
+
+        if (andThen != null) {
+            andThen.accept(this);
+        }
+        mDisableReEntranceUpdate = false;
+    }
+
+    /**
+     * Get the subscription information
+     * @return a list of SubscriptionAnnotation
+     */
+    public List<SubscriptionAnnotation> getSubscriptionList() {
+        return mSubscriptionList;
+    }
+
+    /**
+     * Get unique display name for a specific subscription
+     * @param subscriptionId subscription ID
+     * @return display name for that subscription
+     */
+    public CharSequence getDisplayName(int subscriptionId) {
+        if (mUniqueNameMapping != null) {
+            try {
+                mUniqueNameMappingCache = mUniqueNameMapping.get();
+            } catch (Exception exception) {
+                Log.w(LOG_TAG, "Fail to get display names", exception);
+            }
+            mUniqueNameMapping = null;
+        }
+        if (mUniqueNameMappingCache == null) {
+            return null;
+        }
+        return mUniqueNameMappingCache.get(subscriptionId);
+    }
+
+    // Check if Euicc is currently available
+    public boolean isEuiccConfigSupport() {
+        if (mIsEuiccConfiguable != null) {
+            try {
+                mIsEuiccConfiguableCache = mIsEuiccConfiguable.get();
+            } catch (Exception exception) {
+                Log.w(LOG_TAG, "Fail to get euicc config status", exception);
+            }
+            mIsEuiccConfiguable = null;
+        }
+        return (mIsEuiccConfiguableCache == null) ?
+                false : mIsEuiccConfiguableCache.booleanValue();
+    }
+
+    // Check if disable physical SIM is supported
+    public boolean isPhysicalSimDisableSupport() {
+        if (mIsPsimDisableSupported != null) {
+            try {
+                mIsPsimDisableSupportedCache = mIsPsimDisableSupported.get();
+            } catch (Exception exception) {
+                Log.w(LOG_TAG, "Fail to get pSIM disable support", exception);
+            }
+            mIsPsimDisableSupported = null;
+        }
+        return (mIsPsimDisableSupportedCache == null) ?
+                false : mIsPsimDisableSupportedCache.booleanValue();
+    }
+
+    private List<SubscriptionAnnotation> getSubscriptions(Context context) {
+        return (new SelectableSubscriptions(context, true))
+
+                // To maintain the consistency with SubscriptionUtil#getAvailableSubscriptions().
+                .addFinisher(new SubscriptionGrouping())
+
+                .call()
+                .stream()
+                .filter(SubscriptionAnnotation::isDisplayAllowed)
+                .collect(Collectors.toList());
+    }
+
+    private Map<Integer, CharSequence> getUniqueNameForDisplay(Context context) {
+        return SubscriptionUtil.getUniqueSubscriptionDisplayNames(context);
+    }
+
+    private boolean isPhysicalSimDisableSupported(Context context) {
+        SubscriptionManager subMgr = context.getSystemService(SubscriptionManager.class);
+        return SubscriptionUtil.showToggleForPhysicalSim(subMgr);
+    }
+
+    private boolean isEuiccConfiguable(Context context) {
+        return MobileNetworkUtils.showEuiccSettingsDetecting(context);
+    }
+}

src/com/android/settings/network/helper/QueryEsimCardId.java

@@ -50,8 +50,7 @@ public class QueryEsimCardId implements Callable<AtomicIntegerArray> {
         }
         return new AtomicIntegerArray(cardInfos.stream()
                 .filter(Objects::nonNull)
-                .filter(cardInfo -> (!cardInfo.isRemovable()
+                .filter(cardInfo -> (!cardInfo.isRemovable() && (cardInfo.getCardId() >= 0)))
-                        && (cardInfo.getCardId() != TelephonyManager.UNSUPPORTED_CARD_ID)))
                 .mapToInt(UiccCardInfo::getCardId)
                 .toArray());
     }

src/com/android/settings/network/helper/SelectableSubscriptions.java

@@ -71,8 +71,17 @@ public class SelectableSubscriptions implements Callable<List<SubscriptionAnnota
         mContext = context;
         mSubscriptions = disabledSlotsIncluded ? (() -> getAvailableSubInfoList(context)) :
                 (() -> getActiveSubInfoList(context));
-        mFilter = disabledSlotsIncluded ? (subAnno -> subAnno.isExisted()) :
+        if (disabledSlotsIncluded) {
-                (subAnno -> subAnno.isActive());
+            mFilter = subAnno -> {
+                if (subAnno.isExisted()) {
+                    return true;
+                }
+                return ((subAnno.getType() == SubscriptionAnnotation.TYPE_ESIM)
+                        && (subAnno.isDisplayAllowed()));
+            };
+        } else {
+            mFilter = subAnno -> subAnno.isActive();
+        }
         mFinisher = annoList -> annoList;
     }
 

src/com/android/settings/network/helper/SubscriptionAnnotation.java

@@ -93,10 +93,9 @@ public class SubscriptionAnnotation {
         if (mType == TYPE_ESIM) {
             int cardId = mSubInfo.getCardId();
             mIsExisted = eSimCardId.contains(cardId);
-            if (mIsExisted) {
+            mIsActive = activeSimSlotIndexList.contains(mSubInfo.getSimSlotIndex());
-                mIsActive = activeSimSlotIndexList.contains(mSubInfo.getSimSlotIndex());
+            mIsAllowToDisplay = (cardId < 0)    // always allow when eSIM not in slot
-                mIsAllowToDisplay = isDisplayAllowed(context);
+                  || isDisplayAllowed(context);
-            }
             return;
         }
 
@@ -159,4 +158,11 @@ public class SubscriptionAnnotation {
         return SubscriptionUtil.isSubscriptionVisible(
                 context.getSystemService(SubscriptionManager.class), context, mSubInfo);
     }
+
+    public String toString() {
+        return TAG + "{" + "subId=" + getSubscriptionId()
+                + ",type=" + getType() + ",exist=" + isExisted()
+                + ",active=" + isActive() + ",displayAllow=" + isDisplayAllowed()
+                + "}";
+    }
 }

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

@@ -266,7 +266,8 @@ public class MobileNetworkUtils {
         return false;
     }
 
-    private static Boolean showEuiccSettingsDetecting(Context context) {
+    // The same as #showEuiccSettings(Context context)
+    public static Boolean showEuiccSettingsDetecting(Context context) {
         final EuiccManager euiccManager =
                 (EuiccManager) context.getSystemService(EuiccManager.class);
         if (!euiccManager.isEnabled()) {