482:         public Phone phone;

17: package com.android.phone;

245: public class PhoneInterfaceManager extends ITelephony.Stub {

2322:     private PhoneInterfaceManager(PhoneGlobals app) {

2341:     private Phone getDefaultPhone() {

2375:     private Phone getPhone(int subId) {

3068:     public String getNetworkCountryIsoForPhone(int phoneId) {

6772:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

381:     private PhoneConfigurationManager mPhoneConfigurationManager;

2355:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2363:     private Phone getPhoneFromSubId(int subId) {

2520:         private final int mPhoneId;

2799:     private void shutdownRadioUsingPhoneId(int phoneId) {

3522:     public int getActivePhoneType() {

3527:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

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

5230:     private Phone getPhoneFromValidIccLogicalChannelRequest(

6777:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {

6828:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7520:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7530:     public int getSubIdForPhoneAccountHandle(

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

10144:     private boolean isAnyPhoneInEmergencyState() {

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

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

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

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

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

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

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

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

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

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

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

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

492:             if (phone != null) {

493:                 this.phone = phone;

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

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

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

540:             final Phone defaultPhone = getDefaultPhone();

545:                     final Phone phone = getPhoneFromRequest(request);

564:                         request.result = phone != null

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

576:                     final Phone phone = getPhoneFromRequest(request);

577:                     request.result = phone != null ?

890:                     Phone phone = getPhoneFromRequest(request);

891:                     if (phone != null) {

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

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

930:                     Phone phone = getPhoneFromRequest(request);

931:                     if (phone != null) {

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

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

969:                     Phone phone = getPhoneFromRequest(request);

970:                     if (phone != null) {

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

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

1017:                     Phone phone = getPhoneFromRequest(request);

1018:                     if (phone != null) {

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

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

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

1214:                     request.phone.setCallForwardingOption(

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

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

1693:                     Phone phone = getPhoneFromRequest(request);

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

1703:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1792:                     Phone phone = getPhoneFromRequest(request);

1793:                     if (phone != null) {

1794:                         phone.getSystemSelectionChannels(onCompleted);

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

1943:                     Phone phone = getPhoneFromRequest(request);

1944:                     if (phone != null) {

1945:                         phone.setDataThrottling(onCompleted,

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

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

2037:                     final Phone phone = getPhoneFromRequest(request);

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

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

2048:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

2065:                     Phone phone = getPhoneFromRequest(request);

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

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

2076:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

2092:                     request.phone.getSlicingConfig(onCompleted);

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

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

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

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

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

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

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

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

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

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

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

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

2357:             return request.phone;

2369:         Phone phone = getPhoneFromRequest(request);

2370:         return phone == null ? null :

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

2374:     // returns phone associated with the subId.

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

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

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

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

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

2490:             Phone phone = getPhone(subId);

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

2504:             Phone phone = getPhone(subId);

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

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

2668:             if (phone != null) {

2669:                 phone.updateServiceLocation(workSource);

2714:             final Phone phone = getPhone(subId);

2715:             if (phone != null) {

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

2734:             final Phone phone = getPhone(subId);

2735:             if (phone != null) {

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

2752:             final Phone phone = getPhone(subId);

2753:             if (phone == null) {

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

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

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

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

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

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

2802:             phone.shutdownRadio();

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

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

2829:             final Phone phone = getPhone(subId);

2830:             if (phone != null) {

2831:                 phone.setRadioPower(turnOn);

2849:             final Phone phone = getPhone(subId);

2850:             if (phone != null) {

2851:                 if (phone.isUsingNewDataStack()) {

2852:                     phone.getDataSettingsManager().setDataEnabled(

2855:                     phone.getDataEnabledSettings().setDataEnabled(

2875:             final Phone phone = getPhone(subId);

2876:             if (phone != null) {

2877:                 if (phone.isUsingNewDataStack()) {

2878:                     phone.getDataSettingsManager().setDataEnabled(

2881:                     phone.getDataEnabledSettings().setDataEnabled(

2897:             final Phone phone = getPhone(subId);

2898:             if (phone != null) {

2899:                 return phone.isDataAllowed();

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

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

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

2971:             // Check READ_PHONE_STATE for API version 31+

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

2980:             Phone phone = getPhone(subId);

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

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

2997:             final Phone phone = getPhone(subId);

2998:             if (phone != null) {

2999:                 if (phone.isUsingNewDataStack()) {

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

3002:                 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());

3021:             final Phone phone = getPhone(subId);

3022:             if (phone != null) {

3023:                 return phone.getDataActivityState();

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

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

3074:                 // Get default phone in this case.

3075:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

3080:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3199:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3261:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3283:         if (phone == null) {

3286:         int subId = phone.getSubId();

3295:             return phone.getImei();

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

3305:         if (phone != null) {

3306:             String imei = phone.getImei();

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

3327:         if (phone == null) {

3331:         int subId = phone.getSubId();

3339:             return phone.getMeid();

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

3349:         if (phone != null) {

3350:             String meid = phone.getMeid();

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

3366:         if (phone == null) {

3369:         int subId = phone.getSubId();

3378:             return phone.getDeviceSvn();

3388:             final Phone phone = getPhone(subId);

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

3399:             final Phone phone = getPhone(subId);

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

3410:             final Phone phone = getPhone(subId);

3411:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3412:                     : phone.getSpecificCarrierId();

3422:             final Phone phone = getPhone(subId);

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

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

3435:         if (phone == null) {

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

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

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

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

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

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

3531:             if (phone == null) {

3532:                 return PhoneConstants.PHONE_TYPE_NONE;

3534:                 return phone.getPhoneType();

3561:             final Phone phone = getPhone(subId);

3562:             if (phone != null) {

3563:                 return phone.getCdmaEriIconIndex();

3594:             final Phone phone = getPhone(subId);

3595:             if (phone != null) {

3596:                 return phone.getCdmaEriIconMode();

3625:             final Phone phone = getPhone(subId);

3626:             if (phone != null) {

3627:                 return phone.getCdmaEriText();

3646:             final Phone phone = getPhone(subId);

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

3648:                 return phone.getLine1Number();

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

3668:             final Phone phone = getPhone(subId);

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

3670:                 return phone.getCdmaMin();

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

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

3850:             final Phone phone = getPhone(subId);

3851:             if (phone != null) {

3852:                 phone.setVoiceActivationState(activationState);

3871:             final Phone phone = getPhone(subId);

3872:             if (phone != null) {

3873:                 phone.setDataActivationState(activationState);

3889:         final Phone phone = getPhone(subId);

3892:             if (phone != null) {

3893:                 return phone.getVoiceActivationState();

3909:         final Phone phone = getPhone(subId);

3912:             if (phone != null) {

3913:                 return phone.getDataActivationState();

3935:             final Phone phone = getPhone(subId);

3936:             if (phone != null) {

3937:                 return phone.getVoiceMessageCount();

3954:             final Phone phone = getPhone(subId);

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

3968:         final Phone defaultPhone = getDefaultPhone();

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

4007:                 if (phone.isInEmergencySmsMode()) {

4018:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4045:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4082:             Phone phone = getPhone(subId);

4083:             if (phone == null) {

4088:             phone.getImsRegistrationState(regState -> {

4115:             Phone phone = getPhone(subId);

4116:             if (phone == null) {

4121:             phone.getImsRegistrationTech(regTech -> {

4140:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4166:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4216:             Phone phone = getPhone(subId);

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

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

4269:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4307:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4344:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4382:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4403:      * Requires MODIFY_PHONE_STATE permission.

4426:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4480:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4566:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4668:         Phone phone = getPhone(subId);

4669:         if (phone == null) {

4670:             loge("phone instance null for subid " + subId);

4674:             if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {

4678:             if (!doesRcsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {

5013:             final Phone phone = getPhone(subId);

5014:             if (phone != null) {

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

5050:             final Phone phone = getPhone(subId);

5051:             if (phone != null) {

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

5078:             final Phone phone = getPhone(subId);

5079:             if (phone != null) {

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

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

5106:             if (phone != null) {

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

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

5123:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5142:             final Phone phone = getPhone(subId);

5143:             if (phone == null) {

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

5220:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5227:         return iccOpenLogicalChannelWithPermission(phone, request);

5232:         Phone phone;

5236:             phone = getPhoneFromSubId(request.subId);

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

5243:         return phone;

5246:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

5273:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5278:         return iccCloseLogicalChannelWithPermission(phone, request);

5281:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,

5288:             Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, request.channel, phone,

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

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

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

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

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

5632:         if (phone != null) {

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

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

5658:         if (phone != null) {

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

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

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

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

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

5951:                     phone.setImsRegistrationState(registered);

6034:             final Phone phone = getPhone(subId);

6035:             if (phone == null) {

6038:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6097:             Phone phone = getPhone(subId);

6098:             if (phone == null) {

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

6149:             Phone phone = getPhone(subId);

6150:             if (phone == null) {

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

6177:             Phone phone = getPhone(subId);

6178:             if (phone == null) {

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

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

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

6230:             Phone phone = getPhone(subId);

6231:             if (phone == null) {

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

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

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

6540:         final Phone phone = getPhone(subId);

6542:             if (phone != null) {

6543:                 return phone.hasMatchedTetherApnSetting();

6573:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6583:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

6599:             if (phone != null) {

6600:                 boolean retVal = phone.isUserDataEnabled();

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

6630:                             android.Manifest.permission.READ_PHONE_STATE,

6634:                             permission.READ_BASIC_PHONE_STATE, functionName);

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

6645:             if (phone != null) {

6647:                 if (phone.isUsingNewDataStack()) {

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

6650:                     retVal = phone.getDataEnabledSettings().isDataEnabled();

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

6679:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

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

6701:             if (phone != null) {

6703:                 if (phone.isUsingNewDataStack()) {

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

6707:                         retVal = phone.isUserDataEnabled();

6709:                         retVal = phone.getDataEnabledSettings().isDataEnabledForReason(reason);

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

6739:         Phone phone = getPhone(subId);

6740:         if (phone == null) {

6744:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6758:         Phone phone = getPhone(subId);

6759:         if (phone == null) {

6763:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6784:             if (phone == null) {

6787:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6803:         if (phone == null) {

6806:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6817:         if (phone == null) {

6820:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6847:         if (phone == null) {

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

6858:         final Phone phone = getPhone(subId);

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

6876:             Phone phone = getPhone(subId);

6877:             if (phone != null) {

6878:                 Phone defaultPhone = phone.getImsPhone();

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

6899:             Phone phone = getPhone(subId);

6900:             if (phone != null) {

6901:                 Phone defaultPhone = phone.getImsPhone();

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

6922:             final Phone phone = getPhone(subId);

6923:             if (phone == null) {

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

7149:             final Phone phone = getPhone(subId);

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

7165:             final Phone phone = getPhone(subId);

7166:             if (phone == null) {

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

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

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

7221:         if (phone == null) {

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

7330:         final Phone defaultPhone = getDefaultPhone();

7344:         final Phone defaultPhone = getDefaultPhone();

7398:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7429:         final Phone phone = getPhone(subscriptionId);

7430:         if (phone == null) {

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

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

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

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

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

7487:         if (phone == null) {

7490:         int subId = phone.getSubId();

7498:             return phone.getDeviceId();

7511:         Phone phone = getPhone(subId);

7512:         if (phone != null) {

7513:             return phone.isImsRegistered();

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

7553:             Phone phone = getPhone(subscriptionId);

7554:             if (phone == null) {

7557:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7569:             Phone phone = getPhone(subId);

7570:             if (phone != null) {

7571:                 return phone.isWifiCallingEnabled();

7586:             Phone phone = getPhone(subId);

7587:             if (phone != null) {

7588:                 return phone.isVideoEnabled();

7604:             Phone phone = getPhone(subId);

7605:             if (phone != null) {

7606:                 return phone.getImsRegistrationTech();

7621:         Phone defaultPhone = getDefaultPhone();

7634:                 Phone phone = getPhone(subId);

7635:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7676:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7677:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7690:         final Phone phone = getPhone(subId);

7691:         if (phone == null) {

7698:                     phone.getContext().getOpPackageName(), phone.getContext().getAttributionTag());

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

7839:         final Phone phone = getPhone(subId);

7840:         if (phone == null) {

7846:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

7856:             ServiceState ss = phone.getServiceState();

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

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

7881:             if (phone == null) {

7882:                 phone = getDefaultPhone();

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

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

7905:         final Phone defaultPhone = getDefaultPhone();

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

7917:             if (phone == null) {

7918:                 phone = defaultPhone;

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

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

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

7938:             if (phone == null) {

7939:                 phone = getDefaultPhone();

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

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

7962:         final Phone defaultPhone = getDefaultPhone();

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

7974:             if (phone == null) {

7975:                 phone = defaultPhone;

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

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

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

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

8037:         Phone phone = getPhone(subId);

8041:             if (phone == null) {

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

8066:         Phone phone = getPhone(subId);

8070:             if (phone == null) {

8075:                 esn = phone.getEsn();

8094:         Phone phone = getPhone(subId);

8098:             if (phone == null) {

8103:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8197:         final Phone phone = getPhone(subId);

8200:         if (phone == null) {

8205:             phone.carrierActionSetRadioEnabled(enabled);

8222:         final Phone phone = getPhone(subId);

8225:         if (phone == null) {

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

8282:         final Phone phone = getPhone(subId);

8285:         if (phone == null) {

8290:             phone.carrierActionReportDefaultNetworkStatus(report);

8306:         final Phone phone = getPhone(subId);

8307:         if (phone == null) {

8312:             phone.carrierActionResetAll();

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

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

8370:             Phone phone = getPhone(subId);

8371:             if (phone != null) {

8373:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

8375:                     if (phone.isUsingNewDataStack()) {

8376:                         phone.getDataSettingsManager().setDataEnabled(

8379:                         phone.getDataEnabledSettings().setDataEnabled(reason, enabled);

8400:         Phone phone = getPhone(subId);

8404:             if (phone != null) {

8405:                 return phone.getClientRequestStats();

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

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

8448:             if (phone != null) {

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

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

8477:             if (phone != null) {

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

8501:      * Check if phone is in emergency callback mode

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

8508:         final Phone phone = getPhone(subId);

8512:             if (phone != null) {

8513:                 return phone.isInEcm();

8533:             Phone p = getPhone(subId);

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

8554:         if (phone != null) {

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

8562:                 return phone.getRadioPowerState();

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

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

8593:                         permission.READ_BASIC_PHONE_STATE, functionName);

8603:             Phone phone = getPhone(subId);

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

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

8629:             Phone phone = getPhone(subId);

8630:             if (phone != null) {

8631:                 phone.setDataRoamingEnabled(isEnabled);

8647:             Phone phone = getPhone(subId);

8648:             if (phone != null) {

8649:                 isAllowed = phone.isCspPlmnEnabled();

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

8663:         if (phone == null) {

8666:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

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

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

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

8969:             Phone phone = getPhone(subId);

8970:             if (phone == null) {

8973:             UiccPort uiccPort = phone.getUiccPort();

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

9018:         return Phone.PREFERRED_NT_MODE;

9028:             final Phone phone = getPhone(subId);

9029:             if (phone == null) {

9033:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

9056:             final Phone phone = getPhone(subId);

9057:             if (phone == null) {

9061:             return phone.getCarrierIdListVersion();

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

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

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

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

9153:                             phone.getSubId(),

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

9165:         final Phone defaultPhone = getDefaultPhone();

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

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

9175:                         && phone.getEmergencyNumberTracker()

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

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

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

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

9200:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

9222:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9244:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9263:             final Phone phone = getPhone(subId);

9264:             if (phone == null) {

9268:             return phone.getEmergencyNumberDbVersion();

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

9281:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9298:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9315:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9328:         Phone phone = getPhone(subId);

9329:         if (phone == null) {

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

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

9355:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9483:         Phone phone = getPhone(subId);

9484:         if (phone == null) {

9489:             UiccPort uiccPort = phone.getUiccPort();

9564:         Phone phone = getDefaultPhone();

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

9566:         HalVersion hv = phone.getHalVersion();

9596:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9602:             Phone phone = getPhone(subId);

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

9605:             boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);

9607:             if (phone.isUsingNewDataStack()) {

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

9610:                 isDataEnabled = phone.getDataEnabledSettings().isDataEnabled(apnType);

9625:             Phone phone = getPhone(subId);

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

9628:             return ApnSettingUtils.isMeteredApnType(apnType, phone);

9640:             Phone phone = getPhone(subscriptionId);

9641:             if (phone == null) {

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

9761:             Phone phone = getPhone(subscriptionId);

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

9766:                     if (phone.isUsingNewDataStack()) {

9767:                         return phone.getDataSettingsManager().isDataAllowedInVoiceCall();

9769:                         return phone.getDataEnabledSettings().isDataAllowedInVoiceCall();

9772:                     if (phone.isUsingNewDataStack()) {

9773:                         return phone.getDataSettingsManager().isMmsAlwaysAllowed();

9775:                         return phone.getDataEnabledSettings().isMmsAlwaysAllowed();

9792:             Phone phone = getPhone(subscriptionId);

9793:             if (phone == null) return;

9797:                     if (phone.isUsingNewDataStack()) {

9798:                         phone.getDataSettingsManager().setAllowDataDuringVoiceCall(enabled);

9800:                         phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(enabled);

9804:                     if (phone.isUsingNewDataStack()) {

9805:                         phone.getDataSettingsManager().setAlwaysAllowMmsData(enabled);

9807:                         phone.getDataEnabledSettings().setAlwaysAllowMmsData(enabled);

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

9831:                 Phone defaultPhone = phone.getImsPhone();

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

9881:             Phone phone = getPhone(subId);

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

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

9907:         Phone phone = getPhone(subId);

9908:         if (phone == null) {

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

9939:         Phone phone = getPhone(subId);

9940:         if (phone == null) {

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

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

10009:         Phone phone = getPhone(subId);

10010:         if (phone == null) {

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

10016:             return phone.getEquivalentHomePlmns();

10040:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

10087:             if (phone != null) {

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

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

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

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

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

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

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

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

10154:                     + phone.isInEcm());

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

10245:                         Phone phone = getPhone(subId);

10246:                         if (phone == null) {

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

10394:                 permission.READ_PRIVILEGED_PHONE_STATE);

10425:                 permission.READ_PRIVILEGED_PHONE_STATE);

10456:                 permission.READ_PRIVILEGED_PHONE_STATE);

10633:                         Phone thePhone = p.getImsPhone();

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

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

11009:      * Gets the current phone capability.

11011:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

11048:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11058:             Phone phone = getDefaultPhone();

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

11073:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11081:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11082:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

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

11174:             Phone phone = getPhone(subId);

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

11176:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

72: import android.telecom.PhoneAccount;

73: import android.telecom.PhoneAccountHandle;

96: import android.telephony.PhoneCapability;

97: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

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

369:     private static PhoneInterfaceManager sInstance;

372:     private PhoneGlobals mApp;

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

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

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

879:                     defaultPhone.resetModemConfig(onCompleted);

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

1387:                     if (defaultPhone != null) {

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

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

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

1716:                     defaultPhone.rebootModem(onCompleted);

1726:                     PhoneConfigurationManager.getInstance()

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

1748:                     PhoneConfigurationManager.getInstance()

1865:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

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

1934:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2307:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2311:         synchronized (PhoneInterfaceManager.class) {

2313:                 sInstance = new PhoneInterfaceManager(app);

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

2334:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

2376:         return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));

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

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

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

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

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

2523:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2532:         UnlockSim(int phoneId, IccCard simCard) {

2533:             mPhoneId = phoneId;

2554:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2559:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2561:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2564:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2812:             if (defaultPhone != null) {

2813:                 defaultPhone.setRadioPower(turnOn);

3004:                 return PhoneConstantConversions.convertDataState(

3005:                         PhoneConstants.DataState.DISCONNECTED);

3077:             final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);

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

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

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

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

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

3711:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3747:             if (phoneAccountHandle == null) {

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

3835:         SmsController smsController = PhoneFactory.getSmsController();

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

3979:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

5137:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5144:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5147:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

5210:         if (phoneId == -1) {

5214:         return PhoneFactory.getPhone(phoneId);

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

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

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

6596:             int phoneId = mSubscriptionController.getPhoneId(subId);

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

6643:             int phoneId = mSubscriptionController.getPhoneId(subId);

6695:             int phoneId = mSubscriptionController.getPhoneId(subId);

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

6773:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");

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

6801:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

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

6880:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6881:                     imsPhone.setCallComposerStatus(status);

6903:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6904:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7523:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7538:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7622:         if (defaultPhone != null) {

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

7637:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7650:             if (defaultPhone == null) {

7657:                 sendEraseModemConfig(defaultPhone);

7660:             sendEraseDataInSharedPreferences(defaultPhone);

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

7874:      * PhoneAccount.

7877:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7900:      * PhoneAccount.

7904:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7910:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7934:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7957:      * specific PhoneAccount.

7961:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7967:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

9014:         int phoneId = mSubscriptionController.getPhoneId(subId);

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

9016:             return list.get(phoneId);

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

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

9201:                     gsmCdmaPhone.obtainMessage(

9202:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9433:         PhoneCapability staticCapability =

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

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

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

9833:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9835:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9838:                             + imsPhone.getMsisdn());

9976:         // *  Inherited from PhoneWindowManager  *

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

10077:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10635:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10636:                             CallTracker tracker = imsPhone.getCallTracker();

10716:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

11220:         return getDefaultPhone().isUsingNewDataStack();

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

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

1091:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1639:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1758:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2359:             return getPhoneFromSubId(request.subId);

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

2698:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2792:                 shutdownRadioUsingPhoneId(i);

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

3370:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3523:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3553:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3586:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3617:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3760:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3928:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3988:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4025:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4051:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4107:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4147:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4172:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4274:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4312:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4349:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4387:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4432:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4485:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4571:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4630:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4647:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4688:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4703:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4718:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4731:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4746:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4760:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4842:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4875:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5005:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5040:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5042:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5068:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5070:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5163:         return mSubscriptionController.getPhoneId(getDefaultSubscription());

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

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

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

5376:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,

5461:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5885:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6025:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6387:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6412:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6465:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

6774:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);

6829:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6969:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6996:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7019:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7214:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7227:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7369:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7388:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7547:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7796:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8396:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8596:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8641:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8685:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

8803:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

8875:                                 port.getPhoneId(), true));

9070:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9078:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9087:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9114:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9141:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9168:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9374:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9409:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9434:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9474:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9514:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9521:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9670:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9691:                 SubscriptionManager.getPhoneId(subId), UiccController.APP_FAM_3GPP);

9834:                     ImsPhoneCallTracker imsPhoneCallTracker =

9836:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10004:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10084:         boolean isPhoneAvailable = false;

10089:                 isPhoneAvailable = true;

10095:         return isPhoneAvailable;

10259:                         } else if (isAnyPhoneInEmergencyState()) {

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

10638:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10639:                                         (ImsPhoneCallTracker) tracker;

10640:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11018:         enforceReadPrivilegedPermission("getPhoneCapability");

11021:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11053:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11075:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11196:         return mPhoneConfigurationManager.setModemService(serviceName);

11209:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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