487:         public Phone phone;

17: package com.android.phone;

249: public class PhoneInterfaceManager extends ITelephony.Stub {

2342:     private PhoneInterfaceManager(PhoneGlobals app) {

2367:     private Phone getDefaultPhone() {

2402:     private Phone getPhone(int subId) {

3082:     public String getNetworkCountryIsoForPhone(int phoneId) {

6784:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

6812:     public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {

7413:     public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {

385:     private PhoneConfigurationManager mPhoneConfigurationManager;

2381:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2389:     private Phone getPhoneFromSubId(int subId) {

2547:         private final int mPhoneId;

2826:     private void shutdownRadioUsingPhoneId(int phoneId) {

3536:     public int getActivePhoneType() {

3541:     public int getActivePhoneTypeForSlot(int slotIndex) {

4687:     private void checkModifyPhoneStatePermission(int subId, String message) {

5198:     private Phone getPhoneFromSlotPortIndexOrThrowException(int slotIndex, int portIndex) {

5221:     private Phone getPhoneFromValidIccLogicalChannelRequest(

6789:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {

6840:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7546:     public int getSubIdForPhoneAccountHandle(

7561:     public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {

10241:     private boolean isAnyPhoneInEmergencyState() {

11114:     public PhoneCapability getPhoneCapability() {

21: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_CDMA;

22: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_GSM;

23: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_IMS;

174: import com.android.internal.telephony.Phone;

213: import com.android.phone.callcomposer.CallComposerPictureManager;

214: import com.android.phone.callcomposer.CallComposerPictureTransfer;

215: import com.android.phone.callcomposer.ImageData;

216: import com.android.phone.settings.PickSmsSubscriptionActivity;

217: import com.android.phone.vvm.PhoneAccountHandleConverter;

218: import com.android.phone.vvm.RemoteVvmTaskManager;

219: import com.android.phone.vvm.VisualVoicemailSettingsUtil;

220: import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;

486:         // In cases where subId is unavailable, the caller needs to specify the phone.

495:         MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {

497:             if (phone != null) {

498:                 this.phone = phone;

526:      * A handler that processes messages on the main thread in the phone process. Since many

527:      * of the Phone calls are not thread safe this is needed to shuttle the requests from the

528:      * inbound binder threads to the main thread in the phone process.  The Binder thread

545:             final Phone defaultPhone = getDefaultPhone();

550:                     final Phone phone = getPhoneFromRequest(request);

569:                         request.result = phone != null

570:                                 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;

581:                     final Phone phone = getPhoneFromRequest(request);

582:                     request.result = phone != null ?

902:                     Phone phone = getPhoneFromRequest(request);

903:                     if (phone != null) {

904:                         phone.isNrDualConnectivityEnabled(onCompleted, request.workSource);

906:                         loge("isNRDualConnectivityEnabled: No phone object");

942:                     Phone phone = getPhoneFromRequest(request);

943:                     if (phone != null) {

944:                         phone.isVoNrEnabled(onCompleted, request.workSource);

946:                         loge("isVoNrEnabled: No phone object");

981:                     Phone phone = getPhoneFromRequest(request);

982:                     if (phone != null) {

983:                         phone.setNrDualConnectivityState((int) request.argument, onCompleted,

986:                         loge("enableNrDualConnectivity: No phone object");

1029:                     Phone phone = getPhoneFromRequest(request);

1030:                     if (phone != null) {

1031:                         phone.setVoNrEnabled((boolean) request.argument, onCompleted,

1034:                         loge("setVoNrEnabled: No phone object");

1162:                     request.phone.getCallForwardingOption(callForwardingReason, onCompleted);

1226:                     request.phone.setCallForwardingOption(

1670:                     request.phone.requestCellInfoUpdate(request.workSource, onCompleted);

1684:                     request.phone.requestCellInfoUpdate(request.workSource,

1712:                     Phone phone = getPhoneFromRequest(request);

1713:                     phone.getCellIdentity(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));

1722:                         Phone phone = getPhoneFromRequest(request);

1723:                         request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)

1746:                             .enablePhone(request.phone, enable, onCompleted);

1752:                     int phoneId = request.phone.getPhoneId();

1768:                             .getPhoneStatusFromModem(request.phone, onCompleted);

1773:                     int id = request.phone.getPhoneId();

1796:                     request.phone.setSystemSelectionChannels(args.first, onCompleted);

1811:                     Phone phone = getPhoneFromRequest(request);

1812:                     if (phone != null) {

1813:                         phone.getSystemSelectionChannels(onCompleted);

1815:                         loge("getSystemSelectionChannels: No phone object");

1962:                     Phone phone = getPhoneFromRequest(request);

1963:                     if (phone != null) {

1964:                         phone.setDataThrottling(onCompleted,

1968:                         loge("setDataThrottling: No phone object");

2012:                     request.phone.setSimPowerState(stateToSet, onCompleted, request.workSource);

2056:                     final Phone phone = getPhoneFromRequest(request);

2057:                     if (phone == null || phone.getServiceStateTracker() == null) {

2058:                         request.result = new IllegalStateException("Phone or SST is null");

2067:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

2084:                     Phone phone = getPhoneFromRequest(request);

2085:                     if (phone == null || phone.getServiceStateTracker() == null) {

2086:                         request.result = new IllegalStateException("Phone or SST is null");

2095:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

2111:                     request.phone.getSlicingConfig(onCompleted);

2235:     private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {

2236:         return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone,

2246:     private @Nullable Object sendRequest(int command, Object argument, Integer subId, Phone phone,

2253:         if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {

2254:             throw new IllegalArgumentException("subId and phone cannot both be specified!");

2255:         } else if (phone != null) {

2256:             request = new MainThreadRequest(argument, phone, workSource);

2316:      * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.

2320:             int command, Object argument, Phone phone, WorkSource workSource) {

2321:         MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);

2361:         PropertyInvalidatedCache.invalidateCache(TelephonyManager.CACHE_KEY_PHONE_ACCOUNT_TO_SUBID);

2368:         Phone thePhone = getPhone(getDefaultSubscription());

2382:         if (request.phone != null) {

2383:             return request.phone;

2396:         Phone phone = getPhoneFromRequest(request);

2397:         return phone == null ? null :

2398:                 UiccController.getInstance().getUiccPort(phone.getPhoneId());

2401:     // returns phone associated with the subId.

2406:     private void sendEraseModemConfig(@NonNull Phone phone) {

2411:     private void sendEraseDataInSharedPreferences(@NonNull Phone phone) {

2443:             // PENDING: should we just silently fail if phone is offhook or ringing?

2464:         // from the context of the phone app.

2467:         if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)

2517:             Phone phone = getPhone(subId);

2518:             final UnlockSim checkSimPin = new UnlockSim(phone.getPhoneId(), phone.getIccCard());

2531:             Phone phone = getPhone(subId);

2532:             final UnlockSim checkSimPuk = new UnlockSim(phone.getPhoneId(), phone.getIccCard());

2694:             final Phone phone = getPhone(getDefaultSubscription());

2695:             if (phone != null) {

2696:                 phone.updateServiceLocation(workSource);

2741:             final Phone phone = getPhone(subId);

2742:             if (phone != null) {

2743:                 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;

2761:             final Phone phone = getPhone(subId);

2762:             if (phone != null) {

2763:                 phone.setRadioPower(!isRadioOnForSubscriber(subId));

2779:             final Phone phone = getPhone(subId);

2780:             if (phone == null) {

2783:             if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {

2801:                 Phone phone = PhoneFactory.getPhone(i);

2802:                 if (phone != null && phone.isRadioAvailable()) return true;

2818:                 logv("Shutting down Phone " + i);

2827:         Phone phone = PhoneFactory.getPhone(phoneId);

2828:         if (phone != null && phone.isRadioAvailable()) {

2829:             phone.shutdownRadio();

2838:             final Phone defaultPhone = PhoneFactory.getDefaultPhone();

2843:                 loge("There's no default phone.");

2856:             final Phone phone = getPhone(subId);

2857:             if (phone != null) {

2858:                 phone.setRadioPower(turnOn);

2876:             final Phone phone = getPhone(subId);

2877:             if (phone != null) {

2878:                 phone.getDataSettingsManager().setDataEnabled(

2897:             final Phone phone = getPhone(subId);

2898:             if (phone != null) {

2899:                 phone.getDataSettingsManager().setDataEnabled(

2914:             final Phone phone = getPhone(subId);

2915:             if (phone != null) {

2916:                 return phone.isDataAllowed();

2975:             Phone phone = getPhone(getDefaultSubscription());

2976:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :

2977:                     PhoneConstantConversions.convertCallState(phone.getState());

2988:             // Check READ_PHONE_STATE for API version 31+

2991:                 throw new SecurityException("getCallState requires READ_PHONE_STATE for apps "

2997:             Phone phone = getPhone(subId);

2998:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :

2999:                     PhoneConstantConversions.convertCallState(phone.getState());

3014:             final Phone phone = getPhone(subId);

3015:             if (phone != null) {

3016:                 return phone.getDataNetworkController().getInternetDataNetworkState();

3035:             final Phone phone = getPhone(subId);

3036:             if (phone != null) {

3037:                 return phone.getDataActivityState();

3066:                 return (getDefaultPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)

3087:             if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {

3088:                 // Get default phone in this case.

3089:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

3092:             Phone phone = PhoneFactory.getPhone(phoneId);

3093:             if (phone == null) return "";

3094:             ServiceStateTracker sst = phone.getServiceStateTracker();

3171:         for (Phone phone : PhoneFactory.getPhones()) {

3172:             List<CellInfo> info = phone.getAllCellInfo();

3211:             for (Phone phone : PhoneFactory.getPhones()) {

3213:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3275:         final Phone phone = getPhoneFromSubId(subId);

3276:         if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);

3278:         sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);

3296:         Phone phone = PhoneFactory.getPhone(slotIndex);

3297:         if (phone == null) {

3300:         int subId = phone.getSubId();

3309:             return phone.getImei();

3317:         Phone phone = PhoneFactory.getPhone(slotIndex);

3319:         if (phone != null) {

3320:             String imei = phone.getImei();

3340:         Phone phone = PhoneFactory.getPhone(slotIndex);

3341:         if (phone == null) {

3345:         int subId = phone.getSubId();

3353:             return phone.getMeid();

3361:         Phone phone = PhoneFactory.getPhone(slotIndex);

3363:         if (phone != null) {

3364:             String meid = phone.getMeid();

3379:         Phone phone = PhoneFactory.getPhone(slotIndex);

3380:         if (phone == null) {

3383:         int subId = phone.getSubId();

3392:             return phone.getDeviceSvn();

3402:             final Phone phone = getPhone(subId);

3403:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();

3413:             final Phone phone = getPhone(subId);

3414:             return phone == null ? null : phone.getCarrierName();

3424:             final Phone phone = getPhone(subId);

3425:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3426:                     : phone.getSpecificCarrierId();

3436:             final Phone phone = getPhone(subId);

3437:             return phone == null ? null : phone.getSpecificCarrierName();

3448:         final Phone phone = PhoneFactory.getPhone(slotIndex);

3449:         if (phone == null) {

3454:             return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);

3485:      * Make sure the caller has the MODIFY_PHONE_STATE permission.

3490:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);

3499:      * Make sure the caller has the CALL_PHONE permission.

3504:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);

3544:             final Phone phone = PhoneFactory.getPhone(slotIndex);

3545:             if (phone == null) {

3546:                 return PhoneConstants.PHONE_TYPE_NONE;

3548:                 return phone.getPhoneType();

3575:             final Phone phone = getPhone(subId);

3576:             if (phone != null) {

3577:                 return phone.getCdmaEriIconIndex();

3608:             final Phone phone = getPhone(subId);

3609:             if (phone != null) {

3610:                 return phone.getCdmaEriIconMode();

3639:             final Phone phone = getPhone(subId);

3640:             if (phone != null) {

3641:                 return phone.getCdmaEriText();

3660:             final Phone phone = getPhone(subId);

3661:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {

3662:                 return phone.getLine1Number();

3664:                 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);

3682:             final Phone phone = getPhone(subId);

3683:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {

3684:                 return phone.getCdmaMin();

3696:         if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)

3698:             throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");

3864:             final Phone phone = getPhone(subId);

3865:             if (phone != null) {

3866:                 phone.setVoiceActivationState(activationState);

3885:             final Phone phone = getPhone(subId);

3886:             if (phone != null) {

3887:                 phone.setDataActivationState(activationState);

3903:         final Phone phone = getPhone(subId);

3906:             if (phone != null) {

3907:                 return phone.getVoiceActivationState();

3923:         final Phone phone = getPhone(subId);

3926:             if (phone != null) {

3927:                 return phone.getDataActivationState();

3949:             final Phone phone = getPhone(subId);

3950:             if (phone != null) {

3951:                 return phone.getVoiceMessageCount();

3968:             final Phone phone = getPhone(subId);

3969:             return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());

3982:         final Phone defaultPhone = getDefaultPhone();

4020:             for (Phone phone : PhoneFactory.getPhones()) {

4021:                 if (phone.isInEmergencySmsMode()) {

4032:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4059:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4096:             Phone phone = getPhone(subId);

4097:             if (phone == null) {

4102:             phone.getImsRegistrationState(regState -> {

4129:             Phone phone = getPhone(subId);

4130:             if (phone == null) {

4135:             phone.getImsRegistrationTech(regTech -> {

4154:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4180:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4230:             Phone phone = getPhone(subId);

4231:             if (phone == null) return false;

4232:             return phone.isImsCapabilityAvailable(capability, regTech);

4283:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4321:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4358:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4396:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4417:      * Requires MODIFY_PHONE_STATE permission.

4440:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4494:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4580:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

5000:             final Phone phone = getPhone(subId);

5001:             if (phone != null) {

5002:                 return phone.getServiceState().getDataNetworkType();

5037:             final Phone phone = getPhone(subId);

5038:             if (phone != null) {

5039:                 return phone.getServiceState().getDataNetworkType();

5065:             final Phone phone = getPhone(subId);

5066:             if (phone != null) {

5067:                 return phone.getServiceState().getVoiceNetworkType();

5092:             final Phone phone = PhoneFactory.getPhone(slotIndex);

5093:             if (phone != null) {

5094:                 return phone.getIccCard().hasIccCard();

5109:      * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}

5110:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5129:             final Phone phone = getPhone(subId);

5130:             if (phone == null) {

5203:                      + portIndex + " does not correspond to an active phone");

5211:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5218:         return iccOpenLogicalChannelWithPermission(phone, request);

5223:         Phone phone;

5227:             phone = getPhoneFromSubId(request.subId);

5230:             phone = getPhoneFromSlotPortIndexOrThrowException(request.slotIndex, request.portIndex);

5234:         return phone;

5237:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

5254:                     CMD_OPEN_CHANNEL, channelRequest, phone, null /* workSource */);

5264:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5269:         return iccCloseLogicalChannelWithPermission(phone, request);

5272:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,

5284:             Object result = sendRequest(CMD_CLOSE_CHANNEL, request.channel, phone,

5334:     private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,

5343:                     new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,

5390:     private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,

5408:                     new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,

5640:         Phone phone = PhoneFactory.getPhone(slotIndex);

5641:         if (phone != null) {

5643:                     mApp, phone.getSubId(), "resetModemConfig");

5666:         Phone phone = PhoneFactory.getPhone(slotIndex);

5667:         if (phone != null) {

5669:                     mApp, phone.getSubId(), "rebootModem");

5944:      * Sets the ims registration state on all valid {@link Phone}s.

5951:             // NOTE: Before S, this method only set the default phone.

5952:             for (final Phone phone : PhoneFactory.getPhones()) {

5953:                 if (SubscriptionManager.isValidSubscriptionId(phone.getSubId())) {

5954:                     phone.setImsRegistrationState(registered);

6037:             final Phone phone = getPhone(subId);

6038:             if (phone == null) {

6041:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

6043:                 ? phone.getManualNetworkSelectionPlmn() : networkSelection.getOperatorNumeric();

6100:             Phone phone = getPhone(subId);

6101:             if (phone == null) {

6131:             sendRequestAsync(CMD_GET_CALL_FORWARDING, argument, phone, null);

6152:             Phone phone = getPhone(subId);

6153:             if (phone == null) {

6166:             sendRequestAsync(CMD_SET_CALL_FORWARDING, arguments, phone, null);

6180:             Phone phone = getPhone(subId);

6181:             if (phone == null) {

6189:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());

6196:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),

6216:                 sendRequestAsync(CMD_GET_CALL_WAITING, argument, phone, null);

6233:             Phone phone = getPhone(subId);

6234:             if (phone == null) {

6243:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());

6250:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),

6273:                 sendRequestAsync(CMD_SET_CALL_WAITING, arguments, phone, null);

6509:         if (mApp.checkCallingOrSelfPermission(Manifest.permission.MODIFY_PHONE_STATE)

6530:         Phone phone = getPhone(subId);

6531:         if (phone == null) {

6535:         if (allowedNetworkTypes == phone.getAllowedNetworkTypes(reason)) {

6564:         final Phone phone = getPhone(subId);

6566:             if (phone != null) {

6567:                 return phone.hasMatchedTetherApnSetting();

6597:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6607:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

6622:             Phone phone = PhoneFactory.getPhone(phoneId);

6623:             if (phone != null) {

6624:                 boolean retVal = phone.isUserDataEnabled();

6628:                 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");

6654:                             android.Manifest.permission.READ_PHONE_STATE,

6658:                             permission.READ_BASIC_PHONE_STATE, functionName);

6668:             Phone phone = PhoneFactory.getPhone(phoneId);

6669:             if (phone != null) {

6671:                 retVal = phone.getDataSettingsManager().isDataEnabled();

6675:                 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");

6699:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

6704:                 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,

6720:             Phone phone = PhoneFactory.getPhone(phoneId);

6721:             if (phone != null) {

6723:                 retVal = phone.getDataSettingsManager().isDataEnabledForReason(reason);

6728:                     loge("isDataEnabledForReason: no phone subId="

6751:         Phone phone = getPhone(subId);

6752:         if (phone == null) {

6756:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6770:         Phone phone = getPhone(subId);

6771:         if (phone == null) {

6775:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6795:             Phone phone = PhoneFactory.getPhone(phoneId);

6796:             if (phone == null) {

6799:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6814:         Phone phone = PhoneFactory.getPhone(phoneId);

6815:         if (phone == null) {

6818:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6828:         Phone phone = PhoneFactory.getPhone(phoneId);

6829:         if (phone == null) {

6832:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6858:         final Phone phone = PhoneFactory.getPhone(logicalSlotIndex);

6859:         if (phone == null) {

6862:         final CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6870:         final Phone phone = getPhone(subId);

6871:         UiccPort port = phone == null ? null : phone.getUiccPort();

6888:             Phone phone = getPhone(subId);

6889:             if (phone != null) {

6890:                 Phone defaultPhone = phone.getImsPhone();

6891:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {

6911:             Phone phone = getPhone(subId);

6912:             if (phone != null) {

6913:                 Phone defaultPhone = phone.getImsPhone();

6914:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {

6934:             final Phone phone = getPhone(subId);

6935:             if (phone == null) {

6938:             final String subscriberId = phone.getSubscriberId();

7175:             final Phone phone = getPhone(subId);

7176:             return phone == null ? false : phone.setOperatorBrandOverride(brand);

7191:             final Phone phone = getPhone(subId);

7192:             if (phone == null) {

7195:             return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,

7237:         Phone phone = PhoneFactory.getPhone(phoneId);

7241:                             mApp, phone.getSubId(), "getRadioAccessFamily");

7247:         if (phone == null) {

7254:                             mApp, phone.getSubId(), "getRadioAccessFamily");

7356:         final Phone defaultPhone = getDefaultPhone();

7370:         final Phone defaultPhone = getDefaultPhone();

7424:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7455:         final Phone phone = getPhone(subscriptionId);

7456:         if (phone == null) {

7457:             loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);

7464:                     phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);

7497:      * Returns the unique device ID of phone, for example, the IMEI for

7501:      *   {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

7512:         final Phone phone = PhoneFactory.getPhone(0);

7513:         if (phone == null) {

7516:         int subId = phone.getSubId();

7524:             return phone.getDeviceId();

7537:         Phone phone = getPhone(subId);

7538:         if (phone != null) {

7539:             return phone.isImsRegistered();

7550:             throw new SecurityException("Requires READ_PHONE_STATE permission.");

7569:             Phone phone = getPhone(subscriptionId);

7570:             if (phone == null) {

7573:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7585:             Phone phone = getPhone(subId);

7586:             if (phone != null) {

7587:                 return phone.isWifiCallingEnabled();

7602:             Phone phone = getPhone(subId);

7603:             if (phone != null) {

7604:                 return phone.isVideoEnabled();

7620:             Phone phone = getPhone(subId);

7621:             if (phone != null) {

7622:                 return phone.getImsRegistrationTech();

7637:         Phone defaultPhone = getDefaultPhone();

7650:                 Phone phone = getPhone(subId);

7651:                 cleanUpAllowedNetworkTypes(phone, subId);

7683:     void cleanUpAllowedNetworkTypes(Phone phone, int subId) {

7684:         if (phone == null || !SubscriptionManager.isUsableSubscriptionId(subId)) {

7692:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7693:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7706:         final Phone phone = getPhone(subId);

7707:         if (phone == null) {

7716:                         phone.getContext().getOpPackageName(),

7717:                         phone.getContext().getAttributionTag());

7724:                         phone.getContext().getOpPackageName(),

7725:                         phone.getContext().getAttributionTag());

7735:             final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();

7740:                     return matchLocaleFromSupportedLocaleList(phone, localeFromDefaultSim);

7753:                 return matchLocaleFromSupportedLocaleList(phone, mccLocale);

7764:     String matchLocaleFromSupportedLocaleList(Phone phone, @NonNull Locale inputLocale) {

7766:                 phone.getContext());

7985:         final Phone phone = getPhone(subId);

7986:         if (phone == null) {

7992:         boolean isCallingPackageDataService = phone.getDataServicePackages()

7995:             // isActiveSubId requires READ_PHONE_STATE, which we already check for above

8013:             ServiceState ss = phone.getServiceState();

8026:      * Returns the URI for the per-account voicemail ringtone set in Phone settings.

8037:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);

8038:             if (phone == null) {

8039:                 phone = getDefaultPhone();

8042:             return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());

8052:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.

8062:         final Phone defaultPhone = getDefaultPhone();

8073:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);

8074:             if (phone == null) {

8075:                 phone = defaultPhone;

8077:             VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);

8084:      * Returns whether vibration is set for voicemail notification in Phone settings.

8094:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);

8095:             if (phone == null) {

8096:                 phone = getDefaultPhone();

8099:             return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());

8109:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.

8119:         final Phone defaultPhone = getDefaultPhone();

8130:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);

8131:             if (phone == null) {

8132:                 phone = defaultPhone;

8134:             VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);

8141:      * Make sure either called from same process as self (phone) or IPC caller has read privilege.

8146:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

8151:      * Make sure either called from same process as self (phone) or IPC caller has send SMS

8193:         Phone phone = getPhone(subId);

8197:             if (phone == null) {

8202:                 aid = UiccController.getInstance().getUiccPort(phone.getPhoneId())

8222:         Phone phone = getPhone(subId);

8226:             if (phone == null) {

8231:                 esn = phone.getEsn();

8250:         Phone phone = getPhone(subId);

8254:             if (phone == null) {

8259:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8353:         final Phone phone = getPhone(subId);

8356:         if (phone == null) {

8361:             phone.carrierActionSetRadioEnabled(enabled);

8378:         final Phone phone = getPhone(subId);

8381:         if (phone == null) {

8382:             loge("setVoNrEnabled fails with no phone object for subId: " + subId);

8438:         final Phone phone = getPhone(subId);

8441:         if (phone == null) {

8446:             phone.carrierActionReportDefaultNetworkStatus(report);

8462:         final Phone phone = getPhone(subId);

8463:         if (phone == null) {

8468:             phone.carrierActionResetAll();

8475:      * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a

8482:             writer.println("Permission Denial: can't dump Phone from pid="

8526:             Phone phone = getPhone(subId);

8527:             if (phone != null) {

8529:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

8531:                     phone.getDataSettingsManager().setDataEnabled(

8552:         Phone phone = getPhone(subId);

8556:             if (phone != null) {

8557:                 return phone.getClientRequestStats();

8575:             // $ adb shell cmd phone ...

8594:         Phone phone = PhoneFactory.getPhone(slotIndex);

8600:             if (phone != null) {

8601:                 phone.setSimPowerState(state, null, workSource);

8623:         Phone phone = PhoneFactory.getPhone(slotIndex);

8629:             if (phone != null) {

8631:                 sendRequestAsync(CMD_SET_SIM_POWER, arguments, phone, workSource);

8653:      * Check if phone is in emergency callback mode

8654:      * @return true if phone is in emergency callback mode

8660:         final Phone phone = getPhone(subId);

8664:             if (phone != null) {

8665:                 return phone.isInEcm();

8685:             Phone p = getPhone(subId);

8705:         Phone phone = PhoneFactory.getPhone(slotIndex);

8706:         if (phone != null) {

8707:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, phone.getSubId(),

8714:                 return phone.getRadioPowerState();

8727:      * {@link android.Manifest.permission#READ_BASIC_PHONE_STATE},

8728:      * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier

8745:                         permission.READ_BASIC_PHONE_STATE, functionName);

8755:             Phone phone = getPhone(subId);

8756:             isEnabled =  phone != null ? phone.getDataRoamingEnabled() : false;

8768:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier

8781:             Phone phone = getPhone(subId);

8782:             if (phone != null) {

8783:                 phone.setDataRoamingEnabled(isEnabled);

8799:             Phone phone = getPhone(subId);

8800:             if (phone != null) {

8801:                 isAllowed = phone.isCspPlmnEnabled();

8814:         Phone phone = PhoneFactory.getPhone(profile.getPhoneId());

8815:         if (phone == null) {

8818:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

8835:             // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller

8948:         // This will make sure caller has the READ_PRIVILEGED_PHONE_STATE. Do not remove this as

9069:     @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)

9095:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.

9104:             Phone phone = getPhone(subId);

9105:             if (phone == null) {

9108:             UiccPort uiccPort = phone.getUiccPort();

9145:      * not set, return {@link Phone#PREFERRED_NT_MODE}.

9153:         return Phone.PREFERRED_NT_MODE;

9163:             final Phone phone = getPhone(subId);

9164:             if (phone == null) {

9168:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

9173:             phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,

9191:             final Phone phone = getPhone(subId);

9192:             if (phone == null) {

9196:             return phone.getCarrierIdListVersion();

9279:             throw new SecurityException("Requires READ_PHONE_STATE permission.");

9284:             for (Phone phone: PhoneFactory.getPhones()) {

9285:                 if (phone.getEmergencyNumberTracker() != null

9286:                         && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {

9288:                             phone.getSubId(),

9289:                             phone.getEmergencyNumberTracker().getEmergencyNumberList());

9300:         final Phone defaultPhone = getDefaultPhone();

9308:             for (Phone phone: PhoneFactory.getPhones()) {

9309:                 if (phone.getEmergencyNumberTracker() != null

9310:                         && phone.getEmergencyNumberTracker()

9331:             for (Phone phone : PhoneFactory.getPhones()) {

9332:                 Rlog.d(LOG_TAG, "startEmergencyCallbackMode phone type: " + phone.getPhoneType());

9333:                 if (phone != null && ((phone.getPhoneType() == PHONE_TYPE_GSM)

9334:                         || (phone.getPhoneType() == PHONE_TYPE_CDMA))) {

9335:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

9356:             for (Phone phone: PhoneFactory.getPhones()) {

9357:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9378:             for (Phone phone: PhoneFactory.getPhones()) {

9379:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9398:             final Phone phone = getPhone(subId);

9399:             if (phone == null) {

9403:             return phone.getEmergencyNumberDbVersion();

9415:             for (Phone phone: PhoneFactory.getPhones()) {

9416:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9432:             for (Phone phone: PhoneFactory.getPhones()) {

9433:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9449:             for (Phone phone: PhoneFactory.getPhones()) {

9450:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9463:         Phone phone = getPhone(subId);

9464:         if (phone == null) {

9470:                     .getUiccProfileForPhone(phone.getPhoneId());

9489:             Phone phone = PhoneFactory.getPhone(slotIndex);

9490:             if (phone == null) {

9493:                 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);

9506:         Phone phone = PhoneFactory.getPhone(slotIndex);

9507:         if (phone == null) return false;

9510:                 mApp, phone.getSubId(), callingPackage, callingFeatureId,

9512:             throw new SecurityException("Requires READ_PHONE_STATE permission.");

9518:                 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());

9520:                 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);

9588:      * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE

9589:      * permission, but the other way around is possible with either MODIFY_PHONE_STATE

9618:         Phone phone = getPhone(subId);

9619:         if (phone == null) {

9624:             UiccPort uiccPort = phone.getUiccPort();

9699:         Phone phone = getDefaultPhone();

9700:         if (phone == null) return -1;

9701:         HalVersion hv = phone.getHalVersion();

9731:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9737:             Phone phone = getPhone(subId);

9738:             if (phone == null) return false;

9742:             isMetered = phone.getDataNetworkController().getDataConfigManager()

9744:                             phone.getServiceState().getDataRoaming());

9745:             isDataEnabled = phone.getDataSettingsManager().isDataEnabled(apnType);

9759:             Phone phone = getPhone(subId);

9760:             if (phone == null) return true; // By default return true.

9761:             return phone.getDataNetworkController().getDataConfigManager().isMeteredCapability(

9763:                     phone.getServiceState().getDataRoaming());

9775:             Phone phone = getPhone(subscriptionId);

9776:             if (phone == null) {

9796:             sendRequestAsync(CMD_SET_SYSTEM_SELECTION_CHANNELS, argument, phone, null);

9890:             Phone phone = getPhone(subscriptionId);

9891:             if (phone == null) return false;

9893:             return phone.getDataSettingsManager().isMobileDataPolicyEnabled(policy);

9906:             Phone phone = getPhone(subscriptionId);

9907:             if (phone == null) return;

9909:             phone.getDataSettingsManager().setMobileDataPolicy(policy, enabled);

9927:             for (Phone phone : PhoneFactory.getPhones()) {

9928:                 Phone defaultPhone = phone.getImsPhone();

9929:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {

9978:             Phone phone = getPhone(subId);

9979:             if (phone != null && phone.getIccCard() != null) {

9980:                 return phone.getIccCard().getIccLockEnabled();

10004:         Phone phone = getPhone(subId);

10005:         if (phone == null) {

10012:                     new Pair<Boolean, String>(enabled, password), phone, null);

10036:         Phone phone = getPhone(subId);

10037:         if (phone == null) {

10044:                     new Pair<String, String>(oldPassword, newPassword), phone, null);

10103:             throw new SecurityException("Requires READ_PHONE_STATE permission.");

10106:         Phone phone = getPhone(subId);

10107:         if (phone == null) {

10108:             throw new RuntimeException("phone is not available");

10113:             return phone.getEquivalentHomePlmns();

10137:                 Manifest.permission.MODIFY_PHONE_STATE);

10177:      * @return {@code true} if phone setRadioPowerForReason was called. Otherwise, returns {@code

10183:             Phone phone = PhoneFactory.getPhone(i);

10184:             if (phone != null) {

10185:                 phone.setRadioPowerForReason(enable, Phone.RADIO_POWER_REASON_THERMAL);

10190:         // return true if successfully informed the phone object about the thermal radio power

10204:         // Ensure that radio is on. If not able to power on due to phone being unavailable, return

10244:             Log.e(LOG_TAG , "Phone state is not valid. One of the phones is in an emergency call");

10247:         for (Phone phone : PhoneFactory.getPhones()) {

10248:             if (phone.isInEmergencySmsMode() || phone.isInEcm()) {

10249:                 Log.e(LOG_TAG, "Phone state is not valid. isInEmergencySmsMode = "

10250:                     + phone.isInEmergencySmsMode() + " isInEmergencyCallbackMode = "

10251:                     + phone.isInEcm());

10322:                     // Ensure that radio is on. If not able to power on due to phone being

10342:                         Phone phone = getPhone(subId);

10343:                         if (phone == null) {

10367:                     // Turn radio off. If not able to power off due to phone being unavailable,

10491:                 permission.READ_PRIVILEGED_PHONE_STATE);

10522:                 permission.READ_PRIVILEGED_PHONE_STATE);

10553:                 permission.READ_PRIVILEGED_PHONE_STATE);

10730:                         Phone thePhone = p.getImsPhone();

11069:         if (callingUid == Process.PHONE_UID || callingUid == Process.SYSTEM_UID) {

11070:             // phone/system process do not have further restriction on request

11106:      * Gets the current phone capability.

11108:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

11110:      * It's used to evaluate possible phone config change, for example from single

11146:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11156:             Phone phone = getDefaultPhone();

11157:             sendRequestAsync(CMD_GET_SLICING_CONFIG, callback, phone, null);

11171:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11179:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11180:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

11236:      * com.android.phone.permission.ACCESS_LAST_KNOWN_CELL_ID, otherwise throws

11272:             Phone phone = getPhone(subId);

11273:             if (phone == null) return null;

11274:             ServiceStateTracker sst = phone.getServiceStateTracker();

11324:             Phone phone = getPhone(subId);

11325:             if (phone == null) return;

11326:             phone.setVoiceServiceStateOverride(hasService);

11381:             Phone phone = null;

11383:                 phone = PhoneFactory.getPhone(slotIndex);

11387:             if (phone == null) {

11390:                 IccCard icc = phone.getIccCard();

24: import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;

73: import android.telecom.PhoneAccount;

74: import android.telecom.PhoneAccountHandle;

99: import android.telephony.PhoneCapability;

100: import android.telephony.PhoneNumberRange;

160: import com.android.internal.telephony.GsmCdmaPhone;

175: import com.android.internal.telephony.PhoneConfigurationManager;

176: import com.android.internal.telephony.PhoneConstantConversions;

177: import com.android.internal.telephony.PhoneConstants;

178: import com.android.internal.telephony.PhoneFactory;

193: import com.android.internal.telephony.imsphone.ImsPhone;

194: import com.android.internal.telephony.imsphone.ImsPhoneCallTracker;

250:     private static final String LOG_TAG = "PhoneInterfaceManager";

251:     private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);

373:     private static PhoneInterfaceManager sInstance;

376:     private PhoneGlobals mApp;

843:                     defaultPhone.nvReadItem((Integer) request.argument, onCompleted,

870:                     defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,

881:                     defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);

891:                     defaultPhone.resetModemConfig(onCompleted);

1116:                     defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);

1405:                     if (defaultPhone != null) {

1406:                         defaultPhone.getModemActivityInfo(onCompleted, request.workSource);

1483:                     defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);

1511:                     defaultPhone.getAllowedCarriers(onCompleted, request.workSource);

1735:                     defaultPhone.rebootModem(onCompleted);

1745:                     PhoneConfigurationManager.getInstance()

1755:                         mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);

1767:                     PhoneConfigurationManager.getInstance()

1884:                     defaultPhone.eraseModemConfig(onCompleted);

1892:                     request.result = defaultPhone.eraseDataInSharedPreferences();

1910:                         int phoneId = getPhoneFromRequest(request).getPhoneId();

1912:                                 .storePin(passwords.second, phoneId);

1934:                         int phoneId = getPhoneFromRequest(request).getPhoneId();

1937:                                     .storePin(enabled.second, phoneId);

1939:                             UiccController.getInstance().getPinStorage().clearPin(phoneId);

1953:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2327:      * Initialize the singleton PhoneInterfaceManager instance.

2328:      * This is only done once, at startup, from PhoneApp.onCreate().

2330:     /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {

2331:         synchronized (PhoneInterfaceManager.class) {

2333:                 sInstance = new PhoneInterfaceManager(app);

2344:         mCM = PhoneGlobals.getInstance().mCM;

2350:         if (!PhoneFactory.isSubscriptionManagerServiceEnabled()) {

2358:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

2369:         return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();

2391:                 ? getDefaultPhone() : getPhone(subId);

2403:         return PhoneFactory.getPhone(SubscriptionManager.getPhoneId(subId));

2417:         PackageManager pm = getDefaultPhone().getContext().getPackageManager();

2444:             PhoneConstants.State state = mCM.getState(subId);

2445:             if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {

2504:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;

2509:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;

2550:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2559:         UnlockSim(int phoneId, IccCard simCard) {

2560:             mPhoneId = phoneId;

2581:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2586:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2588:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2591:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

2643:             if (mResult == PhoneConstants.PIN_RESULT_SUCCESS && pin.length() > 0) {

2804:             logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");

2839:             if (defaultPhone != null) {

2840:                 defaultPhone.setRadioPower(turnOn);

3018:                 return PhoneConstantConversions.convertDataState(

3019:                         PhoneConstants.DataState.DISCONNECTED);

3091:             final int subId = SubscriptionManager.getSubscriptionId(phoneId);

3288:             getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);

3524:         Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);

3528:         Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);

3532:         Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);

3694:     public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,

3725:             return getDefaultPhone().needsOtaServiceProvisioning();

3760:             PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);

3761:             if (phoneAccountHandle == null) {

3764:             return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);

3849:         SmsController smsController = PhoneFactory.getSmsController();

3984:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);

3993:             defaultPhone.sendDialerSpecialCode(inputCode);

4821:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.

4861:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.

4888:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.

4927:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.

5124:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5131:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5134:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

5158:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

5199:         int phoneId = UiccController.getInstance().getPhoneIdFromSlotPortIndex(slotIndex,

5201:         if (phoneId == -1) {

5205:         return PhoneFactory.getPhone(phoneId);

5243:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()

5397:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()

6330:                     renounceFineLocationAccess, request, messenger, binder, getPhone(subId),

6620:             int phoneId = SubscriptionManager.getPhoneId(subId);

6621:             if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);

6667:             int phoneId = SubscriptionManager.getPhoneId(subId);

6715:             int phoneId = SubscriptionManager.getPhoneId(subId);

6717:                 log("isDataEnabledForReason: subId=" + subId + " phoneId=" + phoneId

6785:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");

6794:         for (int phoneId = 0; phoneId < TelephonyManager.getDefault().getPhoneCount(); phoneId++) {

6813:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

6826:     public List<String> getPackagesWithCarrierPrivileges(int phoneId) {

6892:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6893:                     imsPhone.setCallComposerStatus(status);

6915:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6916:                     return imsPhone.getCallComposerStatus();

7128:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7145:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7236:     public int getRadioAccessFamily(int phoneId, String callingPackage) {

7255:             raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);

7361:             ImsManager.getInstance(defaultPhone.getContext(),

7362:                     defaultPhone.getPhoneId()).setVtSetting(enable);

7371:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),

7383:                     ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());

7498:      * GSM and the MEID for CDMA phones. Return null if device ID is not available.

7547:             PhoneAccountHandle phoneAccountHandle, String callingPackage, String callingFeatureId) {

7554:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7638:         if (defaultPhone != null) {

7640:                     mApp, getDefaultPhone().getSubId(), "factoryReset");

7653:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

7659:             cleanUpSmsRawTable(getDefaultPhone().getContext());

7666:             if (defaultPhone == null) {

7673:                 sendEraseModemConfig(defaultPhone);

7676:             sendEraseDataInSharedPreferences(defaultPhone);

7714:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7781:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7996:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

8028:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the

8031:      * PhoneAccount.

8034:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

8054:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the

8057:      * PhoneAccount.

8061:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

8064:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);

8067:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

8086:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the

8088:      * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.

8091:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

8111:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the

8114:      * specific PhoneAccount.

8118:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

8121:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);

8124:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

8496:         return new TelephonyShellCommand(this, getDefaultPhone().getContext()).exec(

9149:         int phoneId = SubscriptionManager.getPhoneId(subId);

9150:         if (phoneId >= 0 && phoneId < list.size() && list.get(phoneId) != null) {

9151:             return list.get(phoneId);

9304:                             mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");

9322:      * Start emergency callback mode for GsmCdmaPhone for testing.

9336:                     gsmCdmaPhone.obtainMessage(

9337:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

9545:                 getDefaultPhone().getSubId(), callingPackage, callingFeatureId,

9568:         PhoneCapability staticCapability =

9834:         SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,

9860:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)

9877:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)

9930:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9932:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

9934:                     Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled + ", for imsPhone "

9935:                             + imsPhone.getMsisdn());

10073:         // *  Inherited from PhoneWindowManager  *

10171:      * Attempts to set the radio power state for all phones for thermal reason.

10174:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

10297:         if (!getThermalMitigationAllowlist(getDefaultPhone().getContext())

10728:             Arrays.stream(PhoneFactory.getPhones()).forEach(

10731:                         if (thePhone != null && thePhone instanceof ImsPhone) {

10732:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10733:                             CallTracker tracker = imsPhone.getCallTracker();

10813:             return getDefaultPhone().getMobileProvisioningUrl();

10828:             return EabUtil.getContactFromEab(getDefaultPhone().getContext(), contact);

10843:             return EabUtil.getCapabilityFromEab(getDefaultPhone().getContext(), contact);

10858:             return EabUtil.removeContactFromEab(subId, contacts, getDefaultPhone().getContext());

11109:      * @return the PhoneCapability which describes the data connection capability of modem.

583:                             getPhoneFromRequest(request).handlePinMmi((String) request.argument)

1073:                     getPhoneFromRequest(request).getAllowedNetworkTypesBitmask(onCompleted);

1103:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

1130:                     getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,

1142:                     getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);

1152:                     getPhoneFromRequest(request).getAvailableNetworks(onCompleted);

1267:                     getPhoneFromRequest(request).getCallWaiting(onCompleted);

1316:                     getPhoneFromRequest(request).setCallWaiting(enable, onCompleted);

1385:                     getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,

1594:                     getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);

1615:                     getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);

1631:                     getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);

1642:                     getPhoneFromRequest(request).queryCdmaSubscriptionMode(onCompleted);

1658:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1777:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

1900:                     getPhoneFromRequest(request).getIccCard().changeIccLockPassword(

1923:                     getPhoneFromRequest(request).getIccCard().setIccLockEnabled(

2385:             return getPhoneFromSubId(request.subId);

2644:                 UiccController.getInstance().getPinStorage().storePin(pin, mPhoneId);

2725:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2800:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {

2817:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {

2819:                 shutdownRadioUsingPhoneId(i);

2989:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,

3384:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3537:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3567:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3600:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3631:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3774:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3942:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4002:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4039:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4065:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4121:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4161:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4186:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4288:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4326:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4363:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4401:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4446:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4499:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4585:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4644:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4667:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4695:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4714:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4735:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4753:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4773:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4793:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4816:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4856:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4992:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5027:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5029:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5055:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5057:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5150:         return SubscriptionManager.getPhoneId(getDefaultSubscription());

5316:         return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,

5330:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), channel, cla,

5369:         return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,

5385:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,

5470:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5889:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(mApp,

6028:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6396:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6421:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6425:             return getPhoneFromSubId(subId).getAllowedNetworkTypes(reason);

6474:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6786:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);

6841:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

6845:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {

6981:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

7008:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7031:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7240:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7253:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7395:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7414:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7548:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, getDefaultSubscription(),

7549:                 callingPackage, callingFeatureId, "getSubIdForPhoneAccountHandle")) {

7563:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7566:                 "getPhoneAccountHandleForSubscriptionId, " + "subscriptionId: " + subscriptionId);

7942:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8548:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8748:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8793:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8837:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

9013:                             slot.getPhoneIdFromPortIndex(portIdx), slot.isPortActive(portIdx)));

9205:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9213:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9222:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9249:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9276:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9303:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9509:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9544:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9569:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9609:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9649:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9656:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

9665:         metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);

9681:                         if (SubscriptionManager.isValidPhoneId(portInfo.getLogicalSlotIndex())) {

9805:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9931:                     ImsPhoneCallTracker imsPhoneCallTracker =

9933:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10101:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10181:         boolean isPhoneAvailable = false;

10186:                 isPhoneAvailable = true;

10192:         return isPhoneAvailable;

10356:                         } else if (isAnyPhoneInEmergencyState()) {

10734:                             if (tracker != null && tracker instanceof ImsPhoneCallTracker) {

10735:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10736:                                         (ImsPhoneCallTracker) tracker;

10737:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11115:         enforceReadPrivilegedPermission("getPhoneCapability");

11118:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11151:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11173:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11294:         return mPhoneConfigurationManager.setModemService(serviceName);

11307:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11310:         result = mPhoneConfigurationManager.getModemService();

384:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1655:     private PhoneInterfaceManager(PhoneGlobals app) {

1672:     private Phone getDefaultPhone() {

1706:     private Phone getPhone(int subId) {

2347:     public String getNetworkCountryIsoForPhone(int phoneId) {

5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

5959:     public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {

6417:     public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1694:     private Phone getPhoneFromSubId(int subId) {

2125:     private void shutdownRadioUsingPhoneId(int phoneId) {

2780:     public int getActivePhoneType() {

2785:     public int getActivePhoneTypeForSlot(int slotIndex) {

3824:     private void checkModifyPhoneStatePermission(int subId, String message) {

4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6553:     public int getSubIdForPhoneAccountHandle(

6568:     public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {

21: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_IMS;

140: import com.android.internal.telephony.Phone;

174: import com.android.phone.settings.PickSmsSubscriptionActivity;

175: import com.android.phone.vvm.PhoneAccountHandleConverter;

176: import com.android.phone.vvm.RemoteVvmTaskManager;

177: import com.android.phone.vvm.VisualVoicemailSettingsUtil;

178: import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;

383:         // In cases where subId is unavailable, the caller needs to specify the phone.

392:         MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {

394:             if (phone != null) {

395:                 this.phone = phone;

423:      * A handler that processes messages on the main thread in the phone process. Since many

424:      * of the Phone calls are not thread safe this is needed to shuttle the requests from the

425:      * inbound binder threads to the main thread in the phone process.  The Binder thread

442:             final Phone defaultPhone = getDefaultPhone();

447:                     final Phone phone = getPhoneFromRequest(request);

466:                         request.result = phone != null

467:                                 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;

478:                     final Phone phone = getPhoneFromRequest(request);

479:                     request.result = phone != null ?

1266:                     request.phone.requestCellInfoUpdate(request.workSource, onCompleted);

1280:                     request.phone.requestCellInfoUpdate(request.workSource,

1308:                     Phone phone = getPhoneFromRequest(request);

1309:                     phone.getCellIdentity(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));

1317:                         phone = getPhoneFromRequest(request);

1318:                         request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)

1340:                             .enablePhone(request.phone, enable, onCompleted);

1346:                     int phoneId = request.phone.getPhoneId();

1361:                             .getPhoneStatusFromModem(request.phone, onCompleted);

1366:                     int id = request.phone.getPhoneId();

1389:                     request.phone.setSystemSelectionChannels(args.first, onCompleted);

1569:     private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {

1571:                 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone, workSource);

1580:             int command, Object argument, Integer subId, Phone phone, WorkSource workSource) {

1586:         if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {

1587:             throw new IllegalArgumentException("subId and phone cannot both be specified!");