telephony/java/android/telephony/SubscriptionManager.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.telephony;
  18
  19 import android.annotation.NonNull;
  20 import android.annotation.SdkConstant;
  21 import android.annotation.SdkConstant.SdkConstantType;
  22 import android.content.Context;
  23 import android.content.Intent;
  24 import android.content.res.Configuration;
  25 import android.content.res.Resources;
  26 import android.net.Uri;
  27 import android.telephony.Rlog;
  28 import android.os.Handler;
  29 import android.os.Message;
  30 import android.os.ServiceManager;
  31 import android.os.RemoteException;
  32 import android.util.DisplayMetrics;
  33
  34 import com.android.internal.telephony.ISub;
  35 import com.android.internal.telephony.IOnSubscriptionsChangedListener;
  36 import com.android.internal.telephony.ITelephonyRegistry;
  37 import com.android.internal.telephony.PhoneConstants;
  38 import java.util.ArrayList;
  39 import java.util.List;
  40
  41 /**
  42  * SubscriptionManager is the application interface to SubscriptionController
  43  * and provides information about the current Telephony Subscriptions.
  44  * * <p>
  45  * You do not instantiate this class directly; instead, you retrieve
  46  * a reference to an instance through {@link #from}.
  47  * <p>
  48  * All SDK public methods require android.Manifest.permission.READ_PHONE_STATE.
  49  */
  50 public class SubscriptionManager {
  51     private static final String LOG_TAG = "SubscriptionManager";
  52     private static final boolean DBG = false;
  53     private static final boolean VDBG = false;
  54
  55     /** An invalid subscription identifier */
  56     public static final int INVALID_SUBSCRIPTION_ID = -1;
  57
  58     /** Base value for Dummy SUBSCRIPTION_ID's. */
  59     /** FIXME: Remove DummySubId's, but for now have them map just below INVALID_SUBSCRIPTION_ID
  60     /** @hide */
  61     public static final int DUMMY_SUBSCRIPTION_ID_BASE = INVALID_SUBSCRIPTION_ID - 1;
  62
  63     /** An invalid phone identifier */
  64     /** @hide */
  65     public static final int INVALID_PHONE_INDEX = -1;
  66
  67     /** An invalid slot identifier */
  68     /** @hide */
  69     public static final int INVALID_SIM_SLOT_INDEX = -1;
  70
  71     /** Indicates the caller wants the default sub id. */
  72     /** @hide */
  73     public static final int DEFAULT_SUBSCRIPTION_ID = Integer.MAX_VALUE;
  74
  75     /**
  76      * Indicates the caller wants the default phone id.
  77      * Used in SubscriptionController and Phone but do we really need it???
  78      * @hide
  79      */
  80     public static final int DEFAULT_PHONE_INDEX = Integer.MAX_VALUE;
  81
  82     /** Indicates the caller wants the default slot id. NOT used remove? */
  83     /** @hide */
  84     public static final int DEFAULT_SIM_SLOT_INDEX = Integer.MAX_VALUE;
  85
  86     /** Minimum possible subid that represents a subscription */
  87     /** @hide */
  88     public static final int MIN_SUBSCRIPTION_ID_VALUE = 0;
  89
  90     /** Maximum possible subid that represents a subscription */
  91     /** @hide */
  92     public static final int MAX_SUBSCRIPTION_ID_VALUE = DEFAULT_SUBSCRIPTION_ID - 1;
  93
  94     /** @hide */
  95     public static final Uri CONTENT_URI = Uri.parse("content://telephony/siminfo");
  96
  97     /**
  98      * TelephonyProvider unique key column name is the subscription id.
  99      * <P>Type: TEXT (String)</P>
 100      */
 101     /** @hide */
 102     public static final String UNIQUE_KEY_SUBSCRIPTION_ID = "_id";
 103
 104     /**
 105      * TelephonyProvider column name for SIM ICC Identifier
 106      * <P>Type: TEXT (String)</P>
 107      */
 108     /** @hide */
 109     public static final String ICC_ID = "icc_id";
 110
 111     /**
 112      * TelephonyProvider column name for user SIM_SlOT_INDEX
 113      * <P>Type: INTEGER (int)</P>
 114      */
 115     /** @hide */
 116     public static final String SIM_SLOT_INDEX = "sim_id";
 117
 118     /** SIM is not inserted */
 119     /** @hide */
 120     public static final int SIM_NOT_INSERTED = -1;
 121
 122     /**
 123      * TelephonyProvider column name for user displayed name.
 124      * <P>Type: TEXT (String)</P>
 125      */
 126     /** @hide */
 127     public static final String DISPLAY_NAME = "display_name";
 128
 129     /**
 130      * TelephonyProvider column name for the service provider name for the SIM.
 131      * <P>Type: TEXT (String)</P>
 132      */
 133     /** @hide */
 134     public static final String CARRIER_NAME = "carrier_name";
 135
 136     /**
 137      * Default name resource
 138      * @hide
 139      */
 140     public static final int DEFAULT_NAME_RES = com.android.internal.R.string.unknownName;
 141
 142     /**
 143      * TelephonyProvider column name for source of the user displayed name.
 144      * <P>Type: INT (int)</P> with one of the NAME_SOURCE_XXXX values below
 145      *
 146      * @hide
 147      */
 148     public static final String NAME_SOURCE = "name_source";
 149
 150     /**
 151      * The name_source is undefined
 152      * @hide
 153      */
 154     public static final int NAME_SOURCE_UNDEFINDED = -1;
 155
 156     /**
 157      * The name_source is the default
 158      * @hide
 159      */
 160     public static final int NAME_SOURCE_DEFAULT_SOURCE = 0;
 161
 162     /**
 163      * The name_source is from the SIM
 164      * @hide
 165      */
 166     public static final int NAME_SOURCE_SIM_SOURCE = 1;
 167
 168     /**
 169      * The name_source is from the user
 170      * @hide
 171      */
 172     public static final int NAME_SOURCE_USER_INPUT = 2;
 173
 174     /**
 175      * TelephonyProvider column name for the color of a SIM.
 176      * <P>Type: INTEGER (int)</P>
 177      */
 178     /** @hide */
 179     public static final String COLOR = "color";
 180
 181     /** @hide */
 182     public static final int COLOR_1 = 0;
 183
 184     /** @hide */
 185     public static final int COLOR_2 = 1;
 186
 187     /** @hide */
 188     public static final int COLOR_3 = 2;
 189
 190     /** @hide */
 191     public static final int COLOR_4 = 3;
 192
 193     /** @hide */
 194     public static final int COLOR_DEFAULT = COLOR_1;
 195
 196     /**
 197      * TelephonyProvider column name for the phone number of a SIM.
 198      * <P>Type: TEXT (String)</P>
 199      */
 200     /** @hide */
 201     public static final String NUMBER = "number";
 202
 203     /**
 204      * TelephonyProvider column name for the number display format of a SIM.
 205      * <P>Type: INTEGER (int)</P>
 206      */
 207     /** @hide */
 208     public static final String DISPLAY_NUMBER_FORMAT = "display_number_format";
 209
 210     /** @hide */
 211     public static final int DISPLAY_NUMBER_NONE = 0;
 212
 213     /** @hide */
 214     public static final int DISPLAY_NUMBER_FIRST = 1;
 215
 216     /** @hide */
 217     public static final int DISPLAY_NUMBER_LAST = 2;
 218
 219     /** @hide */
 220     public static final int DISPLAY_NUMBER_DEFAULT = DISPLAY_NUMBER_FIRST;
 221
 222     /**
 223      * TelephonyProvider column name for permission for data roaming of a SIM.
 224      * <P>Type: INTEGER (int)</P>
 225      */
 226     /** @hide */
 227     public static final String DATA_ROAMING = "data_roaming";
 228
 229     /** Indicates that data roaming is enabled for a subscription */
 230     public static final int DATA_ROAMING_ENABLE = 1;
 231
 232     /** Indicates that data roaming is disabled for a subscription */
 233     public static final int DATA_ROAMING_DISABLE = 0;
 234
 235     /** @hide */
 236     public static final int DATA_ROAMING_DEFAULT = DATA_ROAMING_DISABLE;
 237
 238     /** @hide */
 239     public static final int SIM_PROVISIONED = 0;
 240
 241     /**
 242      * TelephonyProvider column name for the MCC associated with a SIM.
 243      * <P>Type: INTEGER (int)</P>
 244      * @hide
 245      */
 246     public static final String MCC = "mcc";
 247
 248     /**
 249      * TelephonyProvider column name for the MNC associated with a SIM.
 250      * <P>Type: INTEGER (int)</P>
 251      * @hide
 252      */
 253     public static final String MNC = "mnc";
 254
 255     /**
 256      * TelephonyProvider column name for the sim provisioning status associated with a SIM.
 257      * <P>Type: INTEGER (int)</P>
 258      * @hide
 259      */
 260     public static final String SIM_PROVISIONING_STATUS = "sim_provisioning_status";
 261
 262     /**
 263      *  TelephonyProvider column name for extreme threat in CB settings
 264      * @hide
 265      */
 266     public static final String CB_EXTREME_THREAT_ALERT = "enable_cmas_extreme_threat_alerts";
 267
 268     /**
 269      * TelephonyProvider column name for severe threat in CB settings
 270      *@hide
 271      */
 272     public static final String CB_SEVERE_THREAT_ALERT = "enable_cmas_severe_threat_alerts";
 273
 274     /**
 275      * TelephonyProvider column name for amber alert in CB settings
 276      *@hide
 277      */
 278     public static final String CB_AMBER_ALERT = "enable_cmas_amber_alerts";
 279
 280     /**
 281      * TelephonyProvider column name for emergency alert in CB settings
 282      *@hide
 283      */
 284     public static final String CB_EMERGENCY_ALERT = "enable_emergency_alerts";
 285
 286     /**
 287      * TelephonyProvider column name for alert sound duration in CB settings
 288      *@hide
 289      */
 290     public static final String CB_ALERT_SOUND_DURATION = "alert_sound_duration";
 291
 292     /**
 293      * TelephonyProvider column name for alert reminder interval in CB settings
 294      *@hide
 295      */
 296     public static final String CB_ALERT_REMINDER_INTERVAL = "alert_reminder_interval";
 297
 298     /**
 299      * TelephonyProvider column name for enabling vibrate in CB settings
 300      *@hide
 301      */
 302     public static final String CB_ALERT_VIBRATE = "enable_alert_vibrate";
 303
 304     /**
 305      * TelephonyProvider column name for enabling alert speech in CB settings
 306      *@hide
 307      */
 308     public static final String CB_ALERT_SPEECH = "enable_alert_speech";
 309
 310     /**
 311      * TelephonyProvider column name for ETWS test alert in CB settings
 312      *@hide
 313      */
 314     public static final String CB_ETWS_TEST_ALERT = "enable_etws_test_alerts";
 315
 316     /**
 317      * TelephonyProvider column name for enable channel50 alert in CB settings
 318      *@hide
 319      */
 320     public static final String CB_CHANNEL_50_ALERT = "enable_channel_50_alerts";
 321
 322     /**
 323      * TelephonyProvider column name for CMAS test alert in CB settings
 324      *@hide
 325      */
 326     public static final String CB_CMAS_TEST_ALERT= "enable_cmas_test_alerts";
 327
 328     /**
 329      * TelephonyProvider column name for Opt out dialog in CB settings
 330      *@hide
 331      */
 332     public static final String CB_OPT_OUT_DIALOG = "show_cmas_opt_out_dialog";
 333
 334     /**
 335      * Broadcast Action: The user has changed one of the default subs related to
 336      * data, phone calls, or sms</p>
 337      *
 338      * TODO: Change to a listener
 339      * @hide
 340      */
 341     @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
 342     public static final String SUB_DEFAULT_CHANGED_ACTION =
 343         "android.intent.action.SUB_DEFAULT_CHANGED";
 344
 345     private final Context mContext;
 346
 347     /**
 348      * A listener class for monitoring changes to {@link SubscriptionInfo} records.
 349      * <p>
 350      * Override the onSubscriptionsChanged method in the object that extends this
 351      * class and pass it to {@link #addOnSubscriptionsChangedListener(OnSubscriptionsChangedListener)}
 352      * to register your listener and to unregister invoke
 353      * {@link #removeOnSubscriptionsChangedListener(OnSubscriptionsChangedListener)}
 354      * <p>
 355      * Permissions android.Manifest.permission.READ_PHONE_STATE is required
 356      * for #onSubscriptionsChanged to be invoked.
 357      */
 358     public static class OnSubscriptionsChangedListener {
 359         private final Handler mHandler  = new Handler() {
 360             @Override
 361             public void handleMessage(Message msg) {
 362                 if (DBG) {
 363                     log("handleMessage: invoke the overriden onSubscriptionsChanged()");
 364                 }
 365                 OnSubscriptionsChangedListener.this.onSubscriptionsChanged();
 366             }
 367         };
 368
 369         /**
 370          * Callback invoked when there is any change to any SubscriptionInfo. Typically
 371          * this method would invoke {@link #getActiveSubscriptionInfoList}
 372          */
 373         public void onSubscriptionsChanged() {
 374             if (DBG) log("onSubscriptionsChanged: NOT OVERRIDDEN");
 375         }
 376
 377         /**
 378          * The callback methods need to be called on the handler thread where
 379          * this object was created.  If the binder did that for us it'd be nice.
 380          */
 381         IOnSubscriptionsChangedListener callback = new IOnSubscriptionsChangedListener.Stub() {
 382             @Override
 383             public void onSubscriptionsChanged() {
 384                 if (DBG) log("callback: received, sendEmptyMessage(0) to handler");
 385                 mHandler.sendEmptyMessage(0);
 386             }
 387         };
 388
 389         private void log(String s) {
 390             Rlog.d(LOG_TAG, s);
 391         }
 392     }
 393
 394     /** @hide */
 395     public SubscriptionManager(Context context) {
 396         if (DBG) logd("SubscriptionManager created");
 397         mContext = context;
 398     }
 399
 400     /**
 401      * Get an instance of the SubscriptionManager from the Context.
 402      * This invokes {@link android.content.Context#getSystemService
 403      * Context.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE)}.
 404      *
 405      * @param context to use.
 406      * @return SubscriptionManager instance
 407      */
 408     public static SubscriptionManager from(Context context) {
 409         return (SubscriptionManager) context.getSystemService(
 410                 Context.TELEPHONY_SUBSCRIPTION_SERVICE);
 411     }
 412
 413     /**
 414      * Register for changes to the list of active {@link SubscriptionInfo} records or to the
 415      * individual records themselves. When a change occurs the onSubscriptionsChanged method of
 416      * the listener will be invoked immediately if there has been a notification.
 417      *
 418      * @param listener an instance of {@link OnSubscriptionsChangedListener} with
 419      *                 onSubscriptionsChanged overridden.
 420      */
 421     public void addOnSubscriptionsChangedListener(OnSubscriptionsChangedListener listener) {
 422         String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>";
 423         if (DBG) {
 424             logd("register OnSubscriptionsChangedListener pkgForDebug=" + pkgForDebug
 425                     + " listener=" + listener);
 426         }
 427         try {
 428             // We use the TelephonyRegistry as it runs in the system and thus is always
 429             // available. Where as SubscriptionController could crash and not be available
 430             ITelephonyRegistry tr = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService(
 431                     "telephony.registry"));
 432             if (tr != null) {
 433                 tr.addOnSubscriptionsChangedListener(pkgForDebug, listener.callback);
 434             }
 435         } catch (RemoteException ex) {
 436             // Should not happen
 437         }
 438     }
 439
 440     /**
 441      * Unregister the {@link OnSubscriptionsChangedListener}. This is not strictly necessary
 442      * as the listener will automatically be unregistered if an attempt to invoke the listener
 443      * fails.
 444      *
 445      * @param listener that is to be unregistered.
 446      */
 447     public void removeOnSubscriptionsChangedListener(OnSubscriptionsChangedListener listener) {
 448         String pkgForDebug = mContext != null ? mContext.getOpPackageName() : "<unknown>";
 449         if (DBG) {
 450             logd("unregister OnSubscriptionsChangedListener pkgForDebug=" + pkgForDebug
 451                     + " listener=" + listener);
 452         }
 453         try {
 454             // We use the TelephonyRegistry as its runs in the system and thus is always
 455             // available where as SubscriptionController could crash and not be available
 456             ITelephonyRegistry tr = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService(
 457                     "telephony.registry"));
 458             if (tr != null) {
 459                 tr.removeOnSubscriptionsChangedListener(pkgForDebug, listener.callback);
 460             }
 461         } catch (RemoteException ex) {
 462             // Should not happen
 463         }
 464     }
 465
 466     /**
 467      * Get the active SubscriptionInfo with the input subId.
 468      *
 469      * @param subId The unique SubscriptionInfo key in database.
 470      * @return SubscriptionInfo, maybe null if its not active.
 471      */
 472     public SubscriptionInfo getActiveSubscriptionInfo(int subId) {
 473         if (VDBG) logd("[getActiveSubscriptionInfo]+ subId=" + subId);
 474         if (!isValidSubscriptionId(subId)) {
 475             if (DBG) {
 476                 logd("[getActiveSubscriptionInfo]- invalid subId");
 477             }
 478             return null;
 479         }
 480
 481         SubscriptionInfo subInfo = null;
 482
 483         try {
 484             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 485             if (iSub != null) {
 486                 subInfo = iSub.getActiveSubscriptionInfo(subId, mContext.getOpPackageName());
 487             }
 488         } catch (RemoteException ex) {
 489             // ignore it
 490         }
 491
 492         return subInfo;
 493
 494     }
 495
 496     /**
 497      * Get the active SubscriptionInfo associated with the iccId
 498      * @param iccId the IccId of SIM card
 499      * @return SubscriptionInfo, maybe null if its not active
 500      * @hide
 501      */
 502     public SubscriptionInfo getActiveSubscriptionInfoForIccIndex(String iccId) {
 503         if (VDBG) logd("[getActiveSubscriptionInfoForIccIndex]+ iccId=" + iccId);
 504         if (iccId == null) {
 505             logd("[getActiveSubscriptionInfoForIccIndex]- null iccid");
 506             return null;
 507         }
 508
 509         SubscriptionInfo result = null;
 510
 511         try {
 512             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 513             if (iSub != null) {
 514                 result = iSub.getActiveSubscriptionInfoForIccId(iccId, mContext.getOpPackageName());
 515             }
 516         } catch (RemoteException ex) {
 517             // ignore it
 518         }
 519
 520         return result;
 521     }
 522
 523     /**
 524      * Get the active SubscriptionInfo associated with the slotIdx
 525      * @param slotIdx the slot which the subscription is inserted
 526      * @return SubscriptionInfo, maybe null if its not active
 527      */
 528     public SubscriptionInfo getActiveSubscriptionInfoForSimSlotIndex(int slotIdx) {
 529         if (VDBG) logd("[getActiveSubscriptionInfoForSimSlotIndex]+ slotIdx=" + slotIdx);
 530         if (!isValidSlotId(slotIdx)) {
 531             logd("[getActiveSubscriptionInfoForSimSlotIndex]- invalid slotIdx");
 532             return null;
 533         }
 534
 535         SubscriptionInfo result = null;
 536
 537         try {
 538             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 539             if (iSub != null) {
 540                 result = iSub.getActiveSubscriptionInfoForSimSlotIndex(slotIdx,
 541                         mContext.getOpPackageName());
 542             }
 543         } catch (RemoteException ex) {
 544             // ignore it
 545         }
 546
 547         return result;
 548     }
 549
 550     /**
 551      * @return List of all SubscriptionInfo records in database,
 552      * include those that were inserted before, maybe empty but not null.
 553      * @hide
 554      */
 555     public List<SubscriptionInfo> getAllSubscriptionInfoList() {
 556         if (VDBG) logd("[getAllSubscriptionInfoList]+");
 557
 558         List<SubscriptionInfo> result = null;
 559
 560         try {
 561             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 562             if (iSub != null) {
 563                 result = iSub.getAllSubInfoList(mContext.getOpPackageName());
 564             }
 565         } catch (RemoteException ex) {
 566             // ignore it
 567         }
 568
 569         if (result == null) {
 570             result = new ArrayList<SubscriptionInfo>();
 571         }
 572         return result;
 573     }
 574
 575     /**
 576      * Get the SubscriptionInfo(s) of the currently inserted SIM(s). The records will be sorted
 577      * by {@link SubscriptionInfo#getSimSlotIndex} then by {@link SubscriptionInfo#getSubscriptionId}.
 578      *
 579      * @return Sorted list of the currently {@link SubscriptionInfo} records available on the device.
 580      * <ul>
 581      * <li>
 582      * If null is returned the current state is unknown but if a {@link OnSubscriptionsChangedListener}
 583      * has been registered {@link OnSubscriptionsChangedListener#onSubscriptionsChanged} will be
 584      * invoked in the future.
 585      * </li>
 586      * <li>
 587      * If the list is empty then there are no {@link SubscriptionInfo} records currently available.
 588      * </li>
 589      * <li>
 590      * if the list is non-empty the list is sorted by {@link SubscriptionInfo#getSimSlotIndex}
 591      * then by {@link SubscriptionInfo#getSubscriptionId}.
 592      * </li>
 593      * </ul>
 594      */
 595     public List<SubscriptionInfo> getActiveSubscriptionInfoList() {
 596         List<SubscriptionInfo> result = null;
 597
 598         try {
 599             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 600             if (iSub != null) {
 601                 result = iSub.getActiveSubscriptionInfoList(mContext.getOpPackageName());
 602             }
 603         } catch (RemoteException ex) {
 604             // ignore it
 605         }
 606         return result;
 607     }
 608
 609     /**
 610      * @return the count of all subscriptions in the database, this includes
 611      * all subscriptions that have been seen.
 612      * @hide
 613      */
 614     public int getAllSubscriptionInfoCount() {
 615         if (VDBG) logd("[getAllSubscriptionInfoCount]+");
 616
 617         int result = 0;
 618
 619         try {
 620             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 621             if (iSub != null) {
 622                 result = iSub.getAllSubInfoCount(mContext.getOpPackageName());
 623             }
 624         } catch (RemoteException ex) {
 625             // ignore it
 626         }
 627
 628         return result;
 629     }
 630
 631     /**
 632      * @return the current number of active subscriptions. There is no guarantee the value
 633      * returned by this method will be the same as the length of the list returned by
 634      * {@link #getActiveSubscriptionInfoList}.
 635      */
 636     public int getActiveSubscriptionInfoCount() {
 637         int result = 0;
 638
 639         try {
 640             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 641             if (iSub != null) {
 642                 result = iSub.getActiveSubInfoCount(mContext.getOpPackageName());
 643             }
 644         } catch (RemoteException ex) {
 645             // ignore it
 646         }
 647
 648         return result;
 649     }
 650
 651     /**
 652      * @return the maximum number of active subscriptions that will be returned by
 653      * {@link #getActiveSubscriptionInfoList} and the value returned by
 654      * {@link #getActiveSubscriptionInfoCount}.
 655      */
 656     public int getActiveSubscriptionInfoCountMax() {
 657         int result = 0;
 658
 659         try {
 660             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 661             if (iSub != null) {
 662                 result = iSub.getActiveSubInfoCountMax();
 663             }
 664         } catch (RemoteException ex) {
 665             // ignore it
 666         }
 667
 668         return result;
 669     }
 670
 671     /**
 672      * Add a new SubscriptionInfo to SubscriptionInfo database if needed
 673      * @param iccId the IccId of the SIM card
 674      * @param slotId the slot which the SIM is inserted
 675      * @return the URL of the newly created row or the updated row
 676      * @hide
 677      */
 678     public Uri addSubscriptionInfoRecord(String iccId, int slotId) {
 679         if (VDBG) logd("[addSubscriptionInfoRecord]+ iccId:" + iccId + " slotId:" + slotId);
 680         if (iccId == null) {
 681             logd("[addSubscriptionInfoRecord]- null iccId");
 682         }
 683         if (!isValidSlotId(slotId)) {
 684             logd("[addSubscriptionInfoRecord]- invalid slotId");
 685         }
 686
 687         try {
 688             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 689             if (iSub != null) {
 690                 // FIXME: This returns 1 on success, 0 on error should should we return it?
 691                 iSub.addSubInfoRecord(iccId, slotId);
 692             }
 693         } catch (RemoteException ex) {
 694             // ignore it
 695         }
 696
 697         // FIXME: Always returns null?
 698         return null;
 699
 700     }
 701
 702     /**
 703      * Set SIM icon tint color by simInfo index
 704      * @param tint the RGB value of icon tint color of the SIM
 705      * @param subId the unique SubInfoRecord index in database
 706      * @return the number of records updated
 707      * @hide
 708      */
 709     public int setIconTint(int tint, int subId) {
 710         if (VDBG) logd("[setIconTint]+ tint:" + tint + " subId:" + subId);
 711         if (!isValidSubscriptionId(subId)) {
 712             logd("[setIconTint]- fail");
 713             return -1;
 714         }
 715
 716         int result = 0;
 717
 718         try {
 719             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 720             if (iSub != null) {
 721                 result = iSub.setIconTint(tint, subId);
 722             }
 723         } catch (RemoteException ex) {
 724             // ignore it
 725         }
 726
 727         return result;
 728
 729     }
 730
 731     /**
 732      * Set display name by simInfo index
 733      * @param displayName the display name of SIM card
 734      * @param subId the unique SubscriptionInfo index in database
 735      * @return the number of records updated
 736      * @hide
 737      */
 738     public int setDisplayName(String displayName, int subId) {
 739         return setDisplayName(displayName, subId, NAME_SOURCE_UNDEFINDED);
 740     }
 741
 742     /**
 743      * Set display name by simInfo index with name source
 744      * @param displayName the display name of SIM card
 745      * @param subId the unique SubscriptionInfo index in database
 746      * @param nameSource 0: NAME_SOURCE_DEFAULT_SOURCE, 1: NAME_SOURCE_SIM_SOURCE,
 747      *                   2: NAME_SOURCE_USER_INPUT, -1 NAME_SOURCE_UNDEFINED
 748      * @return the number of records updated or < 0 if invalid subId
 749      * @hide
 750      */
 751     public int setDisplayName(String displayName, int subId, long nameSource) {
 752         if (VDBG) {
 753             logd("[setDisplayName]+  displayName:" + displayName + " subId:" + subId
 754                     + " nameSource:" + nameSource);
 755         }
 756         if (!isValidSubscriptionId(subId)) {
 757             logd("[setDisplayName]- fail");
 758             return -1;
 759         }
 760
 761         int result = 0;
 762
 763         try {
 764             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 765             if (iSub != null) {
 766                 result = iSub.setDisplayNameUsingSrc(displayName, subId, nameSource);
 767             }
 768         } catch (RemoteException ex) {
 769             // ignore it
 770         }
 771
 772         return result;
 773
 774     }
 775
 776     /**
 777      * Set phone number by subId
 778      * @param number the phone number of the SIM
 779      * @param subId the unique SubscriptionInfo index in database
 780      * @return the number of records updated
 781      * @hide
 782      */
 783     public int setDisplayNumber(String number, int subId) {
 784         if (number == null || !isValidSubscriptionId(subId)) {
 785             logd("[setDisplayNumber]- fail");
 786             return -1;
 787         }
 788
 789         int result = 0;
 790
 791         try {
 792             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 793             if (iSub != null) {
 794                 result = iSub.setDisplayNumber(number, subId);
 795             }
 796         } catch (RemoteException ex) {
 797             // ignore it
 798         }
 799
 800         return result;
 801
 802     }
 803
 804     /**
 805      * Set data roaming by simInfo index
 806      * @param roaming 0:Don't allow data when roaming, 1:Allow data when roaming
 807      * @param subId the unique SubscriptionInfo index in database
 808      * @return the number of records updated
 809      * @hide
 810      */
 811     public int setDataRoaming(int roaming, int subId) {
 812         if (VDBG) logd("[setDataRoaming]+ roaming:" + roaming + " subId:" + subId);
 813         if (roaming < 0 || !isValidSubscriptionId(subId)) {
 814             logd("[setDataRoaming]- fail");
 815             return -1;
 816         }
 817
 818         int result = 0;
 819
 820         try {
 821             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 822             if (iSub != null) {
 823                 result = iSub.setDataRoaming(roaming, subId);
 824             }
 825         } catch (RemoteException ex) {
 826             // ignore it
 827         }
 828
 829         return result;
 830     }
 831
 832     /**
 833      * Get slotId associated with the subscription.
 834      * @return slotId as a positive integer or a negative value if an error either
 835      * SIM_NOT_INSERTED or < 0 if an invalid slot index
 836      * @hide
 837      */
 838     public static int getSlotId(int subId) {
 839         if (!isValidSubscriptionId(subId)) {
 840             if (DBG) {
 841                 logd("[getSlotId]- fail");
 842             }
 843         }
 844
 845         int result = INVALID_SIM_SLOT_INDEX;
 846
 847         try {
 848             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 849             if (iSub != null) {
 850                 result = iSub.getSlotId(subId);
 851             }
 852         } catch (RemoteException ex) {
 853             // ignore it
 854         }
 855
 856         return result;
 857
 858     }
 859
 860     /** @hide */
 861     public static int[] getSubId(int slotId) {
 862         if (!isValidSlotId(slotId)) {
 863             logd("[getSubId]- fail");
 864             return null;
 865         }
 866
 867         int[] subId = null;
 868
 869         try {
 870             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 871             if (iSub != null) {
 872                 subId = iSub.getSubId(slotId);
 873             }
 874         } catch (RemoteException ex) {
 875             // ignore it
 876         }
 877
 878         return subId;
 879     }
 880
 881     /** @hide */
 882     public static int getPhoneId(int subId) {
 883         if (!isValidSubscriptionId(subId)) {
 884             if (DBG) {
 885                 logd("[getPhoneId]- fail");
 886             }
 887             return INVALID_PHONE_INDEX;
 888         }
 889
 890         int result = INVALID_PHONE_INDEX;
 891
 892         try {
 893             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 894             if (iSub != null) {
 895                 result = iSub.getPhoneId(subId);
 896             }
 897         } catch (RemoteException ex) {
 898             // ignore it
 899         }
 900
 901         if (VDBG) logd("[getPhoneId]- phoneId=" + result);
 902         return result;
 903
 904     }
 905
 906     private static void logd(String msg) {
 907         Rlog.d(LOG_TAG, msg);
 908     }
 909
 910     /**
 911      * Returns the system's default subscription id.
 912      *
 913      * For a voice capable device, it will return getDefaultVoiceSubscriptionId.
 914      * For a data only device, it will return the getDefaultDataSubscriptionId.
 915      * May return an INVALID_SUBSCRIPTION_ID on error.
 916      *
 917      * @return the "system" default subscription id.
 918      */
 919     public static int getDefaultSubscriptionId() {
 920         int subId = INVALID_SUBSCRIPTION_ID;
 921
 922         try {
 923             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 924             if (iSub != null) {
 925                 subId = iSub.getDefaultSubId();
 926             }
 927         } catch (RemoteException ex) {
 928             // ignore it
 929         }
 930
 931         if (VDBG) logd("getDefaultSubId=" + subId);
 932         return subId;
 933     }
 934
 935     /**
 936      * Returns the system's default voice subscription id.
 937      *
 938      * On a data only device or on error, will return INVALID_SUBSCRIPTION_ID.
 939      *
 940      * @return the default voice subscription Id.
 941      */
 942     public static int getDefaultVoiceSubscriptionId() {
 943         int subId = INVALID_SUBSCRIPTION_ID;
 944
 945         try {
 946             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 947             if (iSub != null) {
 948                 subId = iSub.getDefaultVoiceSubId();
 949             }
 950         } catch (RemoteException ex) {
 951             // ignore it
 952         }
 953
 954         if (VDBG) logd("getDefaultVoiceSubscriptionId, sub id = " + subId);
 955         return subId;
 956     }
 957
 958     /** @hide */
 959     public void setDefaultVoiceSubId(int subId) {
 960         if (VDBG) logd("setDefaultVoiceSubId sub id = " + subId);
 961         try {
 962             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
 963             if (iSub != null) {
 964                 iSub.setDefaultVoiceSubId(subId);
 965             }
 966         } catch (RemoteException ex) {
 967             // ignore it
 968         }
 969     }
 970
 971     /**
 972      * Return the SubscriptionInfo for default voice subscription.
 973      *
 974      * Will return null on data only devices, or on error.
 975      *
 976      * @return the SubscriptionInfo for the default voice subscription.
 977      * @hide
 978      */
 979     public SubscriptionInfo getDefaultVoiceSubscriptionInfo() {
 980         return getActiveSubscriptionInfo(getDefaultVoiceSubscriptionId());
 981     }
 982
 983     /** @hide */
 984     public static int getDefaultVoicePhoneId() {
 985         return getPhoneId(getDefaultVoiceSubscriptionId());
 986     }
 987
 988     /**
 989      * Returns the system's default SMS subscription id.
 990      *
 991      * On a data only device or on error, will return INVALID_SUBSCRIPTION_ID.
 992      *
 993      * @return the default SMS subscription Id.
 994      */
 995     public static int getDefaultSmsSubscriptionId() {
 996         int subId = INVALID_SUBSCRIPTION_ID;
 997
 998         try {
 999             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1000             if (iSub != null) {
1001                 subId = iSub.getDefaultSmsSubId();
1002             }
1003         } catch (RemoteException ex) {
1004             // ignore it
1005         }
1006
1007         if (VDBG) logd("getDefaultSmsSubscriptionId, sub id = " + subId);
1008         return subId;
1009     }
1010
1011     /** @hide */
1012     public void setDefaultSmsSubId(int subId) {
1013         if (VDBG) logd("setDefaultSmsSubId sub id = " + subId);
1014         try {
1015             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1016             if (iSub != null) {
1017                 iSub.setDefaultSmsSubId(subId);
1018             }
1019         } catch (RemoteException ex) {
1020             // ignore it
1021         }
1022     }
1023
1024     /**
1025      * Return the SubscriptionInfo for default voice subscription.
1026      *
1027      * Will return null on data only devices, or on error.
1028      *
1029      * @return the SubscriptionInfo for the default SMS subscription.
1030      * @hide
1031      */
1032     public SubscriptionInfo getDefaultSmsSubscriptionInfo() {
1033         return getActiveSubscriptionInfo(getDefaultSmsSubscriptionId());
1034     }
1035
1036     /** @hide */
1037     public int getDefaultSmsPhoneId() {
1038         return getPhoneId(getDefaultSmsSubscriptionId());
1039     }
1040
1041     /**
1042      * Returns the system's default data subscription id.
1043      *
1044      * On a voice only device or on error, will return INVALID_SUBSCRIPTION_ID.
1045      *
1046      * @return the default data subscription Id.
1047      */
1048     public static int getDefaultDataSubscriptionId() {
1049         int subId = INVALID_SUBSCRIPTION_ID;
1050
1051         try {
1052             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1053             if (iSub != null) {
1054                 subId = iSub.getDefaultDataSubId();
1055             }
1056         } catch (RemoteException ex) {
1057             // ignore it
1058         }
1059
1060         if (VDBG) logd("getDefaultDataSubscriptionId, sub id = " + subId);
1061         return subId;
1062     }
1063
1064     /** @hide */
1065     public void setDefaultDataSubId(int subId) {
1066         if (VDBG) logd("setDataSubscription sub id = " + subId);
1067         try {
1068             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1069             if (iSub != null) {
1070                 iSub.setDefaultDataSubId(subId);
1071             }
1072         } catch (RemoteException ex) {
1073             // ignore it
1074         }
1075     }
1076
1077     /**
1078      * Return the SubscriptionInfo for default data subscription.
1079      *
1080      * Will return null on voice only devices, or on error.
1081      *
1082      * @return the SubscriptionInfo for the default data subscription.
1083      * @hide
1084      */
1085     public SubscriptionInfo getDefaultDataSubscriptionInfo() {
1086         return getActiveSubscriptionInfo(getDefaultDataSubscriptionId());
1087     }
1088
1089     /** @hide */
1090     public int getDefaultDataPhoneId() {
1091         return getPhoneId(getDefaultDataSubscriptionId());
1092     }
1093
1094     /** @hide */
1095     public void clearSubscriptionInfo() {
1096         try {
1097             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1098             if (iSub != null) {
1099                 iSub.clearSubInfo();
1100             }
1101         } catch (RemoteException ex) {
1102             // ignore it
1103         }
1104
1105         return;
1106     }
1107
1108     //FIXME this is vulnerable to race conditions
1109     /** @hide */
1110     public boolean allDefaultsSelected() {
1111         if (!isValidSubscriptionId(getDefaultDataSubscriptionId())) {
1112             return false;
1113         }
1114         if (!isValidSubscriptionId(getDefaultSmsSubscriptionId())) {
1115             return false;
1116         }
1117         if (!isValidSubscriptionId(getDefaultVoiceSubscriptionId())) {
1118             return false;
1119         }
1120         return true;
1121     }
1122
1123     /**
1124      * If a default is set to subscription which is not active, this will reset that default back to
1125      * an invalid subscription id, i.e. < 0.
1126      * @hide
1127      */
1128     public void clearDefaultsForInactiveSubIds() {
1129         if (VDBG) logd("clearDefaultsForInactiveSubIds");
1130         try {
1131             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1132             if (iSub != null) {
1133                 iSub.clearDefaultsForInactiveSubIds();
1134             }
1135         } catch (RemoteException ex) {
1136             // ignore it
1137         }
1138     }
1139
1140     /**
1141      * @return true if a valid subId else false
1142      * @hide
1143      */
1144     public static boolean isValidSubscriptionId(int subId) {
1145         return subId > INVALID_SUBSCRIPTION_ID ;
1146     }
1147
1148     /**
1149      * @return true if subId is an usable subId value else false. A
1150      * usable subId means its neither a INVALID_SUBSCRIPTION_ID nor a DEFAULT_SUB_ID.
1151      * @hide
1152      */
1153     public static boolean isUsableSubIdValue(int subId) {
1154         return subId >= MIN_SUBSCRIPTION_ID_VALUE && subId <= MAX_SUBSCRIPTION_ID_VALUE;
1155     }
1156
1157     /** @hide */
1158     public static boolean isValidSlotId(int slotId) {
1159         return slotId >= 0 && slotId < TelephonyManager.getDefault().getSimCount();
1160     }
1161
1162     /** @hide */
1163     public static boolean isValidPhoneId(int phoneId) {
1164         return phoneId >= 0 && phoneId < TelephonyManager.getDefault().getPhoneCount();
1165     }
1166
1167     /** @hide */
1168     public static void putPhoneIdAndSubIdExtra(Intent intent, int phoneId) {
1169         int[] subIds = SubscriptionManager.getSubId(phoneId);
1170         if (subIds != null && subIds.length > 0) {
1171             putPhoneIdAndSubIdExtra(intent, phoneId, subIds[0]);
1172         } else {
1173             logd("putPhoneIdAndSubIdExtra: no valid subs");
1174         }
1175     }
1176
1177     /** @hide */
1178     public static void putPhoneIdAndSubIdExtra(Intent intent, int phoneId, int subId) {
1179         if (VDBG) logd("putPhoneIdAndSubIdExtra: phoneId=" + phoneId + " subId=" + subId);
1180         intent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId);
1181         intent.putExtra(PhoneConstants.PHONE_KEY, phoneId);
1182         //FIXME this is using phoneId and slotId interchangeably
1183         //Eventually, this should be removed as it is not the slot id
1184         intent.putExtra(PhoneConstants.SLOT_KEY, phoneId);
1185     }
1186
1187     /**
1188      * @return the list of subId's that are active,
1189      *         is never null but the length maybe 0.
1190      * @hide
1191      */
1192     public @NonNull int[] getActiveSubscriptionIdList() {
1193         int[] subId = null;
1194
1195         try {
1196             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1197             if (iSub != null) {
1198                 subId = iSub.getActiveSubIdList();
1199             }
1200         } catch (RemoteException ex) {
1201             // ignore it
1202         }
1203
1204         if (subId == null) {
1205             subId = new int[0];
1206         }
1207
1208         return subId;
1209
1210     }
1211
1212     /**
1213      * Returns true if the device is considered roaming on the current
1214      * network for a subscription.
1215      * <p>
1216      * Availability: Only when user registered to a network.
1217      *
1218      * @param subId The subscription ID
1219      * @return true if the network for the subscription is roaming, false otherwise
1220      */
1221     public boolean isNetworkRoaming(int subId) {
1222         final int phoneId = getPhoneId(subId);
1223         if (phoneId < 0) {
1224             // What else can we do?
1225             return false;
1226         }
1227         return TelephonyManager.getDefault().isNetworkRoaming(subId);
1228     }
1229
1230     /**
1231      * Returns a constant indicating the state of sim for the slot idx.
1232      *
1233      * @param slotIdx
1234      *
1235      * {@See TelephonyManager#SIM_STATE_UNKNOWN}
1236      * {@See TelephonyManager#SIM_STATE_ABSENT}
1237      * {@See TelephonyManager#SIM_STATE_PIN_REQUIRED}
1238      * {@See TelephonyManager#SIM_STATE_PUK_REQUIRED}
1239      * {@See TelephonyManager#SIM_STATE_NETWORK_LOCKED}
1240      * {@See TelephonyManager#SIM_STATE_READY}
1241      * {@See TelephonyManager#SIM_STATE_NOT_READY}
1242      * {@See TelephonyManager#SIM_STATE_PERM_DISABLED}
1243      * {@See TelephonyManager#SIM_STATE_CARD_IO_ERROR}
1244      *
1245      * {@hide}
1246      */
1247     public static int getSimStateForSlotIdx(int slotIdx) {
1248         int simState = TelephonyManager.SIM_STATE_UNKNOWN;
1249
1250         try {
1251             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1252             if (iSub != null) {
1253                 simState = iSub.getSimStateForSlotIdx(slotIdx);
1254             }
1255         } catch (RemoteException ex) {
1256         }
1257
1258         return simState;
1259     }
1260
1261     /**
1262      * Store properties associated with SubscriptionInfo in database
1263      * @param subId Subscription Id of Subscription
1264      * @param propKey Column name in database associated with SubscriptionInfo
1265      * @param propValue Value to store in DB for particular subId & column name
1266      * @hide
1267      */
1268     public static void setSubscriptionProperty(int subId, String propKey, String propValue) {
1269         try {
1270             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1271             if (iSub != null) {
1272                 iSub.setSubscriptionProperty(subId, propKey, propValue);
1273             }
1274         } catch (RemoteException ex) {
1275             // ignore it
1276         }
1277     }
1278
1279     /**
1280      * Store properties associated with SubscriptionInfo in database
1281      * @param subId Subscription Id of Subscription
1282      * @param propKey Column name in SubscriptionInfo database
1283      * @return Value associated with subId and propKey column in database
1284      * @hide
1285      */
1286     private static String getSubscriptionProperty(int subId, String propKey,
1287             Context context) {
1288         String resultValue = null;
1289         try {
1290             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1291             if (iSub != null) {
1292                 resultValue = iSub.getSubscriptionProperty(subId, propKey,
1293                     context.getOpPackageName());
1294             }
1295         } catch (RemoteException ex) {
1296             // ignore it
1297         }
1298         return resultValue;
1299     }
1300
1301     /**
1302      * Returns boolean value corresponding to query result.
1303      * @param subId Subscription Id of Subscription
1304      * @param propKey Column name in SubscriptionInfo database
1305      * @param defValue Default boolean value to be returned
1306      * @return boolean result value to be returned
1307      * @hide
1308      */
1309     public static boolean getBooleanSubscriptionProperty(int subId, String propKey,
1310             boolean defValue, Context context) {
1311         String result = getSubscriptionProperty(subId, propKey, context);
1312         if (result != null) {
1313             try {
1314                 return Integer.parseInt(result) == 1;
1315             } catch (NumberFormatException err) {
1316                 logd("getBooleanSubscriptionProperty NumberFormat exception");
1317             }
1318         }
1319         return defValue;
1320     }
1321
1322     /**
1323      * Returns integer value corresponding to query result.
1324      * @param subId Subscription Id of Subscription
1325      * @param propKey Column name in SubscriptionInfo database
1326      * @param defValue Default integer value to be returned
1327      * @return integer result value to be returned
1328      * @hide
1329      */
1330     public static int getIntegerSubscriptionProperty(int subId, String propKey, int defValue,
1331             Context context) {
1332         String result = getSubscriptionProperty(subId, propKey, context);
1333         if (result != null) {
1334             try {
1335                 return Integer.parseInt(result);
1336             } catch (NumberFormatException err) {
1337                 logd("getBooleanSubscriptionProperty NumberFormat exception");
1338             }
1339         }
1340         return defValue;
1341     }
1342
1343     /**
1344      * Returns the resources associated with Subscription.
1345      * @param context Context object
1346      * @param subId Subscription Id of Subscription who's resources are required
1347      * @return Resources associated with Subscription.
1348      * @hide
1349      */
1350     public static Resources getResourcesForSubId(Context context, int subId) {
1351         final SubscriptionInfo subInfo =
1352                 SubscriptionManager.from(context).getActiveSubscriptionInfo(subId);
1353
1354         Configuration config = context.getResources().getConfiguration();
1355         Configuration newConfig = new Configuration();
1356         newConfig.setTo(config);
1357         if (subInfo != null) {
1358             newConfig.mcc = subInfo.getMcc();
1359             newConfig.mnc = subInfo.getMnc();
1360             if (newConfig.mnc == 0) newConfig.mnc = Configuration.MNC_ZERO;
1361         }
1362         DisplayMetrics metrics = context.getResources().getDisplayMetrics();
1363         DisplayMetrics newMetrics = new DisplayMetrics();
1364         newMetrics.setTo(metrics);
1365         return new Resources(context.getResources().getAssets(), newMetrics, newConfig);
1366     }
1367
1368     /**
1369      * @return true if the sub ID is active. i.e. The sub ID corresponds to a known subscription
1370      * and the SIM providing the subscription is present in a slot and in "LOADED" state.
1371      * @hide
1372      */
1373     public boolean isActiveSubId(int subId) {
1374         try {
1375             ISub iSub = ISub.Stub.asInterface(ServiceManager.getService("isub"));
1376             if (iSub != null) {
1377                 return iSub.isActiveSubId(subId);
1378             }
1379         } catch (RemoteException ex) {
1380         }
1381         return false;
1382     }
1383 }