482:         public Phone phone;

17: package com.android.phone;

245: public class PhoneInterfaceManager extends ITelephony.Stub {

2334:     private PhoneInterfaceManager(PhoneGlobals app) {

2353:     private Phone getDefaultPhone() {

2388:     private Phone getPhone(int subId) {

3081:     public String getNetworkCountryIsoForPhone(int phoneId) {

6776:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

381:     private PhoneConfigurationManager mPhoneConfigurationManager;

2367:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2375:     private Phone getPhoneFromSubId(int subId) {

2533:         private final int mPhoneId;

2812:     private void shutdownRadioUsingPhoneId(int phoneId) {

3535:     public int getActivePhoneType() {

3540:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

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

5216:     private Phone getPhoneFromValidIccLogicalChannelRequest(

6781:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {

6832:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7524:     public int getSubIdForPhoneAccountHandle(

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

10209:     private boolean isAnyPhoneInEmergencyState() {

11082:     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 ?

897:                     Phone phone = getPhoneFromRequest(request);

898:                     if (phone != null) {

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

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

937:                     Phone phone = getPhoneFromRequest(request);

938:                     if (phone != null) {

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

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

976:                     Phone phone = getPhoneFromRequest(request);

977:                     if (phone != null) {

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

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

1024:                     Phone phone = getPhoneFromRequest(request);

1025:                     if (phone != null) {

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

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

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

1221:                     request.phone.setCallForwardingOption(

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

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

1704:                     Phone phone = getPhoneFromRequest(request);

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

1714:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1803:                     Phone phone = getPhoneFromRequest(request);

1804:                     if (phone != null) {

1805:                         phone.getSystemSelectionChannels(onCompleted);

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

1954:                     Phone phone = getPhoneFromRequest(request);

1955:                     if (phone != null) {

1956:                         phone.setDataThrottling(onCompleted,

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

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

2048:                     final Phone phone = getPhoneFromRequest(request);

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

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

2059:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

2076:                     Phone phone = getPhoneFromRequest(request);

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

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

2087:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

2103:                     request.phone.getSlicingConfig(onCompleted);

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

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

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

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

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

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

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

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

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

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

2349:         PropertyInvalidatedCache.invalidateCache(TelephonyManager.CACHE_KEY_PHONE_ACCOUNT_TO_SUBID);

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

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

2369:             return request.phone;

2382:         Phone phone = getPhoneFromRequest(request);

2383:         return phone == null ? null :

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

2387:     // returns phone associated with the subId.

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

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

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

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

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

2503:             Phone phone = getPhone(subId);

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

2517:             Phone phone = getPhone(subId);

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

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

2681:             if (phone != null) {

2682:                 phone.updateServiceLocation(workSource);

2727:             final Phone phone = getPhone(subId);

2728:             if (phone != null) {

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

2747:             final Phone phone = getPhone(subId);

2748:             if (phone != null) {

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

2765:             final Phone phone = getPhone(subId);

2766:             if (phone == null) {

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

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

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

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

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

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

2815:             phone.shutdownRadio();

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

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

2842:             final Phone phone = getPhone(subId);

2843:             if (phone != null) {

2844:                 phone.setRadioPower(turnOn);

2862:             final Phone phone = getPhone(subId);

2863:             if (phone != null) {

2864:                 if (phone.isUsingNewDataStack()) {

2865:                     phone.getDataSettingsManager().setDataEnabled(

2868:                     phone.getDataEnabledSettings().setDataEnabled(

2888:             final Phone phone = getPhone(subId);

2889:             if (phone != null) {

2890:                 if (phone.isUsingNewDataStack()) {

2891:                     phone.getDataSettingsManager().setDataEnabled(

2894:                     phone.getDataEnabledSettings().setDataEnabled(

2910:             final Phone phone = getPhone(subId);

2911:             if (phone != null) {

2912:                 return phone.isDataAllowed();

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

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

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

2984:             // Check READ_PHONE_STATE for API version 31+

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

2993:             Phone phone = getPhone(subId);

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

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

3010:             final Phone phone = getPhone(subId);

3011:             if (phone != null) {

3012:                 if (phone.isUsingNewDataStack()) {

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

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

3034:             final Phone phone = getPhone(subId);

3035:             if (phone != null) {

3036:                 return phone.getDataActivityState();

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

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

3087:                 // Get default phone in this case.

3088:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

3093:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3212:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3274:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3296:         if (phone == null) {

3299:         int subId = phone.getSubId();

3308:             return phone.getImei();

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

3318:         if (phone != null) {

3319:             String imei = phone.getImei();

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

3340:         if (phone == null) {

3344:         int subId = phone.getSubId();

3352:             return phone.getMeid();

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

3362:         if (phone != null) {

3363:             String meid = phone.getMeid();

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

3379:         if (phone == null) {

3382:         int subId = phone.getSubId();

3391:             return phone.getDeviceSvn();

3401:             final Phone phone = getPhone(subId);

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

3412:             final Phone phone = getPhone(subId);

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

3423:             final Phone phone = getPhone(subId);

3424:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3425:                     : phone.getSpecificCarrierId();

3435:             final Phone phone = getPhone(subId);

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

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

3448:         if (phone == null) {

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

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

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

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

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

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

3544:             if (phone == null) {

3545:                 return PhoneConstants.PHONE_TYPE_NONE;

3547:                 return phone.getPhoneType();

3574:             final Phone phone = getPhone(subId);

3575:             if (phone != null) {

3576:                 return phone.getCdmaEriIconIndex();

3607:             final Phone phone = getPhone(subId);

3608:             if (phone != null) {

3609:                 return phone.getCdmaEriIconMode();

3638:             final Phone phone = getPhone(subId);

3639:             if (phone != null) {

3640:                 return phone.getCdmaEriText();

3659:             final Phone phone = getPhone(subId);

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

3661:                 return phone.getLine1Number();

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

3681:             final Phone phone = getPhone(subId);

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

3683:                 return phone.getCdmaMin();

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

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

3863:             final Phone phone = getPhone(subId);

3864:             if (phone != null) {

3865:                 phone.setVoiceActivationState(activationState);

3884:             final Phone phone = getPhone(subId);

3885:             if (phone != null) {

3886:                 phone.setDataActivationState(activationState);

3902:         final Phone phone = getPhone(subId);

3905:             if (phone != null) {

3906:                 return phone.getVoiceActivationState();

3922:         final Phone phone = getPhone(subId);

3925:             if (phone != null) {

3926:                 return phone.getDataActivationState();

3948:             final Phone phone = getPhone(subId);

3949:             if (phone != null) {

3950:                 return phone.getVoiceMessageCount();

3967:             final Phone phone = getPhone(subId);

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

3981:         final Phone defaultPhone = getDefaultPhone();

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

4020:                 if (phone.isInEmergencySmsMode()) {

4031:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4058:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4095:             Phone phone = getPhone(subId);

4096:             if (phone == null) {

4101:             phone.getImsRegistrationState(regState -> {

4128:             Phone phone = getPhone(subId);

4129:             if (phone == null) {

4134:             phone.getImsRegistrationTech(regTech -> {

4153:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4179:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4229:             Phone phone = getPhone(subId);

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

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

4282:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4320:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4357:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4395:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4416:      * Requires MODIFY_PHONE_STATE permission.

4439:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4493:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4579:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4999:             final Phone phone = getPhone(subId);

5000:             if (phone != null) {

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

5036:             final Phone phone = getPhone(subId);

5037:             if (phone != null) {

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

5064:             final Phone phone = getPhone(subId);

5065:             if (phone != null) {

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

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

5092:             if (phone != null) {

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

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

5109:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5128:             final Phone phone = getPhone(subId);

5129:             if (phone == null) {

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

5206:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5213:         return iccOpenLogicalChannelWithPermission(phone, request);

5218:         Phone phone;

5222:             phone = getPhoneFromSubId(request.subId);

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

5229:         return phone;

5232:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

5259:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,

5264:         return iccCloseLogicalChannelWithPermission(phone, request);

5267:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

5636:         if (phone != null) {

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

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

5662:         if (phone != null) {

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

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

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

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

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

5955:                     phone.setImsRegistrationState(registered);

6038:             final Phone phone = getPhone(subId);

6039:             if (phone == null) {

6042:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6101:             Phone phone = getPhone(subId);

6102:             if (phone == null) {

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

6153:             Phone phone = getPhone(subId);

6154:             if (phone == null) {

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

6181:             Phone phone = getPhone(subId);

6182:             if (phone == null) {

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

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

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

6234:             Phone phone = getPhone(subId);

6235:             if (phone == null) {

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

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

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

6544:         final Phone phone = getPhone(subId);

6546:             if (phone != null) {

6547:                 return phone.hasMatchedTetherApnSetting();

6577:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6587:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

6603:             if (phone != null) {

6604:                 boolean retVal = phone.isUserDataEnabled();

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

6634:                             android.Manifest.permission.READ_PHONE_STATE,

6638:                             permission.READ_BASIC_PHONE_STATE, functionName);

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

6649:             if (phone != null) {

6651:                 if (phone.isUsingNewDataStack()) {

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

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

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

6683:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

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

6705:             if (phone != null) {

6707:                 if (phone.isUsingNewDataStack()) {

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

6711:                         retVal = phone.isUserDataEnabled();

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

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

6743:         Phone phone = getPhone(subId);

6744:         if (phone == null) {

6748:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

6762:         Phone phone = getPhone(subId);

6763:         if (phone == null) {

6767:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6788:             if (phone == null) {

6791:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6807:         if (phone == null) {

6810:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6821:         if (phone == null) {

6824:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

6851:         if (phone == null) {

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

6862:         final Phone phone = getPhone(subId);

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

6880:             Phone phone = getPhone(subId);

6881:             if (phone != null) {

6882:                 Phone defaultPhone = phone.getImsPhone();

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

6903:             Phone phone = getPhone(subId);

6904:             if (phone != null) {

6905:                 Phone defaultPhone = phone.getImsPhone();

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

6926:             final Phone phone = getPhone(subId);

6927:             if (phone == null) {

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

7153:             final Phone phone = getPhone(subId);

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

7169:             final Phone phone = getPhone(subId);

7170:             if (phone == null) {

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

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

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

7225:         if (phone == null) {

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

7334:         final Phone defaultPhone = getDefaultPhone();

7348:         final Phone defaultPhone = getDefaultPhone();

7402:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7433:         final Phone phone = getPhone(subscriptionId);

7434:         if (phone == null) {

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

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

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

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

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

7491:         if (phone == null) {

7494:         int subId = phone.getSubId();

7502:             return phone.getDeviceId();

7515:         Phone phone = getPhone(subId);

7516:         if (phone != null) {

7517:             return phone.isImsRegistered();

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

7547:             Phone phone = getPhone(subscriptionId);

7548:             if (phone == null) {

7551:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7563:             Phone phone = getPhone(subId);

7564:             if (phone != null) {

7565:                 return phone.isWifiCallingEnabled();

7580:             Phone phone = getPhone(subId);

7581:             if (phone != null) {

7582:                 return phone.isVideoEnabled();

7598:             Phone phone = getPhone(subId);

7599:             if (phone != null) {

7600:                 return phone.getImsRegistrationTech();

7615:         Phone defaultPhone = getDefaultPhone();

7628:                 Phone phone = getPhone(subId);

7629:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7670:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7671:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7684:         final Phone phone = getPhone(subId);

7685:         if (phone == null) {

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

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

7918:         final Phone phone = getPhone(subId);

7919:         if (phone == null) {

7925:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

7935:             ServiceState ss = phone.getServiceState();

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

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

7960:             if (phone == null) {

7961:                 phone = getDefaultPhone();

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

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

7984:         final Phone defaultPhone = getDefaultPhone();

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

7996:             if (phone == null) {

7997:                 phone = defaultPhone;

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

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

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

8017:             if (phone == null) {

8018:                 phone = getDefaultPhone();

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

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

8041:         final Phone defaultPhone = getDefaultPhone();

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

8053:             if (phone == null) {

8054:                 phone = defaultPhone;

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

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

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

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

8116:         Phone phone = getPhone(subId);

8120:             if (phone == null) {

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

8145:         Phone phone = getPhone(subId);

8149:             if (phone == null) {

8154:                 esn = phone.getEsn();

8173:         Phone phone = getPhone(subId);

8177:             if (phone == null) {

8182:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8276:         final Phone phone = getPhone(subId);

8279:         if (phone == null) {

8284:             phone.carrierActionSetRadioEnabled(enabled);

8301:         final Phone phone = getPhone(subId);

8304:         if (phone == null) {

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

8361:         final Phone phone = getPhone(subId);

8364:         if (phone == null) {

8369:             phone.carrierActionReportDefaultNetworkStatus(report);

8385:         final Phone phone = getPhone(subId);

8386:         if (phone == null) {

8391:             phone.carrierActionResetAll();

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

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

8449:             Phone phone = getPhone(subId);

8450:             if (phone != null) {

8452:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

8454:                     if (phone.isUsingNewDataStack()) {

8455:                         phone.getDataSettingsManager().setDataEnabled(

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

8479:         Phone phone = getPhone(subId);

8483:             if (phone != null) {

8484:                 return phone.getClientRequestStats();

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

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

8527:             if (phone != null) {

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

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

8556:             if (phone != null) {

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

8580:      * Check if phone is in emergency callback mode

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

8587:         final Phone phone = getPhone(subId);

8591:             if (phone != null) {

8592:                 return phone.isInEcm();

8612:             Phone p = getPhone(subId);

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

8633:         if (phone != null) {

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

8641:                 return phone.getRadioPowerState();

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

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

8672:                         permission.READ_BASIC_PHONE_STATE, functionName);

8682:             Phone phone = getPhone(subId);

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

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

8708:             Phone phone = getPhone(subId);

8709:             if (phone != null) {

8710:                 phone.setDataRoamingEnabled(isEnabled);

8726:             Phone phone = getPhone(subId);

8727:             if (phone != null) {

8728:                 isAllowed = phone.isCspPlmnEnabled();

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

8742:         if (phone == null) {

8745:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

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

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

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

9031:             Phone phone = getPhone(subId);

9032:             if (phone == null) {

9035:             UiccPort uiccPort = phone.getUiccPort();

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

9080:         return Phone.PREFERRED_NT_MODE;

9090:             final Phone phone = getPhone(subId);

9091:             if (phone == null) {

9095:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();

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

9118:             final Phone phone = getPhone(subId);

9119:             if (phone == null) {

9123:             return phone.getCarrierIdListVersion();

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

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

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

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

9215:                             phone.getSubId(),

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

9227:         final Phone defaultPhone = getDefaultPhone();

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

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

9237:                         && phone.getEmergencyNumberTracker()

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

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

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

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

9262:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

9284:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9306:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9325:             final Phone phone = getPhone(subId);

9326:             if (phone == null) {

9330:             return phone.getEmergencyNumberDbVersion();

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

9343:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9360:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9377:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9390:         Phone phone = getPhone(subId);

9391:         if (phone == null) {

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

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

9417:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9545:         Phone phone = getPhone(subId);

9546:         if (phone == null) {

9551:             UiccPort uiccPort = phone.getUiccPort();

9626:         Phone phone = getDefaultPhone();

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

9628:         HalVersion hv = phone.getHalVersion();

9658:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9664:             Phone phone = getPhone(subId);

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

9669:             if (phone.isUsingNewDataStack()) {

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

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

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

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

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

9691:             Phone phone = getPhone(subId);

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

9693:             if (phone.isUsingNewDataStack()) {

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

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

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

9711:             Phone phone = getPhone(subscriptionId);

9712:             if (phone == null) {

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

9826:             Phone phone = getPhone(subscriptionId);

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

9831:                     if (phone.isUsingNewDataStack()) {

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

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

9837:                     if (phone.isUsingNewDataStack()) {

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

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

9857:             Phone phone = getPhone(subscriptionId);

9858:             if (phone == null) return;

9862:                     if (phone.isUsingNewDataStack()) {

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

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

9869:                     if (phone.isUsingNewDataStack()) {

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

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

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

9896:                 Phone defaultPhone = phone.getImsPhone();

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

9946:             Phone phone = getPhone(subId);

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

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

9972:         Phone phone = getPhone(subId);

9973:         if (phone == null) {

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

10004:         Phone phone = getPhone(subId);

10005:         if (phone == null) {

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

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

10074:         Phone phone = getPhone(subId);

10075:         if (phone == null) {

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

10081:             return phone.getEquivalentHomePlmns();

10105:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

10152:             if (phone != null) {

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

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

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

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

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

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

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

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

10219:                     + phone.isInEcm());

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

10310:                         Phone phone = getPhone(subId);

10311:                         if (phone == null) {

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

10459:                 permission.READ_PRIVILEGED_PHONE_STATE);

10490:                 permission.READ_PRIVILEGED_PHONE_STATE);

10521:                 permission.READ_PRIVILEGED_PHONE_STATE);

10698:                         Phone thePhone = p.getImsPhone();

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

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

11074:      * Gets the current phone capability.

11076:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

11114:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11124:             Phone phone = getDefaultPhone();

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

11139:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11147:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11148:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

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

11240:             Phone phone = getPhone(subId);

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

11242:             ServiceStateTracker sst = phone.getServiceStateTracker();

11298:             Phone phone = getPhone(subId);

11299:             if (phone == null) return;

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

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

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

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

886:                     defaultPhone.resetModemConfig(onCompleted);

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

1400:                     if (defaultPhone != null) {

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

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

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

1727:                     defaultPhone.rebootModem(onCompleted);

1737:                     PhoneConfigurationManager.getInstance()

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

1759:                     PhoneConfigurationManager.getInstance()

1876:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

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

1945:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2319:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2323:         synchronized (PhoneInterfaceManager.class) {

2325:                 sInstance = new PhoneInterfaceManager(app);

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

2346:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2536:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2545:         UnlockSim(int phoneId, IccCard simCard) {

2546:             mPhoneId = phoneId;

2567:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2572:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2574:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2577:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2825:             if (defaultPhone != null) {

2826:                 defaultPhone.setRadioPower(turnOn);

3017:                 return PhoneConstantConversions.convertDataState(

3018:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3724:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3760:             if (phoneAccountHandle == null) {

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

3848:         SmsController smsController = PhoneFactory.getSmsController();

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

3992:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

5123:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5130:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5133:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

5196:         if (phoneId == -1) {

5200:         return PhoneFactory.getPhone(phoneId);

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

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

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

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

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

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

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

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

6777:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");

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

6805:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

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

6884:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6885:                     imsPhone.setCallComposerStatus(status);

6907:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6908:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

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

7532:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7616:         if (defaultPhone != null) {

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

7631:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7644:             if (defaultPhone == null) {

7651:                 sendEraseModemConfig(defaultPhone);

7654:             sendEraseDataInSharedPreferences(defaultPhone);

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

7953:      * PhoneAccount.

7956:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7979:      * PhoneAccount.

7983:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7989:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

8013:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

8036:      * specific PhoneAccount.

8040:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

8046:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

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

9078:             return list.get(phoneId);

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

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

9263:                     gsmCdmaPhone.obtainMessage(

9264:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9495:         PhoneCapability staticCapability =

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

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

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

9898:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9900:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9903:                             + imsPhone.getMsisdn());

10041:         // *  Inherited from PhoneWindowManager  *

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

10142:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10700:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10701:                             CallTracker tracker = imsPhone.getCallTracker();

10781:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

11253:         return getDefaultPhone().isUsingNewDataStack();

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

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

1098:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1650:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1769:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2371:             return getPhoneFromSubId(request.subId);

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

2711:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2805:                 shutdownRadioUsingPhoneId(i);

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

3383:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3536:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3566:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3599:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3630:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3773:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3941:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4001:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4038:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4064:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4120:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4160:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4185:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4287:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4325:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4362:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4400:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4445:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4498:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4584:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4643:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4666:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4694:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4713:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4734:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4752:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4772:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4792:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4815:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4855:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4991:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5026:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5028:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5054:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5056:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

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

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

5380:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,

5465:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5889:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6029:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6391:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6416:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6469:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

6778:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);

6833:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6973:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

7000:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7023:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7218:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7231:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7373:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7392:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7541:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7875:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8475:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8675:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8720:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8764:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)

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

9132:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9140:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9149:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9176:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9203:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9230:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9436:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9471:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9496:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9536:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9576:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9583:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9741:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9899:                     ImsPhoneCallTracker imsPhoneCallTracker =

9901:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10069:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10149:         boolean isPhoneAvailable = false;

10154:                 isPhoneAvailable = true;

10160:         return isPhoneAvailable;

10324:                         } else if (isAnyPhoneInEmergencyState()) {

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

10703:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10704:                                         (ImsPhoneCallTracker) tracker;

10705:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11083:         enforceReadPrivilegedPermission("getPhoneCapability");

11086:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11119:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11141:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11268:         return mPhoneConfigurationManager.setModemService(serviceName);

11281:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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