487:         public Phone phone;

17: package com.android.phone;

249: public class PhoneInterfaceManager extends ITelephony.Stub {

2342:     private PhoneInterfaceManager(PhoneGlobals app) {

2363:     private Phone getDefaultPhone() {

2398:     private Phone getPhone(int subId) {

3078:     public String getNetworkCountryIsoForPhone(int phoneId) {

6776:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

385:     private PhoneConfigurationManager mPhoneConfigurationManager;

2377:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2385:     private Phone getPhoneFromSubId(int subId) {

2543:         private final int mPhoneId;

2822:     private void shutdownRadioUsingPhoneId(int phoneId) {

3532:     public int getActivePhoneType() {

3537:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

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

5217:     private Phone getPhoneFromValidIccLogicalChannelRequest(

6781:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {

6832:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7538:     public int getSubIdForPhoneAccountHandle(

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

10233:     private boolean isAnyPhoneInEmergencyState() {

11106:     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);

2357:         PropertyInvalidatedCache.invalidateCache(TelephonyManager.CACHE_KEY_PHONE_ACCOUNT_TO_SUBID);

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

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

2379:             return request.phone;

2392:         Phone phone = getPhoneFromRequest(request);

2393:         return phone == null ? null :

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

2397:     // returns phone associated with the subId.

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

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

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

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

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

2513:             Phone phone = getPhone(subId);

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

2527:             Phone phone = getPhone(subId);

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

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

2691:             if (phone != null) {

2692:                 phone.updateServiceLocation(workSource);

2737:             final Phone phone = getPhone(subId);

2738:             if (phone != null) {

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

2757:             final Phone phone = getPhone(subId);

2758:             if (phone != null) {

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

2775:             final Phone phone = getPhone(subId);

2776:             if (phone == null) {

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

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

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

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

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

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

2825:             phone.shutdownRadio();

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

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

2852:             final Phone phone = getPhone(subId);

2853:             if (phone != null) {

2854:                 phone.setRadioPower(turnOn);

2872:             final Phone phone = getPhone(subId);

2873:             if (phone != null) {

2874:                 phone.getDataSettingsManager().setDataEnabled(

2893:             final Phone phone = getPhone(subId);

2894:             if (phone != null) {

2895:                 phone.getDataSettingsManager().setDataEnabled(

2910:             final Phone phone = getPhone(subId);

2911:             if (phone != null) {

2912:                 return phone.isDataAllowed();

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

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

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

2984:             // Check READ_PHONE_STATE for API version 31+

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

2993:             Phone phone = getPhone(subId);

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

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

3010:             final Phone phone = getPhone(subId);

3011:             if (phone != null) {

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

3031:             final Phone phone = getPhone(subId);

3032:             if (phone != null) {

3033:                 return phone.getDataActivityState();

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

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

3084:                 // Get default phone in this case.

3085:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

3090:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3209:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3271:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3293:         if (phone == null) {

3296:         int subId = phone.getSubId();

3305:             return phone.getImei();

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

3315:         if (phone != null) {

3316:             String imei = phone.getImei();

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

3337:         if (phone == null) {

3341:         int subId = phone.getSubId();

3349:             return phone.getMeid();

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

3359:         if (phone != null) {

3360:             String meid = phone.getMeid();

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

3376:         if (phone == null) {

3379:         int subId = phone.getSubId();

3388:             return phone.getDeviceSvn();

3398:             final Phone phone = getPhone(subId);

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

3409:             final Phone phone = getPhone(subId);

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

3420:             final Phone phone = getPhone(subId);

3421:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3422:                     : phone.getSpecificCarrierId();

3432:             final Phone phone = getPhone(subId);

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

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

3445:         if (phone == null) {

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

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

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

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

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

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

3541:             if (phone == null) {

3542:                 return PhoneConstants.PHONE_TYPE_NONE;

3544:                 return phone.getPhoneType();

3571:             final Phone phone = getPhone(subId);

3572:             if (phone != null) {

3573:                 return phone.getCdmaEriIconIndex();

3604:             final Phone phone = getPhone(subId);

3605:             if (phone != null) {

3606:                 return phone.getCdmaEriIconMode();

3635:             final Phone phone = getPhone(subId);

3636:             if (phone != null) {

3637:                 return phone.getCdmaEriText();

3656:             final Phone phone = getPhone(subId);

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

3658:                 return phone.getLine1Number();

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

3678:             final Phone phone = getPhone(subId);

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

3680:                 return phone.getCdmaMin();

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

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

3860:             final Phone phone = getPhone(subId);

3861:             if (phone != null) {

3862:                 phone.setVoiceActivationState(activationState);

3881:             final Phone phone = getPhone(subId);

3882:             if (phone != null) {

3883:                 phone.setDataActivationState(activationState);

3899:         final Phone phone = getPhone(subId);

3902:             if (phone != null) {

3903:                 return phone.getVoiceActivationState();

3919:         final Phone phone = getPhone(subId);

3922:             if (phone != null) {

3923:                 return phone.getDataActivationState();

3945:             final Phone phone = getPhone(subId);

3946:             if (phone != null) {

3947:                 return phone.getVoiceMessageCount();

3964:             final Phone phone = getPhone(subId);

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

3978:         final Phone defaultPhone = getDefaultPhone();

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

4017:                 if (phone.isInEmergencySmsMode()) {

4028:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4055:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4092:             Phone phone = getPhone(subId);

4093:             if (phone == null) {

4098:             phone.getImsRegistrationState(regState -> {

4125:             Phone phone = getPhone(subId);

4126:             if (phone == null) {

4131:             phone.getImsRegistrationTech(regTech -> {

4150:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4176:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4226:             Phone phone = getPhone(subId);

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

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

4279:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4317:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4354:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4392:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4413:      * Requires MODIFY_PHONE_STATE permission.

4436:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4490:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4576:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4996:             final Phone phone = getPhone(subId);

4997:             if (phone != null) {

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

5033:             final Phone phone = getPhone(subId);

5034:             if (phone != null) {

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

5061:             final Phone phone = getPhone(subId);

5062:             if (phone != null) {

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

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

5089:             if (phone != null) {

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

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

5106:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5125:             final Phone phone = getPhone(subId);

5126:             if (phone == null) {

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

5207:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5214:         return iccOpenLogicalChannelWithPermission(phone, request);

5219:         Phone phone;

5223:             phone = getPhoneFromSubId(request.subId);

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

5230:         return phone;

5233:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

5260:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5265:         return iccCloseLogicalChannelWithPermission(phone, request);

5268:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

5637:         if (phone != null) {

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

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

5663:         if (phone != null) {

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

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

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

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

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

5950:                     phone.setImsRegistrationState(registered);

6033:             final Phone phone = getPhone(subId);

6034:             if (phone == null) {

6037:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6096:             Phone phone = getPhone(subId);

6097:             if (phone == null) {

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

6148:             Phone phone = getPhone(subId);

6149:             if (phone == null) {

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

6176:             Phone phone = getPhone(subId);

6177:             if (phone == null) {

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

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

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

6229:             Phone phone = getPhone(subId);

6230:             if (phone == null) {

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

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

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

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

6556:         final Phone phone = getPhone(subId);

6558:             if (phone != null) {

6559:                 return phone.hasMatchedTetherApnSetting();

6589:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6599:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

6615:             if (phone != null) {

6616:                 boolean retVal = phone.isUserDataEnabled();

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

6646:                             android.Manifest.permission.READ_PHONE_STATE,

6650:                             permission.READ_BASIC_PHONE_STATE, functionName);

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

6661:             if (phone != null) {

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

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

6691:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

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

6713:             if (phone != null) {

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

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

6743:         Phone phone = getPhone(subId);

6744:         if (phone == null) {

6748:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6762:         Phone phone = getPhone(subId);

6763:         if (phone == null) {

6767:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6788:             if (phone == null) {

6791:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6807:         if (phone == null) {

6810:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6821:         if (phone == null) {

6824:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6851:         if (phone == null) {

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

6862:         final Phone phone = getPhone(subId);

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

6880:             Phone phone = getPhone(subId);

6881:             if (phone != null) {

6882:                 Phone defaultPhone = phone.getImsPhone();

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

6903:             Phone phone = getPhone(subId);

6904:             if (phone != null) {

6905:                 Phone defaultPhone = phone.getImsPhone();

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

6926:             final Phone phone = getPhone(subId);

6927:             if (phone == null) {

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

7167:             final Phone phone = getPhone(subId);

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

7183:             final Phone phone = getPhone(subId);

7184:             if (phone == null) {

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

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

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

7239:         if (phone == null) {

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

7348:         final Phone defaultPhone = getDefaultPhone();

7362:         final Phone defaultPhone = getDefaultPhone();

7416:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7447:         final Phone phone = getPhone(subscriptionId);

7448:         if (phone == null) {

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

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

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

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

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

7505:         if (phone == null) {

7508:         int subId = phone.getSubId();

7516:             return phone.getDeviceId();

7529:         Phone phone = getPhone(subId);

7530:         if (phone != null) {

7531:             return phone.isImsRegistered();

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

7561:             Phone phone = getPhone(subscriptionId);

7562:             if (phone == null) {

7565:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7577:             Phone phone = getPhone(subId);

7578:             if (phone != null) {

7579:                 return phone.isWifiCallingEnabled();

7594:             Phone phone = getPhone(subId);

7595:             if (phone != null) {

7596:                 return phone.isVideoEnabled();

7612:             Phone phone = getPhone(subId);

7613:             if (phone != null) {

7614:                 return phone.getImsRegistrationTech();

7629:         Phone defaultPhone = getDefaultPhone();

7642:                 Phone phone = getPhone(subId);

7643:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7684:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7685:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7698:         final Phone phone = getPhone(subId);

7699:         if (phone == null) {

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

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

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

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

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

7732:                     return matchLocaleFromSupportedLocaleList(phone, localeFromDefaultSim);

7745:                 return matchLocaleFromSupportedLocaleList(phone, mccLocale);

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

7758:                 phone.getContext());

7977:         final Phone phone = getPhone(subId);

7978:         if (phone == null) {

7984:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

8005:             ServiceState ss = phone.getServiceState();

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

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

8030:             if (phone == null) {

8031:                 phone = getDefaultPhone();

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

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

8054:         final Phone defaultPhone = getDefaultPhone();

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

8066:             if (phone == null) {

8067:                 phone = defaultPhone;

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

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

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

8087:             if (phone == null) {

8088:                 phone = getDefaultPhone();

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

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

8111:         final Phone defaultPhone = getDefaultPhone();

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

8123:             if (phone == null) {

8124:                 phone = defaultPhone;

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

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

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

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

8185:         Phone phone = getPhone(subId);

8189:             if (phone == null) {

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

8214:         Phone phone = getPhone(subId);

8218:             if (phone == null) {

8223:                 esn = phone.getEsn();

8242:         Phone phone = getPhone(subId);

8246:             if (phone == null) {

8251:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8345:         final Phone phone = getPhone(subId);

8348:         if (phone == null) {

8353:             phone.carrierActionSetRadioEnabled(enabled);

8370:         final Phone phone = getPhone(subId);

8373:         if (phone == null) {

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

8430:         final Phone phone = getPhone(subId);

8433:         if (phone == null) {

8438:             phone.carrierActionReportDefaultNetworkStatus(report);

8454:         final Phone phone = getPhone(subId);

8455:         if (phone == null) {

8460:             phone.carrierActionResetAll();

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

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

8518:             Phone phone = getPhone(subId);

8519:             if (phone != null) {

8521:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

8523:                     phone.getDataSettingsManager().setDataEnabled(

8544:         Phone phone = getPhone(subId);

8548:             if (phone != null) {

8549:                 return phone.getClientRequestStats();

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

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

8592:             if (phone != null) {

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

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

8621:             if (phone != null) {

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

8645:      * Check if phone is in emergency callback mode

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

8652:         final Phone phone = getPhone(subId);

8656:             if (phone != null) {

8657:                 return phone.isInEcm();

8677:             Phone p = getPhone(subId);

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

8698:         if (phone != null) {

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

8706:                 return phone.getRadioPowerState();

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

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

8737:                         permission.READ_BASIC_PHONE_STATE, functionName);

8747:             Phone phone = getPhone(subId);

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

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

8773:             Phone phone = getPhone(subId);

8774:             if (phone != null) {

8775:                 phone.setDataRoamingEnabled(isEnabled);

8791:             Phone phone = getPhone(subId);

8792:             if (phone != null) {

8793:                 isAllowed = phone.isCspPlmnEnabled();

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

8807:         if (phone == null) {

8810:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

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

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

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

9096:             Phone phone = getPhone(subId);

9097:             if (phone == null) {

9100:             UiccPort uiccPort = phone.getUiccPort();

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

9145:         return Phone.PREFERRED_NT_MODE;

9155:             final Phone phone = getPhone(subId);

9156:             if (phone == null) {

9160:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

9183:             final Phone phone = getPhone(subId);

9184:             if (phone == null) {

9188:             return phone.getCarrierIdListVersion();

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

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

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

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

9280:                             phone.getSubId(),

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

9292:         final Phone defaultPhone = getDefaultPhone();

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

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

9302:                         && phone.getEmergencyNumberTracker()

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

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

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

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

9327:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

9349:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9371:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9390:             final Phone phone = getPhone(subId);

9391:             if (phone == null) {

9395:             return phone.getEmergencyNumberDbVersion();

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

9408:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9425:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9442:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9455:         Phone phone = getPhone(subId);

9456:         if (phone == null) {

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

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

9482:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9610:         Phone phone = getPhone(subId);

9611:         if (phone == null) {

9616:             UiccPort uiccPort = phone.getUiccPort();

9691:         Phone phone = getDefaultPhone();

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

9693:         HalVersion hv = phone.getHalVersion();

9723:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9729:             Phone phone = getPhone(subId);

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

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

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

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

9751:             Phone phone = getPhone(subId);

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

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

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

9767:             Phone phone = getPhone(subscriptionId);

9768:             if (phone == null) {

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

9882:             Phone phone = getPhone(subscriptionId);

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

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

9898:             Phone phone = getPhone(subscriptionId);

9899:             if (phone == null) return;

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

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

9920:                 Phone defaultPhone = phone.getImsPhone();

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

9970:             Phone phone = getPhone(subId);

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

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

9996:         Phone phone = getPhone(subId);

9997:         if (phone == null) {

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

10028:         Phone phone = getPhone(subId);

10029:         if (phone == null) {

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

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

10098:         Phone phone = getPhone(subId);

10099:         if (phone == null) {

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

10105:             return phone.getEquivalentHomePlmns();

10129:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

10176:             if (phone != null) {

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

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

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

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

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

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

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

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

10243:                     + phone.isInEcm());

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

10334:                         Phone phone = getPhone(subId);

10335:                         if (phone == null) {

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

10483:                 permission.READ_PRIVILEGED_PHONE_STATE);

10514:                 permission.READ_PRIVILEGED_PHONE_STATE);

10545:                 permission.READ_PRIVILEGED_PHONE_STATE);

10722:                         Phone thePhone = p.getImsPhone();

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

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

11098:      * Gets the current phone capability.

11100:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

11138:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11148:             Phone phone = getDefaultPhone();

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

11163:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11171:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11172:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

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

11264:             Phone phone = getPhone(subId);

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

11266:             ServiceStateTracker sst = phone.getServiceStateTracker();

11316:             Phone phone = getPhone(subId);

11317:             if (phone == null) return;

11318:             phone.setVoiceServiceStateOverride(hasService);

11373:             Phone phone = null;

11375:                 phone = PhoneFactory.getPhone(slotIndex);

11379:             if (phone == null) {

11382:                 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;

2354:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2546:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2555:         UnlockSim(int phoneId, IccCard simCard) {

2556:             mPhoneId = phoneId;

2577:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2582:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2584:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2587:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2835:             if (defaultPhone != null) {

2836:                 defaultPhone.setRadioPower(turnOn);

3014:                 return PhoneConstantConversions.convertDataState(

3015:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3721:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3757:             if (phoneAccountHandle == null) {

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

3845:         SmsController smsController = PhoneFactory.getSmsController();

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

3989:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

5120:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5127:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5130:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

5154:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

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

5197:         if (phoneId == -1) {

5201:         return PhoneFactory.getPhone(phoneId);

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

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

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

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

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

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

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

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

6777:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");

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

6805:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

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

6884:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6885:                     imsPhone.setCallComposerStatus(status);

6907:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6908:                     return imsPhone.getCallComposerStatus();

7120:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7137:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

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

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

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

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

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

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

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

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

7546:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7630:         if (defaultPhone != null) {

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

7645:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7658:             if (defaultPhone == null) {

7665:                 sendEraseModemConfig(defaultPhone);

7668:             sendEraseDataInSharedPreferences(defaultPhone);

7706:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7773:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

7988:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {

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

8023:      * PhoneAccount.

8026:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

8049:      * PhoneAccount.

8053:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

8059:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

8083:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

8106:      * specific PhoneAccount.

8110:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

8116:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

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

9143:             return list.get(phoneId);

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

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

9328:                     gsmCdmaPhone.obtainMessage(

9329:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9560:         PhoneCapability staticCapability =

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

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

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

9922:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9924:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9927:                             + imsPhone.getMsisdn());

10065:         // *  Inherited from PhoneWindowManager  *

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

10166:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10724:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10725:                             CallTracker tracker = imsPhone.getCallTracker();

10805:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

11101:      * @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(

2381:             return getPhoneFromSubId(request.subId);

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

2721:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2815:                 shutdownRadioUsingPhoneId(i);

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

3380:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3533:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3563:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3596:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3627:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3770:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3938:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3998:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4035:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4061:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4117:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4157:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4182:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4284:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4322:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4359:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4397:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4442:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4495:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4581:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4640:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4663:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4691:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4710:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4731:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4749:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4769:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4789:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4812:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4852:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4988:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5023:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5025:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5051:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5053:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

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

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

5381:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,

5466:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5885:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(mApp,

6024:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6392:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6417:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6470:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6527:         if (allowedNetworkTypes == getPhoneFromSubId(subId).getAllowedNetworkTypes(reason)) {

6778:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);

6833:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6973:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

7000:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7023:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7232:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7245:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7387:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7406:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7555:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7934:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8540:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8740:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8785:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8829:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

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

9197:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9205:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9214:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9241:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9268:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9295:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9501:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9536:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9561:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9601:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9641:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9648:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9797:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9923:                     ImsPhoneCallTracker imsPhoneCallTracker =

9925:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10093:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10173:         boolean isPhoneAvailable = false;

10178:                 isPhoneAvailable = true;

10184:         return isPhoneAvailable;

10348:                         } else if (isAnyPhoneInEmergencyState()) {

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

10727:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10728:                                         (ImsPhoneCallTracker) tracker;

10729:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11107:         enforceReadPrivilegedPermission("getPhoneCapability");

11110:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11143:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11165:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11286:         return mPhoneConfigurationManager.setModemService(serviceName);

11299:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11302:         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!");

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

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

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