468:         public Phone phone;

17: package com.android.phone;

240: public class PhoneInterfaceManager extends ITelephony.Stub {

2272:     private PhoneInterfaceManager(PhoneGlobals app) {

2291:     private Phone getDefaultPhone() {

2325:     private Phone getPhone(int subId) {

3005:     public String getNetworkCountryIsoForPhone(int phoneId) {

6896:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

376:     private PhoneConfigurationManager mPhoneConfigurationManager;

2305:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2313:     private Phone getPhoneFromSubId(int subId) {

2470:         private final int mPhoneId;

2749:     private void shutdownRadioUsingPhoneId(int phoneId) {

3459:     public int getActivePhoneType() {

3464:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

5246:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6968:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7647:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7657:     public int getSubIdForPhoneAccountHandle(

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

10176:     private boolean isAnyPhoneInEmergencyState() {

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

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

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

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

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

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

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

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

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

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

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

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

478:             if (phone != null) {

479:                 this.phone = phone;

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

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

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

526:             final Phone defaultPhone = getDefaultPhone();

531:                     final Phone phone = getPhoneFromRequest(request);

550:                         request.result = phone != null

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

562:                     final Phone phone = getPhoneFromRequest(request);

563:                     request.result = phone != null ?

840:                     Phone phone = getPhoneFromRequest(request);

841:                     if (phone != null) {

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

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

880:                     Phone phone = getPhoneFromRequest(request);

881:                     if (phone != null) {

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

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

919:                     Phone phone = getPhoneFromRequest(request);

920:                     if (phone != null) {

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

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

967:                     Phone phone = getPhoneFromRequest(request);

968:                     if (phone != null) {

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

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

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

1164:                     request.phone.setCallForwardingOption(

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

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

1643:                     Phone phone = getPhoneFromRequest(request);

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

1653:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1742:                     Phone phone = getPhoneFromRequest(request);

1743:                     if (phone != null) {

1744:                         phone.getSystemSelectionChannels(onCompleted);

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

1893:                     Phone phone = getPhoneFromRequest(request);

1894:                     if (phone != null) {

1895:                         phone.setDataThrottling(onCompleted,

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

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

1987:                     final Phone phone = getPhoneFromRequest(request);

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

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

1998:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

2015:                     Phone phone = getPhoneFromRequest(request);

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

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

2026:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

2042:                     request.phone.getSlicingConfig(onCompleted);

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

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

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

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

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

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

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

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

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

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

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

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

2307:             return request.phone;

2319:         Phone phone = getPhoneFromRequest(request);

2320:         return phone == null ? null :

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

2324:     // returns phone associated with the subId.

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

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

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

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

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

2440:             Phone phone = getPhone(subId);

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

2454:             Phone phone = getPhone(subId);

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

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

2618:             if (phone != null) {

2619:                 phone.updateServiceLocation(workSource);

2664:             final Phone phone = getPhone(subId);

2665:             if (phone != null) {

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

2684:             final Phone phone = getPhone(subId);

2685:             if (phone != null) {

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

2702:             final Phone phone = getPhone(subId);

2703:             if (phone == null) {

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

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

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

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

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

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

2752:             phone.shutdownRadio();

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

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

2779:             final Phone phone = getPhone(subId);

2780:             if (phone != null) {

2781:                 phone.setRadioPower(turnOn);

2799:             final Phone phone = getPhone(subId);

2800:             if (phone != null) {

2801:                 phone.getDataEnabledSettings().setDataEnabled(

2820:             final Phone phone = getPhone(subId);

2821:             if (phone != null) {

2822:                 phone.getDataEnabledSettings().setDataEnabled(

2837:             final Phone phone = getPhone(subId);

2838:             if (phone != null) {

2839:                 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);

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

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

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

2911:             // Check READ_PHONE_STATE for API version 31+

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

2920:             Phone phone = getPhone(subId);

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

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

2937:             final Phone phone = getPhone(subId);

2938:             if (phone != null) {

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

2958:             final Phone phone = getPhone(subId);

2959:             if (phone != null) {

2960:                 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());

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

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

3011:                 // Get default phone in this case.

3012:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

3017:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3136:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3198:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3220:         if (phone == null) {

3223:         int subId = phone.getSubId();

3232:             return phone.getImei();

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

3242:         if (phone != null) {

3243:             String imei = phone.getImei();

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

3264:         if (phone == null) {

3268:         int subId = phone.getSubId();

3276:             return phone.getMeid();

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

3286:         if (phone != null) {

3287:             String meid = phone.getMeid();

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

3303:         if (phone == null) {

3306:         int subId = phone.getSubId();

3315:             return phone.getDeviceSvn();

3325:             final Phone phone = getPhone(subId);

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

3336:             final Phone phone = getPhone(subId);

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

3347:             final Phone phone = getPhone(subId);

3348:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3349:                     : phone.getSpecificCarrierId();

3359:             final Phone phone = getPhone(subId);

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

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

3372:         if (phone == null) {

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

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

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

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

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

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

3468:             if (phone == null) {

3469:                 return PhoneConstants.PHONE_TYPE_NONE;

3471:                 return phone.getPhoneType();

3498:             final Phone phone = getPhone(subId);

3499:             if (phone != null) {

3500:                 return phone.getCdmaEriIconIndex();

3531:             final Phone phone = getPhone(subId);

3532:             if (phone != null) {

3533:                 return phone.getCdmaEriIconMode();

3562:             final Phone phone = getPhone(subId);

3563:             if (phone != null) {

3564:                 return phone.getCdmaEriText();

3583:             final Phone phone = getPhone(subId);

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

3585:                 return phone.getLine1Number();

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

3605:             final Phone phone = getPhone(subId);

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

3607:                 return phone.getCdmaMin();

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

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

3787:             final Phone phone = getPhone(subId);

3788:             if (phone != null) {

3789:                 phone.setVoiceActivationState(activationState);

3808:             final Phone phone = getPhone(subId);

3809:             if (phone != null) {

3810:                 phone.setDataActivationState(activationState);

3826:         final Phone phone = getPhone(subId);

3829:             if (phone != null) {

3830:                 return phone.getVoiceActivationState();

3846:         final Phone phone = getPhone(subId);

3849:             if (phone != null) {

3850:                 return phone.getDataActivationState();

3872:             final Phone phone = getPhone(subId);

3873:             if (phone != null) {

3874:                 return phone.getVoiceMessageCount();

3891:             final Phone phone = getPhone(subId);

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

3905:         final Phone defaultPhone = getDefaultPhone();

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

3944:                 if (phone.isInEmergencySmsMode()) {

3955:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3982:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4019:             Phone phone = getPhone(subId);

4020:             if (phone == null) {

4025:             phone.getImsRegistrationState(regState -> {

4052:             Phone phone = getPhone(subId);

4053:             if (phone == null) {

4058:             phone.getImsRegistrationTech(regTech -> {

4077:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4103:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4153:             Phone phone = getPhone(subId);

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

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

4206:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4244:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4281:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4319:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4340:      * Requires MODIFY_PHONE_STATE permission.

4363:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4417:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4503:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4570:         Phone phone = getPhone(subId);

4571:         if (phone == null) {

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

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

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

5052:             final Phone phone = getPhone(subId);

5053:             if (phone != null) {

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

5089:             final Phone phone = getPhone(subId);

5090:             if (phone != null) {

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

5117:             final Phone phone = getPhone(subId);

5118:             if (phone != null) {

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

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

5145:             if (phone != null) {

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

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

5162:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5181:             final Phone phone = getPhone(subId);

5182:             if (phone == null) {

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

5281:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

5298:                     CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,

5323:     private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {

5329:             Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,

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

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

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

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

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

5675:         if (phone != null) {

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

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

5701:         if (phone != null) {

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

5719:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

6010:                     phone.setImsRegistrationState(registered);

6093:             final Phone phone = getPhone(subId);

6094:             if (phone == null) {

6097:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6156:             Phone phone = getPhone(subId);

6157:             if (phone == null) {

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

6208:             Phone phone = getPhone(subId);

6209:             if (phone == null) {

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

6236:             Phone phone = getPhone(subId);

6237:             if (phone == null) {

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

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

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

6289:             Phone phone = getPhone(subId);

6290:             if (phone == null) {

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

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

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

6599:         final Phone phone = getPhone(subId);

6601:             if (phone != null) {

6602:                 return phone.hasMatchedTetherApnSetting();

6632:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE

6642:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

6658:             if (phone != null) {

6659:                 boolean retVal = phone.isUserDataEnabled();

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

6689:                             android.Manifest.permission.READ_PHONE_STATE,

6693:                             permission.READ_BASIC_PHONE_STATE, functionName);

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

6705:             if (phone != null) {

6706:                 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();

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

6734:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,

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

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

6756:             if (phone != null) {

6759:                     retVal = phone.isUserDataEnabled();

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

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

6778:             Phone phone) {

6779:         if (uid == Process.PHONE_UID) {

6780:             // Skip the check if it's the phone UID (system UID removed in b/184713596)

6781:             // TODO (b/184954344): Check for system/phone UID at call site instead of here

6790:         PackageManager pkgMgr = phone.getContext().getPackageManager();

6795:             int subId = phone.getSubId();

6803:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);

6815:     private int getCarrierPrivilegeStatusFromCarrierConfigRules(int privilegeFromSim, Phone phone,

6824:             int subId = phone.getSubId();

6832:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);

6842:         final Phone phone = getPhone(subId);

6843:         if (phone == null) {

6847:         UiccPort port = UiccController.getInstance().getUiccPort(phone.getPhoneId());

6855:                 phone.getContext().getPackageManager()), Binder.getCallingUid(), phone);

6861:         final Phone phone = getPhone(subId);

6862:         if (phone == null) {

6867:                 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());

6874:                         phone.getContext().getPackageManager(), uid), uid, phone);

6985:         final Phone phone = getPhone(subId);

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

7003:             Phone phone = getPhone(subId);

7004:             if (phone != null) {

7005:                 Phone defaultPhone = phone.getImsPhone();

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

7026:             Phone phone = getPhone(subId);

7027:             if (phone != null) {

7028:                 Phone defaultPhone = phone.getImsPhone();

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

7049:             final Phone phone = getPhone(subId);

7050:             if (phone == null) {

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

7276:             final Phone phone = getPhone(subId);

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

7292:             final Phone phone = getPhone(subId);

7293:             if (phone == null) {

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

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

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

7348:         if (phone == null) {

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

7457:         final Phone defaultPhone = getDefaultPhone();

7471:         final Phone defaultPhone = getDefaultPhone();

7525:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7556:         final Phone phone = getPhone(subscriptionId);

7557:         if (phone == null) {

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

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

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

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

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

7614:         if (phone == null) {

7617:         int subId = phone.getSubId();

7625:             return phone.getDeviceId();

7638:         Phone phone = getPhone(subId);

7639:         if (phone != null) {

7640:             return phone.isImsRegistered();

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

7680:             Phone phone = getPhone(subscriptionId);

7681:             if (phone == null) {

7684:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7696:             Phone phone = getPhone(subId);

7697:             if (phone != null) {

7698:                 return phone.isWifiCallingEnabled();

7713:             Phone phone = getPhone(subId);

7714:             if (phone != null) {

7715:                 return phone.isVideoEnabled();

7731:             Phone phone = getPhone(subId);

7732:             if (phone != null) {

7733:                 return phone.getImsRegistrationTech();

7748:         Phone defaultPhone = getDefaultPhone();

7761:                 Phone phone = getPhone(subId);

7762:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7803:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7804:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7817:         final Phone phone = getPhone(subId);

7818:         if (phone == null) {

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

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

7966:         final Phone phone = getPhone(subId);

7967:         if (phone == null) {

7973:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

7983:             ServiceState ss = phone.getServiceState();

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

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

8008:             if (phone == null) {

8009:                 phone = getDefaultPhone();

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

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

8032:         final Phone defaultPhone = getDefaultPhone();

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

8044:             if (phone == null) {

8045:                 phone = defaultPhone;

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

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

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

8065:             if (phone == null) {

8066:                 phone = getDefaultPhone();

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

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

8089:         final Phone defaultPhone = getDefaultPhone();

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

8101:             if (phone == null) {

8102:                 phone = defaultPhone;

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

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

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

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

8164:         Phone phone = getPhone(subId);

8168:             if (phone == null) {

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

8193:         Phone phone = getPhone(subId);

8197:             if (phone == null) {

8202:                 esn = phone.getEsn();

8221:         Phone phone = getPhone(subId);

8225:             if (phone == null) {

8230:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8324:         final Phone phone = getPhone(subId);

8327:         if (phone == null) {

8332:             phone.carrierActionSetRadioEnabled(enabled);

8349:         final Phone phone = getPhone(subId);

8352:         if (phone == null) {

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

8399:         final Phone phone = getPhone(subId);

8402:         if (phone == null) {

8407:             phone.carrierActionReportDefaultNetworkStatus(report);

8423:         final Phone phone = getPhone(subId);

8424:         if (phone == null) {

8429:             phone.carrierActionResetAll();

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

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

8486:             Phone phone = getPhone(subId);

8487:             if (phone != null) {

8489:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

8511:         Phone phone = getPhone(subId);

8515:             if (phone != null) {

8516:                 return phone.getClientRequestStats();

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

8549:             if (phone != null) {

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

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

8578:             if (phone != null) {

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

8602:      * Check if phone is in emergency callback mode

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

8609:         final Phone phone = getPhone(subId);

8613:             if (phone != null) {

8614:                 return phone.isInEcm();

8634:             Phone p = getPhone(subId);

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

8655:         if (phone != null) {

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

8663:                 return phone.getRadioPowerState();

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

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

8694:                         permission.READ_BASIC_PHONE_STATE, functionName);

8704:             Phone phone = getPhone(subId);

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

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

8730:             Phone phone = getPhone(subId);

8731:             if (phone != null) {

8732:                 phone.setDataRoamingEnabled(isEnabled);

8748:             Phone phone = getPhone(subId);

8749:             if (phone != null) {

8750:                 isAllowed = phone.isCspPlmnEnabled();

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

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

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

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

9034:             Phone phone = getPhone(subId);

9035:             if (phone == null) {

9038:             UiccPort uiccPort = phone.getUiccPort();

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

9083:         return Phone.PREFERRED_NT_MODE;

9093:             final Phone phone = getPhone(subId);

9094:             if (phone == null) {

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

9116:             final Phone phone = getPhone(subId);

9117:             if (phone == null) {

9121:             return phone.getCarrierIdListVersion();

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

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

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

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

9213:                             phone.getSubId(),

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

9225:         final Phone defaultPhone = getDefaultPhone();

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

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

9235:                         && phone.getEmergencyNumberTracker()

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

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

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

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

9260:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

9282:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9304:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9323:             final Phone phone = getPhone(subId);

9324:             if (phone == null) {

9328:             return phone.getEmergencyNumberDbVersion();

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

9341:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9358:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9375:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9388:         Phone phone = getPhone(subId);

9389:         if (phone == null) {

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

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

9415:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9543:         Phone phone = getPhone(subId);

9544:         if (phone == null) {

9549:             UiccPort uiccPort = phone.getUiccPort();

9619:         Phone phone = getDefaultPhone();

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

9621:         HalVersion hv = phone.getHalVersion();

9651:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9657:             Phone phone = getPhone(subId);

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

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

9661:             return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);

9674:             Phone phone = getPhone(subId);

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

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

9689:             Phone phone = getPhone(subscriptionId);

9690:             if (phone == null) {

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

9810:             Phone phone = getPhone(subscriptionId);

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

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

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

9833:             Phone phone = getPhone(subscriptionId);

9834:             if (phone == null) return;

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

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

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

9864:                 Phone defaultPhone = phone.getImsPhone();

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

9914:             Phone phone = getPhone(subId);

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

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

9940:         Phone phone = getPhone(subId);

9941:         if (phone == null) {

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

9972:         Phone phone = getPhone(subId);

9973:         if (phone == null) {

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

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

10042:         Phone phone = getPhone(subId);

10043:         if (phone == null) {

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

10049:             return phone.getEquivalentHomePlmns();

10073:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

10120:             if (phone != null) {

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

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

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

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

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

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

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

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

10186:                     + phone.isInEcm());

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

10276:                         Phone phone = getPhone(subId);

10277:                         if (phone == null) {

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

10425:                 permission.READ_PRIVILEGED_PHONE_STATE);

10456:                 permission.READ_PRIVILEGED_PHONE_STATE);

10487:                 permission.READ_PRIVILEGED_PHONE_STATE);

10661:                         Phone thePhone = p.getImsPhone();

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

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

11037:      * Gets the current phone capability.

11039:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

11076:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

11084:             Phone phone = getDefaultPhone();

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

11099:             // The following also checks READ_PRIVILEGED_PHONE_STATE.

11107:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,

11108:                     Manifest.permission.READ_PRECISE_PHONE_STATE,

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

11200:             Phone phone = getPhone(subId);

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

11202:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

71: import android.telecom.PhoneAccount;

72: import android.telecom.PhoneAccountHandle;

94: import android.telephony.PhoneCapability;

95: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

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

364:     private static PhoneInterfaceManager sInstance;

367:     private PhoneGlobals mApp;

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

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

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

829:                     defaultPhone.resetModemConfig(onCompleted);

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

1337:                     if (defaultPhone != null) {

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

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

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

1666:                     defaultPhone.rebootModem(onCompleted);

1676:                     PhoneConfigurationManager.getInstance()

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

1698:                     PhoneConfigurationManager.getInstance()

1815:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

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

1884:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2257:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2261:         synchronized (PhoneInterfaceManager.class) {

2263:                 sInstance = new PhoneInterfaceManager(app);

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

2284:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2473:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2482:         UnlockSim(int phoneId, IccCard simCard) {

2483:             mPhoneId = phoneId;

2504:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2509:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2511:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2514:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2762:             if (defaultPhone != null) {

2763:                 defaultPhone.setRadioPower(turnOn);

2941:                 return PhoneConstantConversions.convertDataState(

2942:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3648:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3684:             if (phoneAccountHandle == null) {

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

3772:         SmsController smsController = PhoneFactory.getSmsController();

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

3916:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

5176:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5183:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5186:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

5247:         int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);

5248:         if (phoneId == -1) {

5252:         return PhoneFactory.getPhone(phoneId);

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

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

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

5727:             return defaultPhone.getPcscfAddress(apnType);

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

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

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

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

6703:             if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);

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

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

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

6885:         UiccPort port = UiccController.getInstance().getUiccPort(phoneId);

6892:             getPhone(phoneId), pkgName);

6910:                 getPhone(i), pkgName);

6921:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

6922:         if (!SubscriptionManager.isValidPhoneId(phoneId)) {

6923:             loge("phoneId " + phoneId + " is not valid.");

6926:         UiccPort port = UiccController.getInstance().getUiccPort(phoneId);

6928:             loge("getCarrierPackageNamesForIntentAndPhone: No UICC");

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

6940:         UiccPort port = UiccController.getInstance().getUiccPort(phoneId);

6957:                                     getPhone(phoneId), pkgInfo.packageName)

7007:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

7008:                     imsPhone.setCallComposerStatus(status);

7030:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

7031:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7650:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7665:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7749:         if (defaultPhone != null) {

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

7764:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7777:             if (defaultPhone == null) {

7784:                 sendEraseModemConfig(defaultPhone);

7787:             sendEraseDataInSharedPreferences(defaultPhone);

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

8001:      * PhoneAccount.

8004:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

8027:      * PhoneAccount.

8031:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

8037:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

8061:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

8084:      * specific PhoneAccount.

8088:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

8094:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8788:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

8887:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

9081:             return list.get(phoneId);

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

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

9261:                     gsmCdmaPhone.obtainMessage(

9262:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9493:         PhoneCapability staticCapability =

9599:             int phoneCount = TelephonyManager.getDefault().getPhoneCount();

9601:             int[] logicalSlotsMapping = new int[phoneCount];

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

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

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

9866:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9868:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9871:                             + imsPhone.getMsisdn());

10009:         // *  Inherited from PhoneWindowManager  *

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

10110:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10663:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10664:                             CallTracker tracker = imsPhone.getCallTracker();

10744:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

154: import com.android.internal.telephony.DefaultPhoneNotifier;

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

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

1041:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1589:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1708:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2309:             return getPhoneFromSubId(request.subId);

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

2648:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2742:                 shutdownRadioUsingPhoneId(i);

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

3307:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3460:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3490:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3523:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3554:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3697:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3865:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3925:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3962:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3988:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4044:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4084:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4109:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4211:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4249:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4286:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4324:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4369:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4422:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4508:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4590:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4656:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

5044:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

5079:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5081:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5107:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(

5109:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5264:         return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,

5277:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

5312:         return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);

5319:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

5362:                 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,

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

5417:                 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,

5502:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5944:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6084:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6446:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6471:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6524:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

6969:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

7096:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

7123:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7146:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7341:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7354:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7496:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7515:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7674:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7923:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8507:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8697:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8742:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8968:                                 slot.getPhoneId(),

9130:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9138:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

9147:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9174:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9201:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9228:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9434:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9469:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9494:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9534:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9574:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9581:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

9604:                 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {

9719:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9867:                     ImsPhoneCallTracker imsPhoneCallTracker =

9869:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

10037:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

10117:         boolean isPhoneAvailable = false;

10122:                 isPhoneAvailable = true;

10128:         return isPhoneAvailable;

10290:                         } else if (isAnyPhoneInEmergencyState()) {

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

10666:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10667:                                         (ImsPhoneCallTracker) tracker;

10668:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

11046:         enforceReadPrivilegedPermission("getPhoneCapability");

11049:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

11101:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

11222:         return mPhoneConfigurationManager.setModemService(serviceName);

11235:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

11238:         result = mPhoneConfigurationManager.getModemService();

384:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1655:     private PhoneInterfaceManager(PhoneGlobals app) {

1672:     private Phone getDefaultPhone() {

1706:     private Phone getPhone(int subId) {

2347:     public String getNetworkCountryIsoForPhone(int phoneId) {

5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1694:     private Phone getPhoneFromSubId(int subId) {

2125:     private void shutdownRadioUsingPhoneId(int phoneId) {

2780:     public int getActivePhoneType() {

2785:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6553:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

394:             if (phone != null) {

395:                 this.phone = phone;

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

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

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

442:             final Phone defaultPhone = getDefaultPhone();

447:                     final Phone phone = getPhoneFromRequest(request);

466:                         request.result = phone != null

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

478:                     final Phone phone = getPhoneFromRequest(request);

479:                     request.result = phone != null ?

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

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

1308:                     Phone phone = getPhoneFromRequest(request);

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

1317:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1688:             return request.phone;

1700:         Phone phone = getPhoneFromRequest(request);

1701:         return phone == null ? null :

1702:                 UiccController.getInstance().getUiccCard(phone.getPhoneId());

1705:     // returns phone associated with the subId.

1710:     private void sendEraseModemConfig(Phone phone) {

1711:         if (phone != null) {

1713:                   mApp, phone.getSubId(), "eraseModemConfig");

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