Java tutorial
/* * Copyright (C) 2014 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 android.telephony; import static android.net.NetworkPolicyManager.OVERRIDE_CONGESTED; import static android.net.NetworkPolicyManager.OVERRIDE_UNMETERED; import android.Manifest; import android.annotation.CallbackExecutor; import android.annotation.DurationMillisLong; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.RequiresPermission; import android.annotation.SdkConstant; import android.annotation.SdkConstant.SdkConstantType; import android.annotation.SuppressAutoDoc; import android.annotation.SystemApi; import android.annotation.SystemService; import android.annotation.UnsupportedAppUsage; import android.app.BroadcastOptions; import android.app.PendingIntent; import android.app.job.JobService; import android.content.Context; import android.content.Intent; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.content.res.Resources; import android.database.ContentObserver; import android.net.INetworkPolicyManager; import android.net.NetworkCapabilities; import android.net.Uri; import android.os.Binder; import android.os.Build; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.os.ParcelUuid; import android.os.Process; import android.os.RemoteException; import android.os.ServiceManager; import android.telephony.euicc.EuiccManager; import android.telephony.ims.ImsMmTelManager; import android.util.DisplayMetrics; import android.util.Log; import com.android.internal.telephony.IOnSubscriptionsChangedListener; import com.android.internal.telephony.ISetOpportunisticDataCallback; import com.android.internal.telephony.ISub; import com.android.internal.telephony.ITelephonyRegistry; import com.android.internal.telephony.PhoneConstants; import com.android.internal.util.Preconditions; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.concurrent.Executor; import java.util.concurrent.TimeUnit; import java.util.function.Consumer; import java.util.stream.Collectors; /** * SubscriptionManager is the application interface to SubscriptionController * and provides information about the current Telephony Subscriptions. */ @SystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE) public class SubscriptionManager { private static final String LOG_TAG = "SubscriptionManager"; private static final boolean DBG = false; private static final boolean VDBG = false; /** An invalid subscription identifier */ public static final int INVALID_SUBSCRIPTION_ID = -1; /** Base value for Dummy SUBSCRIPTION_ID's. */ /** FIXME: Remove DummySubId's, but for now have them map just below INVALID_SUBSCRIPTION_ID /** @hide */ public static final int DUMMY_SUBSCRIPTION_ID_BASE = INVALID_SUBSCRIPTION_ID - 1; /** An invalid phone identifier */ /** @hide */ public static final int INVALID_PHONE_INDEX = -1; /** Indicates invalid sim slot. This can be returned by {@link #getSlotIndex(int)}. */ public static final int INVALID_SIM_SLOT_INDEX = -1; /** Indicates the default subscription ID in Telephony. */ public static final int DEFAULT_SUBSCRIPTION_ID = Integer.MAX_VALUE; /** * Indicates the caller wants the default phone id. * Used in SubscriptionController and Phone but do we really need it??? * @hide */ public static final int DEFAULT_PHONE_INDEX = Integer.MAX_VALUE; /** Indicates the caller wants the default slot id. NOT used remove? */ /** @hide */ public static final int DEFAULT_SIM_SLOT_INDEX = Integer.MAX_VALUE; /** Minimum possible subid that represents a subscription */ /** @hide */ public static final int MIN_SUBSCRIPTION_ID_VALUE = 0; /** Maximum possible subid that represents a subscription */ /** @hide */ public static final int MAX_SUBSCRIPTION_ID_VALUE = DEFAULT_SUBSCRIPTION_ID - 1; /** @hide */ @UnsupportedAppUsage public static final Uri CONTENT_URI = Uri.parse("content://telephony/siminfo"); /** * Generates a content {@link Uri} used to receive updates on simInfo change * on the given subscriptionId * @param subscriptionId the subscriptionId to receive updates on * @return the Uri used to observe carrier identity changes * @hide */ public static Uri getUriForSubscriptionId(int subscriptionId) { return Uri.withAppendedPath(CONTENT_URI, String.valueOf(subscriptionId)); } /** * A content {@link Uri} used to receive updates on wfc enabled user setting. * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription wfc enabled {@link ImsMmTelManager#isVoWiFiSettingEnabled()} * while your app is running. You can also use a {@link JobService} to ensure your app * is notified of changes to the {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri WFC_ENABLED_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "wfc"); /** * A content {@link Uri} used to receive updates on advanced calling user setting * @see ImsMmTelManager#isAdvancedCallingSettingEnabled(). * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription advanced calling enabled * {@link ImsMmTelManager#isAdvancedCallingSettingEnabled()} while your app is running. * You can also use a {@link JobService} to ensure your app is notified of changes to the * {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri ADVANCED_CALLING_ENABLED_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "advanced_calling"); /** * A content {@link Uri} used to receive updates on wfc mode setting. * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription wfc mode {@link ImsMmTelManager#getVoWiFiModeSetting()} * while your app is running. You can also use a {@link JobService} to ensure your app * is notified of changes to the {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri WFC_MODE_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "wfc_mode"); /** * A content {@link Uri} used to receive updates on wfc roaming mode setting. * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription wfc roaming mode {@link ImsMmTelManager#getVoWiFiRoamingModeSetting()} * while your app is running. You can also use a {@link JobService} to ensure your app * is notified of changes to the {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri WFC_ROAMING_MODE_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "wfc_roaming_mode"); /** * A content {@link Uri} used to receive updates on vt(video telephony over IMS) enabled * setting. * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription vt enabled {@link ImsMmTelManager#isVtSettingEnabled()} * while your app is running. You can also use a {@link JobService} to ensure your app * is notified of changes to the {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri VT_ENABLED_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "vt_enabled"); /** * A content {@link Uri} used to receive updates on wfc roaming enabled setting. * <p> * Use this {@link Uri} with a {@link ContentObserver} to be notified of changes to the * subscription wfc roaming enabled {@link ImsMmTelManager#isVoWiFiRoamingSettingEnabled()} * while your app is running. You can also use a {@link JobService} to ensure your app * is notified of changes to the {@link Uri} even when it is not running. * Note, however, that using a {@link JobService} does not guarantee timely delivery of * updates to the {@link Uri}. * To be notified of changes to a specific subId, append subId to the URI * {@link Uri#withAppendedPath(Uri, String)}. * @hide */ @NonNull @SystemApi public static final Uri WFC_ROAMING_ENABLED_CONTENT_URI = Uri.withAppendedPath(CONTENT_URI, "wfc_roaming_enabled"); /** * TelephonyProvider unique key column name is the subscription id. * <P>Type: TEXT (String)</P> */ /** @hide */ public static final String UNIQUE_KEY_SUBSCRIPTION_ID = "_id"; /** * TelephonyProvider column name for a unique identifier for the subscription within the * specific subscription type. For example, it contains SIM ICC Identifier subscriptions * on Local SIMs. and Mac-address for Remote-SIM Subscriptions for Bluetooth devices. * <P>Type: TEXT (String)</P> */ /** @hide */ public static final String ICC_ID = "icc_id"; /** * TelephonyProvider column name for user SIM_SlOT_INDEX * <P>Type: INTEGER (int)</P> */ /** @hide */ public static final String SIM_SLOT_INDEX = "sim_id"; /** SIM is not inserted */ /** @hide */ public static final int SIM_NOT_INSERTED = -1; /** * The slot-index for Bluetooth Remote-SIM subscriptions * @hide */ public static final int SLOT_INDEX_FOR_REMOTE_SIM_SUB = INVALID_SIM_SLOT_INDEX; /** * TelephonyProvider column name Subscription-type. * <P>Type: INTEGER (int)</P> {@link #SUBSCRIPTION_TYPE_LOCAL_SIM} for Local-SIM Subscriptions, * {@link #SUBSCRIPTION_TYPE_REMOTE_SIM} for Remote-SIM Subscriptions. * Default value is 0. */ /** @hide */ public static final String SUBSCRIPTION_TYPE = "subscription_type"; /** * TelephonyProvider column name white_listed_apn_data. * It's a bitmask of APN types that will be allowed on this subscription even if it's metered * and mobile data is turned off by the user. * <P>Type: INTEGER (int)</P> For example, if TYPE_MMS is is true, Telephony will allow MMS * data connection to setup even if MMS is metered and mobile_data is turned off on that * subscription. * * Default value is 0. * * @deprecated Replaced by {@link #DATA_ENABLED_OVERRIDE_RULES} * @hide */ @Deprecated public static final String WHITE_LISTED_APN_DATA = "white_listed_apn_data"; /** * TelephonyProvider column name data_enabled_override_rules. * It's a list of rules for overriding data enabled settings. The syntax is * For example, "mms=nonDefault" indicates enabling data for mms in non-default subscription. * "default=nonDefault&inVoiceCall" indicates enabling data for internet in non-default * subscription and while is in voice call. * * Default value is empty string. * * @hide */ public static final String DATA_ENABLED_OVERRIDE_RULES = "data_enabled_override_rules"; /** * This constant is to designate a subscription as a Local-SIM Subscription. * <p> A Local-SIM can be a physical SIM inserted into a sim-slot in the device, or eSIM on the * device. * </p> */ public static final int SUBSCRIPTION_TYPE_LOCAL_SIM = 0; /** * This constant is to designate a subscription as a Remote-SIM Subscription. * <p> * A Remote-SIM subscription is for a SIM on a phone connected to this device via some * connectivity mechanism, for example bluetooth. Similar to Local SIM, this subscription can * be used for SMS, Voice and data by proxying data through the connected device. * Certain data of the SIM, such as IMEI, are not accessible for Remote SIMs. * </p> * * <p> * A Remote-SIM is available only as long the phone stays connected to this device. * When the phone disconnects, Remote-SIM subscription is removed from this device and is * no longer known. All data associated with the subscription, such as stored SMS, call logs, * contacts etc, are removed from this device. * </p> * * <p> * If the phone re-connects to this device, a new Remote-SIM subscription is created for * the phone. The Subscription Id associated with the new subscription is different from * the Subscription Id of the previous Remote-SIM subscription created (and removed) for the * phone; i.e., new Remote-SIM subscription treats the reconnected phone as a Remote-SIM that * was never seen before. * </p> */ public static final int SUBSCRIPTION_TYPE_REMOTE_SIM = 1; /** @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(prefix = { "SUBSCRIPTION_TYPE_" }, value = { SUBSCRIPTION_TYPE_LOCAL_SIM, SUBSCRIPTION_TYPE_REMOTE_SIM }) public @interface SubscriptionType { } /** * TelephonyProvider column name for user displayed name. * <P>Type: TEXT (String)</P> */ /** @hide */ public static final String DISPLAY_NAME = "display_name"; /** * TelephonyProvider column name for the service provider name for the SIM. * <P>Type: TEXT (String)</P> */ /** @hide */ public static final String CARRIER_NAME = "carrier_name"; /** * Default name resource * @hide */ public static final int DEFAULT_NAME_RES = com.android.internal.R.string.unknownName; /** * TelephonyProvider column name for source of the user displayed name. * <P>Type: INT (int)</P> with one of the NAME_SOURCE_XXXX values below * * @hide */ public static final String NAME_SOURCE = "name_source"; /** * The name_source is the default * @hide */ public static final int NAME_SOURCE_DEFAULT_SOURCE = 0; /** * The name_source is from the SIM * @hide */ public static final int NAME_SOURCE_SIM_SOURCE = 1; /** * The name_source is from the user * @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) public static final int NAME_SOURCE_USER_INPUT = 2; /** * The name_source is carrier (carrier app, carrier config, etc.) * @hide */ public static final int NAME_SOURCE_CARRIER = 3; /** * TelephonyProvider column name for the color of a SIM. * <P>Type: INTEGER (int)</P> */ /** @hide */ public static final String COLOR = "color"; /** @hide */ public static final int COLOR_1 = 0; /** @hide */ public static final int COLOR_2 = 1; /** @hide */ public static final int COLOR_3 = 2; /** @hide */ public static final int COLOR_4 = 3; /** @hide */ public static final int COLOR_DEFAULT = COLOR_1; /** * TelephonyProvider column name for the phone number of a SIM. * <P>Type: TEXT (String)</P> */ /** @hide */ public static final String NUMBER = "number"; /** * TelephonyProvider column name for the number display format of a SIM. * <P>Type: INTEGER (int)</P> */ /** @hide */ public static final String DISPLAY_NUMBER_FORMAT = "display_number_format"; /** @hide */ public static final int DISPLAY_NUMBER_NONE = 0; /** @hide */ public static final int DISPLAY_NUMBER_FIRST = 1; /** @hide */ public static final int DISPLAY_NUMBER_LAST = 2; /** @hide */ public static final int DISPLAY_NUMBER_DEFAULT = DISPLAY_NUMBER_FIRST; /** * TelephonyProvider column name for permission for data roaming of a SIM. * <P>Type: INTEGER (int)</P> */ /** @hide */ public static final String DATA_ROAMING = "data_roaming"; /** Indicates that data roaming is enabled for a subscription */ public static final int DATA_ROAMING_ENABLE = 1; /** Indicates that data roaming is disabled for a subscription */ public static final int DATA_ROAMING_DISABLE = 0; /** @hide */ public static final int DATA_ROAMING_DEFAULT = DATA_ROAMING_DISABLE; /** @hide */ public static final int SIM_PROVISIONED = 0; /** * TelephonyProvider column name for subscription carrier id. * @see TelephonyManager#getSimCarrierId() * <p>Type: INTEGER (int) </p> * @hide */ public static final String CARRIER_ID = "carrier_id"; /** * @hide A comma-separated list of EHPLMNs associated with the subscription * <P>Type: TEXT (String)</P> */ public static final String EHPLMNS = "ehplmns"; /** * @hide A comma-separated list of HPLMNs associated with the subscription * <P>Type: TEXT (String)</P> */ public static final String HPLMNS = "hplmns"; /** * TelephonyProvider column name for the MCC associated with a SIM, stored as a string. * <P>Type: TEXT (String)</P> * @hide */ public static final String MCC_STRING = "mcc_string"; /** * TelephonyProvider column name for the MNC associated with a SIM, stored as a string. * <P>Type: TEXT (String)</P> * @hide */ public static final String MNC_STRING = "mnc_string"; /** * TelephonyProvider column name for the MCC associated with a SIM. * <P>Type: INTEGER (int)</P> * @hide */ public static final String MCC = "mcc"; /** * TelephonyProvider column name for the MNC associated with a SIM. * <P>Type: INTEGER (int)</P> * @hide */ public static final String MNC = "mnc"; /** * TelephonyProvider column name for the iso country code associated with a SIM. * <P>Type: TEXT (String)</P> * @hide */ public static final String ISO_COUNTRY_CODE = "iso_country_code"; /** * TelephonyProvider column name for the sim provisioning status associated with a SIM. * <P>Type: INTEGER (int)</P> * @hide */ public static final String SIM_PROVISIONING_STATUS = "sim_provisioning_status"; /** * TelephonyProvider column name for whether a subscription is embedded (that is, present on an * eSIM). * <p>Type: INTEGER (int), 1 for embedded or 0 for non-embedded. * @hide */ public static final String IS_EMBEDDED = "is_embedded"; /** * TelephonyProvider column name for SIM card identifier. For UICC card it is the ICCID of the * current enabled profile on the card, while for eUICC card it is the EID of the card. * <P>Type: TEXT (String)</P> * @hide */ public static final String CARD_ID = "card_id"; /** * TelephonyProvider column name for the encoded {@link UiccAccessRule}s from * {@link UiccAccessRule#encodeRules}. Only present if {@link #IS_EMBEDDED} is 1. * <p>TYPE: BLOB * @hide */ public static final String ACCESS_RULES = "access_rules"; /** * TelephonyProvider column name identifying whether an embedded subscription is on a removable * card. Such subscriptions are marked inaccessible as soon as the current card is removed. * Otherwise, they will remain accessible unless explicitly deleted. Only present if * {@link #IS_EMBEDDED} is 1. * <p>TYPE: INTEGER (int), 1 for removable or 0 for non-removable. * @hide */ public static final String IS_REMOVABLE = "is_removable"; /** * TelephonyProvider column name for extreme threat in CB settings * @hide */ public static final String CB_EXTREME_THREAT_ALERT = "enable_cmas_extreme_threat_alerts"; /** * TelephonyProvider column name for severe threat in CB settings *@hide */ public static final String CB_SEVERE_THREAT_ALERT = "enable_cmas_severe_threat_alerts"; /** * TelephonyProvider column name for amber alert in CB settings *@hide */ public static final String CB_AMBER_ALERT = "enable_cmas_amber_alerts"; /** * TelephonyProvider column name for emergency alert in CB settings *@hide */ public static final String CB_EMERGENCY_ALERT = "enable_emergency_alerts"; /** * TelephonyProvider column name for alert sound duration in CB settings *@hide */ public static final String CB_ALERT_SOUND_DURATION = "alert_sound_duration"; /** * TelephonyProvider column name for alert reminder interval in CB settings *@hide */ public static final String CB_ALERT_REMINDER_INTERVAL = "alert_reminder_interval"; /** * TelephonyProvider column name for enabling vibrate in CB settings *@hide */ public static final String CB_ALERT_VIBRATE = "enable_alert_vibrate"; /** * TelephonyProvider column name for enabling alert speech in CB settings *@hide */ public static final String CB_ALERT_SPEECH = "enable_alert_speech"; /** * TelephonyProvider column name for ETWS test alert in CB settings *@hide */ public static final String CB_ETWS_TEST_ALERT = "enable_etws_test_alerts"; /** * TelephonyProvider column name for enable channel50 alert in CB settings *@hide */ public static final String CB_CHANNEL_50_ALERT = "enable_channel_50_alerts"; /** * TelephonyProvider column name for CMAS test alert in CB settings *@hide */ public static final String CB_CMAS_TEST_ALERT = "enable_cmas_test_alerts"; /** * TelephonyProvider column name for Opt out dialog in CB settings *@hide */ public static final String CB_OPT_OUT_DIALOG = "show_cmas_opt_out_dialog"; /** * TelephonyProvider column name for enable Volte. * * If this setting is not initialized (set to -1) then we use the Carrier Config value * {@link CarrierConfigManager#KEY_ENHANCED_4G_LTE_ON_BY_DEFAULT_BOOL}. *@hide */ public static final String ENHANCED_4G_MODE_ENABLED = "volte_vt_enabled"; /** * TelephonyProvider column name for enable VT (Video Telephony over IMS) *@hide */ public static final String VT_IMS_ENABLED = "vt_ims_enabled"; /** * TelephonyProvider column name for enable Wifi calling *@hide */ public static final String WFC_IMS_ENABLED = "wfc_ims_enabled"; /** * TelephonyProvider column name for Wifi calling mode *@hide */ public static final String WFC_IMS_MODE = "wfc_ims_mode"; /** * TelephonyProvider column name for Wifi calling mode in roaming *@hide */ public static final String WFC_IMS_ROAMING_MODE = "wfc_ims_roaming_mode"; /** * TelephonyProvider column name for enable Wifi calling in roaming *@hide */ public static final String WFC_IMS_ROAMING_ENABLED = "wfc_ims_roaming_enabled"; /** * TelephonyProvider column name for whether a subscription is opportunistic, that is, * whether the network it connects to is limited in functionality or coverage. * For example, CBRS. * <p>Type: INTEGER (int), 1 for opportunistic or 0 for non-opportunistic. * @hide */ public static final String IS_OPPORTUNISTIC = "is_opportunistic"; /** * TelephonyProvider column name for group ID. Subscriptions with same group ID * are considered bundled together, and should behave as a single subscription at * certain scenarios. * * @hide */ public static final String GROUP_UUID = "group_uuid"; /** * TelephonyProvider column name for group owner. It's the package name who created * the subscription group. * * @hide */ public static final String GROUP_OWNER = "group_owner"; /** * TelephonyProvider column name for whether a subscription is metered or not, that is, whether * the network it connects to charges for subscription or not. For example, paid CBRS or unpaid. * @hide */ public static final String IS_METERED = "is_metered"; /** * TelephonyProvider column name for the profile class of a subscription * Only present if {@link #IS_EMBEDDED} is 1. * <P>Type: INTEGER (int)</P> * @hide */ public static final String PROFILE_CLASS = "profile_class"; /** * Profile class of the subscription * @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(prefix = { "PROFILE_CLASS_" }, value = { PROFILE_CLASS_TESTING, PROFILE_CLASS_PROVISIONING, PROFILE_CLASS_OPERATIONAL, PROFILE_CLASS_UNSET, PROFILE_CLASS_DEFAULT }) public @interface ProfileClass { } /** * A testing profile can be pre-loaded or downloaded onto * the eUICC and provides connectivity to test equipment * for the purpose of testing the device and the eUICC. It * is not intended to store any operator credentials. * @hide */ @SystemApi public static final int PROFILE_CLASS_TESTING = 0; /** * A provisioning profile is pre-loaded onto the eUICC and * provides connectivity to a mobile network solely for the * purpose of provisioning profiles. * @hide */ @SystemApi public static final int PROFILE_CLASS_PROVISIONING = 1; /** * An operational profile can be pre-loaded or downloaded * onto the eUICC and provides services provided by the * operator. * @hide */ @SystemApi public static final int PROFILE_CLASS_OPERATIONAL = 2; /** * The profile class is unset. This occurs when profile class * info is not available. The subscription either has no profile * metadata or the profile metadata did not encode profile class. * @hide */ @SystemApi public static final int PROFILE_CLASS_UNSET = -1; /** * Default profile class * @hide */ @SystemApi public static final int PROFILE_CLASS_DEFAULT = PROFILE_CLASS_UNSET; /** * IMSI (International Mobile Subscriber Identity). * <P>Type: TEXT </P> * @hide */ //TODO: add @SystemApi public static final String IMSI = "imsi"; /** * Broadcast Action: The user has changed one of the default subs related to * data, phone calls, or sms</p> * * TODO: Change to a listener * @hide */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String SUB_DEFAULT_CHANGED_ACTION = "android.intent.action.SUB_DEFAULT_CHANGED"; /** * Broadcast Action: The default subscription has changed. This has the following * extra values:</p> * The {@link #EXTRA_SUBSCRIPTION_INDEX} extra indicates the current default subscription index */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String ACTION_DEFAULT_SUBSCRIPTION_CHANGED = "android.telephony.action.DEFAULT_SUBSCRIPTION_CHANGED"; /** * Broadcast Action: The default sms subscription has changed. This has the following * extra values:</p> * {@link #EXTRA_SUBSCRIPTION_INDEX} extra indicates the current default sms * subscription index */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String ACTION_DEFAULT_SMS_SUBSCRIPTION_CHANGED = "android.telephony.action.DEFAULT_SMS_SUBSCRIPTION_CHANGED"; /** * Activity Action: Display UI for managing the billing relationship plans * between a carrier and a specific subscriber. * <p> * Carrier apps are encouraged to implement this activity, and the OS will * provide an affordance to quickly enter this activity, typically via * Settings. This affordance will only be shown when the carrier app is * actively providing subscription plan information via * {@link #setSubscriptionPlans(int, List)}. * <p> * Contains {@link #EXTRA_SUBSCRIPTION_INDEX} to indicate which subscription * the user is interested in. */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_MANAGE_SUBSCRIPTION_PLANS = "android.telephony.action.MANAGE_SUBSCRIPTION_PLANS"; /** * Broadcast Action: Request a refresh of the billing relationship plans * between a carrier and a specific subscriber. * <p> * Carrier apps are encouraged to implement this receiver, and the OS will * provide an affordance to request a refresh. This affordance will only be * shown when the carrier app is actively providing subscription plan * information via {@link #setSubscriptionPlans(int, List)}. * <p> * Contains {@link #EXTRA_SUBSCRIPTION_INDEX} to indicate which subscription * the user is interested in. * <p> * Receivers should protect themselves by checking that the sender holds the * {@code android.permission.MANAGE_SUBSCRIPTION_PLANS} permission. */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String ACTION_REFRESH_SUBSCRIPTION_PLANS = "android.telephony.action.REFRESH_SUBSCRIPTION_PLANS"; /** * Broadcast Action: The billing relationship plans between a carrier and a * specific subscriber has changed. * <p> * Contains {@link #EXTRA_SUBSCRIPTION_INDEX} to indicate which subscription * changed. * * @hide */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) @RequiresPermission(android.Manifest.permission.MANAGE_SUBSCRIPTION_PLANS) public static final String ACTION_SUBSCRIPTION_PLANS_CHANGED = "android.telephony.action.SUBSCRIPTION_PLANS_CHANGED"; /** * Integer extra used with {@link #ACTION_DEFAULT_SUBSCRIPTION_CHANGED} and * {@link #ACTION_DEFAULT_SMS_SUBSCRIPTION_CHANGED} to indicate the subscription * which has changed. */ public static final String EXTRA_SUBSCRIPTION_INDEX = "android.telephony.extra.SUBSCRIPTION_INDEX"; private final Context mContext; private volatile INetworkPolicyManager mNetworkPolicy; /** * A listener class for monitoring changes to {@link SubscriptionInfo} records. * <p> * Override the onSubscriptionsChanged method in the object that extends this * class and pass it to {@link #addOnSubscriptionsChangedListener(OnSubscriptionsChangedListener)} * to register your listener and to unregister invoke * {@link #removeOnSubscriptionsChangedListener(OnSubscriptionsChangedListener)} * <p> * Permissions android.Manifest.permission.READ_PHONE_STATE is required * for #onSubscriptionsChanged to be invoked. */ public static class OnSubscriptionsChangedListener { private class OnSubscriptionsChangedListenerHandler extends Handler { OnSubscriptionsChangedListenerHandler() { super(); } OnSubscriptionsChangedListenerHandler(Looper looper) { super(looper); } @Override public void handleMessage(Message msg) { if (DBG) { log("handleMessage: invoke the overriden onSubscriptionsChanged()"); } OnSubscriptionsChangedListener.this.onSubscriptionsChanged(); } } private final Handler mHandler; public OnSubscriptionsChangedListener() { mHandler = new OnSubscriptionsChangedListenerHandler(); } /** * Allow a listener to be created with a custom looper * @param looper the looper that the underlining handler should run on * @hide */ public OnSubscriptionsChangedListener(Looper looper) { mHandler = new OnSubscriptionsChangedListenerHandler(looper); } /** * Callback invoked when there is any change to any SubscriptionInfo, as well as once on * registering for changes with {@link #addOnSubscriptionsChangedListener}. Typically * this method would invoke {@link #getActiveSubscriptionInfoList} */ public void onSubscriptionsChanged() { if (DBG) log("onSubscriptionsChanged: NOT OVERRIDDEN"); } /** * The callback methods need to be called on the handler thread where * this object was created. If the binder did that for us it'd be nice. */ IOnSubscriptionsChangedListener callback = new IOnSubscriptionsChangedListener.Stub() { @Override public void onSubscriptionsChanged() { if (DBG) log("callback: received, sendEmptyMessage(0) to handler"); mHandler.sendEmptyMessage(0); } }; private void log(String s) { Rlog.d(LOG_TAG, s); } } /** @hide */ @UnsupportedAppUsage public SubscriptionManager(Context context) { if (DBG) logd("SubscriptionManager created"); mContext = context; } /** * @deprecated developers should always obtain references directly from * {@link Context#getSystemService(Class)}. */ @Deprecated public static SubscriptionManager from(Context context) { return (SubscriptionManager) context.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE); } private final INetworkPolicyManager getNetworkPolicy() { if (mNetworkPolicy == null) { mNetworkPolicy = INetworkPolicyManager.Stub .asInterface(ServiceManager.getService(Context.NETWORK_POLICY_SERVICE)); } return mNetworkPolicy; } /** * Register for changes to the list of active {@link SubscriptionInfo} records or to the * individual records themselves. When a change occurs the onSubscriptionsChanged method of * the listener will be invoked immediately if there has been a notification. The * onSubscriptionChanged method will also be triggered once initially when calling this * function. * * @param listener an instance of {@link OnSubscriptionsChangedListener} with * onSubscriptionsChanged overridden. */ public void addOnSubscriptionsChangedListener(OnSubscriptionsChangedListener listener) { String pkgName = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (DBG) { logd("register OnSubscriptionsChangedListener pkgName=" + pkgName + " listener=" + listener); } try { // We use the TelephonyRegistry as it runs in the system and thus is always // available. Where as SubscriptionController could crash and not be available ITelephonyRegistry tr = ITelephonyRegistry.Stub .asInterface(ServiceManager.getService("telephony.registry")); if (tr != null) { tr.addOnSubscriptionsChangedListener(pkgName, listener.callback); } } catch (RemoteException ex) { Log.e(LOG_TAG, "Remote exception ITelephonyRegistry " + ex); } } /** * Unregister the {@link OnSubscriptionsChangedListener}. This is not strictly necessary * as the listener will automatically be unregistered if an attempt to invoke the listener * fails. * * @param listener that is to be unregistered. */ public void removeOnSubscriptionsChangedListener(OnSubscriptionsChangedListener listener) { String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (DBG) { logd("unregister OnSubscriptionsChangedListener pkgForDebug=" + pkgForDebug + " listener=" + listener); } try { // We use the TelephonyRegistry as it runs in the system and thus is always // available where as SubscriptionController could crash and not be available ITelephonyRegistry tr = ITelephonyRegistry.Stub .asInterface(ServiceManager.getService("telephony.registry")); if (tr != null) { tr.removeOnSubscriptionsChangedListener(pkgForDebug, listener.callback); } } catch (RemoteException ex) { Log.e(LOG_TAG, "Remote exception ITelephonyRegistry " + ex); } } /** * A listener class for monitoring changes to {@link SubscriptionInfo} records of opportunistic * subscriptions. * <p> * Override the onOpportunisticSubscriptionsChanged method in the object that extends this * or {@link #addOnOpportunisticSubscriptionsChangedListener( * Executor, OnOpportunisticSubscriptionsChangedListener)} * to register your listener and to unregister invoke * {@link #removeOnOpportunisticSubscriptionsChangedListener( * OnOpportunisticSubscriptionsChangedListener)} * <p> * Permissions android.Manifest.permission.READ_PHONE_STATE is required * for #onOpportunisticSubscriptionsChanged to be invoked. */ public static class OnOpportunisticSubscriptionsChangedListener { private Executor mExecutor; /** * Callback invoked when there is any change to any SubscriptionInfo. Typically * this method would invoke {@link #getActiveSubscriptionInfoList} */ public void onOpportunisticSubscriptionsChanged() { if (DBG) log("onOpportunisticSubscriptionsChanged: NOT OVERRIDDEN"); } private void setExecutor(Executor executor) { mExecutor = executor; } /** * The callback methods need to be called on the handler thread where * this object was created. If the binder did that for us it'd be nice. */ IOnSubscriptionsChangedListener callback = new IOnSubscriptionsChangedListener.Stub() { @Override public void onSubscriptionsChanged() { final long identity = Binder.clearCallingIdentity(); try { if (DBG) log("onOpportunisticSubscriptionsChanged callback received."); mExecutor.execute(() -> onOpportunisticSubscriptionsChanged()); } finally { Binder.restoreCallingIdentity(identity); } } }; private void log(String s) { Rlog.d(LOG_TAG, s); } } /** * Register for changes to the list of opportunistic subscription records or to the * individual records themselves. When a change occurs the onOpportunisticSubscriptionsChanged * method of the listener will be invoked immediately if there has been a notification. * * @param listener an instance of {@link OnOpportunisticSubscriptionsChangedListener} with * onOpportunisticSubscriptionsChanged overridden. */ public void addOnOpportunisticSubscriptionsChangedListener(@NonNull @CallbackExecutor Executor executor, @NonNull OnOpportunisticSubscriptionsChangedListener listener) { if (executor == null || listener == null) { return; } String pkgName = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (DBG) { logd("register addOnOpportunisticSubscriptionsChangedListener pkgName=" + pkgName + " listener=" + listener); } listener.setExecutor(executor); try { // We use the TelephonyRegistry as it runs in the system and thus is always // available. Where as SubscriptionController could crash and not be available ITelephonyRegistry tr = ITelephonyRegistry.Stub .asInterface(ServiceManager.getService("telephony.registry")); if (tr != null) { tr.addOnOpportunisticSubscriptionsChangedListener(pkgName, listener.callback); } } catch (RemoteException ex) { Log.e(LOG_TAG, "Remote exception ITelephonyRegistry " + ex); } } /** * Unregister the {@link OnOpportunisticSubscriptionsChangedListener} that is currently * listening opportunistic subscriptions change. This is not strictly necessary * as the listener will automatically be unregistered if an attempt to invoke the listener * fails. * * @param listener that is to be unregistered. */ public void removeOnOpportunisticSubscriptionsChangedListener( @NonNull OnOpportunisticSubscriptionsChangedListener listener) { Preconditions.checkNotNull(listener, "listener cannot be null"); String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (DBG) { logd("unregister OnOpportunisticSubscriptionsChangedListener pkgForDebug=" + pkgForDebug + " listener=" + listener); } try { // We use the TelephonyRegistry as it runs in the system and thus is always // available where as SubscriptionController could crash and not be available ITelephonyRegistry tr = ITelephonyRegistry.Stub .asInterface(ServiceManager.getService("telephony.registry")); if (tr != null) { tr.removeOnSubscriptionsChangedListener(pkgForDebug, listener.callback); } } catch (RemoteException ex) { Log.e(LOG_TAG, "Remote exception ITelephonyRegistry " + ex); } } /** * Get the active SubscriptionInfo with the input subId. * * <p>Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * or that the calling app has carrier privileges (see * {@link TelephonyManager#hasCarrierPrivileges}). * * @param subId The unique SubscriptionInfo key in database. * @return SubscriptionInfo, maybe null if its not active. */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public SubscriptionInfo getActiveSubscriptionInfo(int subId) { if (VDBG) logd("[getActiveSubscriptionInfo]+ subId=" + subId); if (!isValidSubscriptionId(subId)) { if (DBG) { logd("[getActiveSubscriptionInfo]- invalid subId"); } return null; } SubscriptionInfo subInfo = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subInfo = iSub.getActiveSubscriptionInfo(subId, mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return subInfo; } /** * Get the active SubscriptionInfo associated with the iccId * @param iccId the IccId of SIM card * @return SubscriptionInfo, maybe null if its not active * @hide */ public SubscriptionInfo getActiveSubscriptionInfoForIccIndex(String iccId) { if (VDBG) logd("[getActiveSubscriptionInfoForIccIndex]+ iccId=" + iccId); if (iccId == null) { logd("[getActiveSubscriptionInfoForIccIndex]- null iccid"); return null; } SubscriptionInfo result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getActiveSubscriptionInfoForIccId(iccId, mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * Get the active SubscriptionInfo associated with the slotIndex * * <p>Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * or that the calling app has carrier privileges (see * {@link TelephonyManager#hasCarrierPrivileges}). * * @param slotIndex the slot which the subscription is inserted * @return SubscriptionInfo, maybe null if its not active */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public SubscriptionInfo getActiveSubscriptionInfoForSimSlotIndex(int slotIndex) { if (VDBG) logd("[getActiveSubscriptionInfoForSimSlotIndex]+ slotIndex=" + slotIndex); if (!isValidSlotIndex(slotIndex)) { logd("[getActiveSubscriptionInfoForSimSlotIndex]- invalid slotIndex"); return null; } SubscriptionInfo result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getActiveSubscriptionInfoForSimSlotIndex(slotIndex, mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * @return List of all SubscriptionInfo records in database, * include those that were inserted before, maybe empty but not null. * @hide */ @UnsupportedAppUsage public List<SubscriptionInfo> getAllSubscriptionInfoList() { if (VDBG) logd("[getAllSubscriptionInfoList]+"); List<SubscriptionInfo> result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getAllSubInfoList(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } if (result == null) { result = new ArrayList<>(); } return result; } /** * Get the SubscriptionInfo(s) of the currently active SIM(s). The records will be sorted * by {@link SubscriptionInfo#getSimSlotIndex} then by {@link SubscriptionInfo#getSubscriptionId}. * * <p>Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * or that the calling app has carrier privileges (see * {@link TelephonyManager#hasCarrierPrivileges}). In the latter case, only records accessible * to the calling app are returned. * * @return Sorted list of the currently {@link SubscriptionInfo} records available on the device. * <ul> * <li> * If null is returned the current state is unknown but if a {@link OnSubscriptionsChangedListener} * has been registered {@link OnSubscriptionsChangedListener#onSubscriptionsChanged} will be * invoked in the future. * </li> * <li> * If the list is empty then there are no {@link SubscriptionInfo} records currently available. * </li> * <li> * if the list is non-empty the list is sorted by {@link SubscriptionInfo#getSimSlotIndex} * then by {@link SubscriptionInfo#getSubscriptionId}. * </li> * </ul> */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public List<SubscriptionInfo> getActiveSubscriptionInfoList() { return getActiveSubscriptionInfoList(/* userVisibleonly */true); } /** * This is similar to {@link #getActiveSubscriptionInfoList()}, but if userVisibleOnly * is true, it will filter out the hidden subscriptions. * * @hide */ public List<SubscriptionInfo> getActiveSubscriptionInfoList(boolean userVisibleOnly) { List<SubscriptionInfo> activeList = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { activeList = iSub.getActiveSubscriptionInfoList(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } if (!userVisibleOnly || activeList == null) { return activeList; } else { return activeList.stream().filter(subInfo -> isSubscriptionVisible(subInfo)) .collect(Collectors.toList()); } } /** * Gets the SubscriptionInfo(s) of all available subscriptions, if any. * * <p>Available subscriptions include active ones (those with a non-negative * {@link SubscriptionInfo#getSimSlotIndex()}) as well as inactive but installed embedded * subscriptions. * * <p>The records will be sorted by {@link SubscriptionInfo#getSimSlotIndex} then by * {@link SubscriptionInfo#getSubscriptionId}. * * @return Sorted list of the current {@link SubscriptionInfo} records available on the * device. * <ul> * <li> * If null is returned the current state is unknown but if a * {@link OnSubscriptionsChangedListener} has been registered * {@link OnSubscriptionsChangedListener#onSubscriptionsChanged} will be invoked in the future. * <li> * If the list is empty then there are no {@link SubscriptionInfo} records currently available. * <li> * if the list is non-empty the list is sorted by {@link SubscriptionInfo#getSimSlotIndex} * then by {@link SubscriptionInfo#getSubscriptionId}. * </ul> * * <p> * Permissions android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE is required * for #getAvailableSubscriptionInfoList to be invoked. * @hide */ @SystemApi public List<SubscriptionInfo> getAvailableSubscriptionInfoList() { List<SubscriptionInfo> result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getAvailableSubscriptionInfoList(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * Gets the SubscriptionInfo(s) of all embedded subscriptions accessible to the calling app, if * any. * * <p>Only those subscriptions for which the calling app has carrier privileges per the * subscription metadata, if any, will be included in the returned list. * * <p>The records will be sorted by {@link SubscriptionInfo#getSimSlotIndex} then by * {@link SubscriptionInfo#getSubscriptionId}. * * @return Sorted list of the current embedded {@link SubscriptionInfo} records available on the * device which are accessible to the caller. * <ul> * <li> * If null is returned the current state is unknown but if a * {@link OnSubscriptionsChangedListener} has been registered * {@link OnSubscriptionsChangedListener#onSubscriptionsChanged} will be invoked in the future. * <li> * If the list is empty then there are no {@link SubscriptionInfo} records currently available. * <li> * if the list is non-empty the list is sorted by {@link SubscriptionInfo#getSimSlotIndex} * then by {@link SubscriptionInfo#getSubscriptionId}. * </ul> */ public List<SubscriptionInfo> getAccessibleSubscriptionInfoList() { List<SubscriptionInfo> result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getAccessibleSubscriptionInfoList(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * Request a refresh of the platform cache of profile information for the eUICC which * corresponds to the card ID returned by {@link TelephonyManager#getCardIdForDefaultEuicc()}. * * <p>Should be called by the EuiccService implementation whenever this information changes due * to an operation done outside the scope of a request initiated by the platform to the * EuiccService. There is no need to refresh for downloads, deletes, or other operations that * were made through the EuiccService. * * <p>Requires the {@link android.Manifest.permission#WRITE_EMBEDDED_SUBSCRIPTIONS} permission. * * @see {@link TelephonyManager#getCardIdForDefaultEuicc()} for more information on the card ID. * * @hide */ @SystemApi public void requestEmbeddedSubscriptionInfoListRefresh() { int cardId = TelephonyManager.from(mContext).getCardIdForDefaultEuicc(); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.requestEmbeddedSubscriptionInfoListRefresh(cardId); } } catch (RemoteException ex) { logd("requestEmbeddedSubscriptionInfoListFresh for card = " + cardId + " failed."); } } /** * Request a refresh of the platform cache of profile information for the eUICC with the given * {@code cardId}. * * <p>Should be called by the EuiccService implementation whenever this information changes due * to an operation done outside the scope of a request initiated by the platform to the * EuiccService. There is no need to refresh for downloads, deletes, or other operations that * were made through the EuiccService. * * <p>Requires the {@link android.Manifest.permission#WRITE_EMBEDDED_SUBSCRIPTIONS} permission. * * @param cardId the card ID of the eUICC. * * @see {@link TelephonyManager#getCardIdForDefaultEuicc()} for more information on the card ID. * * @hide */ @SystemApi public void requestEmbeddedSubscriptionInfoListRefresh(int cardId) { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.requestEmbeddedSubscriptionInfoListRefresh(cardId); } } catch (RemoteException ex) { logd("requestEmbeddedSubscriptionInfoListFresh for card = " + cardId + " failed."); } } /** * @return the count of all subscriptions in the database, this includes * all subscriptions that have been seen. * @hide */ @UnsupportedAppUsage public int getAllSubscriptionInfoCount() { if (VDBG) logd("[getAllSubscriptionInfoCount]+"); int result = 0; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getAllSubInfoCount(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * * Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * or that the calling app has carrier privileges (see * {@link TelephonyManager#hasCarrierPrivileges}). In the latter case, the count will include * only those subscriptions accessible to the caller. * * @return the current number of active subscriptions. There is no guarantee the value * returned by this method will be the same as the length of the list returned by * {@link #getActiveSubscriptionInfoList}. */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public int getActiveSubscriptionInfoCount() { int result = 0; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getActiveSubInfoCount(mContext.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return result; } /** * @return the maximum number of active subscriptions that will be returned by * {@link #getActiveSubscriptionInfoList} and the value returned by * {@link #getActiveSubscriptionInfoCount}. */ public int getActiveSubscriptionInfoCountMax() { int result = 0; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getActiveSubInfoCountMax(); } } catch (RemoteException ex) { // ignore it } return result; } /** * Add a new SubscriptionInfo to SubscriptionInfo database if needed * @param iccId the IccId of the SIM card * @param slotIndex the slot which the SIM is inserted * @return the URL of the newly created row or the updated row * @hide */ public Uri addSubscriptionInfoRecord(String iccId, int slotIndex) { if (VDBG) logd("[addSubscriptionInfoRecord]+ iccId:" + iccId + " slotIndex:" + slotIndex); if (iccId == null) { logd("[addSubscriptionInfoRecord]- null iccId"); } if (!isValidSlotIndex(slotIndex)) { logd("[addSubscriptionInfoRecord]- invalid slotIndex"); } addSubscriptionInfoRecord(iccId, null, slotIndex, SUBSCRIPTION_TYPE_LOCAL_SIM); // FIXME: Always returns null? return null; } /** * Add a new SubscriptionInfo to SubscriptionInfo database if needed * @param uniqueId This is the unique identifier for the subscription within the * specific subscription type. * @param displayName human-readable name of the device the subscription corresponds to. * @param slotIndex the slot assigned to this subscription. It is ignored for subscriptionType * of {@link #SUBSCRIPTION_TYPE_REMOTE_SIM}. * @param subscriptionType the {@link #SUBSCRIPTION_TYPE} * @hide */ public void addSubscriptionInfoRecord(String uniqueId, String displayName, int slotIndex, int subscriptionType) { if (VDBG) { logd("[addSubscriptionInfoRecord]+ uniqueId:" + uniqueId + ", displayName:" + displayName + ", slotIndex:" + slotIndex + ", subscriptionType: " + subscriptionType); } if (uniqueId == null) { Log.e(LOG_TAG, "[addSubscriptionInfoRecord]- uniqueId is null"); return; } try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub == null) { Log.e(LOG_TAG, "[addSubscriptionInfoRecord]- ISub service is null"); return; } int result = iSub.addSubInfo(uniqueId, displayName, slotIndex, subscriptionType); if (result < 0) { Log.e(LOG_TAG, "Adding of subscription didn't succeed: error = " + result); } else { logd("successfully added new subscription"); } } catch (RemoteException ex) { // ignore it } } /** * Remove SubscriptionInfo record from the SubscriptionInfo database * @param uniqueId This is the unique identifier for the subscription within the specific * subscription type. * @param subscriptionType the {@link #SUBSCRIPTION_TYPE} * @hide */ public void removeSubscriptionInfoRecord(String uniqueId, int subscriptionType) { if (VDBG) { logd("[removeSubscriptionInfoRecord]+ uniqueId:" + uniqueId + ", subscriptionType: " + subscriptionType); } if (uniqueId == null) { Log.e(LOG_TAG, "[addSubscriptionInfoRecord]- uniqueId is null"); return; } try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub == null) { Log.e(LOG_TAG, "[removeSubscriptionInfoRecord]- ISub service is null"); return; } int result = iSub.removeSubInfo(uniqueId, subscriptionType); if (result < 0) { Log.e(LOG_TAG, "Removal of subscription didn't succeed: error = " + result); } else { logd("successfully removed subscription"); } } catch (RemoteException ex) { // ignore it } } /** * Set SIM icon tint color by simInfo index * @param tint the RGB value of icon tint color of the SIM * @param subId the unique SubInfoRecord index in database * @return the number of records updated * @hide */ @UnsupportedAppUsage public int setIconTint(int tint, int subId) { if (VDBG) logd("[setIconTint]+ tint:" + tint + " subId:" + subId); return setSubscriptionPropertyHelper(subId, "setIconTint", (iSub) -> iSub.setIconTint(tint, subId)); } /** * Set display name by simInfo index with name source * @param displayName the display name of SIM card * @param subId the unique SubscriptionInfo index in database * @param nameSource 0: NAME_SOURCE_DEFAULT_SOURCE, 1: NAME_SOURCE_SIM_SOURCE, * 2: NAME_SOURCE_USER_INPUT * @return the number of records updated or < 0 if invalid subId * @hide */ @UnsupportedAppUsage public int setDisplayName(String displayName, int subId, int nameSource) { if (VDBG) { logd("[setDisplayName]+ displayName:" + displayName + " subId:" + subId + " nameSource:" + nameSource); } return setSubscriptionPropertyHelper(subId, "setDisplayName", (iSub) -> iSub.setDisplayNameUsingSrc(displayName, subId, nameSource)); } /** * Set phone number by subId * @param number the phone number of the SIM * @param subId the unique SubscriptionInfo index in database * @return the number of records updated * @hide */ @UnsupportedAppUsage public int setDisplayNumber(String number, int subId) { if (number == null) { logd("[setDisplayNumber]- fail"); return -1; } return setSubscriptionPropertyHelper(subId, "setDisplayNumber", (iSub) -> iSub.setDisplayNumber(number, subId)); } /** * Set data roaming by simInfo index * @param roaming 0:Don't allow data when roaming, 1:Allow data when roaming * @param subId the unique SubscriptionInfo index in database * @return the number of records updated * @hide */ @UnsupportedAppUsage public int setDataRoaming(int roaming, int subId) { if (VDBG) logd("[setDataRoaming]+ roaming:" + roaming + " subId:" + subId); return setSubscriptionPropertyHelper(subId, "setDataRoaming", (iSub) -> iSub.setDataRoaming(roaming, subId)); } /** * Get slotIndex associated with the subscription. * * @param subscriptionId the unique SubscriptionInfo index in database * @return slotIndex as a positive integer or {@link #INVALID_SIM_SLOT_INDEX} if the supplied * subscriptionId doesn't have an associated slot index. */ public static int getSlotIndex(int subscriptionId) { if (!isValidSubscriptionId(subscriptionId)) { if (DBG) { logd("[getSlotIndex]- supplied subscriptionId is invalid."); } } int result = INVALID_SIM_SLOT_INDEX; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getSlotIndex(subscriptionId); } } catch (RemoteException ex) { // ignore it } return result; } /** * Get an array of Subscription Ids for specified slot Index. * @param slotIndex the slot index. * @return subscription Ids or null if the given slot Index is not valid or there are no active * subscriptions in the slot. */ @Nullable public int[] getSubscriptionIds(int slotIndex) { return getSubId(slotIndex); } /** @hide */ @UnsupportedAppUsage public static int[] getSubId(int slotIndex) { if (!isValidSlotIndex(slotIndex)) { logd("[getSubId]- fail"); return null; } int[] subId = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getSubId(slotIndex); } } catch (RemoteException ex) { // ignore it } return subId; } /** @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P) public static int getPhoneId(int subId) { if (!isValidSubscriptionId(subId)) { if (DBG) { logd("[getPhoneId]- fail"); } return INVALID_PHONE_INDEX; } int result = INVALID_PHONE_INDEX; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getPhoneId(subId); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("[getPhoneId]- phoneId=" + result); return result; } private static void logd(String msg) { Rlog.d(LOG_TAG, msg); } private static void loge(String msg) { Rlog.e(LOG_TAG, msg); } /** * Returns the system's default subscription id. * * For a voice capable device, it will return getDefaultVoiceSubscriptionId. * For a data only device, it will return the getDefaultDataSubscriptionId. * May return an INVALID_SUBSCRIPTION_ID on error. * * @return the "system" default subscription id. */ public static int getDefaultSubscriptionId() { int subId = INVALID_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getDefaultSubId(); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("getDefaultSubId=" + subId); return subId; } /** * Returns the system's default voice subscription id. * * On a data only device or on error, will return INVALID_SUBSCRIPTION_ID. * * @return the default voice subscription Id. */ public static int getDefaultVoiceSubscriptionId() { int subId = INVALID_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getDefaultVoiceSubId(); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("getDefaultVoiceSubscriptionId, sub id = " + subId); return subId; } /** @hide */ public void setDefaultVoiceSubId(int subId) { if (VDBG) logd("setDefaultVoiceSubId sub id = " + subId); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.setDefaultVoiceSubId(subId); } } catch (RemoteException ex) { // ignore it } } /** * Return the SubscriptionInfo for default voice subscription. * * Will return null on data only devices, or on error. * * @return the SubscriptionInfo for the default voice subscription. * @hide */ @UnsupportedAppUsage public SubscriptionInfo getDefaultVoiceSubscriptionInfo() { return getActiveSubscriptionInfo(getDefaultVoiceSubscriptionId()); } /** @hide */ @UnsupportedAppUsage public static int getDefaultVoicePhoneId() { return getPhoneId(getDefaultVoiceSubscriptionId()); } /** * Returns the system's default SMS subscription id. * * On a data only device or on error, will return INVALID_SUBSCRIPTION_ID. * * @return the default SMS subscription Id. */ public static int getDefaultSmsSubscriptionId() { int subId = INVALID_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getDefaultSmsSubId(); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("getDefaultSmsSubscriptionId, sub id = " + subId); return subId; } /** * Set the subscription which will be used by default for SMS, with the subscription which * the supplied subscription ID corresponds to; or throw a RuntimeException if the supplied * subscription ID is not usable (check with {@link #isUsableSubscriptionId(int)}). * * @param subscriptionId the supplied subscription ID * * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void setDefaultSmsSubId(int subscriptionId) { if (VDBG) logd("setDefaultSmsSubId sub id = " + subscriptionId); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.setDefaultSmsSubId(subscriptionId); } } catch (RemoteException ex) { ex.rethrowFromSystemServer(); } } /** * Return the SubscriptionInfo for default voice subscription. * * Will return null on data only devices, or on error. * * @return the SubscriptionInfo for the default SMS subscription. * @hide */ public SubscriptionInfo getDefaultSmsSubscriptionInfo() { return getActiveSubscriptionInfo(getDefaultSmsSubscriptionId()); } /** @hide */ @UnsupportedAppUsage public int getDefaultSmsPhoneId() { return getPhoneId(getDefaultSmsSubscriptionId()); } /** * Returns the system's default data subscription id. * * On a voice only device or on error, will return INVALID_SUBSCRIPTION_ID. * * @return the default data subscription Id. */ public static int getDefaultDataSubscriptionId() { int subId = INVALID_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getDefaultDataSubId(); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("getDefaultDataSubscriptionId, sub id = " + subId); return subId; } /** * Set the subscription which will be used by default for data, with the subscription which * the supplied subscription ID corresponds to; or throw a RuntimeException if the supplied * subscription ID is not usable (check with {@link #isUsableSubscriptionId(int)}). * * @param subscriptionId the supplied subscription ID * * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void setDefaultDataSubId(int subscriptionId) { if (VDBG) logd("setDataSubscription sub id = " + subscriptionId); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.setDefaultDataSubId(subscriptionId); } } catch (RemoteException ex) { // ignore it } } /** * Return the SubscriptionInfo for default data subscription. * * Will return null on voice only devices, or on error. * * @return the SubscriptionInfo for the default data subscription. * @hide */ @UnsupportedAppUsage public SubscriptionInfo getDefaultDataSubscriptionInfo() { return getActiveSubscriptionInfo(getDefaultDataSubscriptionId()); } /** @hide */ @UnsupportedAppUsage public int getDefaultDataPhoneId() { return getPhoneId(getDefaultDataSubscriptionId()); } /** @hide */ public void clearSubscriptionInfo() { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.clearSubInfo(); } } catch (RemoteException ex) { // ignore it } return; } //FIXME this is vulnerable to race conditions /** @hide */ public boolean allDefaultsSelected() { if (!isValidSubscriptionId(getDefaultDataSubscriptionId())) { return false; } if (!isValidSubscriptionId(getDefaultSmsSubscriptionId())) { return false; } if (!isValidSubscriptionId(getDefaultVoiceSubscriptionId())) { return false; } return true; } /** * Check if the supplied subscription ID is valid. * * <p>A valid subscription ID is not necessarily an active subscription ID * (see {@link #isActiveSubscriptionId(int)}) or an usable subscription ID * (see {@link #isUsableSubscriptionId(int)}). Unless specifically noted, subscription * APIs work with a valid subscription ID. * * @param subscriptionId The subscription ID. * @return {@code true} if the supplied subscriptionId is valid; {@code false} otherwise. */ public static boolean isValidSubscriptionId(int subscriptionId) { return subscriptionId > INVALID_SUBSCRIPTION_ID; } /** * Check if the supplied subscription ID is usable. * * <p>A usable subscription ID is a valid subscription ID, but not necessarily an active * subscription ID (see {@link #isActiveSubscriptionId(int)}). Some subscription APIs * require a usable subscription ID, and this is noted in their documentation; otherwise, a * subscription ID does not need to be usable for subscription functions, only valid. * * @param subscriptionId the subscription ID * @return {@code true} if the subscription ID is usable; {@code false} otherwise. */ public static boolean isUsableSubscriptionId(int subscriptionId) { return isUsableSubIdValue(subscriptionId); } /** * @return true if subId is an usable subId value else false. A * usable subId means its neither a INVALID_SUBSCRIPTION_ID nor a DEFAULT_SUB_ID. * @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P) public static boolean isUsableSubIdValue(int subId) { return subId >= MIN_SUBSCRIPTION_ID_VALUE && subId <= MAX_SUBSCRIPTION_ID_VALUE; } /** @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) public static boolean isValidSlotIndex(int slotIndex) { return slotIndex >= 0 && slotIndex < TelephonyManager.getDefault().getSimCount(); } /** @hide */ @UnsupportedAppUsage public static boolean isValidPhoneId(int phoneId) { return phoneId >= 0 && phoneId < TelephonyManager.getDefault().getPhoneCount(); } /** @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P) public static void putPhoneIdAndSubIdExtra(Intent intent, int phoneId) { int[] subIds = SubscriptionManager.getSubId(phoneId); if (subIds != null && subIds.length > 0) { putPhoneIdAndSubIdExtra(intent, phoneId, subIds[0]); } else { logd("putPhoneIdAndSubIdExtra: no valid subs"); intent.putExtra(PhoneConstants.PHONE_KEY, phoneId); } } /** @hide */ @UnsupportedAppUsage public static void putPhoneIdAndSubIdExtra(Intent intent, int phoneId, int subId) { if (VDBG) logd("putPhoneIdAndSubIdExtra: phoneId=" + phoneId + " subId=" + subId); intent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId); intent.putExtra(EXTRA_SUBSCRIPTION_INDEX, subId); intent.putExtra(PhoneConstants.PHONE_KEY, phoneId); } /** * @return the list of subId's that are active, * is never null but the length maybe 0. * @hide */ @UnsupportedAppUsage public @NonNull int[] getActiveSubscriptionIdList() { int[] subId = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getActiveSubIdList(/*visibleOnly*/true); } } catch (RemoteException ex) { // ignore it } if (subId == null) { subId = new int[0]; } return subId; } /** * Returns true if the device is considered roaming on the current * network for a subscription. * <p> * Availability: Only when user registered to a network. * * @param subId The subscription ID * @return true if the network for the subscription is roaming, false otherwise */ public boolean isNetworkRoaming(int subId) { final int phoneId = getPhoneId(subId); if (phoneId < 0) { // What else can we do? return false; } return TelephonyManager.getDefault().isNetworkRoaming(subId); } /** * Returns a constant indicating the state of sim for the slot index. * * @param slotIndex * * {@See TelephonyManager#SIM_STATE_UNKNOWN} * {@See TelephonyManager#SIM_STATE_ABSENT} * {@See TelephonyManager#SIM_STATE_PIN_REQUIRED} * {@See TelephonyManager#SIM_STATE_PUK_REQUIRED} * {@See TelephonyManager#SIM_STATE_NETWORK_LOCKED} * {@See TelephonyManager#SIM_STATE_READY} * {@See TelephonyManager#SIM_STATE_NOT_READY} * {@See TelephonyManager#SIM_STATE_PERM_DISABLED} * {@See TelephonyManager#SIM_STATE_CARD_IO_ERROR} * * {@hide} */ public static int getSimStateForSlotIndex(int slotIndex) { int simState = TelephonyManager.SIM_STATE_UNKNOWN; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { simState = iSub.getSimStateForSlotIndex(slotIndex); } } catch (RemoteException ex) { } return simState; } /** * Store properties associated with SubscriptionInfo in database * @param subId Subscription Id of Subscription * @param propKey Column name in database associated with SubscriptionInfo * @param propValue Value to store in DB for particular subId & column name * @hide */ public static void setSubscriptionProperty(int subId, String propKey, String propValue) { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.setSubscriptionProperty(subId, propKey, propValue); } } catch (RemoteException ex) { // ignore it } } /** * Store properties associated with SubscriptionInfo in database * @param subId Subscription Id of Subscription * @param propKey Column name in SubscriptionInfo database * @return Value associated with subId and propKey column in database * @hide */ private static String getSubscriptionProperty(int subId, String propKey, Context context) { String resultValue = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { resultValue = iSub.getSubscriptionProperty(subId, propKey, context.getOpPackageName()); } } catch (RemoteException ex) { // ignore it } return resultValue; } /** * Returns boolean value corresponding to query result. * @param subId Subscription Id of Subscription * @param propKey Column name in SubscriptionInfo database * @param defValue Default boolean value to be returned * @return boolean result value to be returned * @hide */ public static boolean getBooleanSubscriptionProperty(int subId, String propKey, boolean defValue, Context context) { String result = getSubscriptionProperty(subId, propKey, context); if (result != null) { try { return Integer.parseInt(result) == 1; } catch (NumberFormatException err) { logd("getBooleanSubscriptionProperty NumberFormat exception"); } } return defValue; } /** * Returns integer value corresponding to query result. * @param subId Subscription Id of Subscription * @param propKey Column name in SubscriptionInfo database * @param defValue Default integer value to be returned * @return integer result value to be returned * @hide */ public static int getIntegerSubscriptionProperty(int subId, String propKey, int defValue, Context context) { String result = getSubscriptionProperty(subId, propKey, context); if (result != null) { try { return Integer.parseInt(result); } catch (NumberFormatException err) { logd("getBooleanSubscriptionProperty NumberFormat exception"); } } return defValue; } /** * Returns the resources associated with Subscription. * @param context Context object * @param subId Subscription Id of Subscription who's resources are required * @return Resources associated with Subscription. * @hide */ @UnsupportedAppUsage public static Resources getResourcesForSubId(Context context, int subId) { return getResourcesForSubId(context, subId, false); } /** * Returns the resources associated with Subscription. * @param context Context object * @param subId Subscription Id of Subscription who's resources are required * @param useRootLocale if root locale should be used. Localized locale is used if false. * @return Resources associated with Subscription. * @hide */ public static Resources getResourcesForSubId(Context context, int subId, boolean useRootLocale) { final SubscriptionInfo subInfo = SubscriptionManager.from(context).getActiveSubscriptionInfo(subId); Configuration config = context.getResources().getConfiguration(); Configuration newConfig = new Configuration(); newConfig.setTo(config); if (subInfo != null) { newConfig.mcc = subInfo.getMcc(); newConfig.mnc = subInfo.getMnc(); if (newConfig.mnc == 0) newConfig.mnc = Configuration.MNC_ZERO; } if (useRootLocale) { newConfig.setLocale(Locale.ROOT); } DisplayMetrics metrics = context.getResources().getDisplayMetrics(); DisplayMetrics newMetrics = new DisplayMetrics(); newMetrics.setTo(metrics); return new Resources(context.getResources().getAssets(), newMetrics, newConfig); } /** * Checks if the supplied subscription ID corresponds to a subscription which is actively in * use on the device. An active subscription ID is a valid and usable subscription ID. * * @param subscriptionId the subscription ID. * @return {@code true} if the supplied subscription ID corresponds to an active subscription; * {@code false} if it does not correspond to an active subscription; or throw a * SecurityException if the caller hasn't got the right permission. */ @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public boolean isActiveSubscriptionId(int subscriptionId) { return isActiveSubId(subscriptionId); } /** * @return true if the sub ID is active. i.e. The sub ID corresponds to a known subscription * and the SIM providing the subscription is present in a slot and in "LOADED" state. * @hide */ @UnsupportedAppUsage public boolean isActiveSubId(int subId) { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { return iSub.isActiveSubId(subId, mContext.getOpPackageName()); } } catch (RemoteException ex) { } return false; } /** * Get the description of the billing relationship plan between a carrier * and a specific subscriber. * <p> * This method is only accessible to the following narrow set of apps: * <ul> * <li>The carrier app for this subscriberId, as determined by * {@link TelephonyManager#hasCarrierPrivileges()}. * <li>The carrier app explicitly delegated access through * {@link CarrierConfigManager#KEY_CONFIG_PLANS_PACKAGE_OVERRIDE_STRING}. * </ul> * * @param subId the subscriber this relationship applies to * @throws SecurityException if the caller doesn't meet the requirements * outlined above. */ public @NonNull List<SubscriptionPlan> getSubscriptionPlans(int subId) { try { SubscriptionPlan[] subscriptionPlans = getNetworkPolicy().getSubscriptionPlans(subId, mContext.getOpPackageName()); return subscriptionPlans == null ? Collections.emptyList() : Arrays.asList(subscriptionPlans); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Set the description of the billing relationship plan between a carrier * and a specific subscriber. * <p> * This method is only accessible to the following narrow set of apps: * <ul> * <li>The carrier app for this subscriberId, as determined by * {@link TelephonyManager#hasCarrierPrivileges()}. * <li>The carrier app explicitly delegated access through * {@link CarrierConfigManager#KEY_CONFIG_PLANS_PACKAGE_OVERRIDE_STRING}. * </ul> * * @param subId the subscriber this relationship applies to. An empty list * may be sent to clear any existing plans. * @param plans the list of plans. The first plan is always the primary and * most important plan. Any additional plans are secondary and * may not be displayed or used by decision making logic. * @throws SecurityException if the caller doesn't meet the requirements * outlined above. */ public void setSubscriptionPlans(int subId, @NonNull List<SubscriptionPlan> plans) { try { getNetworkPolicy().setSubscriptionPlans(subId, plans.toArray(new SubscriptionPlan[plans.size()]), mContext.getOpPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** @hide */ private String getSubscriptionPlansOwner(int subId) { try { return getNetworkPolicy().getSubscriptionPlansOwner(subId); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Temporarily override the billing relationship plan between a carrier and * a specific subscriber to be considered unmetered. This will be reflected * to apps via {@link NetworkCapabilities#NET_CAPABILITY_NOT_METERED}. * <p> * This method is only accessible to the following narrow set of apps: * <ul> * <li>The carrier app for this subscriberId, as determined by * {@link TelephonyManager#hasCarrierPrivileges()}. * <li>The carrier app explicitly delegated access through * {@link CarrierConfigManager#KEY_CONFIG_PLANS_PACKAGE_OVERRIDE_STRING}. * </ul> * * @param subId the subscriber this override applies to. * @param overrideUnmetered set if the billing relationship should be * considered unmetered. * @param timeoutMillis the timeout after which the requested override will * be automatically cleared, or {@code 0} to leave in the * requested state until explicitly cleared, or the next reboot, * whichever happens first. * @throws SecurityException if the caller doesn't meet the requirements * outlined above. */ public void setSubscriptionOverrideUnmetered(int subId, boolean overrideUnmetered, @DurationMillisLong long timeoutMillis) { try { final int overrideValue = overrideUnmetered ? OVERRIDE_UNMETERED : 0; getNetworkPolicy().setSubscriptionOverride(subId, OVERRIDE_UNMETERED, overrideValue, timeoutMillis, mContext.getOpPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Temporarily override the billing relationship plan between a carrier and * a specific subscriber to be considered congested. This will cause the * device to delay certain network requests when possible, such as developer * jobs that are willing to run in a flexible time window. * <p> * This method is only accessible to the following narrow set of apps: * <ul> * <li>The carrier app for this subscriberId, as determined by * {@link TelephonyManager#hasCarrierPrivileges()}. * <li>The carrier app explicitly delegated access through * {@link CarrierConfigManager#KEY_CONFIG_PLANS_PACKAGE_OVERRIDE_STRING}. * </ul> * * @param subId the subscriber this override applies to. * @param overrideCongested set if the subscription should be considered * congested. * @param timeoutMillis the timeout after which the requested override will * be automatically cleared, or {@code 0} to leave in the * requested state until explicitly cleared, or the next reboot, * whichever happens first. * @throws SecurityException if the caller doesn't meet the requirements * outlined above. */ public void setSubscriptionOverrideCongested(int subId, boolean overrideCongested, @DurationMillisLong long timeoutMillis) { try { final int overrideValue = overrideCongested ? OVERRIDE_CONGESTED : 0; getNetworkPolicy().setSubscriptionOverride(subId, OVERRIDE_CONGESTED, overrideValue, timeoutMillis, mContext.getOpPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Create an {@link Intent} that can be launched towards the carrier app * that is currently defining the billing relationship plan through * {@link #setSubscriptionPlans(int, List)}. * * @return ready to launch Intent targeted towards the carrier app, or * {@code null} if no carrier app is defined, or if the defined * carrier app provides no management activity. * @hide */ public @Nullable Intent createManageSubscriptionIntent(int subId) { // Bail if no owner final String owner = getSubscriptionPlansOwner(subId); if (owner == null) return null; // Bail if no plans final List<SubscriptionPlan> plans = getSubscriptionPlans(subId); if (plans.isEmpty()) return null; final Intent intent = new Intent(ACTION_MANAGE_SUBSCRIPTION_PLANS); intent.setPackage(owner); intent.putExtra(EXTRA_SUBSCRIPTION_INDEX, subId); // Bail if not implemented if (mContext.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY) .isEmpty()) { return null; } return intent; } /** @hide */ private @Nullable Intent createRefreshSubscriptionIntent(int subId) { // Bail if no owner final String owner = getSubscriptionPlansOwner(subId); if (owner == null) return null; // Bail if no plans final List<SubscriptionPlan> plans = getSubscriptionPlans(subId); if (plans.isEmpty()) return null; final Intent intent = new Intent(ACTION_REFRESH_SUBSCRIPTION_PLANS); intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); intent.setPackage(owner); intent.putExtra(EXTRA_SUBSCRIPTION_INDEX, subId); // Bail if not implemented if (mContext.getPackageManager().queryBroadcastReceivers(intent, 0).isEmpty()) { return null; } return intent; } /** * Check if there is a carrier app that is currently defining the billing * relationship plan through {@link #setSubscriptionPlans(int, List)} that * supports refreshing of subscription plans. * * @hide */ public boolean isSubscriptionPlansRefreshSupported(int subId) { return createRefreshSubscriptionIntent(subId) != null; } /** * Request that the carrier app that is currently defining the billing * relationship plan through {@link #setSubscriptionPlans(int, List)} * refresh its subscription plans. * <p> * If the app is able to successfully update the plans, you'll expect to * receive the {@link #ACTION_SUBSCRIPTION_PLANS_CHANGED} broadcast. * * @hide */ public void requestSubscriptionPlansRefresh(int subId) { final Intent intent = createRefreshSubscriptionIntent(subId); final BroadcastOptions options = BroadcastOptions.makeBasic(); options.setTemporaryAppWhitelistDuration(TimeUnit.MINUTES.toMillis(1)); mContext.sendBroadcast(intent, null, options.toBundle()); } /** * Checks whether the app with the given context is authorized to manage the given subscription * according to its metadata. Only supported for embedded subscriptions (if * {@code SubscriptionInfo#isEmbedded} returns true). * * @param info The subscription to check. * @return whether the app is authorized to manage this subscription per its metadata. * @throws IllegalArgumentException if this subscription is not embedded. */ public boolean canManageSubscription(SubscriptionInfo info) { return canManageSubscription(info, mContext.getPackageName()); } /** * Checks whether the given app is authorized to manage the given subscription. An app can only * be authorized if it is included in the {@link android.telephony.UiccAccessRule} of the * {@link android.telephony.SubscriptionInfo} with the access status. * Only supported for embedded subscriptions (if {@link SubscriptionInfo#isEmbedded} * returns true). * * @param info The subscription to check. * @param packageName Package name of the app to check. * @return whether the app is authorized to manage this subscription per its access rules. * @throws IllegalArgumentException if this subscription is not embedded. * @hide */ public boolean canManageSubscription(SubscriptionInfo info, String packageName) { if (!info.isEmbedded()) { throw new IllegalArgumentException("Not an embedded subscription"); } if (info.getAccessRules() == null) { return false; } PackageManager packageManager = mContext.getPackageManager(); PackageInfo packageInfo; try { packageInfo = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES); } catch (PackageManager.NameNotFoundException e) { throw new IllegalArgumentException("Unknown package: " + packageName, e); } for (UiccAccessRule rule : info.getAccessRules()) { if (rule.getCarrierPrivilegeStatus( packageInfo) == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) { return true; } } return false; } /** * Set which subscription is preferred for cellular data. * It's also usually the subscription we set up internet connection on. * * PreferredData overwrites user setting of default data subscription. And it's used * by AlternativeNetworkService or carrier apps to switch primary and CBRS * subscription dynamically in multi-SIM devices. * * @param subId which subscription is preferred to for cellular data. If it's * {@link SubscriptionManager#DEFAULT_SUBSCRIPTION_ID}, it means * it's unset and {@link SubscriptionManager#getDefaultDataSubscriptionId()} * is used to determine which modem is preferred. * @param needValidation whether Telephony will wait until the network is validated by * connectivity service before switching data to it. More details see * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED}. * @param executor The executor of where the callback will execute. * @param callback Callback will be triggered once it succeeds or failed. * Pass null if don't care about the result. * * @hide * */ @SystemApi @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void setPreferredDataSubscriptionId(int subId, boolean needValidation, @Nullable @CallbackExecutor Executor executor, @Nullable @TelephonyManager.SetOpportunisticSubscriptionResult Consumer<Integer> callback) { if (VDBG) logd("[setPreferredDataSubscriptionId]+ subId:" + subId); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub == null) return; ISetOpportunisticDataCallback callbackStub = new ISetOpportunisticDataCallback.Stub() { @Override public void onComplete(int result) { if (executor == null || callback == null) { return; } Binder.withCleanCallingIdentity(() -> executor.execute(() -> { callback.accept(result); })); } }; iSub.setPreferredDataSubscriptionId(subId, needValidation, callbackStub); } catch (RemoteException ex) { // ignore it } } /** * Get which subscription is preferred for cellular data. * It's also usually the subscription we set up internet connection on. * * PreferredData overwrites user setting of default data subscription. And it's used * by AlternativeNetworkService or carrier apps to switch primary and CBRS * subscription dynamically in multi-SIM devices. * * @return preferred subscription id for cellular data. {@link DEFAULT_SUBSCRIPTION_ID} if * there's no prefered subscription. * * @hide * */ @RequiresPermission(Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public int getPreferredDataSubscriptionId() { int preferredSubId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { preferredSubId = iSub.getPreferredDataSubscriptionId(); } } catch (RemoteException ex) { // ignore it } return preferredSubId; } /** * Return opportunistic subscriptions that can be visible to the caller. * Opportunistic subscriptions are for opportunistic networks, which are cellular * networks with limited capabilities and coverage, for example, CBRS. * * <p>Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * or that the calling app has carrier privileges (see * {@link TelephonyManager#hasCarrierPrivileges}). * * @return the list of opportunistic subscription info. If none exists, an empty list. */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) public @NonNull List<SubscriptionInfo> getOpportunisticSubscriptions() { String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; List<SubscriptionInfo> subInfoList = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subInfoList = iSub.getOpportunisticSubscriptions(pkgForDebug); } } catch (RemoteException ex) { // ignore it } if (subInfoList == null) { subInfoList = new ArrayList<>(); } return subInfoList; } /** * Switch to a certain subscription * * @param subId sub id * @param callbackIntent pending intent that will be sent after operation is done. */ @RequiresPermission(android.Manifest.permission.WRITE_EMBEDDED_SUBSCRIPTIONS) public void switchToSubscription(int subId, @NonNull PendingIntent callbackIntent) { Preconditions.checkNotNull(callbackIntent, "callbackIntent cannot be null"); EuiccManager euiccManager = new EuiccManager(mContext); euiccManager.switchToSubscription(subId, callbackIntent); } /** * Set whether a subscription is opportunistic, that is, whether the network it connects * to has limited coverage. For example, CBRS. Setting a subscription opportunistic has * following impacts: * 1) Even if it's active, it will be dormant most of the time. The modem will not try * to scan or camp until it knows an available network is nearby to save power. * 2) Telephony relies on system app or carrier input to notify nearby available networks. * See {@link TelephonyManager#updateAvailableNetworks(List, Executor, Consumer)} * for more information. * 3) In multi-SIM devices, when the network is nearby and camped, system may automatically * switch internet data between it and default data subscription, based on carrier * recommendation and its signal strength and metered-ness, etc. * * * Caller will either have {@link android.Manifest.permission#MODIFY_PHONE_STATE} or carrier * privilege permission of the subscription. * * @param opportunistic whether its opportunistic subscription. * @param subId the unique SubscriptionInfo index in database * @return {@code true} if the operation is succeed, {@code false} otherwise. */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public boolean setOpportunistic(boolean opportunistic, int subId) { if (VDBG) logd("[setOpportunistic]+ opportunistic:" + opportunistic + " subId:" + subId); return setSubscriptionPropertyHelper(subId, "setOpportunistic", (iSub) -> iSub.setOpportunistic(opportunistic, subId, mContext.getOpPackageName())) == 1; } /** * Inform SubscriptionManager that subscriptions in the list are bundled * as a group. It can be multiple primary (non-opportunistic) subscriptions, * or one or more primary plus one or more opportunistic subscriptions. * * This API will always create a new immutable group and assign group UUID to all the * subscriptions, regardless whether they are in a group already or not. * * Grouped subscriptions will have below behaviors: * 1) They will share the same user settings. * 2) The opportunistic subscriptions in the group is considered invisible and will not * return from {@link #getActiveSubscriptionInfoList()}, unless caller has carrier * privilege permission of the subscriptions. * 3) The opportunistic subscriptions in the group can't be active by itself. If all other * non-opportunistic ones are deactivated (unplugged or disabled in Settings), * the opportunistic ones will be deactivated automatically. * * Caller will either have {@link android.Manifest.permission#MODIFY_PHONE_STATE} * permission or had carrier privilege permission on the subscriptions: * {@link TelephonyManager#hasCarrierPrivileges()} or * {@link #canManageSubscription(SubscriptionInfo)} * * @throws SecurityException if the caller doesn't meet the requirements * outlined above. * @throws IllegalArgumentException if any of the subscriptions in the list doesn't exist. * @throws IllegalStateException if Telephony service is in bad state. * * @param subIdList list of subId that will be in the same group * @return groupUUID a UUID assigned to the subscription group. * */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public @NonNull ParcelUuid createSubscriptionGroup(@NonNull List<Integer> subIdList) { Preconditions.checkNotNull(subIdList, "can't create group for null subId list"); String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (VDBG) { logd("[createSubscriptionGroup]"); } ParcelUuid groupUuid = null; int[] subIdArray = subIdList.stream().mapToInt(i -> i).toArray(); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { groupUuid = iSub.createSubscriptionGroup(subIdArray, pkgForDebug); } else { if (!isSystemProcess()) { throw new IllegalStateException("telephony service is null."); } } } catch (RemoteException ex) { loge("createSubscriptionGroup RemoteException " + ex); if (!isSystemProcess()) { ex.rethrowAsRuntimeException(); } } return groupUuid; } /** * Add a list of subscriptions into a group. * See {@link #createSubscriptionGroup(List)} for more details. * * Caller will either have {@link android.Manifest.permission#MODIFY_PHONE_STATE} * permission or had carrier privilege permission on the subscriptions: * {@link TelephonyManager#hasCarrierPrivileges()} or * {@link #canManageSubscription(SubscriptionInfo)} * * @throws SecurityException if the caller doesn't meet the requirements * outlined above. * @throws IllegalArgumentException if the some subscriptions in the list doesn't exist, * or the groupUuid doesn't exist. * @throws IllegalStateException if Telephony service is in bad state. * * @param subIdList list of subId that need adding into the group * @param groupUuid the groupUuid the subscriptions are being added to. * */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(Manifest.permission.MODIFY_PHONE_STATE) public void addSubscriptionsIntoGroup(@NonNull List<Integer> subIdList, @NonNull ParcelUuid groupUuid) { Preconditions.checkNotNull(subIdList, "subIdList can't be null."); Preconditions.checkNotNull(groupUuid, "groupUuid can't be null."); String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (VDBG) { logd("[addSubscriptionsIntoGroup]"); } int[] subIdArray = subIdList.stream().mapToInt(i -> i).toArray(); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.addSubscriptionsIntoGroup(subIdArray, groupUuid, pkgForDebug); } else { if (!isSystemProcess()) { throw new IllegalStateException("telephony service is null."); } } } catch (RemoteException ex) { loge("addSubscriptionsIntoGroup RemoteException " + ex); if (!isSystemProcess()) { ex.rethrowAsRuntimeException(); } } } private boolean isSystemProcess() { return Process.myUid() == Process.SYSTEM_UID; } /** * Remove a list of subscriptions from their subscription group. * See {@link #createSubscriptionGroup(List)} for more details. * * Caller will either have {@link android.Manifest.permission#MODIFY_PHONE_STATE} * permission or had carrier privilege permission on the subscriptions: * {@link TelephonyManager#hasCarrierPrivileges()} or * {@link #canManageSubscription(SubscriptionInfo)} * * @throws SecurityException if the caller doesn't meet the requirements * outlined above. * @throws IllegalArgumentException if the some subscriptions in the list doesn't belong * the specified group. * @throws IllegalStateException if Telephony service is in bad state. * * @param subIdList list of subId that need removing from their groups. * */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(Manifest.permission.MODIFY_PHONE_STATE) public void removeSubscriptionsFromGroup(@NonNull List<Integer> subIdList, @NonNull ParcelUuid groupUuid) { Preconditions.checkNotNull(subIdList, "subIdList can't be null."); Preconditions.checkNotNull(groupUuid, "groupUuid can't be null."); String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (VDBG) { logd("[removeSubscriptionsFromGroup]"); } int[] subIdArray = subIdList.stream().mapToInt(i -> i).toArray(); try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { iSub.removeSubscriptionsFromGroup(subIdArray, groupUuid, pkgForDebug); } else { if (!isSystemProcess()) { throw new IllegalStateException("telephony service is null."); } } } catch (RemoteException ex) { loge("removeSubscriptionsFromGroup RemoteException " + ex); if (!isSystemProcess()) { ex.rethrowAsRuntimeException(); } } } /** * Get subscriptionInfo list of subscriptions that are in the same group of given subId. * See {@link #createSubscriptionGroup(List)} for more details. * * Caller will either have {@link android.Manifest.permission#READ_PHONE_STATE} * permission or had carrier privilege permission on the subscription. * {@link TelephonyManager#hasCarrierPrivileges()} * * @throws SecurityException if the caller doesn't meet the requirements * outlined above. * * @param groupUuid of which list of subInfo will be returned. * @return list of subscriptionInfo that belong to the same group, including the given * subscription itself. It will return an empty list if no subscription belongs to the group. * */ @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges @RequiresPermission(Manifest.permission.READ_PHONE_STATE) public @NonNull List<SubscriptionInfo> getSubscriptionsInGroup(@NonNull ParcelUuid groupUuid) { Preconditions.checkNotNull(groupUuid, "groupUuid can't be null"); String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>"; if (VDBG) { logd("[getSubscriptionsInGroup]+ groupUuid:" + groupUuid); } List<SubscriptionInfo> result = null; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = iSub.getSubscriptionsInGroup(groupUuid, pkgForDebug); } else { if (!isSystemProcess()) { throw new IllegalStateException("telephony service is null."); } } } catch (RemoteException ex) { loge("removeSubscriptionsFromGroup RemoteException " + ex); if (!isSystemProcess()) { ex.rethrowAsRuntimeException(); } } return result; } /** * Whether a subscription is visible to API caller. If it's a bundled opportunistic * subscription, it should be hidden anywhere in Settings, dialer, status bar etc. * Exception is if caller owns carrier privilege, in which case they will * want to see their own hidden subscriptions. * * @param info the subscriptionInfo to check against. * @return true if this subscription should be visible to the API caller. * */ private boolean isSubscriptionVisible(SubscriptionInfo info) { if (info == null) return false; // If subscription is NOT grouped opportunistic subscription, it's visible. if (info.getGroupUuid() == null || !info.isOpportunistic()) return true; // If the caller is the carrier app and owns the subscription, it should be visible // to the caller. boolean hasCarrierPrivilegePermission = TelephonyManager.from(mContext).hasCarrierPrivileges( info.getSubscriptionId()) || (info.isEmbedded() && canManageSubscription(info)); return hasCarrierPrivilegePermission; } /** * Return a list of subscriptions that are available and visible to the user. * Used by Settings app to show a list of subscriptions for user to pick. * * <p> * Permissions android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE is required * for getSelectableSubscriptionInfoList to be invoked. * @return list of user selectable subscriptions. * * @hide */ public @Nullable List<SubscriptionInfo> getSelectableSubscriptionInfoList() { List<SubscriptionInfo> availableList = getAvailableSubscriptionInfoList(); if (availableList == null) { return null; } else { // Multiple subscriptions in a group should only have one representative. // It should be the current active primary subscription if any, or any // primary subscription. List<SubscriptionInfo> selectableList = new ArrayList<>(); Map<ParcelUuid, SubscriptionInfo> groupMap = new HashMap<>(); for (SubscriptionInfo info : availableList) { // Opportunistic subscriptions are considered invisible // to users so they should never be returned. if (!isSubscriptionVisible(info)) continue; ParcelUuid groupUuid = info.getGroupUuid(); if (groupUuid == null) { // Doesn't belong to any group. Add in the list. selectableList.add(info); } else if (!groupMap.containsKey(groupUuid) || (groupMap.get(groupUuid).getSimSlotIndex() == INVALID_SIM_SLOT_INDEX && info.getSimSlotIndex() != INVALID_SIM_SLOT_INDEX)) { // If it belongs to a group that has never been recorded or it's the current // active subscription, add it in the list. selectableList.remove(groupMap.get(groupUuid)); selectableList.add(info); groupMap.put(groupUuid, info); } } return selectableList; } } /** * Enables or disables a subscription. This is currently used in the settings page. * * <p> * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required * * @param enable whether user is turning it on or off. * @param subscriptionId Subscription to be enabled or disabled. * It could be a eSIM or pSIM subscription. * * @return whether the operation is successful. * * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public boolean setSubscriptionEnabled(int subscriptionId, boolean enable) { if (VDBG) { logd("setSubscriptionActivated subId= " + subscriptionId + " enable " + enable); } try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { return iSub.setSubscriptionEnabled(enable, subscriptionId); } } catch (RemoteException ex) { // ignore it } return false; } /** * DO NOT USE. * This API is designed for features that are not finished at this point. Do not call this API. * @hide * TODO b/135547512: further clean up */ @SystemApi @RequiresPermission(Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public boolean isSubscriptionEnabled(int subscriptionId) { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { return iSub.isSubscriptionEnabled(subscriptionId); } } catch (RemoteException ex) { // ignore it } return false; } /** * DO NOT USE. * This API is designed for features that are not finished at this point. Do not call this API. * @hide * TODO b/135547512: further clean up */ @SystemApi @RequiresPermission(Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public int getEnabledSubscriptionId(int slotIndex) { int subId = INVALID_SUBSCRIPTION_ID; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { subId = iSub.getEnabledSubscriptionId(slotIndex); } } catch (RemoteException ex) { // ignore it } if (VDBG) logd("getEnabledSubscriptionId, subId = " + subId); return subId; } /** * Set whether a subscription always allows MMS connection. If true, MMS network * request will be accepted by telephony even if user turns "mobile data" off * on this subscription. * * @param subId which subscription it's setting to. * @param alwaysAllow whether Mms data is always allowed. * @return whether operation is successful. * * @hide */ public boolean setAlwaysAllowMmsData(int subId, boolean alwaysAllow) { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { return iSub.setAlwaysAllowMmsData(subId, alwaysAllow); } } catch (RemoteException ex) { if (!isSystemProcess()) { ex.rethrowAsRuntimeException(); } } return false; } private interface CallISubMethodHelper { int callMethod(ISub iSub) throws RemoteException; } private int setSubscriptionPropertyHelper(int subId, String methodName, CallISubMethodHelper helper) { if (!isValidSubscriptionId(subId)) { logd("[" + methodName + "]" + "- fail"); return -1; } int result = 0; try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { result = helper.callMethod(iSub); } } catch (RemoteException ex) { // ignore it } return result; } /** * Get active data subscription id. * See {@link PhoneStateListener#onActiveDataSubscriptionIdChanged(int)} for the details. * * @return Active data subscription id * * //TODO: Refactor this API in b/134702460 * @hide */ public static int getActiveDataSubscriptionId() { try { ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub")); if (iSub != null) { return iSub.getActiveDataSubscriptionId(); } } catch (RemoteException ex) { } return SubscriptionManager.INVALID_SUBSCRIPTION_ID; } }