Merge "[Settings] Hide subscriptions not existed within device" into sc-dev
diff --git a/src/com/android/settings/network/SubscriptionUtil.java b/src/com/android/settings/network/SubscriptionUtil.java
index c2ec13a..2d60778 100644
--- a/src/com/android/settings/network/SubscriptionUtil.java
+++ b/src/com/android/settings/network/SubscriptionUtil.java
@@ -486,7 +486,7 @@
* @param info the subscriptionInfo to check against.
* @return true if this subscription should be visible to the API caller.
*/
- private static boolean isSubscriptionVisible(
+ public static boolean isSubscriptionVisible(
SubscriptionManager subscriptionManager, Context context, SubscriptionInfo info) {
if (info == null) return false;
// If subscription is NOT grouped opportunistic subscription, it's visible.
diff --git a/src/com/android/settings/network/helper/QueryEsimCardId.java b/src/com/android/settings/network/helper/QueryEsimCardId.java
new file mode 100644
index 0000000..dc29c47
--- /dev/null
+++ b/src/com/android/settings/network/helper/QueryEsimCardId.java
@@ -0,0 +1,58 @@
+/*
+ * 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.helper;
+
+import android.telephony.TelephonyManager;
+import android.telephony.UiccCardInfo;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicIntegerArray;
+
+/**
+ * This is a Callable class which queries valid card ID for eSIM
+ */
+public class QueryEsimCardId implements Callable<AtomicIntegerArray> {
+ private static final String TAG = "QueryEsimCardId";
+
+ private TelephonyManager mTelephonyManager;
+
+ /**
+ * Constructor of class
+ * @param TelephonyManager
+ */
+ public QueryEsimCardId(TelephonyManager telephonyManager) {
+ mTelephonyManager = telephonyManager;
+ }
+
+ /**
+ * Implementation of Callable
+ * @return card ID(s) in AtomicIntegerArray
+ */
+ public AtomicIntegerArray call() {
+ List<UiccCardInfo> cardInfos = mTelephonyManager.getUiccCardsInfo();
+ if (cardInfos == null) {
+ return new AtomicIntegerArray(0);
+ }
+ return new AtomicIntegerArray(cardInfos.stream()
+ .filter(Objects::nonNull)
+ .filter(cardInfo -> (!cardInfo.isRemovable()
+ && (cardInfo.getCardId() != TelephonyManager.UNSUPPORTED_CARD_ID)))
+ .mapToInt(UiccCardInfo::getCardId)
+ .toArray());
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/network/helper/QuerySimSlotIndex.java b/src/com/android/settings/network/helper/QuerySimSlotIndex.java
new file mode 100644
index 0000000..b70a148
--- /dev/null
+++ b/src/com/android/settings/network/helper/QuerySimSlotIndex.java
@@ -0,0 +1,87 @@
+/*
+ * 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.helper;
+
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.telephony.UiccSlotInfo;
+
+import java.util.Arrays;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicIntegerArray;
+
+/**
+ * This is a Callable class which query slot index within device
+ */
+public class QuerySimSlotIndex implements Callable<AtomicIntegerArray> {
+ private static final String TAG = "QuerySimSlotIndex";
+
+ private TelephonyManager mTelephonyManager;
+ private boolean mDisabledSlotsIncluded;
+ private boolean mOnlySlotWithSim;
+
+ /**
+ * Constructor of class
+ * @param TelephonyManager
+ * @param disabledSlotsIncluded query both active and inactive slots when true,
+ * only query active slot when false.
+ * @param onlySlotWithSim query slot index with SIM available when true,
+ * include absent ones when false.
+ */
+ public QuerySimSlotIndex(TelephonyManager telephonyManager,
+ boolean disabledSlotsIncluded, boolean onlySlotWithSim) {
+ mTelephonyManager = telephonyManager;
+ mDisabledSlotsIncluded = disabledSlotsIncluded;
+ mOnlySlotWithSim = onlySlotWithSim;
+ }
+
+ /**
+ * Implementation of Callable
+ * @return slot index in AtomicIntegerArray
+ */
+ public AtomicIntegerArray call() {
+ UiccSlotInfo [] slotInfo = mTelephonyManager.getUiccSlotsInfo();
+ if (slotInfo == null) {
+ return new AtomicIntegerArray(0);
+ }
+ int slotIndexFilter = mOnlySlotWithSim ? 0 : SubscriptionManager.INVALID_SIM_SLOT_INDEX;
+ return new AtomicIntegerArray(Arrays.stream(slotInfo)
+ .filter(slot -> filterSlot(slot))
+ .mapToInt(slot -> mapToSlotIndex(slot))
+ .filter(slotIndex -> (slotIndex >= slotIndexFilter))
+ .toArray());
+ }
+
+ protected boolean filterSlot(UiccSlotInfo slotInfo) {
+ if (mDisabledSlotsIncluded) {
+ return true;
+ }
+ if (slotInfo == null) {
+ return false;
+ }
+ return slotInfo.getIsActive();
+ }
+
+ protected int mapToSlotIndex(UiccSlotInfo slotInfo) {
+ if (slotInfo == null) {
+ return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
+ }
+ if (slotInfo.getCardStateInfo() == UiccSlotInfo.CARD_STATE_INFO_ABSENT) {
+ return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
+ }
+ return slotInfo.getLogicalSlotIdx();
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/network/helper/SelectableSubscriptions.java b/src/com/android/settings/network/helper/SelectableSubscriptions.java
new file mode 100644
index 0000000..436e84c
--- /dev/null
+++ b/src/com/android/settings/network/helper/SelectableSubscriptions.java
@@ -0,0 +1,160 @@
+/*
+ * 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.helper;
+
+import android.content.Context;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.annotation.Keep;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.settings.network.helper.SubscriptionAnnotation;
+import com.android.settingslib.utils.ThreadUtils;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicIntegerArray;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * This is a Callable class to query user selectable subscription list.
+ *
+ * Here's example of creating a Callable for retrieving a list of SubscriptionAnnotation
+ * for active Subscriptions:
+ *
+ * List<SubscriptionAnnotation> result = (new SelectableSubscriptions(context, false)).call();
+ *
+ * Another example for retrieving a list of SubscriptionAnnotation for all subscriptions
+ * accessible in another thread.
+ *
+ * List<SubscriptionAnnotation> result = ExecutorService.submit(
+ * new SelectableSubscriptions(context, true)).get()
+ */
+public class SelectableSubscriptions implements Callable<List<SubscriptionAnnotation>> {
+ private static final String TAG = "SelectableSubscriptions";
+
+ private Context mContext;
+ private Supplier<List<SubscriptionInfo>> mSubscriptions;
+ private Predicate<SubscriptionAnnotation> mFilter;
+ private Function<List<SubscriptionAnnotation>, List<SubscriptionAnnotation>> mFinisher;
+
+ /**
+ * Constructor of class
+ * @param context
+ * @param disabledSlotsIncluded query both active and inactive slots when true,
+ * only query active slot when false.
+ */
+ public SelectableSubscriptions(Context context, boolean disabledSlotsIncluded) {
+ mContext = context;
+ mSubscriptions = disabledSlotsIncluded ? (() -> getAvailableSubInfoList(context)) :
+ (() -> getActiveSubInfoList(context));
+ mFilter = disabledSlotsIncluded ? (subAnno -> subAnno.isExisted()) :
+ (subAnno -> subAnno.isActive());
+ mFinisher = annoList -> annoList;
+ }
+
+ /**
+ * Add UnaryOperator to be applied to the final result.
+ * @param finisher a function to be applied to the final result.
+ */
+ public SelectableSubscriptions addFinisher(
+ UnaryOperator<List<SubscriptionAnnotation>> finisher) {
+ mFinisher = mFinisher.andThen(finisher);
+ return this;
+ }
+
+ /**
+ * Implementation of Callable
+ * @return a list of SubscriptionAnnotation which is user selectable
+ */
+ public List<SubscriptionAnnotation> call() {
+ TelephonyManager telMgr = mContext.getSystemService(TelephonyManager.class);
+
+ try {
+ // query in background thread
+ Future<AtomicIntegerArray> eSimCardId =
+ ThreadUtils.postOnBackgroundThread(new QueryEsimCardId(telMgr));
+
+ // query in background thread
+ Future<AtomicIntegerArray> simSlotIndex =
+ ThreadUtils.postOnBackgroundThread(
+ new QuerySimSlotIndex(telMgr, true, true));
+
+ // query in background thread
+ Future<AtomicIntegerArray> activeSimSlotIndex =
+ ThreadUtils.postOnBackgroundThread(
+ new QuerySimSlotIndex(telMgr, false, true));
+
+ List<SubscriptionInfo> subInfoList = mSubscriptions.get();
+
+ // wait for result from background thread
+ List<Integer> eSimCardIdList = atomicToList(eSimCardId.get());
+ List<Integer> simSlotIndexList = atomicToList(simSlotIndex.get());
+ List<Integer> activeSimSlotIndexList = atomicToList(activeSimSlotIndex.get());
+
+ // build a list of SubscriptionAnnotation
+ return IntStream.range(0, subInfoList.size())
+ .mapToObj(subInfoIndex ->
+ new SubscriptionAnnotation.Builder(subInfoList, subInfoIndex))
+ .map(annoBdr -> annoBdr.build(mContext,
+ eSimCardIdList, simSlotIndexList, activeSimSlotIndexList))
+ .filter(mFilter)
+ .collect(Collectors.collectingAndThen(Collectors.toList(), mFinisher));
+ } catch (Exception exception) {
+ Log.w(TAG, "Fail to request subIdList", exception);
+ }
+ return Collections.emptyList();
+ }
+
+ protected List<SubscriptionInfo> getSubInfoList(Context context,
+ Function<SubscriptionManager, List<SubscriptionInfo>> convertor) {
+ SubscriptionManager subManager = getSubscriptionManager(context);
+ return (subManager == null) ? Collections.emptyList() : convertor.apply(subManager);
+ }
+
+ protected SubscriptionManager getSubscriptionManager(Context context) {
+ return context.getSystemService(SubscriptionManager.class);
+ }
+
+ protected List<SubscriptionInfo> getAvailableSubInfoList(Context context) {
+ return getSubInfoList(context, SubscriptionManager::getAvailableSubscriptionInfoList);
+ }
+
+ protected List<SubscriptionInfo> getActiveSubInfoList(Context context) {
+ return getSubInfoList(context, SubscriptionManager::getActiveSubscriptionInfoList);
+ }
+
+ @Keep
+ @VisibleForTesting
+ protected static List<Integer> atomicToList(AtomicIntegerArray atomicIntArray) {
+ if (atomicIntArray == null) {
+ return Collections.emptyList();
+ }
+ return IntStream.range(0, atomicIntArray.length())
+ .map(idx -> atomicIntArray.get(idx)).boxed()
+ .collect(Collectors.toList());
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/network/helper/SubscriptionAnnotation.java b/src/com/android/settings/network/helper/SubscriptionAnnotation.java
new file mode 100644
index 0000000..fae5b9b
--- /dev/null
+++ b/src/com/android/settings/network/helper/SubscriptionAnnotation.java
@@ -0,0 +1,163 @@
+/*
+ * 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.helper;
+
+import android.content.Context;
+import android.os.ParcelUuid;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
+
+import androidx.annotation.Keep;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.settings.network.SubscriptionUtil;
+
+import java.util.List;
+
+/**
+ * This is a class helps providing additional info required by UI
+ * based on SubscriptionInfo.
+ */
+public class SubscriptionAnnotation {
+ private static final String TAG = "SubscriptionAnnotation";
+
+ private SubscriptionInfo mSubInfo;
+ private int mOrderWithinList;
+ private int mType = TYPE_UNKNOWN;
+ private boolean mIsExisted;
+ private boolean mIsActive;
+ private boolean mIsAllowToDisplay;
+
+ public static final ParcelUuid EMPTY_UUID = ParcelUuid.fromString("0-0-0-0-0");
+
+ public static final int TYPE_UNKNOWN = 0x0;
+ public static final int TYPE_PSIM = 0x1;
+ public static final int TYPE_ESIM = 0x2;
+
+ /**
+ * Builder class for SubscriptionAnnotation
+ */
+ public static class Builder {
+
+ private List<SubscriptionInfo> mSubInfoList;
+ private int mIndexWithinList;
+
+ /**
+ * Constructor of builder
+ * @param subInfoList list of subscription info
+ * @param indexWithinList target index within list provided
+ */
+ public Builder(List<SubscriptionInfo> subInfoList, int indexWithinList) {
+ mSubInfoList = subInfoList;
+ mIndexWithinList = indexWithinList;
+ }
+
+ public SubscriptionAnnotation build(Context context, List<Integer> eSimCardId,
+ List<Integer> simSlotIndex, List<Integer> activeSimSlotIndex) {
+ return new SubscriptionAnnotation(mSubInfoList, mIndexWithinList, context,
+ eSimCardId, simSlotIndex, activeSimSlotIndex);
+ }
+ }
+
+ /**
+ * Constructor of class
+ */
+ @Keep
+ @VisibleForTesting
+ protected SubscriptionAnnotation(List<SubscriptionInfo> subInfoList, int subInfoIndex,
+ Context context, List<Integer> eSimCardId,
+ List<Integer> simSlotIndex, List<Integer> activeSimSlotIndexList) {
+ if ((subInfoIndex < 0) || (subInfoIndex >= subInfoList.size())) {
+ return;
+ }
+ mSubInfo = subInfoList.get(subInfoIndex);
+ if (mSubInfo == null) {
+ return;
+ }
+
+ mOrderWithinList = subInfoIndex;
+ mType = mSubInfo.isEmbedded() ? TYPE_ESIM : TYPE_PSIM;
+ if (mType == TYPE_ESIM) {
+ int cardId = mSubInfo.getCardId();
+ mIsExisted = eSimCardId.contains(cardId);
+ if (mIsExisted) {
+ mIsActive = activeSimSlotIndexList.contains(mSubInfo.getSimSlotIndex());
+ mIsAllowToDisplay = isDisplayAllowed(context);
+ }
+ return;
+ }
+
+ mIsExisted = simSlotIndex.contains(mSubInfo.getSimSlotIndex());
+ mIsActive = activeSimSlotIndexList.contains(mSubInfo.getSimSlotIndex());
+ if (mIsExisted) {
+ mIsAllowToDisplay = isDisplayAllowed(context);
+ }
+ }
+
+ // the index provided during construction of Builder
+ @Keep
+ public int getOrderingInList() {
+ return mOrderWithinList;
+ }
+
+ // type of subscription
+ @Keep
+ public int getType() {
+ return mType;
+ }
+
+ // if a subscription is existed within device
+ @Keep
+ public boolean isExisted() {
+ return mIsExisted;
+ }
+
+ // if a subscription is currently ON
+ @Keep
+ public boolean isActive() {
+ return mIsActive;
+ }
+
+ // if display of subscription is allowed
+ @Keep
+ public boolean isDisplayAllowed() {
+ return mIsAllowToDisplay;
+ }
+
+ // the subscription ID
+ @Keep
+ public int getSubscriptionId() {
+ return (mSubInfo == null) ? SubscriptionManager.INVALID_SUBSCRIPTION_ID :
+ mSubInfo.getSubscriptionId();
+ }
+
+ // the grouping UUID
+ @Keep
+ public ParcelUuid getGroupUuid() {
+ return (mSubInfo == null) ? null : mSubInfo.getGroupUuid();
+ }
+
+ // the SubscriptionInfo
+ @Keep
+ public SubscriptionInfo getSubInfo() {
+ return mSubInfo;
+ }
+
+ private boolean isDisplayAllowed(Context context) {
+ return SubscriptionUtil.isSubscriptionVisible(
+ context.getSystemService(SubscriptionManager.class), context, mSubInfo);
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/network/helper/SubscriptionGrouping.java b/src/com/android/settings/network/helper/SubscriptionGrouping.java
new file mode 100644
index 0000000..cfb5ea9
--- /dev/null
+++ b/src/com/android/settings/network/helper/SubscriptionGrouping.java
@@ -0,0 +1,96 @@
+/*
+ * 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.helper;
+
+import android.os.ParcelUuid;
+
+import androidx.annotation.Keep;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.settings.network.helper.SubscriptionAnnotation;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+
+/**
+ * A UnaryOperator for converting a list of SubscriptionAnnotation into
+ * another list of SubscriptionAnnotation based on group UUID.
+ * Only one SubscriptionAnnotation with entries with same (valid) group UUID would be kept.
+ *
+ * Here's an example when applying this operation as a finisher of SelectableSubscriptions:
+ *
+ * Callable<SubscriptionAnnotation> callable = (new SelectableSubscriptions(context, true))
+ * .addFinisher(new SubscriptionGrouping());
+ *
+ * List<SubscriptionAnnotation> result = ExecutorService.submit(callable).get()
+ */
+public class SubscriptionGrouping
+ implements UnaryOperator<List<SubscriptionAnnotation>> {
+
+ // implementation of UnaryOperator
+ public List<SubscriptionAnnotation> apply(List<SubscriptionAnnotation> listOfSubscriptions) {
+ // group by GUID
+ Map<ParcelUuid, List<SubscriptionAnnotation>> groupedSubInfoList =
+ listOfSubscriptions.stream()
+ .filter(Objects::nonNull)
+ .collect(Collectors.groupingBy(subAnno -> getGroupUuid(subAnno)));
+
+ // select best one from subscription(s) within the same group
+ groupedSubInfoList.replaceAll((uuid, annoList) -> {
+ if ((uuid == SubscriptionAnnotation.EMPTY_UUID) || (annoList.size() <= 1)) {
+ return annoList;
+ }
+ return Collections.singletonList(selectBestFromList(annoList));
+ });
+
+ // build a stream of subscriptions
+ return groupedSubInfoList.values()
+ .stream().flatMap(List::stream).collect(Collectors.toList());
+ }
+
+ @Keep
+ @VisibleForTesting
+ protected ParcelUuid getGroupUuid(SubscriptionAnnotation subAnno) {
+ ParcelUuid groupUuid = subAnno.getGroupUuid();
+ return (groupUuid == null) ? SubscriptionAnnotation.EMPTY_UUID : groupUuid;
+ }
+
+ protected SubscriptionAnnotation selectBestFromList(List<SubscriptionAnnotation> annoList) {
+ Comparator<SubscriptionAnnotation> annoSelector = (anno1, anno2) -> {
+ if (anno1.isDisplayAllowed() != anno2.isDisplayAllowed()) {
+ return anno1.isDisplayAllowed() ? -1 : 1;
+ }
+ if (anno1.isActive() != anno2.isActive()) {
+ return anno1.isActive() ? -1 : 1;
+ }
+ if (anno1.isExisted() != anno2.isExisted()) {
+ return anno1.isExisted() ? -1 : 1;
+ }
+ return 0;
+ };
+ annoSelector = annoSelector
+ // eSIM in front of pSIM
+ .thenComparingInt(anno -> -anno.getType())
+ // subscription ID in reverse order
+ .thenComparingInt(anno -> -anno.getSubscriptionId());
+ return annoList.stream().sorted(annoSelector).findFirst().orElse(null);
+ }
+}
diff --git a/src/com/android/settings/network/telephony/MobileNetworkActivity.java b/src/com/android/settings/network/telephony/MobileNetworkActivity.java
index f2be37f..5016460 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkActivity.java
+++ b/src/com/android/settings/network/telephony/MobileNetworkActivity.java
@@ -19,6 +19,7 @@
import static com.android.settings.SettingsActivity.EXTRA_FRAGMENT_ARG_KEY;
import android.app.ActionBar;
+import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.UserManager;
@@ -43,6 +44,8 @@
import com.android.settings.core.SettingsBaseActivity;
import com.android.settings.network.ProxySubscriptionManager;
import com.android.settings.network.SubscriptionUtil;
+import com.android.settings.network.helper.SelectableSubscriptions;
+import com.android.settings.network.helper.SubscriptionAnnotation;
import java.util.List;
@@ -244,15 +247,21 @@
*/
@VisibleForTesting
SubscriptionInfo getSubscription() {
+ List<SubscriptionAnnotation> subList =
+ (new SelectableSubscriptions(this, true)).call();
+ SubscriptionAnnotation currentSubInfo = null;
if (mCurSubscriptionId != SUB_ID_NULL) {
- return getSubscriptionForSubId(mCurSubscriptionId);
+ currentSubInfo = subList.stream()
+ .filter(SubscriptionAnnotation::isDisplayAllowed)
+ .filter(subAnno -> (subAnno.getSubscriptionId() == mCurSubscriptionId))
+ .findFirst().orElse(null);
}
- final List<SubscriptionInfo> subInfos = getProxySubscriptionManager()
- .getActiveSubscriptionsInfo();
- if (CollectionUtils.isEmpty(subInfos)) {
- return null;
+ if (currentSubInfo == null) {
+ currentSubInfo = subList.stream()
+ .filter(SubscriptionAnnotation::isDisplayAllowed)
+ .findFirst().orElse(null);
}
- return subInfos.get(0);
+ return (currentSubInfo == null) ? null : currentSubInfo.getSubInfo();
}
@VisibleForTesting
diff --git a/tests/unit/src/com/android/settings/network/helper/SelectableSubscriptionsTest.java b/tests/unit/src/com/android/settings/network/helper/SelectableSubscriptionsTest.java
new file mode 100644
index 0000000..04e9122
--- /dev/null
+++ b/tests/unit/src/com/android/settings/network/helper/SelectableSubscriptionsTest.java
@@ -0,0 +1,64 @@
+/*
+ * 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.helper;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicIntegerArray;
+
+@RunWith(AndroidJUnit4.class)
+public class SelectableSubscriptionsTest {
+
+ @Before
+ public void setUp() {
+ }
+
+ @Test
+ public void atomicToList_nullInput_getNoneNullEmptyList() {
+ List<Integer> result = SelectableSubscriptions.atomicToList(null);
+
+ assertThat(result.size()).isEqualTo(0);
+ }
+
+ @Test
+ public void atomicToList_zeroLengthInput_getEmptyList() {
+ List<Integer> result = SelectableSubscriptions.atomicToList(new AtomicIntegerArray(0));
+
+ assertThat(result.size()).isEqualTo(0);
+ }
+
+ @Test
+ public void atomicToList_subIdInArray_getList() {
+ AtomicIntegerArray array = new AtomicIntegerArray(3);
+ array.set(0, 3);
+ array.set(1, 7);
+ array.set(2, 4);
+
+ List<Integer> result = SelectableSubscriptions.atomicToList(array);
+
+ assertThat(result.size()).isEqualTo(3);
+ assertThat(result.get(0)).isEqualTo(3);
+ assertThat(result.get(1)).isEqualTo(7);
+ assertThat(result.get(2)).isEqualTo(4);
+ }
+}
diff --git a/tests/unit/src/com/android/settings/network/helper/SubscriptionGroupingTest.java b/tests/unit/src/com/android/settings/network/helper/SubscriptionGroupingTest.java
new file mode 100644
index 0000000..97bdb74
--- /dev/null
+++ b/tests/unit/src/com/android/settings/network/helper/SubscriptionGroupingTest.java
@@ -0,0 +1,137 @@
+/*
+ * 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.helper;
+
+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.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.os.ParcelUuid;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.settings.network.helper.SubscriptionAnnotation;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockitoAnnotations;
+
+import java.util.Arrays;
+import java.util.List;
+
+@RunWith(AndroidJUnit4.class)
+public class SubscriptionGroupingTest {
+
+ private ParcelUuid mMockUuid;
+
+ private Context mContext;
+ private SubscriptionGrouping mTarget;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+
+ mContext = spy(ApplicationProvider.getApplicationContext());
+ mMockUuid = ParcelUuid.fromString("1-1-1-1-1");
+ mTarget = spy(new SubscriptionGrouping());
+ }
+
+ @Test
+ public void apply_multipleEntriesWithSameGroupUuid_onlyOneLeft() {
+ SubscriptionAnnotation subAnno1 = new TestSubAnnotation(1,
+ SubscriptionAnnotation.TYPE_ESIM, true, true, mMockUuid);
+ SubscriptionAnnotation subAnno2 = new TestSubAnnotation(2,
+ SubscriptionAnnotation.TYPE_PSIM, true, true, mMockUuid);
+ SubscriptionAnnotation subAnno3 = new TestSubAnnotation(3,
+ SubscriptionAnnotation.TYPE_ESIM, true, true, mMockUuid);
+ doReturn(mMockUuid).when(mTarget).getGroupUuid(any());
+
+ List<SubscriptionAnnotation> result = mTarget
+ .apply(Arrays.asList(subAnno2, subAnno1, subAnno3));
+ assertThat(result.size()).isEqualTo(1);
+ assertThat(result.get(0)).isEqualTo(subAnno3);
+ }
+
+ @Test
+ public void apply_multipleEntriesWithSameGroupUuid_disabledOneIsAvoided() {
+ SubscriptionAnnotation subAnno1 = new TestSubAnnotation(1,
+ SubscriptionAnnotation.TYPE_ESIM, true, true, mMockUuid);
+ SubscriptionAnnotation subAnno2 = new TestSubAnnotation(2,
+ SubscriptionAnnotation.TYPE_PSIM, true, true, mMockUuid);
+ SubscriptionAnnotation subAnno3 = new TestSubAnnotation(3,
+ SubscriptionAnnotation.TYPE_ESIM, false, false, mMockUuid);
+ doReturn(mMockUuid).when(mTarget).getGroupUuid(any());
+
+ List<SubscriptionAnnotation> result = mTarget
+ .apply(Arrays.asList(subAnno2, subAnno1, subAnno3));
+ assertThat(result.size()).isEqualTo(1);
+ assertThat(result.get(0)).isEqualTo(subAnno1);
+ }
+
+ private class TestSubAnnotation extends SubscriptionAnnotation {
+ private int mSubId;
+ private int mSimType;
+ private boolean mIsActive;
+ private boolean mIsDisplayAllowed;
+ private ParcelUuid mUuid;
+
+ private TestSubAnnotation(int subId, int simType,
+ boolean isActive, boolean isDisplayAllowed, ParcelUuid guuid) {
+ super(null, -1, null, null, null, null);
+ mSubId = subId;
+ mSimType = simType;
+ mIsActive = isActive;
+ mIsDisplayAllowed = isDisplayAllowed;
+ mUuid = guuid;
+ }
+
+ @Override
+ public int getSubscriptionId() {
+ return mSubId;
+ }
+
+ @Override
+ public int getType() {
+ return mSimType;
+ }
+
+ @Override
+ public boolean isExisted() {
+ return true;
+ }
+
+ @Override
+ public boolean isActive() {
+ return mIsActive;
+ }
+
+ @Override
+ public boolean isDisplayAllowed() {
+ return mIsDisplayAllowed;
+ }
+
+ @Override
+ public ParcelUuid getGroupUuid() {
+ return mUuid;
+ }
+ }
+}