| /* |
| * Copyright (C) 2018 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.internal.telephony; |
| |
| import static android.telephony.TelephonyManager.ACTION_MULTI_SIM_CONFIG_CHANGED; |
| import static android.telephony.TelephonyManager.EXTRA_ACTIVE_SIM_SUPPORTED_COUNT; |
| |
| import android.annotation.NonNull; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.os.AsyncResult; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.PowerManager; |
| import android.os.RegistrantList; |
| import android.os.SystemProperties; |
| import android.provider.DeviceConfig; |
| import android.sysprop.TelephonyProperties; |
| import android.telephony.PhoneCapability; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.telephony.TelephonyRegistryManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.telephony.flags.FeatureFlags; |
| import com.android.internal.telephony.subscription.SubscriptionManagerService; |
| import com.android.telephony.Rlog; |
| |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.NoSuchElementException; |
| import java.util.Optional; |
| import java.util.Set; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| import java.util.function.Consumer; |
| import java.util.stream.Collectors; |
| |
| /** |
| * This class manages phone's configuration which defines the potential capability (static) of the |
| * phone and its current activated capability (current). |
| * It gets and monitors static and current phone capability from the modem; send broadcast |
| * if they change, and sends commands to modem to enable or disable phones. |
| */ |
| public class PhoneConfigurationManager { |
| public static final String DSDA = "dsda"; |
| public static final String DSDS = "dsds"; |
| public static final String TSTS = "tsts"; |
| public static final String SSSS = ""; |
| /** DeviceConfig key for whether Virtual DSDA is enabled. */ |
| private static final String KEY_ENABLE_VIRTUAL_DSDA = "enable_virtual_dsda"; |
| private static final String LOG_TAG = "PhoneCfgMgr"; |
| private static final int EVENT_SWITCH_DSDS_CONFIG_DONE = 100; |
| private static final int EVENT_GET_MODEM_STATUS = 101; |
| private static final int EVENT_GET_MODEM_STATUS_DONE = 102; |
| private static final int EVENT_GET_PHONE_CAPABILITY_DONE = 103; |
| private static final int EVENT_DEVICE_CONFIG_CHANGED = 104; |
| private static final int EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE = 105; |
| private static final int EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED = 106; |
| |
| /** |
| * Listener interface for events related to the {@link PhoneConfigurationManager} which should |
| * be reported to the {@link SimultaneousCallingTracker}. |
| */ |
| public interface Listener { |
| public void onPhoneCapabilityChanged(); |
| public void onDeviceConfigChanged(); |
| } |
| |
| /** |
| * Base listener implementation. |
| */ |
| public abstract static class ListenerBase implements Listener { |
| @Override |
| public void onPhoneCapabilityChanged() {} |
| @Override |
| public void onDeviceConfigChanged() {} |
| } |
| |
| |
| private static PhoneConfigurationManager sInstance = null; |
| private final Context mContext; |
| // Static capability retrieved from the modem - may be null in the case where no info has been |
| // retrieved yet. |
| private PhoneCapability mStaticCapability = null; |
| private final Set<Integer> mSlotsSupportingSimultaneousCellularCalls = new HashSet<>(3); |
| private final Set<Integer> mSubIdsSupportingSimultaneousCellularCalls = new HashSet<>(3); |
| private final HashSet<Consumer<Set<Integer>>> mSimultaneousCellularCallingListeners = |
| new HashSet<>(1); |
| private final RadioConfig mRadioConfig; |
| private final Handler mHandler; |
| // mPhones is obtained from PhoneFactory and can have phones corresponding to inactive modems as |
| // well. That is, the array size can be 2 even if num of active modems is 1. |
| private Phone[] mPhones; |
| private final Map<Integer, Boolean> mPhoneStatusMap; |
| private MockableInterface mMi = new MockableInterface(); |
| private TelephonyManager mTelephonyManager; |
| |
| /** Feature flags */ |
| @NonNull |
| private final FeatureFlags mFeatureFlags; |
| private final DefaultPhoneNotifier mNotifier; |
| public Set<Listener> mListeners = new CopyOnWriteArraySet<>(); |
| |
| /** |
| * True if 'Virtual DSDA' i.e., in-call IMS connectivity on both subs with only single logical |
| * modem, is enabled. |
| */ |
| private boolean mVirtualDsdaEnabled; |
| private static final RegistrantList sMultiSimConfigChangeRegistrants = new RegistrantList(); |
| private static final String ALLOW_MOCK_MODEM_PROPERTY = "persist.radio.allow_mock_modem"; |
| private static final String BOOT_ALLOW_MOCK_MODEM_PROPERTY = "ro.boot.radio.allow_mock_modem"; |
| private static final boolean DEBUG = !"user".equals(Build.TYPE); |
| /** |
| * Init method to instantiate the object |
| * Should only be called once. |
| */ |
| public static PhoneConfigurationManager init(Context context, |
| @NonNull FeatureFlags featureFlags) { |
| synchronized (PhoneConfigurationManager.class) { |
| if (sInstance == null) { |
| sInstance = new PhoneConfigurationManager(context, featureFlags); |
| } else { |
| Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance); |
| } |
| return sInstance; |
| } |
| } |
| |
| /** |
| * Constructor. |
| * @param context context needed to send broadcast. |
| */ |
| private PhoneConfigurationManager(Context context, @NonNull FeatureFlags featureFlags) { |
| mContext = context; |
| mFeatureFlags = featureFlags; |
| // TODO: send commands to modem once interface is ready. |
| mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); |
| mRadioConfig = RadioConfig.getInstance(); |
| mHandler = new ConfigManagerHandler(); |
| mPhoneStatusMap = new HashMap<>(); |
| mVirtualDsdaEnabled = DeviceConfig.getBoolean( |
| DeviceConfig.NAMESPACE_TELEPHONY, KEY_ENABLE_VIRTUAL_DSDA, false); |
| mNotifier = new DefaultPhoneNotifier(mContext, mFeatureFlags); |
| DeviceConfig.addOnPropertiesChangedListener( |
| DeviceConfig.NAMESPACE_TELEPHONY, Runnable::run, |
| properties -> { |
| if (TextUtils.equals(DeviceConfig.NAMESPACE_TELEPHONY, |
| properties.getNamespace())) { |
| mHandler.sendEmptyMessage(EVENT_DEVICE_CONFIG_CHANGED); |
| } |
| }); |
| |
| notifyCapabilityChanged(); |
| |
| mPhones = PhoneFactory.getPhones(); |
| |
| for (Phone phone : mPhones) { |
| registerForRadioState(phone); |
| } |
| } |
| |
| /** |
| * Assign a listener to be notified of state changes. |
| * |
| * @param listener A listener. |
| */ |
| public void addListener(Listener listener) { |
| mListeners.add(listener); |
| } |
| |
| /** |
| * Removes a listener. |
| * |
| * @param listener A listener. |
| */ |
| public final void removeListener(Listener listener) { |
| mListeners.remove(listener); |
| } |
| |
| /** |
| * Updates the mapping between the slot IDs that support simultaneous calling and the |
| * associated sub IDs as well as notifies listeners. |
| */ |
| private void updateSimultaneousSubIdsFromPhoneIdMappingAndNotify() { |
| if (!mFeatureFlags.simultaneousCallingIndications()) return; |
| Set<Integer> slotCandidates = mSlotsSupportingSimultaneousCellularCalls.stream() |
| .map(i -> mPhones[i].getSubId()) |
| .filter(i ->i > SubscriptionManager.INVALID_SUBSCRIPTION_ID) |
| .collect(Collectors.toSet()); |
| if (mSubIdsSupportingSimultaneousCellularCalls.equals(slotCandidates)) return; |
| log("updateSimultaneousSubIdsFromPhoneIdMapping update: " |
| + mSubIdsSupportingSimultaneousCellularCalls + " -> " + slotCandidates); |
| mSubIdsSupportingSimultaneousCellularCalls.clear(); |
| mSubIdsSupportingSimultaneousCellularCalls.addAll(slotCandidates); |
| mNotifier.notifySimultaneousCellularCallingSubscriptionsChanged( |
| mSubIdsSupportingSimultaneousCellularCalls); |
| } |
| |
| private void registerForRadioState(Phone phone) { |
| phone.mCi.registerForAvailable(mHandler, Phone.EVENT_RADIO_AVAILABLE, phone); |
| } |
| |
| private PhoneCapability getDefaultCapability() { |
| if (getPhoneCount() > 1) { |
| return PhoneCapability.DEFAULT_DSDS_CAPABILITY; |
| } else { |
| return PhoneCapability.DEFAULT_SSSS_CAPABILITY; |
| } |
| } |
| |
| /** |
| * If virtual DSDA is enabled for this UE, then increase maxActiveVoiceSubscriptions to 2. |
| */ |
| private PhoneCapability maybeOverrideMaxActiveVoiceSubscriptions( |
| final PhoneCapability staticCapability) { |
| boolean isVDsdaEnabled = staticCapability.getLogicalModemList().size() > 1 |
| && mVirtualDsdaEnabled; |
| boolean isBkwdCompatDsdaEnabled = mFeatureFlags.simultaneousCallingIndications() |
| && mMi.getMultiSimProperty().orElse(SSSS).equals(DSDA); |
| if (isVDsdaEnabled || isBkwdCompatDsdaEnabled) { |
| // Since we already initialized maxActiveVoiceSubscriptions to the count the |
| // modem is capable of, we are only able to increase that count via this method. We do |
| // not allow a decrease of maxActiveVoiceSubscriptions: |
| int updatedMaxActiveVoiceSubscriptions = |
| Math.max(staticCapability.getMaxActiveVoiceSubscriptions(), 2); |
| return new PhoneCapability.Builder(staticCapability) |
| .setMaxActiveVoiceSubscriptions(updatedMaxActiveVoiceSubscriptions) |
| .build(); |
| } else { |
| return staticCapability; |
| } |
| } |
| |
| private void maybeEnableCellularDSDASupport() { |
| boolean bkwdsCompatDsda = mFeatureFlags.simultaneousCallingIndications() |
| && getPhoneCount() > 1 |
| && mMi.getMultiSimProperty().orElse(SSSS).equals(DSDA); |
| boolean halSupportSimulCalling = mRadioConfig != null |
| && mRadioConfig.getRadioConfigProxy(null).getVersion().greaterOrEqual( |
| RIL.RADIO_HAL_VERSION_2_2) |
| && getPhoneCount() > 1 |
| && getCellularStaticPhoneCapability().getMaxActiveVoiceSubscriptions() > 1; |
| // Register for simultaneous calling support changes in the modem if the HAL supports it |
| if (halSupportSimulCalling) { |
| updateSimultaneousCallingSupport(); |
| mRadioConfig.registerForSimultaneousCallingSupportStatusChanged(mHandler, |
| EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED, null); |
| } else if (bkwdsCompatDsda) { |
| // For older devices that only declare that they support DSDA via modem config, |
| // set DSDA as capable now statically. |
| log("DSDA modem config detected - setting DSDA enabled"); |
| for (Phone p : mPhones) { |
| mSlotsSupportingSimultaneousCellularCalls.add(p.getPhoneId()); |
| } |
| updateSimultaneousSubIdsFromPhoneIdMappingAndNotify(); |
| notifySimultaneousCellularCallingSlotsChanged(); |
| } |
| // Register for subId updates to notify listeners when simultaneous calling is configured |
| if (mFeatureFlags.simultaneousCallingIndications() |
| && (bkwdsCompatDsda || halSupportSimulCalling)) { |
| mContext.getSystemService(TelephonyRegistryManager.class) |
| .addOnSubscriptionsChangedListener( |
| new SubscriptionManager.OnSubscriptionsChangedListener() { |
| @Override |
| public void onSubscriptionsChanged() { |
| updateSimultaneousSubIdsFromPhoneIdMappingAndNotify(); |
| } |
| }, mHandler::post); |
| } |
| } |
| |
| /** |
| * Static method to get instance. |
| */ |
| public static PhoneConfigurationManager getInstance() { |
| if (sInstance == null) { |
| Log.wtf(LOG_TAG, "getInstance null"); |
| } |
| |
| return sInstance; |
| } |
| |
| /** |
| * Handler class to handle callbacks |
| */ |
| private final class ConfigManagerHandler extends Handler { |
| @Override |
| public void handleMessage(Message msg) { |
| AsyncResult ar; |
| Phone phone = null; |
| switch (msg.what) { |
| case Phone.EVENT_RADIO_AVAILABLE: |
| case Phone.EVENT_RADIO_ON: |
| log("Received EVENT_RADIO_AVAILABLE/EVENT_RADIO_ON"); |
| ar = (AsyncResult) msg.obj; |
| if (ar.userObj != null && ar.userObj instanceof Phone) { |
| phone = (Phone) ar.userObj; |
| updatePhoneStatus(phone); |
| } else { |
| // phone is null |
| log("Unable to add phoneStatus to cache. " |
| + "No phone object provided for event " + msg.what); |
| } |
| updateRadioCapability(); |
| break; |
| case EVENT_SWITCH_DSDS_CONFIG_DONE: |
| ar = (AsyncResult) msg.obj; |
| if (ar != null && ar.exception == null) { |
| int numOfLiveModems = msg.arg1; |
| onMultiSimConfigChanged(numOfLiveModems); |
| } else { |
| log(msg.what + " failure. Not switching multi-sim config." + ar.exception); |
| } |
| break; |
| case EVENT_GET_MODEM_STATUS_DONE: |
| ar = (AsyncResult) msg.obj; |
| if (ar != null && ar.exception == null) { |
| int phoneId = msg.arg1; |
| boolean enabled = (boolean) ar.result; |
| // update the cache each time getModemStatus is requested |
| addToPhoneStatusCache(phoneId, enabled); |
| } else { |
| log(msg.what + " failure. Not updating modem status." + ar.exception); |
| } |
| break; |
| case EVENT_GET_PHONE_CAPABILITY_DONE: |
| ar = (AsyncResult) msg.obj; |
| if (ar != null && ar.exception == null) { |
| setStaticPhoneCapability((PhoneCapability) ar.result); |
| notifyCapabilityChanged(); |
| for (Listener l : mListeners) { |
| l.onPhoneCapabilityChanged(); |
| } |
| maybeEnableCellularDSDASupport(); |
| } else { |
| log(msg.what + " failure. Not getting phone capability." + ar.exception); |
| } |
| break; |
| case EVENT_DEVICE_CONFIG_CHANGED: |
| boolean isVirtualDsdaEnabled = DeviceConfig.getBoolean( |
| DeviceConfig.NAMESPACE_TELEPHONY, KEY_ENABLE_VIRTUAL_DSDA, false); |
| if (isVirtualDsdaEnabled != mVirtualDsdaEnabled) { |
| log("EVENT_DEVICE_CONFIG_CHANGED: from " + mVirtualDsdaEnabled + " to " |
| + isVirtualDsdaEnabled); |
| mVirtualDsdaEnabled = isVirtualDsdaEnabled; |
| for (Listener l : mListeners) { |
| l.onDeviceConfigChanged(); |
| } |
| } |
| break; |
| case EVENT_SIMULTANEOUS_CALLING_SUPPORT_CHANGED: |
| case EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE: |
| log("Received EVENT_SLOTS_SUPPORTING_SIMULTANEOUS_CALL_CHANGED/DONE"); |
| if (getPhoneCount() < 2) { |
| if (!mSlotsSupportingSimultaneousCellularCalls.isEmpty()) { |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| } |
| break; |
| } |
| ar = (AsyncResult) msg.obj; |
| if (ar != null && ar.exception == null) { |
| List<Integer> returnedArrayList = (List<Integer>) ar.result; |
| if (!mSlotsSupportingSimultaneousCellularCalls.isEmpty()) { |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| } |
| int maxValidPhoneSlot = getPhoneCount() - 1; |
| for (int i : returnedArrayList) { |
| if (i < 0 || i > maxValidPhoneSlot) { |
| loge("Invalid slot supporting DSDA =" + i + ". Disabling DSDA."); |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| break; |
| } |
| mSlotsSupportingSimultaneousCellularCalls.add(i); |
| } |
| // Ensure the slots supporting cellular DSDA does not exceed the phone count |
| if (mSlotsSupportingSimultaneousCellularCalls.size() > getPhoneCount()) { |
| loge("Invalid size of DSDA slots. Disabling cellular DSDA."); |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| } |
| } else { |
| log(msg.what + " failure. Not getting logical slots that support " |
| + "simultaneous calling." + ar.exception); |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| } |
| if (mFeatureFlags.simultaneousCallingIndications()) { |
| updateSimultaneousSubIdsFromPhoneIdMappingAndNotify(); |
| notifySimultaneousCellularCallingSlotsChanged(); |
| } |
| break; |
| default: |
| log("Unknown event: " + msg.what); |
| } |
| } |
| } |
| |
| /** |
| * Enable or disable phone |
| * |
| * @param phone which phone to operate on |
| * @param enable true or false |
| * @param result the message to sent back when it's done. |
| */ |
| public void enablePhone(Phone phone, boolean enable, Message result) { |
| if (phone == null) { |
| log("enablePhone failed phone is null"); |
| return; |
| } |
| phone.mCi.enableModem(enable, result); |
| } |
| |
| /** |
| * Get phone status (enabled/disabled) |
| * first query cache, if the status is not in cache, |
| * add it to cache and return a default value true (non-blocking). |
| * |
| * @param phone which phone to operate on |
| */ |
| public boolean getPhoneStatus(Phone phone) { |
| if (phone == null) { |
| log("getPhoneStatus failed phone is null"); |
| return false; |
| } |
| |
| int phoneId = phone.getPhoneId(); |
| |
| //use cache if the status has already been updated/queried |
| try { |
| return getPhoneStatusFromCache(phoneId); |
| } catch (NoSuchElementException ex) { |
| // Return true if modem status cannot be retrieved. For most cases, modem status |
| // is on. And for older version modems, GET_MODEM_STATUS and disable modem are not |
| // supported. Modem is always on. |
| //TODO: this should be fixed in R to support a third status UNKNOWN b/131631629 |
| return true; |
| } finally { |
| //in either case send an asynchronous request to retrieve the phone status |
| updatePhoneStatus(phone); |
| } |
| } |
| |
| /** |
| * Get phone status (enabled/disabled) directly from modem, and use a result Message object |
| * Note: the caller of this method is reponsible to call this in a blocking fashion as well |
| * as read the results and handle the error case. |
| * (In order to be consistent, in error case, we should return default value of true; refer |
| * to #getPhoneStatus method) |
| * |
| * @param phone which phone to operate on |
| * @param result message that will be updated with result |
| */ |
| public void getPhoneStatusFromModem(Phone phone, Message result) { |
| if (phone == null) { |
| log("getPhoneStatus failed phone is null"); |
| } |
| phone.mCi.getModemStatus(result); |
| } |
| |
| /** |
| * return modem status from cache, NoSuchElementException if phoneId not in cache |
| * @param phoneId |
| */ |
| public boolean getPhoneStatusFromCache(int phoneId) throws NoSuchElementException { |
| if (mPhoneStatusMap.containsKey(phoneId)) { |
| return mPhoneStatusMap.get(phoneId); |
| } else { |
| throw new NoSuchElementException("phoneId not found: " + phoneId); |
| } |
| } |
| |
| /** |
| * method to call RIL getModemStatus |
| */ |
| private void updatePhoneStatus(Phone phone) { |
| Message result = Message.obtain( |
| mHandler, EVENT_GET_MODEM_STATUS_DONE, phone.getPhoneId(), 0 /**dummy arg*/); |
| phone.mCi.getModemStatus(result); |
| } |
| |
| /** |
| * Add status of the phone to the status HashMap |
| * @param phoneId |
| * @param status |
| */ |
| public void addToPhoneStatusCache(int phoneId, boolean status) { |
| mPhoneStatusMap.put(phoneId, status); |
| } |
| |
| /** |
| * Returns how many phone objects the device supports. |
| */ |
| public int getPhoneCount() { |
| return mTelephonyManager.getActiveModemCount(); |
| } |
| |
| /** |
| * @return The updated list of logical slots that support simultaneous cellular calling from the |
| * modem based on current network conditions. |
| */ |
| public Set<Integer> getSlotsSupportingSimultaneousCellularCalls() { |
| return mSlotsSupportingSimultaneousCellularCalls; |
| } |
| |
| /** |
| * Get the current the list of logical slots supporting simultaneous cellular calling from the |
| * modem based on current network conditions. |
| */ |
| @VisibleForTesting |
| public void updateSimultaneousCallingSupport() { |
| log("updateSimultaneousCallingSupport: sending the request for " |
| + "getting the list of logical slots supporting simultaneous cellular calling"); |
| Message callback = Message.obtain( |
| mHandler, EVENT_GET_SIMULTANEOUS_CALLING_SUPPORT_DONE); |
| mRadioConfig.updateSimultaneousCallingSupport(callback); |
| log("updateSimultaneousCallingSupport: " |
| + "mSlotsSupportingSimultaneousCellularCalls = " + |
| mSlotsSupportingSimultaneousCellularCalls); |
| } |
| |
| /** |
| * @return static overall phone capabilities for all phones, including voice overrides. |
| */ |
| public synchronized PhoneCapability getStaticPhoneCapability() { |
| boolean isDefault = mStaticCapability == null; |
| PhoneCapability caps = isDefault ? getDefaultCapability() : mStaticCapability; |
| caps = maybeOverrideMaxActiveVoiceSubscriptions(caps); |
| log("getStaticPhoneCapability: isDefault=" + isDefault + ", caps=" + caps); |
| return caps; |
| } |
| |
| /** |
| * @return untouched capabilities returned from the modem |
| */ |
| private synchronized PhoneCapability getCellularStaticPhoneCapability() { |
| log("getCellularStaticPhoneCapability: mStaticCapability " + mStaticCapability); |
| return mStaticCapability; |
| } |
| |
| /** |
| * Caches the static PhoneCapability returned by the modem |
| */ |
| public synchronized void setStaticPhoneCapability(PhoneCapability capability) { |
| log("setStaticPhoneCapability: mStaticCapability " + capability); |
| mStaticCapability = capability; |
| } |
| |
| /** |
| * Query the modem to return its static PhoneCapability and cache it |
| */ |
| @VisibleForTesting |
| public void updateRadioCapability() { |
| log("updateRadioCapability: sending the request for getting PhoneCapability"); |
| Message callback = Message.obtain(mHandler, EVENT_GET_PHONE_CAPABILITY_DONE); |
| mRadioConfig.getPhoneCapability(callback); |
| } |
| |
| /** |
| * get configuration related status of each phone. |
| */ |
| public PhoneCapability getCurrentPhoneCapability() { |
| return getStaticPhoneCapability(); |
| } |
| |
| public int getNumberOfModemsWithSimultaneousDataConnections() { |
| return getStaticPhoneCapability().getMaxActiveDataSubscriptions(); |
| } |
| |
| public int getNumberOfModemsWithSimultaneousVoiceConnections() { |
| return getStaticPhoneCapability().getMaxActiveVoiceSubscriptions(); |
| } |
| |
| public boolean isVirtualDsdaEnabled() { |
| return mVirtualDsdaEnabled; |
| } |
| |
| /** |
| * Register to listen to changes in the Phone slots that support simultaneous calling. |
| * @param consumer A consumer that will be used to consume the new slots supporting simultaneous |
| * cellular calling when it changes. |
| */ |
| public void registerForSimultaneousCellularCallingSlotsChanged( |
| Consumer<Set<Integer>> consumer) { |
| mSimultaneousCellularCallingListeners.add(consumer); |
| } |
| |
| private void notifySimultaneousCellularCallingSlotsChanged() { |
| log("notifying listeners of changes to simultaneous cellular calling - new state:" |
| + mSlotsSupportingSimultaneousCellularCalls); |
| for (Consumer<Set<Integer>> consumer : mSimultaneousCellularCallingListeners) { |
| try { |
| consumer.accept(new HashSet<>(mSlotsSupportingSimultaneousCellularCalls)); |
| } catch (Exception e) { |
| log("Unexpected Exception encountered when notifying listener: " + e); |
| } |
| } |
| } |
| |
| private void notifyCapabilityChanged() { |
| mNotifier.notifyPhoneCapabilityChanged(getStaticPhoneCapability()); |
| } |
| |
| /** |
| * Switch configs to enable multi-sim or switch back to single-sim |
| * @param numOfSims number of active sims we want to switch to |
| */ |
| public void switchMultiSimConfig(int numOfSims) { |
| log("switchMultiSimConfig: with numOfSims = " + numOfSims); |
| if (getStaticPhoneCapability().getLogicalModemList().size() < numOfSims) { |
| log("switchMultiSimConfig: Phone is not capable of enabling " |
| + numOfSims + " sims, exiting!"); |
| return; |
| } |
| if (getPhoneCount() != numOfSims) { |
| log("switchMultiSimConfig: sending the request for switching"); |
| Message callback = Message.obtain( |
| mHandler, EVENT_SWITCH_DSDS_CONFIG_DONE, numOfSims, 0 /**dummy arg*/); |
| mRadioConfig.setNumOfLiveModems(numOfSims, callback); |
| } else { |
| log("switchMultiSimConfig: No need to switch. getNumOfActiveSims is already " |
| + numOfSims); |
| } |
| } |
| |
| /** |
| * Get whether reboot is required or not after making changes to modem configurations. |
| * Return value defaults to true |
| */ |
| public boolean isRebootRequiredForModemConfigChange() { |
| return mMi.isRebootRequiredForModemConfigChange(); |
| } |
| |
| private void onMultiSimConfigChanged(int numOfActiveModems) { |
| int oldNumOfActiveModems = getPhoneCount(); |
| setMultiSimProperties(numOfActiveModems); |
| |
| if (isRebootRequiredForModemConfigChange()) { |
| log("onMultiSimConfigChanged: Rebooting."); |
| PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); |
| pm.reboot("Multi-SIM config changed."); |
| } else { |
| log("onMultiSimConfigChanged: Rebooting is not required."); |
| mMi.notifyPhoneFactoryOnMultiSimConfigChanged(mContext, numOfActiveModems); |
| broadcastMultiSimConfigChange(numOfActiveModems); |
| boolean subInfoCleared = false; |
| // if numOfActiveModems is decreasing, deregister old RILs |
| // eg if we are going from 2 phones to 1 phone, we need to deregister RIL for the |
| // second phone. This loop does nothing if numOfActiveModems is increasing. |
| for (int phoneId = numOfActiveModems; phoneId < oldNumOfActiveModems; phoneId++) { |
| SubscriptionManagerService.getInstance().markSubscriptionsInactive(phoneId); |
| subInfoCleared = true; |
| mPhones[phoneId].mCi.onSlotActiveStatusChange( |
| SubscriptionManager.isValidPhoneId(phoneId)); |
| } |
| if (subInfoCleared) { |
| // This triggers update of default subs. This should be done asap after |
| // setMultiSimProperties() to avoid (minimize) duration for which default sub can be |
| // invalid and can map to a non-existent phone. |
| // If forexample someone calls a TelephonyManager API on default sub after |
| // setMultiSimProperties() and before onSubscriptionsChanged() below -- they can be |
| // using an invalid sub, which can map to a non-existent phone and can cause an |
| // exception (see b/163582235). |
| MultiSimSettingController.getInstance().onPhoneRemoved(); |
| } |
| // old phone objects are not needed now; mPhones can be updated |
| mPhones = PhoneFactory.getPhones(); |
| // if numOfActiveModems is increasing, register new RILs |
| // eg if we are going from 1 phone to 2 phones, we need to register RIL for the second |
| // phone. This loop does nothing if numOfActiveModems is decreasing. |
| for (int phoneId = oldNumOfActiveModems; phoneId < numOfActiveModems; phoneId++) { |
| Phone phone = mPhones[phoneId]; |
| registerForRadioState(phone); |
| phone.mCi.onSlotActiveStatusChange(SubscriptionManager.isValidPhoneId(phoneId)); |
| } |
| |
| if (numOfActiveModems > 1) { |
| // Check if cellular DSDA is supported. If it is, then send a request to the |
| // modem to refresh the list of SIM slots that currently support DSDA based on |
| // current network conditions |
| maybeEnableCellularDSDASupport(); |
| } else { |
| // The number of active modems is 0 or 1, disable cellular DSDA: |
| mSlotsSupportingSimultaneousCellularCalls.clear(); |
| if (mFeatureFlags.simultaneousCallingIndications()) { |
| updateSimultaneousSubIdsFromPhoneIdMappingAndNotify(); |
| notifySimultaneousCellularCallingSlotsChanged(); |
| } |
| } |
| |
| // When the user enables DSDS mode, the default VOICE and SMS subId should be switched |
| // to "No Preference". Doing so will sync the network/sim settings and telephony. |
| // (see b/198123192) |
| if (numOfActiveModems > oldNumOfActiveModems && numOfActiveModems == 2) { |
| Log.i(LOG_TAG, " onMultiSimConfigChanged: DSDS mode enabled; " |
| + "setting VOICE & SMS subId to -1 (No Preference)"); |
| |
| //Set the default VOICE subId to -1 ("No Preference") |
| SubscriptionManagerService.getInstance().setDefaultVoiceSubId( |
| SubscriptionManager.INVALID_SUBSCRIPTION_ID); |
| |
| //TODO:: Set the default SMS sub to "No Preference". Tracking this bug (b/227386042) |
| } else { |
| Log.i(LOG_TAG, |
| "onMultiSimConfigChanged: DSDS mode NOT detected. NOT setting the " |
| + "default VOICE and SMS subId to -1 (No Preference)"); |
| } |
| } |
| } |
| |
| /** |
| * Helper method to set system properties for setting multi sim configs, |
| * as well as doing the phone reboot |
| * NOTE: In order to support more than 3 sims, we need to change this method. |
| * @param numOfActiveModems number of active sims |
| */ |
| private void setMultiSimProperties(int numOfActiveModems) { |
| mMi.setMultiSimProperties(numOfActiveModems); |
| } |
| |
| @VisibleForTesting |
| public static void notifyMultiSimConfigChange(int numOfActiveModems) { |
| sMultiSimConfigChangeRegistrants.notifyResult(numOfActiveModems); |
| } |
| |
| /** |
| * Register for multi-SIM configuration change, for example if the devices switched from single |
| * SIM to dual-SIM mode. |
| * |
| * It doesn't trigger callback upon registration as multi-SIM config change is in-frequent. |
| */ |
| public static void registerForMultiSimConfigChange(Handler h, int what, Object obj) { |
| sMultiSimConfigChangeRegistrants.addUnique(h, what, obj); |
| } |
| |
| /** |
| * Unregister for multi-SIM configuration change. |
| */ |
| public static void unregisterForMultiSimConfigChange(Handler h) { |
| sMultiSimConfigChangeRegistrants.remove(h); |
| } |
| |
| /** |
| * Unregister for all multi-SIM configuration change events. |
| */ |
| public static void unregisterAllMultiSimConfigChangeRegistrants() { |
| sMultiSimConfigChangeRegistrants.removeAll(); |
| } |
| |
| private void broadcastMultiSimConfigChange(int numOfActiveModems) { |
| log("broadcastSimSlotNumChange numOfActiveModems" + numOfActiveModems); |
| // Notify internal registrants first. |
| notifyMultiSimConfigChange(numOfActiveModems); |
| |
| Intent intent = new Intent(ACTION_MULTI_SIM_CONFIG_CHANGED); |
| intent.putExtra(EXTRA_ACTIVE_SIM_SUPPORTED_COUNT, numOfActiveModems); |
| mContext.sendBroadcast(intent); |
| } |
| /** |
| * This is invoked from shell commands during CTS testing only. |
| * @return true if the modem service is set successfully, false otherwise. |
| */ |
| public boolean setModemService(String serviceName) { |
| log("setModemService: " + serviceName); |
| boolean statusRadioConfig = false; |
| boolean statusRil = false; |
| final boolean isAllowed = SystemProperties.getBoolean(ALLOW_MOCK_MODEM_PROPERTY, false); |
| final boolean isAllowedForBoot = |
| SystemProperties.getBoolean(BOOT_ALLOW_MOCK_MODEM_PROPERTY, false); |
| |
| // Check for ALLOW_MOCK_MODEM_PROPERTY and BOOT_ALLOW_MOCK_MODEM_PROPERTY on user builds |
| if (isAllowed || isAllowedForBoot || DEBUG) { |
| if (mRadioConfig != null) { |
| statusRadioConfig = mRadioConfig.setModemService(serviceName); |
| } |
| |
| if (!statusRadioConfig) { |
| loge("setModemService: switching modem service for radioconfig fail"); |
| return false; |
| } |
| |
| for (int i = 0; i < getPhoneCount(); i++) { |
| if (mPhones[i] != null) { |
| statusRil = mPhones[i].mCi.setModemService(serviceName); |
| } |
| |
| if (!statusRil) { |
| loge("setModemService: switch modem for radio " + i + " fail"); |
| |
| // Disconnect the switched service |
| mRadioConfig.setModemService(null); |
| for (int t = 0; t < i; t++) { |
| mPhones[t].mCi.setModemService(null); |
| } |
| return false; |
| } |
| } |
| } else { |
| loge("setModemService is not allowed"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * This is invoked from shell commands to query during CTS testing only. |
| * @return the service name of the connected service. |
| */ |
| public String getModemService() { |
| if (mPhones[0] == null) { |
| return ""; |
| } |
| |
| return mPhones[0].mCi.getModemService(); |
| } |
| |
| /** |
| * A wrapper class that wraps some methods so that they can be replaced or mocked in unit-tests. |
| * |
| * For example, setting or reading system property are static native methods that can't be |
| * directly mocked. We can mock it by replacing MockableInterface object with a mock instance |
| * in unittest. |
| */ |
| @VisibleForTesting |
| public static class MockableInterface { |
| /** |
| * Wrapper function to decide whether reboot is required for modem config change. |
| */ |
| @VisibleForTesting |
| public boolean isRebootRequiredForModemConfigChange() { |
| boolean rebootRequired = TelephonyProperties.reboot_on_modem_change().orElse(false); |
| log("isRebootRequiredForModemConfigChange: isRebootRequired = " + rebootRequired); |
| return rebootRequired; |
| } |
| |
| /** |
| * Wrapper function to call setMultiSimProperties. |
| */ |
| @VisibleForTesting |
| public void setMultiSimProperties(int numOfActiveModems) { |
| String multiSimConfig; |
| switch(numOfActiveModems) { |
| case 3: |
| multiSimConfig = TSTS; |
| break; |
| case 2: |
| multiSimConfig = DSDS; |
| break; |
| default: |
| multiSimConfig = SSSS; |
| } |
| |
| log("setMultiSimProperties to " + multiSimConfig); |
| TelephonyProperties.multi_sim_config(multiSimConfig); |
| } |
| |
| /** |
| * Wrapper function to call PhoneFactory.onMultiSimConfigChanged. |
| */ |
| @VisibleForTesting |
| public void notifyPhoneFactoryOnMultiSimConfigChanged( |
| Context context, int numOfActiveModems) { |
| PhoneFactory.onMultiSimConfigChanged(context, numOfActiveModems); |
| } |
| |
| /** |
| * Wrapper function to query the sysprop for multi_sim_config |
| */ |
| public Optional<String> getMultiSimProperty() { |
| return TelephonyProperties.multi_sim_config(); |
| } |
| } |
| |
| private static void log(String s) { |
| Rlog.d(LOG_TAG, s); |
| } |
| |
| private static void loge(String s) { |
| Rlog.e(LOG_TAG, s); |
| } |
| |
| private static void loge(String s, Exception ex) { |
| Rlog.e(LOG_TAG, s, ex); |
| } |
| } |
