414 lines
19 KiB
Java
414 lines
19 KiB
Java
/*
|
|
* Copyright (C) 2020 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.annotation.IntDef;
|
|
import android.content.Context;
|
|
import android.provider.Settings;
|
|
import android.telephony.SubscriptionInfo;
|
|
import android.telephony.SubscriptionManager;
|
|
import android.telephony.TelephonyManager;
|
|
import android.telephony.UiccCardInfo;
|
|
import android.telephony.UiccSlotInfo;
|
|
import android.telephony.UiccSlotMapping;
|
|
import android.util.Log;
|
|
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
import com.android.internal.telephony.uicc.UiccController;
|
|
import com.android.settingslib.utils.ThreadUtils;
|
|
|
|
import com.google.common.collect.ImmutableList;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
import java.util.concurrent.CountDownLatch;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.IntStream;
|
|
|
|
// ToDo: to do the refactor for renaming
|
|
public class UiccSlotUtil {
|
|
|
|
private static final String TAG = "UiccSlotUtil";
|
|
|
|
private static final long DEFAULT_WAIT_AFTER_SWITCH_TIMEOUT_MILLIS = 25 * 1000L;
|
|
|
|
public static final int INVALID_LOGICAL_SLOT_ID = -1;
|
|
public static final int INVALID_PHYSICAL_SLOT_ID = -1;
|
|
public static final int INVALID_PORT_ID = -1;
|
|
|
|
/**
|
|
* Mode for switching to eSIM slot which decides whether there is cleanup process, e.g.
|
|
* disabling test profile, after eSIM slot is activated and whether we will wait it finished.
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({
|
|
SwitchingEsimMode.NO_CLEANUP,
|
|
SwitchingEsimMode.ASYNC_CLEANUP,
|
|
SwitchingEsimMode.SYNC_CLEANUP
|
|
})
|
|
public @interface SwitchingEsimMode {
|
|
/** No cleanup process after switching to eSIM slot */
|
|
int NO_CLEANUP = 0;
|
|
/** Has cleanup process, but we will not wait it finished. */
|
|
int ASYNC_CLEANUP = 1;
|
|
/** Has cleanup process and we will wait until it's finished */
|
|
int SYNC_CLEANUP = 2;
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable list of all UICC slots. If TelephonyManager#getUiccSlotsInfo returns, it
|
|
* returns an empty list instead.
|
|
*/
|
|
public static ImmutableList<UiccSlotInfo> getSlotInfos(TelephonyManager telMgr) {
|
|
UiccSlotInfo[] slotInfos = telMgr.getUiccSlotsInfo();
|
|
if (slotInfos == null) {
|
|
return ImmutableList.of();
|
|
}
|
|
return ImmutableList.copyOf(slotInfos);
|
|
}
|
|
|
|
/**
|
|
* Switches to the removable slot. It waits for SIM_STATE_LOADED after switch. If slotId is
|
|
* INVALID_PHYSICAL_SLOT_ID, the method will use the first detected inactive removable slot.
|
|
*
|
|
* @param slotId the physical removable slot id.
|
|
* @param context the application context.
|
|
* @throws UiccSlotsException if there is an error.
|
|
*/
|
|
//ToDo: delete this api and refactor the related code.
|
|
public static synchronized void switchToRemovableSlot(int slotId, Context context)
|
|
throws UiccSlotsException {
|
|
switchToRemovableSlot(context, slotId, null);
|
|
}
|
|
|
|
/**
|
|
* Switches to the removable slot. It waits for SIM_STATE_LOADED after switch. If slotId is
|
|
* INVALID_PHYSICAL_SLOT_ID, the method will use the first detected inactive removable slot.
|
|
*
|
|
* @param slotId the physical removable slot id.
|
|
* @param context the application context.
|
|
* @param removedSubInfo In the DSDS+MEP mode, if the all of slots have sims, it should
|
|
* remove the one of active sim.
|
|
* If the removedSubInfo is null, then use the default value.
|
|
* The default value is the esim slot and portId 0.
|
|
* @throws UiccSlotsException if there is an error.
|
|
*/
|
|
public static synchronized void switchToRemovableSlot(Context context, int slotId,
|
|
SubscriptionInfo removedSubInfo) throws UiccSlotsException {
|
|
if (ThreadUtils.isMainThread()) {
|
|
throw new IllegalThreadStateException(
|
|
"Do not call switchToRemovableSlot on the main thread.");
|
|
}
|
|
TelephonyManager telMgr = context.getSystemService(TelephonyManager.class);
|
|
int inactiveRemovableSlot = getInactiveRemovableSlot(telMgr.getUiccSlotsInfo(), slotId);
|
|
Log.d(TAG, "The InactiveRemovableSlot: " + inactiveRemovableSlot);
|
|
if (inactiveRemovableSlot == INVALID_PHYSICAL_SLOT_ID) {
|
|
// The slot is invalid slot id, then to skip this.
|
|
// The slot is active, then the sim can enable directly.
|
|
return;
|
|
}
|
|
|
|
Collection<UiccSlotMapping> uiccSlotMappings = telMgr.getSimSlotMapping();
|
|
Log.d(TAG, "The SimSlotMapping: " + uiccSlotMappings);
|
|
|
|
SubscriptionManager subscriptionManager = context.getSystemService(
|
|
SubscriptionManager.class);
|
|
int excludedLogicalSlotIndex = getExcludedLogicalSlotIndex(uiccSlotMappings,
|
|
SubscriptionUtil.getActiveSubscriptions(subscriptionManager), removedSubInfo,
|
|
telMgr.isMultiSimEnabled());
|
|
performSwitchToSlot(telMgr,
|
|
prepareUiccSlotMappings(uiccSlotMappings,
|
|
/*slot is psim*/ true,
|
|
inactiveRemovableSlot,
|
|
/*removable sim's port Id*/ TelephonyManager.DEFAULT_PORT_INDEX,
|
|
excludedLogicalSlotIndex),
|
|
context);
|
|
}
|
|
|
|
/**
|
|
* Switches to the Euicc slot. It waits for SIM_STATE_LOADED after switch.
|
|
*
|
|
* @param context the application context.
|
|
* @param physicalSlotId the Euicc slot id.
|
|
* @param port the Euicc slot port id.
|
|
* @param removedSubInfo In the DSDS+MEP mode, if the all of slots have sims, it should
|
|
* remove the one of active sim.
|
|
* If the removedSubInfo is null, then it uses the default value.
|
|
* The default value is the esim slot and portId 0.
|
|
* @throws UiccSlotsException if there is an error.
|
|
*/
|
|
public static synchronized void switchToEuiccSlot(Context context, int physicalSlotId, int port,
|
|
SubscriptionInfo removedSubInfo) throws UiccSlotsException {
|
|
if (ThreadUtils.isMainThread()) {
|
|
throw new IllegalThreadStateException(
|
|
"Do not call switchToRemovableSlot on the main thread.");
|
|
}
|
|
TelephonyManager telMgr = context.getSystemService(TelephonyManager.class);
|
|
Collection<UiccSlotMapping> uiccSlotMappings = telMgr.getSimSlotMapping();
|
|
Log.d(TAG, "The SimSlotMapping: " + uiccSlotMappings);
|
|
|
|
if (isTargetSlotActive(uiccSlotMappings, physicalSlotId, port)) {
|
|
Log.d(TAG, "The slot is active, then the sim can enable directly.");
|
|
return;
|
|
}
|
|
|
|
SubscriptionManager subscriptionManager = context.getSystemService(
|
|
SubscriptionManager.class);
|
|
int excludedLogicalSlotIndex = getExcludedLogicalSlotIndex(uiccSlotMappings,
|
|
SubscriptionUtil.getActiveSubscriptions(subscriptionManager), removedSubInfo,
|
|
telMgr.isMultiSimEnabled());
|
|
performSwitchToSlot(telMgr,
|
|
prepareUiccSlotMappings(uiccSlotMappings, /*slot is not psim*/ false,
|
|
physicalSlotId, port, excludedLogicalSlotIndex),
|
|
context);
|
|
}
|
|
|
|
/**
|
|
* @param context the application context.
|
|
* @return the esim slot. If the value is -1, there is not the esim.
|
|
*/
|
|
public static int getEsimSlotId(Context context, int subId) {
|
|
TelephonyManager telMgr = context.getSystemService(TelephonyManager.class);
|
|
List<UiccCardInfo> uiccCardInfos = telMgr.getUiccCardsInfo();
|
|
ImmutableList<UiccSlotInfo> slotInfos = UiccSlotUtil.getSlotInfos(telMgr);
|
|
SubscriptionManager subscriptionManager = context.getSystemService(
|
|
SubscriptionManager.class);
|
|
SubscriptionInfo subInfo = SubscriptionUtil.getSubById(subscriptionManager, subId);
|
|
|
|
// checking whether this is the removable esim. If it is, then return the removable slot id.
|
|
if (subInfo != null && subInfo.isEmbedded()) {
|
|
for (UiccCardInfo uiccCardInfo : uiccCardInfos) {
|
|
if (uiccCardInfo.getCardId() == subInfo.getCardId()
|
|
&& uiccCardInfo.getCardId() > TelephonyManager.UNSUPPORTED_CARD_ID
|
|
&& uiccCardInfo.isEuicc()
|
|
&& uiccCardInfo.isRemovable()) {
|
|
Log.d(TAG, "getEsimSlotId: This subInfo is a removable esim.");
|
|
return uiccCardInfo.getPhysicalSlotIndex();
|
|
}
|
|
}
|
|
}
|
|
|
|
int firstEsimSlot = IntStream.range(0, slotInfos.size())
|
|
.filter(
|
|
index -> {
|
|
UiccSlotInfo slotInfo = slotInfos.get(index);
|
|
if (slotInfo == null) {
|
|
return false;
|
|
}
|
|
return slotInfo.getIsEuicc();
|
|
})
|
|
.findFirst().orElse(-1);
|
|
|
|
Log.i(TAG, "firstEsimSlot: " + firstEsimSlot);
|
|
return firstEsimSlot;
|
|
}
|
|
|
|
private static boolean isTargetSlotActive(Collection<UiccSlotMapping> uiccSlotMappings,
|
|
int physicalSlotId, int port) {
|
|
return uiccSlotMappings.stream()
|
|
.anyMatch(
|
|
uiccSlotMapping -> uiccSlotMapping.getPhysicalSlotIndex() == physicalSlotId
|
|
&& uiccSlotMapping.getPortIndex() == port);
|
|
}
|
|
|
|
private static void performSwitchToSlot(TelephonyManager telMgr,
|
|
Collection<UiccSlotMapping> uiccSlotMappings, Context context)
|
|
throws UiccSlotsException {
|
|
CarrierConfigChangedReceiver receiver = null;
|
|
long waitingTimeMillis =
|
|
Settings.Global.getLong(
|
|
context.getContentResolver(),
|
|
Settings.Global.EUICC_SWITCH_SLOT_TIMEOUT_MILLIS,
|
|
DEFAULT_WAIT_AFTER_SWITCH_TIMEOUT_MILLIS);
|
|
try {
|
|
CountDownLatch latch = new CountDownLatch(1);
|
|
receiver = new CarrierConfigChangedReceiver(latch);
|
|
receiver.registerOn(context);
|
|
telMgr.setSimSlotMapping(uiccSlotMappings);
|
|
latch.await(waitingTimeMillis, TimeUnit.MILLISECONDS);
|
|
} catch (InterruptedException e) {
|
|
Thread.currentThread().interrupt();
|
|
Log.e(TAG, "Failed switching to physical slot.", e);
|
|
} finally {
|
|
if (receiver != null) {
|
|
context.unregisterReceiver(receiver);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param slots The UiccSlotInfo list.
|
|
* @param slotId The physical removable slot id.
|
|
* @return The inactive physical removable slot id. If the physical removable slot id is
|
|
* active, then return -1.
|
|
* @throws UiccSlotsException if there is an error.
|
|
*/
|
|
private static int getInactiveRemovableSlot(UiccSlotInfo[] slots, int slotId)
|
|
throws UiccSlotsException {
|
|
if (slots == null) {
|
|
throw new UiccSlotsException("UiccSlotInfo is null");
|
|
}
|
|
if (slotId == INVALID_PHYSICAL_SLOT_ID) {
|
|
for (int i = 0; i < slots.length; i++) {
|
|
if (slots[i].isRemovable()
|
|
&& !slots[i].getPorts().stream().findFirst().get().isActive()
|
|
&& slots[i].getCardStateInfo() != UiccSlotInfo.CARD_STATE_INFO_ERROR
|
|
&& slots[i].getCardStateInfo() != UiccSlotInfo.CARD_STATE_INFO_RESTRICTED) {
|
|
return i;
|
|
}
|
|
}
|
|
} else {
|
|
if (slotId >= slots.length || !slots[slotId].isRemovable()) {
|
|
throw new UiccSlotsException("The given slotId is not a removable slot: " + slotId);
|
|
}
|
|
if (!slots[slotId].getPorts().stream().findFirst().get().isActive()) {
|
|
return slotId;
|
|
}
|
|
}
|
|
return INVALID_PHYSICAL_SLOT_ID;
|
|
}
|
|
|
|
// Device | |Slot |
|
|
// Working| |Mapping|
|
|
// State |Type |Mode |Friendly name
|
|
//--------------------------------------------------------------------------
|
|
// Single |SIM pSIM [RIL 0] |1 |pSIM active
|
|
// Single |SIM MEP Port #0 [RIL0] |2 |eSIM Port0 active
|
|
// Single |SIM MEP Port #1 [RIL0] |2.1 |eSIM Port1 active
|
|
// DSDS |pSIM [RIL 0] + MEP Port #0 [RIL 1] |3 |pSIM+Port0
|
|
// DSDS |pSIM [RIL 0] + MEP Port #1 [RIL 1] |3.1 |pSIM+Port1
|
|
// DSDS |MEP Port #0 [RIL 0] + MEP Port #1 [RIL1]|3.2 |Dual-Ports-A
|
|
// DSDS |MEP Port #1 [RIL 0] + MEP Port #0 [RIL1]|4 |Dual-Ports-B
|
|
//
|
|
// The rules are:
|
|
// 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<UiccSlotMapping> prepareUiccSlotMappings(
|
|
Collection<UiccSlotMapping> uiccSlotMappings, boolean isPsim, int physicalSlotId,
|
|
int port, int removedLogicalSlotId) {
|
|
if (removedLogicalSlotId == INVALID_LOGICAL_SLOT_ID) {
|
|
Log.d(TAG, "There is no removedLogicalSlotId. Do nothing.");
|
|
return uiccSlotMappings;
|
|
}
|
|
Log.d(TAG,
|
|
String.format(
|
|
"Create new SimSlotMapping. Remove the UiccSlotMapping of logicalSlot%d"
|
|
+ ", and insert PhysicalSlotId%d-Port%d",
|
|
removedLogicalSlotId, physicalSlotId, port));
|
|
Collection<UiccSlotMapping> newUiccSlotMappings = new ArrayList<>();
|
|
int logicalSlotIndex = 0;
|
|
if (isPsim) {
|
|
// The target slot is psim. The psim is always the first index at LogicalSlot.
|
|
newUiccSlotMappings.add(
|
|
new UiccSlotMapping(port, physicalSlotId, logicalSlotIndex++));
|
|
}
|
|
Collection<UiccSlotMapping> tempUiccSlotMappings =
|
|
uiccSlotMappings.stream()
|
|
.sorted(Comparator.comparingInt(UiccSlotMapping::getLogicalSlotIndex))
|
|
.collect(Collectors.toList());
|
|
for (UiccSlotMapping uiccSlotMapping : tempUiccSlotMappings) {
|
|
if (uiccSlotMapping.getLogicalSlotIndex() == removedLogicalSlotId) {
|
|
if (!isPsim) {
|
|
// Replace this uiccSlotMapping
|
|
newUiccSlotMappings.add(new UiccSlotMapping(port, physicalSlotId,
|
|
uiccSlotMapping.getLogicalSlotIndex()));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// If the psim is inserted, then change the logicalSlotIndex for another
|
|
// uiccSlotMappings.
|
|
newUiccSlotMappings.add(isPsim
|
|
? new UiccSlotMapping(uiccSlotMapping.getPortIndex(),
|
|
uiccSlotMapping.getPhysicalSlotIndex(), logicalSlotIndex++)
|
|
: uiccSlotMapping);
|
|
}
|
|
|
|
Log.d(TAG, "The new SimSlotMapping: " + newUiccSlotMappings);
|
|
return newUiccSlotMappings;
|
|
}
|
|
|
|
/**
|
|
* To get the excluded logical slot index from uiccSlotMapping list. If the sim which is
|
|
* enabled by user does not have the corresponding slot, then it needs to do the
|
|
* SimSlotMapping changed. This method can find the logical slot index of the corresponding slot
|
|
* before the Frameworks do the SimSlotMapping changed.
|
|
*
|
|
* @param uiccSlotMappings The uiccSlotMapping list from the Telephony Frameworks.
|
|
* @param activeSubInfos The active subscriptionInfo list.
|
|
* @param removedSubInfo The removed sim card which is selected by the user. If the user
|
|
* don't select removed sim , then the value is null.
|
|
* @param isMultiSimEnabled whether the device is in the DSDS mode or not.
|
|
* @return The logical slot index of removed slot. If it can't find the removed slot, it
|
|
* returns {@link #INVALID_LOGICAL_SLOT_ID}.
|
|
*/
|
|
@VisibleForTesting
|
|
static int getExcludedLogicalSlotIndex(Collection<UiccSlotMapping> uiccSlotMappings,
|
|
Collection<SubscriptionInfo> activeSubInfos, SubscriptionInfo removedSubInfo,
|
|
boolean isMultiSimEnabled) {
|
|
if (!isMultiSimEnabled) {
|
|
Log.i(TAG, "In the ss mode.");
|
|
return 0;
|
|
}
|
|
if (removedSubInfo != null) {
|
|
// Use removedSubInfo's logicalSlotIndex
|
|
Log.i(TAG, "The removedSubInfo is not null");
|
|
return removedSubInfo.getSimSlotIndex();
|
|
}
|
|
// If it needs to do simSlotMapping when user enables sim and there is an empty slot which
|
|
// there is no enabled sim in this slot, then the empty slot can be removed.
|
|
Log.i(TAG, "The removedSubInfo is null");
|
|
return uiccSlotMappings.stream()
|
|
.filter(uiccSlotMapping -> {
|
|
// find the empty slots.
|
|
for (SubscriptionInfo subInfo : activeSubInfos) {
|
|
if (subInfo.getSimSlotIndex() == uiccSlotMapping.getLogicalSlotIndex()) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
})
|
|
.sorted(Comparator.comparingInt(UiccSlotMapping::getLogicalSlotIndex))
|
|
.mapToInt(uiccSlotMapping -> uiccSlotMapping.getLogicalSlotIndex())
|
|
.findFirst()
|
|
.orElse(INVALID_LOGICAL_SLOT_ID);
|
|
}
|
|
}
|