446:         public Phone phone;

17: package com.android.phone;

232: public class PhoneInterfaceManager extends ITelephony.Stub {

2165:     private PhoneInterfaceManager(PhoneGlobals app) {

2184:     private Phone getDefaultPhone() {

2218:     private Phone getPhone(int subId) {

2898:     public String getNetworkCountryIsoForPhone(int phoneId) {

6767:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

364:     private PhoneConfigurationManager mPhoneConfigurationManager;

2198:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2206:     private Phone getPhoneFromSubId(int subId) {

2363:         private final int mPhoneId;

2642:     private void shutdownRadioUsingPhoneId(int phoneId) {

3348:     public int getActivePhoneType() {

3353:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

5122:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6839:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7511:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7521:     public int getSubIdForPhoneAccountHandle(

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

9861:     private boolean isAnyPhoneInEmergencyState() {

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

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

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

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

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

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

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

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

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

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

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

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

456:             if (phone != null) {

457:                 this.phone = phone;

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

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

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

504:             final Phone defaultPhone = getDefaultPhone();

509:                     final Phone phone = getPhoneFromRequest(request);

528:                         request.result = phone != null

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

540:                     final Phone phone = getPhoneFromRequest(request);

541:                     request.result = phone != null ?

818:                     Phone phone = getPhoneFromRequest(request);

819:                     if (phone != null) {

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

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

857:                     Phone phone = getPhoneFromRequest(request);

858:                     if (phone != null) {

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

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

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

1057:                     request.phone.setCallForwardingOption(

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

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

1536:                     Phone phone = getPhoneFromRequest(request);

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

1546:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1635:                     Phone phone = getPhoneFromRequest(request);

1636:                     if (phone != null) {

1637:                         phone.getSystemSelectionChannels(onCompleted);

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

1786:                     Phone phone = getPhoneFromRequest(request);

1787:                     if (phone != null) {

1788:                         phone.setDataThrottling(onCompleted,

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

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

1880:                     final Phone phone = getPhoneFromRequest(request);

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

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

1891:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(

1908:                     Phone phone = getPhoneFromRequest(request);

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

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

1919:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(

1935:                     request.phone.getSlicingConfig(onCompleted);

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

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

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

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

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

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

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

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

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

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

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

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

2200:             return request.phone;

2212:         Phone phone = getPhoneFromRequest(request);

2213:         return phone == null ? null :

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

2217:     // returns phone associated with the subId.

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

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

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

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

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

2333:             Phone phone = getPhone(subId);

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

2347:             Phone phone = getPhone(subId);

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

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

2511:             if (phone != null) {

2512:                 phone.updateServiceLocation(workSource);

2557:             final Phone phone = getPhone(subId);

2558:             if (phone != null) {

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

2577:             final Phone phone = getPhone(subId);

2578:             if (phone != null) {

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

2595:             final Phone phone = getPhone(subId);

2596:             if (phone == null) {

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

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

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

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

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

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

2645:             phone.shutdownRadio();

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

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

2672:             final Phone phone = getPhone(subId);

2673:             if (phone != null) {

2674:                 phone.setRadioPower(turnOn);

2692:             final Phone phone = getPhone(subId);

2693:             if (phone != null) {

2694:                 phone.getDataEnabledSettings().setDataEnabled(

2713:             final Phone phone = getPhone(subId);

2714:             if (phone != null) {

2715:                 phone.getDataEnabledSettings().setDataEnabled(

2730:             final Phone phone = getPhone(subId);

2731:             if (phone != null) {

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

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

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

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

2804:             // Check READ_PHONE_STATE for API version 31+

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

2813:             Phone phone = getPhone(subId);

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

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

2830:             final Phone phone = getPhone(subId);

2831:             if (phone != null) {

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

2851:             final Phone phone = getPhone(subId);

2852:             if (phone != null) {

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

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

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

2904:                 // Get default phone in this case.

2905:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2910:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

3021:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

3083:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3105:         if (phone == null) {

3108:         int subId = phone.getSubId();

3117:             return phone.getImei();

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

3127:         if (phone != null) {

3128:             String imei = phone.getImei();

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

3142:         if (phone == null) {

3146:         int subId = phone.getSubId();

3154:             return phone.getMeid();

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

3164:         if (phone != null) {

3165:             String meid = phone.getMeid();

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

3181:         if (phone == null) {

3184:         int subId = phone.getSubId();

3193:             return phone.getDeviceSvn();

3203:             final Phone phone = getPhone(subId);

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

3214:             final Phone phone = getPhone(subId);

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

3225:             final Phone phone = getPhone(subId);

3226:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3227:                     : phone.getSpecificCarrierId();

3237:             final Phone phone = getPhone(subId);

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

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

3250:         if (phone == null) {

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

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

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

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

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

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

3357:             if (phone == null) {

3358:                 return PhoneConstants.PHONE_TYPE_NONE;

3360:                 return phone.getPhoneType();

3387:             final Phone phone = getPhone(subId);

3388:             if (phone != null) {

3389:                 return phone.getCdmaEriIconIndex();

3420:             final Phone phone = getPhone(subId);

3421:             if (phone != null) {

3422:                 return phone.getCdmaEriIconMode();

3451:             final Phone phone = getPhone(subId);

3452:             if (phone != null) {

3453:                 return phone.getCdmaEriText();

3472:             final Phone phone = getPhone(subId);

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

3474:                 return phone.getLine1Number();

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

3494:             final Phone phone = getPhone(subId);

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

3496:                 return phone.getCdmaMin();

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

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

3676:             final Phone phone = getPhone(subId);

3677:             if (phone != null) {

3678:                 phone.setVoiceActivationState(activationState);

3697:             final Phone phone = getPhone(subId);

3698:             if (phone != null) {

3699:                 phone.setDataActivationState(activationState);

3715:         final Phone phone = getPhone(subId);

3718:             if (phone != null) {

3719:                 return phone.getVoiceActivationState();

3735:         final Phone phone = getPhone(subId);

3738:             if (phone != null) {

3739:                 return phone.getDataActivationState();

3761:             final Phone phone = getPhone(subId);

3762:             if (phone != null) {

3763:                 return phone.getVoiceMessageCount();

3780:             final Phone phone = getPhone(subId);

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

3794:         final Phone defaultPhone = getDefaultPhone();

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

3833:                 if (phone.isInEmergencySmsMode()) {

3844:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3871:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3908:             Phone phone = getPhone(subId);

3909:             if (phone == null) {

3914:             phone.getImsRegistrationState(regState -> {

3941:             Phone phone = getPhone(subId);

3942:             if (phone == null) {

3947:             phone.getImsRegistrationTech(regTech -> {

3966:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3992:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4042:             Phone phone = getPhone(subId);

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

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

4095:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4133:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4170:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4208:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4229:      * Requires MODIFY_PHONE_STATE permission.

4252:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4306:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4392:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4459:         Phone phone = getPhone(subId);

4460:         if (phone == null) {

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

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

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

4934:             final Phone phone = getPhone(subId);

4935:             if (phone != null) {

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

4968:             final Phone phone = getPhone(subId);

4969:             if (phone != null) {

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

4993:             final Phone phone = getPhone(subId);

4994:             if (phone != null) {

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

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

5021:             if (phone != null) {

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

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

5038:      * or {@link Phone#LTE_ON_CDMA_TRUE}

5057:             final Phone phone = getPhone(subId);

5058:             if (phone == null) {

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

5157:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5551:         if (phone != null) {

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

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

5577:         if (phone != null) {

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

5595:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

5886:                     phone.setImsRegistrationState(registered);

5969:             final Phone phone = getPhone(subId);

5970:             if (phone == null) {

5973:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

6032:             Phone phone = getPhone(subId);

6033:             if (phone == null) {

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

6084:             Phone phone = getPhone(subId);

6085:             if (phone == null) {

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

6112:             Phone phone = getPhone(subId);

6113:             if (phone == null) {

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

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

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

6165:             Phone phone = getPhone(subId);

6166:             if (phone == null) {

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

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

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

6468:         final Phone phone = getPhone(subId);

6470:             if (phone != null) {

6471:                 return phone.hasMatchedTetherApnSetting();

6491:         final Phone phone = getPhone(subId);

6493:             if (phone != null) {

6498:                 phone.setAlwaysReportSignalStrength(isEnable);

6500:                 loge("setAlwaysReportSignalStrength: no phone found for subId="

6529:      * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.

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

6548:             if (phone != null) {

6549:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6588:             if (phone != null) {

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

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

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

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

6627:             if (phone != null) {

6630:                     retVal = phone.isUserDataEnabled();

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

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

6649:             Phone phone) {

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

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

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

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

6666:             int subId = phone.getSubId();

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

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

6695:             int subId = phone.getSubId();

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

6713:         final Phone phone = getPhone(subId);

6714:         if (phone == null) {

6718:         UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());

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

6732:         final Phone phone = getPhone(subId);

6733:         if (phone == null) {

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

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

6856:         final Phone phone = getPhone(subId);

6857:         UiccCard card = phone == null ? null : phone.getUiccCard();

6874:             Phone phone = getPhone(subId);

6875:             if (phone != null) {

6876:                 Phone defaultPhone = phone.getImsPhone();

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

6897:             Phone phone = getPhone(subId);

6898:             if (phone != null) {

6899:                 Phone defaultPhone = phone.getImsPhone();

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

6920:             final Phone phone = getPhone(subId);

6921:             if (phone == null) {

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

7147:             final Phone phone = getPhone(subId);

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

7163:             final Phone phone = getPhone(subId);

7164:             if (phone == null) {

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

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

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

7219:         if (phone == null) {

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

7328:         final Phone defaultPhone = getDefaultPhone();

7342:         final Phone defaultPhone = getDefaultPhone();

7396:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7427:         final Phone phone = getPhone(subscriptionId);

7428:         if (phone == null) {

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

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

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

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

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

7478:         if (phone == null) {

7481:         int subId = phone.getSubId();

7489:             return phone.getDeviceId();

7502:         Phone phone = getPhone(subId);

7503:         if (phone != null) {

7504:             return phone.isImsRegistered();

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

7544:             Phone phone = getPhone(subscriptionId);

7545:             if (phone == null) {

7548:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7560:             Phone phone = getPhone(subId);

7561:             if (phone != null) {

7562:                 return phone.isWifiCallingEnabled();

7577:             Phone phone = getPhone(subId);

7578:             if (phone != null) {

7579:                 return phone.isVideoEnabled();

7595:             Phone phone = getPhone(subId);

7596:             if (phone != null) {

7597:                 return phone.getImsRegistrationTech();

7612:         Phone defaultPhone = getDefaultPhone();

7625:                 Phone phone = getPhone(subId);

7626:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7667:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7668:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7681:         final Phone phone = getPhone(subId);

7682:         if (phone == null) {

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

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

7825:         final Phone phone = getPhone(subId);

7826:         if (phone == null) {

7832:         boolean isCallingPackageDataService = phone.getDataServicePackages()

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

7842:             ServiceState ss = phone.getServiceState();

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

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

7867:             if (phone == null) {

7868:                 phone = getDefaultPhone();

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

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

7891:         final Phone defaultPhone = getDefaultPhone();

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

7903:             if (phone == null) {

7904:                 phone = defaultPhone;

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

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

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

7924:             if (phone == null) {

7925:                 phone = getDefaultPhone();

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

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

7948:         final Phone defaultPhone = getDefaultPhone();

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

7960:             if (phone == null) {

7961:                 phone = defaultPhone;

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

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

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

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

8023:         Phone phone = getPhone(subId);

8027:             if (phone == null) {

8032:                 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())

8052:         Phone phone = getPhone(subId);

8056:             if (phone == null) {

8061:                 esn = phone.getEsn();

8080:         Phone phone = getPhone(subId);

8084:             if (phone == null) {

8089:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

8183:         final Phone phone = getPhone(subId);

8186:         if (phone == null) {

8191:             phone.carrierActionSetRadioEnabled(enabled);

8211:         final Phone phone = getPhone(subId);

8214:         if (phone == null) {

8219:             phone.carrierActionReportDefaultNetworkStatus(report);

8235:         final Phone phone = getPhone(subId);

8236:         if (phone == null) {

8241:             phone.carrierActionResetAll();

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

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

8298:             Phone phone = getPhone(subId);

8299:             if (phone != null) {

8301:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

8323:         Phone phone = getPhone(subId);

8327:             if (phone != null) {

8328:                 return phone.getClientRequestStats();

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

8361:             if (phone != null) {

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

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

8390:             if (phone != null) {

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

8414:      * Check if phone is in emergency callback mode

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

8421:         final Phone phone = getPhone(subId);

8425:             if (phone != null) {

8426:                 return phone.isInEcm();

8446:             Phone p = getPhone(subId);

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

8467:         if (phone != null) {

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

8475:                 return phone.getRadioPowerState();

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

8508:             Phone phone = getPhone(subId);

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

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

8534:             Phone phone = getPhone(subId);

8535:             if (phone != null) {

8536:                 phone.setDataRoamingEnabled(isEnabled);

8552:             Phone phone = getPhone(subId);

8553:             if (phone != null) {

8554:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8719:             Phone phone = getPhone(subId);

8720:             if (phone == null) {

8723:             UiccCard uiccCard = phone.getUiccCard();

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

8768:         return Phone.PREFERRED_NT_MODE;

8778:             final Phone phone = getPhone(subId);

8779:             if (phone == null) {

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

8801:             final Phone phone = getPhone(subId);

8802:             if (phone == null) {

8806:             return phone.getCarrierIdListVersion();

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

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

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

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

8898:                             phone.getSubId(),

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

8910:         final Phone defaultPhone = getDefaultPhone();

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

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

8920:                         && phone.getEmergencyNumberTracker()

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

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

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

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

8945:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

8967:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8989:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9008:             final Phone phone = getPhone(subId);

9009:             if (phone == null) {

9013:             return phone.getEmergencyNumberDbVersion();

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

9026:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9043:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

9060:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

9073:         Phone phone = getPhone(subId);

9074:         if (phone == null) {

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

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

9100:             if (phone == null) {

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

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

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

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

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

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

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

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

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

9228:         Phone phone = getPhone(subId);

9229:         if (phone == null) {

9234:             UiccCard uiccCard = phone.getUiccCard();

9304:         Phone phone = getDefaultPhone();

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

9306:         HalVersion hv = phone.getHalVersion();

9336:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9342:             Phone phone = getPhone(subId);

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

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

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

9359:             Phone phone = getPhone(subId);

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

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

9374:             Phone phone = getPhone(subscriptionId);

9375:             if (phone == null) {

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

9495:             Phone phone = getPhone(subscriptionId);

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

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

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

9518:             Phone phone = getPhone(subscriptionId);

9519:             if (phone == null) return;

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

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

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

9549:                 Phone defaultPhone = phone.getImsPhone();

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

9599:             Phone phone = getPhone(subId);

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

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

9625:         Phone phone = getPhone(subId);

9626:         if (phone == null) {

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

9657:         Phone phone = getPhone(subId);

9658:         if (phone == null) {

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

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

9727:         Phone phone = getPhone(subId);

9728:         if (phone == null) {

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

9734:             return phone.getEquivalentHomePlmns();

9758:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

9805:             if (phone != null) {

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

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

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

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

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

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

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

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

9871:                     + phone.isInEcm());

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

9961:                         Phone phone = getPhone(subId);

9962:                         if (phone == null) {

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

10110:                 permission.READ_PRIVILEGED_PHONE_STATE);

10141:                 permission.READ_PRIVILEGED_PHONE_STATE);

10172:                 permission.READ_PRIVILEGED_PHONE_STATE);

10346:                         Phone thePhone = p.getImsPhone();

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

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

10722:      * Gets the current phone capability.

10724:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

10761:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.

10769:             Phone phone = getDefaultPhone();

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

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

68: import android.telecom.PhoneAccount;

69: import android.telecom.PhoneAccountHandle;

91: import android.telephony.PhoneCapability;

92: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

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

352:     private static PhoneInterfaceManager sInstance;

355:     private PhoneGlobals mApp;

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

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

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

807:                     defaultPhone.resetModemConfig(onCompleted);

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

1230:                     if (defaultPhone != null) {

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

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

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

1559:                     defaultPhone.rebootModem(onCompleted);

1569:                     PhoneConfigurationManager.getInstance()

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

1591:                     PhoneConfigurationManager.getInstance()

1708:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

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

1777:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2150:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2154:         synchronized (PhoneInterfaceManager.class) {

2156:                 sInstance = new PhoneInterfaceManager(app);

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

2177:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2366:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2375:         UnlockSim(int phoneId, IccCard simCard) {

2376:             mPhoneId = phoneId;

2397:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2402:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2404:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2407:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2655:             if (defaultPhone != null) {

2656:                 defaultPhone.setRadioPower(turnOn);

2834:                 return PhoneConstantConversions.convertDataState(

2835:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3537:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3573:             if (phoneAccountHandle == null) {

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

3661:         SmsController smsController = PhoneFactory.getSmsController();

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

3805:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

5052:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5059:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

5062:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

5124:         if (phoneId == -1) {

5128:         return PhoneFactory.getPhone(phoneId);

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

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

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

5603:             return defaultPhone.getPcscfAddress(apnType);

6255:                     request, messenger, binder, getPhone(subId),

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

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

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

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

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

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

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

6756:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);

6763:             getPhone(phoneId), pkgName);

6781:                 getPhone(i), pkgName);

6792:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");

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

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

6797:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);

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

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

6811:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);

6828:                                     getPhone(phoneId), pkgInfo.packageName)

6878:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6879:                     imsPhone.setCallComposerStatus(status);

6901:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6902:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7514:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7529:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

7613:         if (defaultPhone != null) {

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

7628:                 getPhone(subId).resetCarrierKeysForImsiEncryption();

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

7641:             if (defaultPhone == null) {

7648:                 sendEraseModemConfig(defaultPhone);

7651:             sendEraseDataInSharedPreferences(defaultPhone);

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

7860:      * PhoneAccount.

7863:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7886:      * PhoneAccount.

7890:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7896:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7920:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7943:      * specific PhoneAccount.

7947:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7953:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8575:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8766:             return list.get(phoneId);

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

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

8946:                     gsmCdmaPhone.obtainMessage(

8947:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

9178:         PhoneCapability staticCapability =

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

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

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

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

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

9551:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9553:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9556:                             + imsPhone.getMsisdn());

9694:         // *  Inherited from PhoneWindowManager  *

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

9795:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

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

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

10348:                             ImsPhone imsPhone = (ImsPhone) thePhone;

10349:                             CallTracker tracker = imsPhone.getCallTracker();

10429:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

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

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

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

936:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1482:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1601:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2202:             return getPhoneFromSubId(request.subId);

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

2541:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2635:                 shutdownRadioUsingPhoneId(i);

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

3185:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3349:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3379:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3412:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3443:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3586:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3754:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3814:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3851:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3877:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3933:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3973:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3998:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4100:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4138:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4175:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4213:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4258:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4311:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4397:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4479:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4545:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4926:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4960:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4985:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

5153:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

5195:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

5378:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5820:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5960:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6315:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6340:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6393:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

6840:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6967:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6994:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7017:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7212:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7225:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7367:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7386:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7538:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

7787:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8319:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8501:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8546:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8674:                         slot.getPhoneId(),

8815:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8823:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8832:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8859:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8886:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8913:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

9119:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9154:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

9179:                 mPhoneConfigurationManager.getStaticPhoneCapability();

9219:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

9259:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9266:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9404:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9552:                     ImsPhoneCallTracker imsPhoneCallTracker =

9554:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

9722:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9802:         boolean isPhoneAvailable = false;

9807:                 isPhoneAvailable = true;

9813:         return isPhoneAvailable;

9975:                         } else if (isAnyPhoneInEmergencyState()) {

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

10351:                                 ImsPhoneCallTracker imsPhoneCallTracker =

10352:                                         (ImsPhoneCallTracker) tracker;

10353:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);

10731:         enforceReadPrivilegedPermission("getPhoneCapability");

10734:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

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?

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

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

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

1994:             if (phone != null) {

1995:                 phone.updateServiceLocation(workSource);

2040:             final Phone phone = getPhone(subId);

2041:             if (phone != null) {

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

2060:             final Phone phone = getPhone(subId);

2061:             if (phone != null) {

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

2078:             final Phone phone = getPhone(subId);

2079:             if (phone == null) {

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

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

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

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

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

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

2128:             phone.shutdownRadio();

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

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

2155:             final Phone phone = getPhone(subId);

2156:             if (phone != null) {

2157:                 phone.setRadioPower(turnOn);

2175:             final Phone phone = getPhone(subId);