483:         public Phone phone;

17: package com.android.phone;

245: public class PhoneInterfaceManager extends ITelephony.Stub {

2335:     private PhoneInterfaceManager(PhoneGlobals app) {

2357:     private Phone getDefaultPhone() {

2392:     private Phone getPhone(int subId) {

3085:     public String getNetworkCountryIsoForPhone(int phoneId) {

6791:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

381:     private PhoneConfigurationManager mPhoneConfigurationManager;

2371:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2379:     private Phone getPhoneFromSubId(int subId) {

2537:         private final int mPhoneId;

2816:     private void shutdownRadioUsingPhoneId(int phoneId) {

3539:     public int getActivePhoneType() {

3544:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

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

5220:     private Phone getPhoneFromValidIccLogicalChannelRequest(

6796:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {

6847:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7539:     public int getSubIdForPhoneAccountHandle(

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

10224:     private boolean isAnyPhoneInEmergencyState() {

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

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

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

493:             if (phone != null) {

494:                 this.phone = phone;

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

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

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

541:             final Phone defaultPhone = getDefaultPhone();

546:                     final Phone phone = getPhoneFromRequest(request);

565:                         request.result = phone != null

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

577:                     final Phone phone = getPhoneFromRequest(request);

578:                     request.result = phone != null ?

898:                     Phone phone = getPhoneFromRequest(request);

899:                     if (phone != null) {

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

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

938:                     Phone phone = getPhoneFromRequest(request);

939:                     if (phone != null) {

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

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

977:                     Phone phone = getPhoneFromRequest(request);

978:                     if (phone != null) {

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

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

1025:                     Phone phone = getPhoneFromRequest(request);

1026:                     if (phone != null) {

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

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

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

1222:                     request.phone.setCallForwardingOption(

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

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

1705:                     Phone phone = getPhoneFromRequest(request);

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

1715:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1804:                     Phone phone = getPhoneFromRequest(request);

1805:                     if (phone != null) {

1806:                         phone.getSystemSelectionChannels(onCompleted);

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

1955:                     Phone phone = getPhoneFromRequest(request);

1956:                     if (phone != null) {

1957:                         phone.setDataThrottling(onCompleted,

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

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

2049:                     final Phone phone = getPhoneFromRequest(request);

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

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

2060:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

2077:                     Phone phone = getPhoneFromRequest(request);

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

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

2088:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

2104:                     request.phone.getSlicingConfig(onCompleted);

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

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

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

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

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

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

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

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

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

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

2350:         PropertyInvalidatedCache.invalidateCache(TelephonyManager.CACHE_KEY_PHONE_ACCOUNT_TO_SUBID);

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

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

2373:             return request.phone;

2386:         Phone phone = getPhoneFromRequest(request);

2387:         return phone == null ? null :

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

2391:     // returns phone associated with the subId.

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

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

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

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

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

2507:             Phone phone = getPhone(subId);

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

2521:             Phone phone = getPhone(subId);

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

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

2685:             if (phone != null) {

2686:                 phone.updateServiceLocation(workSource);

2731:             final Phone phone = getPhone(subId);

2732:             if (phone != null) {

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

2751:             final Phone phone = getPhone(subId);

2752:             if (phone != null) {

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

2769:             final Phone phone = getPhone(subId);

2770:             if (phone == null) {

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

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

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

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

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

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

2819:             phone.shutdownRadio();

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

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

2846:             final Phone phone = getPhone(subId);

2847:             if (phone != null) {

2848:                 phone.setRadioPower(turnOn);

2866:             final Phone phone = getPhone(subId);

2867:             if (phone != null) {

2868:                 if (phone.isUsingNewDataStack()) {

2869:                     phone.getDataSettingsManager().setDataEnabled(

2872:                     phone.getDataEnabledSettings().setDataEnabled(

2892:             final Phone phone = getPhone(subId);

2893:             if (phone != null) {

2894:                 if (phone.isUsingNewDataStack()) {

2895:                     phone.getDataSettingsManager().setDataEnabled(

2898:                     phone.getDataEnabledSettings().setDataEnabled(

2914:             final Phone phone = getPhone(subId);

2915:             if (phone != null) {

2916:                 return phone.isDataAllowed();

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

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

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

2988:             // Check READ_PHONE_STATE for API version 31+

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

2997:             Phone phone = getPhone(subId);

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

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

3014:             final Phone phone = getPhone(subId);

3015:             if (phone != null) {

3016:                 if (phone.isUsingNewDataStack()) {

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

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

3038:             final Phone phone = getPhone(subId);

3039:             if (phone != null) {

3040:                 return phone.getDataActivityState();

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

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

3091:                 // Get default phone in this case.

3092:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

3097:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3216:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3278:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3300:         if (phone == null) {

3303:         int subId = phone.getSubId();

3312:             return phone.getImei();

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

3322:         if (phone != null) {

3323:             String imei = phone.getImei();

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

3344:         if (phone == null) {

3348:         int subId = phone.getSubId();

3356:             return phone.getMeid();

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

3366:         if (phone != null) {

3367:             String meid = phone.getMeid();

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

3383:         if (phone == null) {

3386:         int subId = phone.getSubId();

3395:             return phone.getDeviceSvn();

3405:             final Phone phone = getPhone(subId);

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

3416:             final Phone phone = getPhone(subId);

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

3427:             final Phone phone = getPhone(subId);

3428:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3429:                     : phone.getSpecificCarrierId();

3439:             final Phone phone = getPhone(subId);

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

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

3452:         if (phone == null) {

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

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

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

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

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

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

3548:             if (phone == null) {

3549:                 return PhoneConstants.PHONE_TYPE_NONE;

3551:                 return phone.getPhoneType();

3578:             final Phone phone = getPhone(subId);

3579:             if (phone != null) {

3580:                 return phone.getCdmaEriIconIndex();

3611:             final Phone phone = getPhone(subId);

3612:             if (phone != null) {

3613:                 return phone.getCdmaEriIconMode();

3642:             final Phone phone = getPhone(subId);

3643:             if (phone != null) {

3644:                 return phone.getCdmaEriText();

3663:             final Phone phone = getPhone(subId);

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

3665:                 return phone.getLine1Number();

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

3685:             final Phone phone = getPhone(subId);

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

3687:                 return phone.getCdmaMin();

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

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

3867:             final Phone phone = getPhone(subId);

3868:             if (phone != null) {

3869:                 phone.setVoiceActivationState(activationState);

3888:             final Phone phone = getPhone(subId);

3889:             if (phone != null) {

3890:                 phone.setDataActivationState(activationState);

3906:         final Phone phone = getPhone(subId);

3909:             if (phone != null) {

3910:                 return phone.getVoiceActivationState();

3926:         final Phone phone = getPhone(subId);

3929:             if (phone != null) {

3930:                 return phone.getDataActivationState();

3952:             final Phone phone = getPhone(subId);

3953:             if (phone != null) {

3954:                 return phone.getVoiceMessageCount();

3971:             final Phone phone = getPhone(subId);

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

3985:         final Phone defaultPhone = getDefaultPhone();

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

4024:                 if (phone.isInEmergencySmsMode()) {

4035:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4062:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4099:             Phone phone = getPhone(subId);

4100:             if (phone == null) {

4105:             phone.getImsRegistrationState(regState -> {

4132:             Phone phone = getPhone(subId);

4133:             if (phone == null) {

4138:             phone.getImsRegistrationTech(regTech -> {

4157:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4183:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4233:             Phone phone = getPhone(subId);

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

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

4286:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4324:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4361:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4399:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4420:      * Requires MODIFY_PHONE_STATE permission.

4443:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4497:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4583:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

5003:             final Phone phone = getPhone(subId);

5004:             if (phone != null) {

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

5040:             final Phone phone = getPhone(subId);

5041:             if (phone != null) {

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

5068:             final Phone phone = getPhone(subId);

5069:             if (phone != null) {

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

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

5096:             if (phone != null) {

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

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

5113:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5132:             final Phone phone = getPhone(subId);

5133:             if (phone == null) {

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

5210:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5217:         return iccOpenLogicalChannelWithPermission(phone, request);

5222:         Phone phone;

5226:             phone = getPhoneFromSubId(request.subId);

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

5233:         return phone;

5236:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

5263:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5268:         return iccCloseLogicalChannelWithPermission(phone, request);

5271:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

5640:         if (phone != null) {

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

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

5666:         if (phone != null) {

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

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

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

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

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

5959:                     phone.setImsRegistrationState(registered);

6042:             final Phone phone = getPhone(subId);

6043:             if (phone == null) {

6046:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6105:             Phone phone = getPhone(subId);

6106:             if (phone == null) {

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

6157:             Phone phone = getPhone(subId);

6158:             if (phone == null) {

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

6185:             Phone phone = getPhone(subId);

6186:             if (phone == null) {

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

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

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

6238:             Phone phone = getPhone(subId);

6239:             if (phone == null) {

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

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

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

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

6559:         final Phone phone = getPhone(subId);

6561:             if (phone != null) {

6562:                 return phone.hasMatchedTetherApnSetting();

6592:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6602:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

6618:             if (phone != null) {

6619:                 boolean retVal = phone.isUserDataEnabled();

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

6649:                             android.Manifest.permission.READ_PHONE_STATE,

6653:                             permission.READ_BASIC_PHONE_STATE, functionName);

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

6664:             if (phone != null) {

6666:                 if (phone.isUsingNewDataStack()) {

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

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

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

6698:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

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

6720:             if (phone != null) {

6722:                 if (phone.isUsingNewDataStack()) {

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

6726:                         retVal = phone.isUserDataEnabled();

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

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

6758:         Phone phone = getPhone(subId);

6759:         if (phone == null) {

6763:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6777:         Phone phone = getPhone(subId);

6778:         if (phone == null) {

6782:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6803:             if (phone == null) {

6806:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6822:         if (phone == null) {

6825:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6836:         if (phone == null) {

6839:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6866:         if (phone == null) {

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

6877:         final Phone phone = getPhone(subId);

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

6895:             Phone phone = getPhone(subId);

6896:             if (phone != null) {

6897:                 Phone defaultPhone = phone.getImsPhone();

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

6918:             Phone phone = getPhone(subId);

6919:             if (phone != null) {

6920:                 Phone defaultPhone = phone.getImsPhone();

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

6941:             final Phone phone = getPhone(subId);

6942:             if (phone == null) {

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

7168:             final Phone phone = getPhone(subId);

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

7184:             final Phone phone = getPhone(subId);

7185:             if (phone == null) {

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

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

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

7240:         if (phone == null) {

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

7349:         final Phone defaultPhone = getDefaultPhone();

7363:         final Phone defaultPhone = getDefaultPhone();

7417:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7448:         final Phone phone = getPhone(subscriptionId);

7449:         if (phone == null) {

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

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

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

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

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

7506:         if (phone == null) {

7509:         int subId = phone.getSubId();

7517:             return phone.getDeviceId();

7530:         Phone phone = getPhone(subId);

7531:         if (phone != null) {

7532:             return phone.isImsRegistered();

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

7562:             Phone phone = getPhone(subscriptionId);

7563:             if (phone == null) {

7566:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7578:             Phone phone = getPhone(subId);

7579:             if (phone != null) {

7580:                 return phone.isWifiCallingEnabled();

7595:             Phone phone = getPhone(subId);

7596:             if (phone != null) {

7597:                 return phone.isVideoEnabled();

7613:             Phone phone = getPhone(subId);

7614:             if (phone != null) {

7615:                 return phone.getImsRegistrationTech();

7630:         Phone defaultPhone = getDefaultPhone();

7643:                 Phone phone = getPhone(subId);

7644:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7685:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7686:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7699:         final Phone phone = getPhone(subId);

7700:         if (phone == null) {

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

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

7933:         final Phone phone = getPhone(subId);

7934:         if (phone == null) {

7940:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

7950:             ServiceState ss = phone.getServiceState();

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

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

7975:             if (phone == null) {

7976:                 phone = getDefaultPhone();

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

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

7999:         final Phone defaultPhone = getDefaultPhone();

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

8011:             if (phone == null) {

8012:                 phone = defaultPhone;

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

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

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

8032:             if (phone == null) {

8033:                 phone = getDefaultPhone();

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

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

8056:         final Phone defaultPhone = getDefaultPhone();

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

8068:             if (phone == null) {

8069:                 phone = defaultPhone;

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

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

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

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

8131:         Phone phone = getPhone(subId);

8135:             if (phone == null) {

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

8160:         Phone phone = getPhone(subId);

8164:             if (phone == null) {

8169:                 esn = phone.getEsn();

8188:         Phone phone = getPhone(subId);

8192:             if (phone == null) {

8197:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8291:         final Phone phone = getPhone(subId);

8294:         if (phone == null) {

8299:             phone.carrierActionSetRadioEnabled(enabled);

8316:         final Phone phone = getPhone(subId);

8319:         if (phone == null) {

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

8376:         final Phone phone = getPhone(subId);

8379:         if (phone == null) {

8384:             phone.carrierActionReportDefaultNetworkStatus(report);

8400:         final Phone phone = getPhone(subId);

8401:         if (phone == null) {

8406:             phone.carrierActionResetAll();

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

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

8464:             Phone phone = getPhone(subId);

8465:             if (phone != null) {

8467:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

8469:                     if (phone.isUsingNewDataStack()) {

8470:                         phone.getDataSettingsManager().setDataEnabled(

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

8494:         Phone phone = getPhone(subId);

8498:             if (phone != null) {

8499:                 return phone.getClientRequestStats();

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

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

8542:             if (phone != null) {

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

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

8571:             if (phone != null) {

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

8595:      * Check if phone is in emergency callback mode

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

8602:         final Phone phone = getPhone(subId);

8606:             if (phone != null) {

8607:                 return phone.isInEcm();

8627:             Phone p = getPhone(subId);

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

8648:         if (phone != null) {

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

8656:                 return phone.getRadioPowerState();

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

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

8687:                         permission.READ_BASIC_PHONE_STATE, functionName);

8697:             Phone phone = getPhone(subId);

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

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

8723:             Phone phone = getPhone(subId);

8724:             if (phone != null) {

8725:                 phone.setDataRoamingEnabled(isEnabled);

8741:             Phone phone = getPhone(subId);

8742:             if (phone != null) {

8743:                 isAllowed = phone.isCspPlmnEnabled();

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

8757:         if (phone == null) {

8760:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

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

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

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

9046:             Phone phone = getPhone(subId);

9047:             if (phone == null) {

9050:             UiccPort uiccPort = phone.getUiccPort();

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

9095:         return Phone.PREFERRED_NT_MODE;

9105:             final Phone phone = getPhone(subId);

9106:             if (phone == null) {

9110:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

9133:             final Phone phone = getPhone(subId);

9134:             if (phone == null) {

9138:             return phone.getCarrierIdListVersion();

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

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

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

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

9230:                             phone.getSubId(),

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

9242:         final Phone defaultPhone = getDefaultPhone();

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

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

9252:                         && phone.getEmergencyNumberTracker()

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

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

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

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

9277:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

9299:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9321:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9340:             final Phone phone = getPhone(subId);

9341:             if (phone == null) {

9345:             return phone.getEmergencyNumberDbVersion();

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

9358:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9375:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9392:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9405:         Phone phone = getPhone(subId);

9406:         if (phone == null) {

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

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

9432:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9560:         Phone phone = getPhone(subId);

9561:         if (phone == null) {

9566:             UiccPort uiccPort = phone.getUiccPort();

9641:         Phone phone = getDefaultPhone();

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

9643:         HalVersion hv = phone.getHalVersion();

9673:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9679:             Phone phone = getPhone(subId);

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

9684:             if (phone.isUsingNewDataStack()) {

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

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

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

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

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

9706:             Phone phone = getPhone(subId);

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

9708:             if (phone.isUsingNewDataStack()) {

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

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

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

9726:             Phone phone = getPhone(subscriptionId);

9727:             if (phone == null) {

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

9841:             Phone phone = getPhone(subscriptionId);

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

9846:                     if (phone.isUsingNewDataStack()) {

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

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

9852:                     if (phone.isUsingNewDataStack()) {

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

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

9872:             Phone phone = getPhone(subscriptionId);

9873:             if (phone == null) return;

9877:                     if (phone.isUsingNewDataStack()) {

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

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

9884:                     if (phone.isUsingNewDataStack()) {

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

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

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

9911:                 Phone defaultPhone = phone.getImsPhone();

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

9961:             Phone phone = getPhone(subId);

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

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

9987:         Phone phone = getPhone(subId);

9988:         if (phone == null) {

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

10019:         Phone phone = getPhone(subId);

10020:         if (phone == null) {

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

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

10089:         Phone phone = getPhone(subId);

10090:         if (phone == null) {

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

10096:             return phone.getEquivalentHomePlmns();

10120:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

10167:             if (phone != null) {

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

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

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

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

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

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

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

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

10234:                     + phone.isInEcm());

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

10325:                         Phone phone = getPhone(subId);

10326:                         if (phone == null) {

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

10474:                 permission.READ_PRIVILEGED_PHONE_STATE);

10505:                 permission.READ_PRIVILEGED_PHONE_STATE);

10536:                 permission.READ_PRIVILEGED_PHONE_STATE);

10713:                         Phone thePhone = p.getImsPhone();

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

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

11089:      * Gets the current phone capability.

11091:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

11129:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11139:             Phone phone = getDefaultPhone();

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

11154:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11162:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11163:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

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

11255:             Phone phone = getPhone(subId);

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

11257:             ServiceStateTracker sst = phone.getServiceStateTracker();

11313:             Phone phone = getPhone(subId);

11314:             if (phone == null) return;

11315:             phone.setVoiceServiceStateOverride(hasService);

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

72: import android.telecom.PhoneAccount;

73: import android.telecom.PhoneAccountHandle;

98: import android.telephony.PhoneCapability;

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

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

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

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

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

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

887:                     defaultPhone.resetModemConfig(onCompleted);

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

1401:                     if (defaultPhone != null) {

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

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

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

1728:                     defaultPhone.rebootModem(onCompleted);

1738:                     PhoneConfigurationManager.getInstance()

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

1760:                     PhoneConfigurationManager.getInstance()

1877:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

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

1946:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2320:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2324:         synchronized (PhoneInterfaceManager.class) {

2326:                 sInstance = new PhoneInterfaceManager(app);

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

2347:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2540:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2549:         UnlockSim(int phoneId, IccCard simCard) {

2550:             mPhoneId = phoneId;

2571:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2576:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2578:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2581:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2829:             if (defaultPhone != null) {

2830:                 defaultPhone.setRadioPower(turnOn);

3021:                 return PhoneConstantConversions.convertDataState(

3022:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3728:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3764:             if (phoneAccountHandle == null) {

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

3852:         SmsController smsController = PhoneFactory.getSmsController();

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

3996:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

5127:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5134:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5137:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

5200:         if (phoneId == -1) {

5204:         return PhoneFactory.getPhone(phoneId);

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

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

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

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

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

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

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

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

6792:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");

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

6820:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

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

6899:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6900:                     imsPhone.setCallComposerStatus(status);

6922:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6923:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

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

7547:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7631:         if (defaultPhone != null) {

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

7646:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7659:             if (defaultPhone == null) {

7666:                 sendEraseModemConfig(defaultPhone);

7669:             sendEraseDataInSharedPreferences(defaultPhone);

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

7968:      * PhoneAccount.

7971:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7994:      * PhoneAccount.

7998:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

8004:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

8028:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

8051:      * specific PhoneAccount.

8055:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

8061:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

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

9093:             return list.get(phoneId);

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

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

9278:                     gsmCdmaPhone.obtainMessage(

9279:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9510:         PhoneCapability staticCapability =

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

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

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

9913:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9915:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9918:                             + imsPhone.getMsisdn());

10056:         // *  Inherited from PhoneWindowManager  *

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

10157:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10715:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10716:                             CallTracker tracker = imsPhone.getCallTracker();

10796:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

11268:         return getDefaultPhone().isUsingNewDataStack();

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

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

1099:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1651:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1770:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2375:             return getPhoneFromSubId(request.subId);

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

2715:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2809:                 shutdownRadioUsingPhoneId(i);

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

3387:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3540:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3570:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3603:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3634:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3777:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3945:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4005:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4042:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4068:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4124:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4164:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4189:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4291:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4329:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4366:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4404:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4449:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4502:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4588:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4647:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4670:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4698:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4717:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4738:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4756:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4776:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4796:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4819:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4859:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4995:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5030:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5032:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5058:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5060:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

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

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

5384:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,

5469:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5893:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6033:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6395:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6420:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6473:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

6793:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);

6848:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6988:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

7015:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7038:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7233:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7246:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7388:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7407:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7556:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7890:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8490:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8690:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8735:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8779:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

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

9147:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9155:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9164:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9191:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9218:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9245:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9451:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9486:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9511:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9551:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9591:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9598:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9756:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9914:                     ImsPhoneCallTracker imsPhoneCallTracker =

9916:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10084:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10164:         boolean isPhoneAvailable = false;

10169:                 isPhoneAvailable = true;

10175:         return isPhoneAvailable;

10339:                         } else if (isAnyPhoneInEmergencyState()) {

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

10718:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10719:                                         (ImsPhoneCallTracker) tracker;

10720:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11098:         enforceReadPrivilegedPermission("getPhoneCapability");

11101:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11134:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11156:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11283:         return mPhoneConfigurationManager.setModemService(serviceName);

11296:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11299:         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();