419:         public Phone phone;

17: package com.android.phone;

215: public class PhoneInterfaceManager extends ITelephony.Stub {

2015:     private PhoneInterfaceManager(PhoneGlobals app) {

2032:     private Phone getDefaultPhone() {

2066:     private Phone getPhone(int subId) {

2709:     public String getNetworkCountryIsoForPhone(int phoneId) {

6503:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

341:     private PhoneConfigurationManager mPhoneConfigurationManager;

2046:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2054:     private Phone getPhoneFromSubId(int subId) {

2485:     private void shutdownRadioUsingPhoneId(int phoneId) {

3125:     public int getActivePhoneType() {

3130:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4810:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6570:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7159:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7169:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

429:             if (phone != null) {

430:                 this.phone = phone;

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

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

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

477:             final Phone defaultPhone = getDefaultPhone();

482:                     final Phone phone = getPhoneFromRequest(request);

501:                         request.result = phone != null

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

513:                     final Phone phone = getPhoneFromRequest(request);

514:                     request.result = phone != null ?

791:                     Phone phone = getPhoneFromRequest(request);

792:                     if (phone != null) {

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

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

830:                     Phone phone = getPhoneFromRequest(request);

831:                     if (phone != null) {

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

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

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

1020:                     request.phone.setCallForwardingOption(

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

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

1487:                     Phone phone = getPhoneFromRequest(request);

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

1497:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1585:                     Phone phone = getPhoneFromRequest(request);

1586:                     if (phone != null) {

1587:                         phone.getSystemSelectionChannels(onCompleted);

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

1713:                     Phone phone = getPhoneFromRequest(request);

1714:                     if (phone != null) {

1715:                         phone.setDataThrottling(onCompleted,

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

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

1805:                     final Phone phone = getPhoneFromRequest(request);

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

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

1816:                     phone.getServiceStateTracker().setSignalStrengthUpdateRequest(

1833:                     Phone phone = getPhoneFromRequest(request);

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

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

1844:                     phone.getServiceStateTracker().clearSignalStrengthUpdateRequest(

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

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

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

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

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

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

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

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

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

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

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

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

2048:             return request.phone;

2060:         Phone phone = getPhoneFromRequest(request);

2061:         return phone == null ? null :

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

2065:     // returns phone associated with the subId.

2070:     private void sendEraseModemConfig(Phone phone) {

2071:         if (phone != null) {

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

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

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

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

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

2354:             if (phone != null) {

2355:                 phone.updateServiceLocation(workSource);

2400:             final Phone phone = getPhone(subId);

2401:             if (phone != null) {

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

2420:             final Phone phone = getPhone(subId);

2421:             if (phone != null) {

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

2438:             final Phone phone = getPhone(subId);

2439:             if (phone == null) {

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

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

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

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

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

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

2488:             phone.shutdownRadio();

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

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

2515:             final Phone phone = getPhone(subId);

2516:             if (phone != null) {

2517:                 phone.setRadioPower(turnOn);

2535:             final Phone phone = getPhone(subId);

2536:             if (phone != null) {

2537:                 phone.getDataEnabledSettings().setDataEnabled(

2556:             final Phone phone = getPhone(subId);

2557:             if (phone != null) {

2558:                 phone.getDataEnabledSettings().setDataEnabled(

2573:             final Phone phone = getPhone(subId);

2574:             if (phone != null) {

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

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

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

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

2641:             final Phone phone = getPhone(subId);

2642:             if (phone != null) {

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

2662:             final Phone phone = getPhone(subId);

2663:             if (phone != null) {

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

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

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

2715:                 // Get default phone in this case.

2716:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2721:             ServiceStateTracker sst = phone.getServiceStateTracker();

2726:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2834:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2896:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2918:         if (phone == null) {

2921:         int subId = phone.getSubId();

2929:             return phone.getImei();

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

2939:         if (phone != null) {

2940:             String imei = phone.getImei();

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

2949:         if (phone == null) {

2953:         int subId = phone.getSubId();

2961:             return phone.getMeid();

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

2971:         if (phone != null) {

2972:             String meid = phone.getMeid();

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

2982:         if (phone == null) {

2985:         int subId = phone.getSubId();

2994:             return phone.getDeviceSvn();

3004:             final Phone phone = getPhone(subId);

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

3015:             final Phone phone = getPhone(subId);

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

3026:             final Phone phone = getPhone(subId);

3027:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3028:                     : phone.getSpecificCarrierId();

3038:             final Phone phone = getPhone(subId);

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

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

3051:         if (phone == null) {

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

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

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

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

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

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

3134:             if (phone == null) {

3135:                 return PhoneConstants.PHONE_TYPE_NONE;

3137:                 return phone.getPhoneType();

3164:             final Phone phone = getPhone(subId);

3165:             if (phone != null) {

3166:                 return phone.getCdmaEriIconIndex();

3197:             final Phone phone = getPhone(subId);

3198:             if (phone != null) {

3199:                 return phone.getCdmaEriIconMode();

3228:             final Phone phone = getPhone(subId);

3229:             if (phone != null) {

3230:                 return phone.getCdmaEriText();

3249:             final Phone phone = getPhone(subId);

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

3251:                 return phone.getLine1Number();

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

3271:             final Phone phone = getPhone(subId);

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

3273:                 return phone.getCdmaMin();

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

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

3453:             final Phone phone = getPhone(subId);

3454:             if (phone != null) {

3455:                 phone.setVoiceActivationState(activationState);

3474:             final Phone phone = getPhone(subId);

3475:             if (phone != null) {

3476:                 phone.setDataActivationState(activationState);

3492:         final Phone phone = getPhone(subId);

3495:             if (phone != null) {

3496:                 return phone.getVoiceActivationState();

3512:         final Phone phone = getPhone(subId);

3515:             if (phone != null) {

3516:                 return phone.getDataActivationState();

3538:             final Phone phone = getPhone(subId);

3539:             if (phone != null) {

3540:                 return phone.getVoiceMessageCount();

3557:             final Phone phone = getPhone(subId);

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

3571:         final Phone defaultPhone = getDefaultPhone();

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

3610:                 if (phone.isInEmergencySmsMode()) {

3621:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3648:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3686:             Phone phone = getPhone(subId);

3687:             if (phone == null) {

3692:             phone.getImsRegistrationState(regState -> {

3719:             Phone phone = getPhone(subId);

3720:             if (phone == null) {

3725:             phone.getImsRegistrationTech(regTech -> {

3744:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3770:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3821:             Phone phone = getPhone(subId);

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

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

3871:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3908:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3942:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3977:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4029:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4111:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4178:         Phone phone = getPhone(subId);

4179:         if (phone == null) {

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

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

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

4622:             final Phone phone = getPhone(subId);

4623:             if (phone != null) {

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

4656:             final Phone phone = getPhone(subId);

4657:             if (phone != null) {

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

4681:             final Phone phone = getPhone(subId);

4682:             if (phone != null) {

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

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

4709:             if (phone != null) {

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

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

4726:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4745:             final Phone phone = getPhone(subId);

4746:             if (phone == null) {

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

4845:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5239:         if (phone != null) {

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

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

5265:         if (phone != null) {

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

5283:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

5571:                     phone.setImsRegistrationState(registered);

5653:             final Phone phone = getPhone(subId);

5654:             if (phone == null) {

5657:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5714:             Phone phone = getPhone(subId);

5715:             if (phone == null) {

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

5766:             Phone phone = getPhone(subId);

5767:             if (phone == null) {

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

5795:             Phone phone = getPhone(subId);

5796:             if (phone == null) {

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

5824:             Phone phone = getPhone(subId);

5825:             if (phone == null) {

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

5944:         final Phone defaultPhone = getDefaultPhone();

6206:         final Phone phone = getPhone(subId);

6208:             if (phone != null) {

6209:                 return phone.hasMatchedTetherApnSetting();

6229:         final Phone phone = getPhone(subId);

6231:             if (phone != null) {

6236:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

6286:             if (phone != null) {

6287:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6326:             if (phone != null) {

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

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

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

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

6365:             if (phone != null) {

6368:                     retVal = phone.isUserDataEnabled();

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

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

6387:             Phone phone) {

6388:         if (uid == Process.SYSTEM_UID || uid == Process.PHONE_UID) {

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

6403:             int subId = phone.getSubId();

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

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

6432:             int subId = phone.getSubId();

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

6450:         final Phone phone = getPhone(subId);

6451:         if (phone == null) {

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

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

6469:         final Phone phone = getPhone(subId);

6470:         if (phone == null) {

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

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

6587:         final Phone phone = getPhone(subId);

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

6605:             Phone phone = getPhone(subId);

6606:             if (phone != null) {

6607:                 Phone defaultPhone = phone.getImsPhone();

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

6628:             Phone phone = getPhone(subId);

6629:             if (phone != null) {

6630:                 Phone defaultPhone = phone.getImsPhone();

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

6651:             final Phone phone = getPhone(subId);

6652:             if (phone == null) {

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

6878:             final Phone phone = getPhone(subId);

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

6894:             final Phone phone = getPhone(subId);

6895:             if (phone == null) {

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

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

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

6959:         if (phone == null) {

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

6976:         final Phone defaultPhone = getDefaultPhone();

6990:         final Phone defaultPhone = getDefaultPhone();

7044:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7075:         final Phone phone = getPhone(subscriptionId);

7076:         if (phone == null) {

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

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

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

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

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

7126:         if (phone == null) {

7129:         int subId = phone.getSubId();

7137:             return phone.getDeviceId();

7150:         Phone phone = getPhone(subId);

7151:         if (phone != null) {

7152:             return phone.isImsRegistered();

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

7189:             Phone phone = getPhone(subscriptionId);

7190:             if (phone == null) {

7193:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7205:             Phone phone = getPhone(subId);

7206:             if (phone != null) {

7207:                 return phone.isWifiCallingEnabled();

7222:             Phone phone = getPhone(subId);

7223:             if (phone != null) {

7224:                 return phone.isVideoEnabled();

7240:             Phone phone = getPhone(subId);

7241:             if (phone != null) {

7242:                 return phone.getImsRegistrationTech();

7301:         final Phone phone = getPhone(subId);

7302:         if (phone == null) {

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

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

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

7453:             final Phone phone = getPhone(subId);

7454:             if (phone == null) {

7458:             ServiceState ss = phone.getServiceState();

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

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

7483:             if (phone == null) {

7484:                 phone = getDefaultPhone();

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

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

7507:         final Phone defaultPhone = getDefaultPhone();

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

7519:             if (phone == null) {

7520:                 phone = defaultPhone;

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

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

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

7540:             if (phone == null) {

7541:                 phone = getDefaultPhone();

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

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

7564:         final Phone defaultPhone = getDefaultPhone();

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

7576:             if (phone == null) {

7577:                 phone = defaultPhone;

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

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

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

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

7639:         Phone phone = getPhone(subId);

7643:             if (phone == null) {

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

7668:         Phone phone = getPhone(subId);

7672:             if (phone == null) {

7677:                 esn = phone.getEsn();

7696:         Phone phone = getPhone(subId);

7700:             if (phone == null) {

7705:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7799:         final Phone phone = getPhone(subId);

7802:         if (phone == null) {

7807:             phone.carrierActionSetRadioEnabled(enabled);

7827:         final Phone phone = getPhone(subId);

7830:         if (phone == null) {

7835:             phone.carrierActionReportDefaultNetworkStatus(report);

7851:         final Phone phone = getPhone(subId);

7852:         if (phone == null) {

7857:             phone.carrierActionResetAll();

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

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

7914:             Phone phone = getPhone(subId);

7915:             if (phone != null) {

7917:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

7939:         Phone phone = getPhone(subId);

7943:             if (phone != null) {

7944:                 return phone.getClientRequestStats();

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

7977:             if (phone != null) {

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

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

8006:             if (phone != null) {

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

8030:      * Check if phone is in emergency callback mode

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

8037:         final Phone phone = getPhone(subId);

8041:             if (phone != null) {

8042:                 return phone.isInEcm();

8062:             Phone p = getPhone(subId);

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

8083:         if (phone != null) {

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

8091:                 return phone.getRadioPowerState();

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

8124:             Phone phone = getPhone(subId);

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

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

8150:             Phone phone = getPhone(subId);

8151:             if (phone != null) {

8152:                 phone.setDataRoamingEnabled(isEnabled);

8168:             Phone phone = getPhone(subId);

8169:             if (phone != null) {

8170:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8335:             Phone phone = getPhone(subId);

8336:             if (phone == null) {

8339:             UiccCard uiccCard = phone.getUiccCard();

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

8384:         return Phone.PREFERRED_NT_MODE;

8394:             final Phone phone = getPhone(subId);

8395:             if (phone == null) {

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

8417:             final Phone phone = getPhone(subId);

8418:             if (phone == null) {

8422:             return phone.getCarrierIdListVersion();

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

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

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

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

8514:                             phone.getSubId(),

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

8526:         final Phone defaultPhone = getDefaultPhone();

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

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

8536:                         && phone.getEmergencyNumberTracker()

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

8558:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8580:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8599:             final Phone phone = getPhone(subId);

8600:             if (phone == null) {

8604:             return phone.getEmergencyNumberDbVersion();

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

8617:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8634:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8651:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8664:         Phone phone = getPhone(subId);

8665:         if (phone == null) {

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

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

8691:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8819:         Phone phone = getPhone(subId);

8820:         if (phone == null) {

8825:             UiccCard uiccCard = phone.getUiccCard();

8895:         Phone phone = getDefaultPhone();

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

8897:         HalVersion hv = phone.getHalVersion();

8927:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8933:             Phone phone = getPhone(subId);

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

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

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

8950:             Phone phone = getPhone(subId);

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

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

8965:             Phone phone = getPhone(subscriptionId);

8966:             if (phone == null) {

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

9084:             Phone phone = getPhone(subscriptionId);

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

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

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

9107:             Phone phone = getPhone(subscriptionId);

9108:             if (phone == null) return;

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

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

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

9138:                 Phone defaultPhone = phone.getImsPhone();

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

9188:             Phone phone = getPhone(subId);

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

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

9214:         Phone phone = getPhone(subId);

9215:         if (phone == null) {

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

9246:         Phone phone = getPhone(subId);

9247:         if (phone == null) {

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

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

9316:         Phone phone = getPhone(subId);

9317:         if (phone == null) {

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

9323:             return phone.getEquivalentHomePlmns();

9384:      * @param subId the subscription ID of the phone requesting to set the radio power state.

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

9390:         Phone phone = getPhone(subId);

9391:         if (phone != null) {

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

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

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

9471:                         Phone phone = getPhone(subId);

9472:                         if (phone == null) {

9478:                         if (PhoneConstantConversions.convertCallState(phone.getState())

9480:                                 || phone.isInEmergencySmsMode() || phone.isInEcm()

9482:                             String errorMessage = "Phone state is not valid. call state = "

9483:                                     + PhoneConstantConversions.convertCallState(phone.getState())

9484:                                     + " isInEmergencySmsMode = " + phone.isInEmergencySmsMode()

9485:                                     + " isInEmergencyCallbackMode = " + phone.isInEcm();

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

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

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

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

62: import android.telecom.PhoneAccount;

63: import android.telecom.PhoneAccountHandle;

86: import android.telephony.PhoneCapability;

87: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

331:     private static PhoneInterfaceManager sInstance;

333:     private PhoneGlobals mApp;

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

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

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

780:                     defaultPhone.resetModemConfig(onCompleted);

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

1194:                     if (defaultPhone != null) {

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

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

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

1510:                     defaultPhone.rebootModem(onCompleted);

1520:                     PhoneConfigurationManager.getInstance()

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

1541:                     PhoneConfigurationManager.getInstance()

1658:                     defaultPhone.eraseModemConfig(onCompleted);

1704:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2000:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2004:         synchronized (PhoneInterfaceManager.class) {

2006:                 sInstance = new PhoneInterfaceManager(app);

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

2018:         mImsResolver = PhoneGlobals.getInstance().getImsResolver();

2026:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2185:             final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());

2198:             final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());

2215:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2245:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2250:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2252:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2255:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2498:             if (defaultPhone != null) {

2499:                 defaultPhone.setRadioPower(turnOn);

2645:                 return PhoneConstantConversions.convertDataState(

2646:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3314:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3350:             if (phoneAccountHandle == null) {

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

3438:         SmsController smsController = PhoneFactory.getSmsController();

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

3582:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4740:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4747:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4750:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4812:         if (phoneId == -1) {

4816:         return PhoneFactory.getPhone(phoneId);

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

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

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

5291:             return defaultPhone.getPcscfAddress(apnType);

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

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

5953:             return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);

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

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

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

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

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

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

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

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

6499:             getPhone(phoneId), pkgName);

6516:                 getPhone(i), pkgName);

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

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

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

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

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

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

6609:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6610:                     imsPhone.setCallComposerStatus(status);

6632:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6633:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7162:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7177:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7285:               sendEraseModemConfig(getDefaultPhone());

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

7476:      * PhoneAccount.

7479:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7502:      * PhoneAccount.

7506:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7512:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7536:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7559:      * specific PhoneAccount.

7563:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7569:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8191:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8382:             return list.get(phoneId);

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

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

8769:         PhoneCapability staticCapability =

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

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

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

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

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

9140:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9142:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9145:                             + imsPhone.getMsisdn());

9283:         // *  Inherited from PhoneWindowManager  *

9382:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

9803:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

874:                     getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);

902:                     getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);

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

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

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

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

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

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

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

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

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

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

1433:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1551:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2050:             return getPhoneFromSubId(request.subId);

2384:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2478:                 shutdownRadioUsingPhoneId(i);

2986:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3126:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3156:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3189:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3220:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3363:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3531:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3591:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3628:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3654:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3711:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3751:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3776:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3876:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3913:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3947:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3982:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4034:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4116:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4198:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4262:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4614:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4648:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4673:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4841:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4883:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

5066:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5508:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5644:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5968:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6019:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6064:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

6112:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6134:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6140:                     getPhoneFromSubId(subId).getCarrierBandwidth();

6159:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6163:             return getPhoneFromSubId(subId).getEffectiveAllowedNetworkTypes();

6185:             getPhoneFromSubId(subId).setAllowedNetworkTypes(reason, allowedNetworkTypes);

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

6571:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6698:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6725:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6748:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6952:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6965:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7015:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7034:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7185:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7410:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7935:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8117:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8162:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8290:                         slot.getPhoneId(),

8431:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8439:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8448:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8475:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8502:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8529:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8710:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8745:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8770:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8810:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8850:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8857:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

8995:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9141:                     ImsPhoneCallTracker imsPhoneCallTracker =

9143:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

9311:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9333:                 mPhoneConfigurationManager.getRadioInterfaceCapabilities();

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

2176:             if (phone != null) {

2177:                 phone.getDataEnabledSettings().setUserDataEnabled(true);

2195:             final Phone phone = getPhone(subId);

2196:             if (phone != null) {

2197:                 phone.getDataEnabledSettings().setUserDataEnabled(false);

2211:             final Phone phone = getPhone(subId);

2212:             if (phone != null) {

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

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

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

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

2279:             final Phone phone = getPhone(subId);

2280:             if (phone != null) {

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

2300:             final Phone phone = getPhone(subId);

2301:             if (phone != null) {

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

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

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

2353:                 // Get default phone in this case.

2354:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2359:             ServiceStateTracker sst = phone.getServiceStateTracker();

2364:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2491:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2551:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2573:         if (phone == null) {

2576:         int subId = phone.getSubId();

2584:             return phone.getImei();

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

2594:         if (phone != null) {

2595:             String imei = phone.getImei();

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

2604:         if (phone == null) {

2608:         int subId = phone.getSubId();

2616:             return phone.getMeid();

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

2626:         if (phone != null) {

2627:             String meid = phone.getMeid();

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

2637:         if (phone == null) {

2640:         int subId = phone.getSubId();

2649:             return phone.getDeviceSvn();

2659:             final Phone phone = getPhone(subId);

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

2670:             final Phone phone = getPhone(subId);

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

2681:             final Phone phone = getPhone(subId);

2682:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2683:                     : phone.getSpecificCarrierId();