393:         public Phone phone;

17: package com.android.phone;

201: public class PhoneInterfaceManager extends ITelephony.Stub {

1808:     private PhoneInterfaceManager(PhoneGlobals app) {

1825:     private Phone getDefaultPhone() {

1859:     private Phone getPhone(int subId) {

2502:     public String getNetworkCountryIsoForPhone(int phoneId) {

6271:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

317:     private PhoneConfigurationManager mPhoneConfigurationManager;

1839:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1847:     private Phone getPhoneFromSubId(int subId) {

2278:     private void shutdownRadioUsingPhoneId(int phoneId) {

2935:     public int getActivePhoneType() {

2940:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4618:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6338:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6876:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6886:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

403:             if (phone != null) {

404:                 this.phone = phone;

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

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

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

451:             final Phone defaultPhone = getDefaultPhone();

456:                     final Phone phone = getPhoneFromRequest(request);

475:                         request.result = phone != null

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

487:                     final Phone phone = getPhoneFromRequest(request);

488:                     request.result = phone != null ?

765:                     Phone phone = getPhoneFromRequest(request);

766:                     if (phone != null) {

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

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

804:                     Phone phone = getPhoneFromRequest(request);

805:                     if (phone != null) {

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

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

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

994:                     request.phone.setCallForwardingOption(

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

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

1461:                     Phone phone = getPhoneFromRequest(request);

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

1470:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1841:             return request.phone;

1853:         Phone phone = getPhoneFromRequest(request);

1854:         return phone == null ? null :

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

1858:     // returns phone associated with the subId.

1863:     private void sendEraseModemConfig(Phone phone) {

1864:         if (phone != null) {

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

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

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

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

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

2147:             if (phone != null) {

2148:                 phone.updateServiceLocation(workSource);

2193:             final Phone phone = getPhone(subId);

2194:             if (phone != null) {

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

2213:             final Phone phone = getPhone(subId);

2214:             if (phone != null) {

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

2231:             final Phone phone = getPhone(subId);

2232:             if (phone == null) {

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

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

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

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

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

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

2281:             phone.shutdownRadio();

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

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

2308:             final Phone phone = getPhone(subId);

2309:             if (phone != null) {

2310:                 phone.setRadioPower(turnOn);

2328:             final Phone phone = getPhone(subId);

2329:             if (phone != null) {

2330:                 phone.getDataEnabledSettings().setDataEnabled(

2349:             final Phone phone = getPhone(subId);

2350:             if (phone != null) {

2351:                 phone.getDataEnabledSettings().setDataEnabled(

2366:             final Phone phone = getPhone(subId);

2367:             if (phone != null) {

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

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

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

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

2434:             final Phone phone = getPhone(subId);

2435:             if (phone != null) {

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

2455:             final Phone phone = getPhone(subId);

2456:             if (phone != null) {

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

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

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

2508:                 // Get default phone in this case.

2509:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2514:             ServiceStateTracker sst = phone.getServiceStateTracker();

2519:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2646:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2706:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2728:         if (phone == null) {

2731:         int subId = phone.getSubId();

2739:             return phone.getImei();

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

2749:         if (phone != null) {

2750:             String imei = phone.getImei();

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

2759:         if (phone == null) {

2763:         int subId = phone.getSubId();

2771:             return phone.getMeid();

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

2781:         if (phone != null) {

2782:             String meid = phone.getMeid();

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

2792:         if (phone == null) {

2795:         int subId = phone.getSubId();

2804:             return phone.getDeviceSvn();

2814:             final Phone phone = getPhone(subId);

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

2825:             final Phone phone = getPhone(subId);

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

2836:             final Phone phone = getPhone(subId);

2837:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2838:                     : phone.getSpecificCarrierId();

2848:             final Phone phone = getPhone(subId);

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

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

2861:         if (phone == null) {

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

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

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

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

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

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

2944:             if (phone == null) {

2945:                 return PhoneConstants.PHONE_TYPE_NONE;

2947:                 return phone.getPhoneType();

2974:             final Phone phone = getPhone(subId);

2975:             if (phone != null) {

2976:                 return phone.getCdmaEriIconIndex();

3007:             final Phone phone = getPhone(subId);

3008:             if (phone != null) {

3009:                 return phone.getCdmaEriIconMode();

3038:             final Phone phone = getPhone(subId);

3039:             if (phone != null) {

3040:                 return phone.getCdmaEriText();

3059:             final Phone phone = getPhone(subId);

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

3061:                 return phone.getLine1Number();

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

3081:             final Phone phone = getPhone(subId);

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

3083:                 return phone.getCdmaMin();

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

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

3261:             final Phone phone = getPhone(subId);

3262:             if (phone != null) {

3263:                 phone.setVoiceActivationState(activationState);

3282:             final Phone phone = getPhone(subId);

3283:             if (phone != null) {

3284:                 phone.setDataActivationState(activationState);

3300:         final Phone phone = getPhone(subId);

3303:             if (phone != null) {

3304:                 return phone.getVoiceActivationState();

3320:         final Phone phone = getPhone(subId);

3323:             if (phone != null) {

3324:                 return phone.getDataActivationState();

3346:             final Phone phone = getPhone(subId);

3347:             if (phone != null) {

3348:                 return phone.getVoiceMessageCount();

3365:             final Phone phone = getPhone(subId);

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

3379:         final Phone defaultPhone = getDefaultPhone();

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

3418:                 if (phone.isInEmergencySmsMode()) {

3429:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3456:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3494:             Phone phone = getPhone(subId);

3495:             if (phone == null) {

3500:             phone.getImsRegistrationState(regState -> {

3527:             Phone phone = getPhone(subId);

3528:             if (phone == null) {

3533:             phone.getImsRegistrationTech(regTech -> {

3552:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3578:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3629:             Phone phone = getPhone(subId);

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

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

3679:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3716:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3750:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3785:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3837:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3919:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3986:         Phone phone = getPhone(subId);

3987:         if (phone == null) {

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

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

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

4430:             final Phone phone = getPhone(subId);

4431:             if (phone != null) {

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

4464:             final Phone phone = getPhone(subId);

4465:             if (phone != null) {

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

4489:             final Phone phone = getPhone(subId);

4490:             if (phone != null) {

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

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

4517:             if (phone != null) {

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

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

4534:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4553:             final Phone phone = getPhone(subId);

4554:             if (phone == null) {

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

4653:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5047:         if (phone != null) {

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

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

5073:         if (phone != null) {

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

5091:         final Phone defaultPhone = getDefaultPhone();

5423:             final Phone phone = getPhone(subId);

5424:             if (phone == null) {

5427:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5484:             Phone phone = getPhone(subId);

5485:             if (phone == null) {

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

5536:             Phone phone = getPhone(subId);

5537:             if (phone == null) {

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

5565:             Phone phone = getPhone(subId);

5566:             if (phone == null) {

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

5594:             Phone phone = getPhone(subId);

5595:             if (phone == null) {

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

5714:         final Phone defaultPhone = getDefaultPhone();

5974:         final Phone phone = getPhone(subId);

5976:             if (phone != null) {

5977:                 return phone.hasMatchedTetherApnSetting();

5997:         final Phone phone = getPhone(subId);

5999:             if (phone != null) {

6004:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

6054:             if (phone != null) {

6055:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6094:             if (phone != null) {

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

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

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

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

6133:             if (phone != null) {

6136:                     retVal = phone.isUserDataEnabled();

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

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

6155:             Phone phone) {

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

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

6171:             int subId = phone.getSubId();

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

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

6200:             int subId = phone.getSubId();

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

6218:         final Phone phone = getPhone(subId);

6219:         if (phone == null) {

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

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

6237:         final Phone phone = getPhone(subId);

6238:         if (phone == null) {

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

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

6355:         final Phone phone = getPhone(subId);

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

6376:             final Phone phone = getPhone(subId);

6377:             if (phone == null) {

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

6603:             final Phone phone = getPhone(subId);

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

6619:             final Phone phone = getPhone(subId);

6620:             if (phone == null) {

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

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

6676:         if (phone == null) {

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

6693:         final Phone defaultPhone = getDefaultPhone();

6707:         final Phone defaultPhone = getDefaultPhone();

6761:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6792:         final Phone phone = getPhone(subscriptionId);

6793:         if (phone == null) {

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

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

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

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

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

6843:         if (phone == null) {

6846:         int subId = phone.getSubId();

6854:             return phone.getDeviceId();

6867:         Phone phone = getPhone(subId);

6868:         if (phone != null) {

6869:             return phone.isImsRegistered();

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

6906:             Phone phone = getPhone(subscriptionId);

6907:             if (phone == null) {

6910:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6922:             Phone phone = getPhone(subId);

6923:             if (phone != null) {

6924:                 return phone.isWifiCallingEnabled();

6939:             Phone phone = getPhone(subId);

6940:             if (phone != null) {

6941:                 return phone.isVideoEnabled();

6957:             Phone phone = getPhone(subId);

6958:             if (phone != null) {

6959:                 return phone.getImsRegistrationTech();

7018:         final Phone phone = getPhone(subId);

7019:         if (phone == null) {

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

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

7163:             final Phone phone = getPhone(subId);

7164:             if (phone == null) {

7168:             ServiceState ss = phone.getServiceState();

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

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

7193:             if (phone == null) {

7194:                 phone = getDefaultPhone();

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

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

7217:         final Phone defaultPhone = getDefaultPhone();

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

7229:             if (phone == null) {

7230:                 phone = defaultPhone;

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

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

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

7250:             if (phone == null) {

7251:                 phone = getDefaultPhone();

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

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

7274:         final Phone defaultPhone = getDefaultPhone();

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

7286:             if (phone == null) {

7287:                 phone = defaultPhone;

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

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

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

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

7349:         Phone phone = getPhone(subId);

7353:             if (phone == null) {

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

7378:         Phone phone = getPhone(subId);

7382:             if (phone == null) {

7387:                 esn = phone.getEsn();

7406:         Phone phone = getPhone(subId);

7410:             if (phone == null) {

7415:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7509:         final Phone phone = getPhone(subId);

7512:         if (phone == null) {

7517:             phone.carrierActionSetRadioEnabled(enabled);

7537:         final Phone phone = getPhone(subId);

7540:         if (phone == null) {

7545:             phone.carrierActionReportDefaultNetworkStatus(report);

7561:         final Phone phone = getPhone(subId);

7562:         if (phone == null) {

7567:             phone.carrierActionResetAll();

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

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

7624:             Phone phone = getPhone(subId);

7625:             if (phone != null) {

7627:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

7649:         Phone phone = getPhone(subId);

7653:             if (phone != null) {

7654:                 return phone.getClientRequestStats();

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

7687:             if (phone != null) {

7688:                 phone.setSimPowerState(state, workSource);

7710:      * Check if phone is in emergency callback mode

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

7717:         final Phone phone = getPhone(subId);

7721:             if (phone != null) {

7722:                 return phone.isInEcm();

7742:             Phone p = getPhone(subId);

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

7763:         if (phone != null) {

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

7771:                 return phone.getRadioPowerState();

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

7804:             Phone phone = getPhone(subId);

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

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

7830:             Phone phone = getPhone(subId);

7831:             if (phone != null) {

7832:                 phone.setDataRoamingEnabled(isEnabled);

7848:             Phone phone = getPhone(subId);

7849:             if (phone != null) {

7850:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8015:             Phone phone = getPhone(subId);

8016:             if (phone == null) {

8019:             UiccCard uiccCard = phone.getUiccCard();

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

8064:         return Phone.PREFERRED_NT_MODE;

8074:             final Phone phone = getPhone(subId);

8075:             if (phone == null) {

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

8097:             final Phone phone = getPhone(subId);

8098:             if (phone == null) {

8102:             return phone.getCarrierIdListVersion();

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

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

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

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

8194:                             phone.getSubId(),

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

8206:         final Phone defaultPhone = getDefaultPhone();

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

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

8216:                         && phone.getEmergencyNumberTracker()

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

8238:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8260:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8279:             final Phone phone = getPhone(subId);

8280:             if (phone == null) {

8284:             return phone.getEmergencyNumberDbVersion();

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

8297:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8314:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8331:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8344:         Phone phone = getPhone(subId);

8345:         if (phone == null) {

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

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

8371:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8499:         Phone phone = getPhone(subId);

8500:         if (phone == null) {

8505:             UiccCard uiccCard = phone.getUiccCard();

8575:         Phone phone = getDefaultPhone();

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

8577:         HalVersion hv = phone.getHalVersion();

8607:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8613:             Phone phone = getPhone(subId);

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

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

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

8630:             Phone phone = getPhone(subId);

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

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

8645:             Phone phone = getPhone(subscriptionId);

8646:             if (phone == null) {

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

8746:             Phone phone = getPhone(subscriptionId);

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

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

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

8769:             Phone phone = getPhone(subscriptionId);

8770:             if (phone == null) return;

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

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

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

8800:                 Phone defaultPhone = phone.getImsPhone();

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

8846:             Phone phone = getPhone(subId);

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

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

8872:         Phone phone = getPhone(subId);

8873:         if (phone == null) {

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

8904:         Phone phone = getPhone(subId);

8905:         if (phone == null) {

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

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

8974:         Phone phone = getPhone(subId);

8975:         if (phone == null) {

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

8981:             return phone.getEquivalentHomePlmns();

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

63: import android.telecom.PhoneAccount;

64: import android.telecom.PhoneAccountHandle;

84: import android.telephony.PhoneCapability;

85: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

307:     private static PhoneInterfaceManager sInstance;

309:     private PhoneGlobals mApp;

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

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

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

754:                     defaultPhone.resetModemConfig(onCompleted);

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

1168:                     if (defaultPhone != null) {

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

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

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

1482:                     defaultPhone.rebootModem(onCompleted);

1492:                     PhoneConfigurationManager.getInstance()

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

1513:                     PhoneConfigurationManager.getInstance()

1601:                     defaultPhone.eraseModemConfig(onCompleted);

1647:                     getDefaultPhone().getContext().sendBroadcastAsUser(

1793:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1797:         synchronized (PhoneInterfaceManager.class) {

1799:                 sInstance = new PhoneInterfaceManager(app);

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

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

1819:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

2008:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2038:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2043:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2045:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2048:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2291:             if (defaultPhone != null) {

2292:                 defaultPhone.setRadioPower(turnOn);

2438:                 return PhoneConstantConversions.convertDataState(

2439:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3122:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3158:             if (phoneAccountHandle == null) {

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

3246:         SmsController smsController = PhoneFactory.getSmsController();

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

3390:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4548:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4555:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4558:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4620:         if (phoneId == -1) {

4624:         return PhoneFactory.getPhone(phoneId);

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

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

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

5099:             return defaultPhone.getPcscfAddress(apnType);

5343:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

6267:             getPhone(phoneId), pkgName);

6284:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6879:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6894:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7002:               sendEraseModemConfig(getDefaultPhone());

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

7186:      * PhoneAccount.

7189:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7212:      * PhoneAccount.

7216:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7222:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7246:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7269:      * specific PhoneAccount.

7273:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7279:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7871:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8062:             return list.get(phoneId);

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

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

8449:         PhoneCapability staticCapability =

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

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

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

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

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

8802:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8804:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8807:                             + imsPhone.getMsisdn());

8941:         // *  Inherited from PhoneWindowManager  *

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1407:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1523:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1843:             return getPhoneFromSubId(request.subId);

2177:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2271:                 shutdownRadioUsingPhoneId(i);

2796:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2936:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2966:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2999:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3030:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3171:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3339:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3399:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3436:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3462:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3519:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3559:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3584:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3684:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3721:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3755:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3790:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3842:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3924:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4006:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4070:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4422:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4456:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4481:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4649:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4691:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4874:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5286:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5414:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5738:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5787:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5832:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5880:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5902:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5908:                     getPhoneFromSubId(subId).getCarrierBandwidth();

5927:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

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

6339:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6423:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6450:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6473:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6682:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6732:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6751:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6902:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7127:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7645:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7797:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7842:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7970:                         slot.getPhoneId(),

8111:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8119:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8128:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8155:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8182:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8209:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8390:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8425:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8450:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8490:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8530:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8537:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8803:                     ImsPhoneCallTracker imsPhoneCallTracker =

8805:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

8969:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

2693:             final Phone phone = getPhone(subId);

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

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

2706:         if (phone == null) {

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

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

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

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

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

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

2789:             if (phone == null) {

2790:                 return PhoneConstants.PHONE_TYPE_NONE;

2792:                 return phone.getPhoneType();

2819:             final Phone phone = getPhone(subId);

2820:             if (phone != null) {

2821:                 return phone.getCdmaEriIconIndex();

2852:             final Phone phone = getPhone(subId);

2853:             if (phone != null) {

2854:                 return phone.getCdmaEriIconMode();

2883:             final Phone phone = getPhone(subId);

2884:             if (phone != null) {

2885:                 return phone.getCdmaEriText();

2904:             final Phone phone = getPhone(subId);

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

2906:                 return phone.getLine1Number();

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

2926:             final Phone phone = getPhone(subId);

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

2928:                 return phone.getCdmaMin();

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

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

3106:             final Phone phone = getPhone(subId);

3107:             if (phone != null) {

3108:                 phone.setVoiceActivationState(activationState);

3127:             final Phone phone = getPhone(subId);

3128:             if (phone != null) {

3129:                 phone.setDataActivationState(activationState);

3145:         final Phone phone = getPhone(subId);

3148:             if (phone != null) {

3149:                 return phone.getVoiceActivationState();

3165:         final Phone phone = getPhone(subId);

3168:             if (phone != null) {

3169:                 return phone.getDataActivationState();

3191:             final Phone phone = getPhone(subId);

3192:             if (phone != null) {

3193:                 return phone.getVoiceMessageCount();

3210:             final Phone phone = getPhone(subId);

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

3224:         final Phone defaultPhone = getDefaultPhone();

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

3263:                 if (phone.isInEmergencySmsMode()) {

3274:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3301:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3339:             Phone phone = getPhone(subId);

3340:             if (phone == null) {

3345:             phone.getImsRegistrationState(regState -> {

3372:             Phone phone = getPhone(subId);

3373:             if (phone == null) {

3378:             phone.getImsRegistrationTech(regTech -> {

3397:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.