384:         public Phone phone;

17: package com.android.phone;

200: 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) {

5947:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

310:     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) {

6014:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6554:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6564:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

180: 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.

3423:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3474:             Phone phone = getPhone(subId);

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

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

3524:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3561:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3595:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3630:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3682:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3764:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3831:         Phone phone = getPhone(subId);

3832:         if (phone == null) {

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

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

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

4275:             final Phone phone = getPhone(subId);

4276:             if (phone != null) {

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

4309:             final Phone phone = getPhone(subId);

4310:             if (phone != null) {

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

4334:             final Phone phone = getPhone(subId);

4335:             if (phone != null) {

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

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

4362:             if (phone != null) {

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

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

4379:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4398:             final Phone phone = getPhone(subId);

4399:             if (phone == null) {

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

4498:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4892:         if (phone != null) {

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

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

4918:         if (phone != null) {

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

4936:         final Phone defaultPhone = getDefaultPhone();

5291:             final Phone phone = getPhone(subId);

5292:             if (phone == null) {

5295:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5507:         final Phone defaultPhone = getDefaultPhone();

5693:         final Phone phone = getPhone(subId);

5695:             if (phone != null) {

5696:                 return phone.hasMatchedTetherApnSetting();

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

5721:             if (phone != null) {

5723:                 phone.getDataEnabledSettings().setUserDataEnabled(enable);

5725:                 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);

5743:         final Phone phone = getPhone(subId);

5745:             if (phone != null) {

5750:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

5800:             if (phone != null) {

5801:                 boolean retVal = phone.isUserDataEnabled();

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

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

5829:             if (phone != null) {

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

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

5843:             Phone phone) {

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

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

5859:             SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());

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

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

5882:             SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());

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

5894:         final Phone phone = getPhone(subId);

5895:         if (phone == null) {

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

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

5913:         final Phone phone = getPhone(subId);

5914:         if (phone == null) {

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

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

6031:         final Phone phone = getPhone(subId);

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

6054:             final Phone phone = getPhone(subId);

6055:             if (phone == null) {

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

6281:             final Phone phone = getPhone(subId);

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

6297:             final Phone phone = getPhone(subId);

6298:             if (phone == null) {

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

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

6354:         if (phone == null) {

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

6371:         final Phone defaultPhone = getDefaultPhone();

6385:         final Phone defaultPhone = getDefaultPhone();

6439:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6470:         final Phone phone = getPhone(subscriptionId);

6471:         if (phone == null) {

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

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

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

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

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

6521:         if (phone == null) {

6524:         int subId = phone.getSubId();

6532:             return phone.getDeviceId();

6545:         Phone phone = getPhone(subId);

6546:         if (phone != null) {

6547:             return phone.isImsRegistered();

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

6584:             Phone phone = getPhone(subscriptionId);

6585:             if (phone == null) {

6588:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6600:             Phone phone = getPhone(subId);

6601:             if (phone != null) {

6602:                 return phone.isWifiCallingEnabled();

6617:             Phone phone = getPhone(subId);

6618:             if (phone != null) {

6619:                 return phone.isVideoEnabled();

6635:             Phone phone = getPhone(subId);

6636:             if (phone != null) {

6637:                 return phone.getImsRegistrationTech();

6695:         final Phone phone = getPhone(subId);

6696:         if (phone == null) {

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

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

6840:             final Phone phone = getPhone(subId);

6841:             if (phone == null) {

6845:             ServiceState ss = phone.getServiceState();

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

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

6870:             if (phone == null) {

6871:                 phone = getDefaultPhone();

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

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

6894:         final Phone defaultPhone = getDefaultPhone();

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

6906:             if (phone == null) {

6907:                 phone = defaultPhone;

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

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

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

6927:             if (phone == null) {

6928:                 phone = getDefaultPhone();

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

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

6951:         final Phone defaultPhone = getDefaultPhone();

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

6963:             if (phone == null) {

6964:                 phone = defaultPhone;

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

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

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

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

7026:         Phone phone = getPhone(subId);

7030:             if (phone == null) {

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

7055:         Phone phone = getPhone(subId);

7059:             if (phone == null) {

7064:                 esn = phone.getEsn();

7083:         Phone phone = getPhone(subId);

7087:             if (phone == null) {

7092:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7186:         final Phone phone = getPhone(subId);

7189:         if (phone == null) {

7194:             phone.carrierActionSetMeteredApnsEnabled(enabled);

7211:         final Phone phone = getPhone(subId);

7214:         if (phone == null) {

7219:             phone.carrierActionSetRadioEnabled(enabled);

7239:         final Phone phone = getPhone(subId);

7242:         if (phone == null) {

7247:             phone.carrierActionReportDefaultNetworkStatus(report);

7263:         final Phone phone = getPhone(subId);

7264:         if (phone == null) {

7269:             phone.carrierActionResetAll();

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

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

7314:             Phone phone = getPhone(subId);

7315:             if (phone != null) {

7316:                 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);

7335:         Phone phone = getPhone(subId);

7339:             if (phone != null) {

7340:                 return phone.getClientRequestStats();

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

7373:             if (phone != null) {

7374:                 phone.setSimPowerState(state, workSource);

7396:      * Check if phone is in emergency callback mode

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

7403:         final Phone phone = getPhone(subId);

7407:             if (phone != null) {

7408:                 return phone.isInEcm();

7428:             Phone p = getPhone(subId);

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

7449:         if (phone != null) {

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

7457:                 return phone.getRadioPowerState();

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

7490:             Phone phone = getPhone(subId);

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

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

7516:             Phone phone = getPhone(subId);

7517:             if (phone != null) {

7518:                 phone.setDataRoamingEnabled(isEnabled);

7534:             Phone phone = getPhone(subId);

7535:             if (phone != null) {

7536:                 isAllowed = phone.isCspPlmnEnabled();

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

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

7701:             Phone phone = getPhone(subId);

7702:             if (phone == null) {

7705:             UiccCard uiccCard = phone.getUiccCard();

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

7750:         return Phone.PREFERRED_NT_MODE;

7760:             final Phone phone = getPhone(subId);

7761:             if (phone == null) {

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

7778:             final Phone phone = getPhone(subId);

7779:             if (phone == null) {

7783:             return phone.getCarrierIdListVersion();

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

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

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

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

7861:                             phone.getSubId(),

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

7873:         final Phone defaultPhone = getDefaultPhone();

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

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

7883:                         && phone.getEmergencyNumberTracker() != null) {

7884:                     if (phone.getEmergencyNumberTracker().isEmergencyNumber(

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

7907:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7929:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7948:             final Phone phone = getPhone(subId);

7949:             if (phone == null) {

7953:             return phone.getEmergencyNumberDbVersion();

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

7966:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7983:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8000:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8013:         Phone phone = getPhone(subId);

8014:         if (phone == null) {

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

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

8040:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8168:         Phone phone = getPhone(subId);

8169:         if (phone == null) {

8174:             UiccCard uiccCard = phone.getUiccCard();

8244:         Phone phone = getDefaultPhone();

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

8246:         HalVersion hv = phone.getHalVersion();

8276:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8282:             Phone phone = getPhone(subId);

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

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

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

8299:             Phone phone = getPhone(subId);

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

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

8314:             Phone phone = getPhone(subscriptionId);

8315:             if (phone == null) {

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

8416:             Phone phone = getPhone(subId);

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

8419:             return phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(allow);

8432:             Phone phone = getPhone(subId);

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

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

8448:             Phone phone = getPhone(subId);

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

8451:             return phone.getDataEnabledSettings().setAlwaysAllowMmsData(alwaysAllow);

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

8470:                 Phone defaultPhone = phone.getImsPhone();

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

8516:             Phone phone = getPhone(subId);

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

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

8542:         Phone phone = getPhone(subId);

8543:         if (phone == null) {

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

8574:         Phone phone = getPhone(subId);

8575:         if (phone == null) {

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

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

63: import android.telecom.PhoneAccount;

64: import android.telecom.PhoneAccountHandle;

83: import android.telephony.PhoneCapability;

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

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

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

300:     private static PhoneInterfaceManager sInstance;

302:     private PhoneGlobals mApp;

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

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

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

745:                     defaultPhone.resetModemConfig(onCompleted);

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

1031:                     if (defaultPhone != null) {

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

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

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

1329:                     defaultPhone.rebootModem(onCompleted);

1339:                     PhoneConfigurationManager.getInstance()

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

1360:                     PhoneConfigurationManager.getInstance()

1448:                     defaultPhone.eraseModemConfig(onCompleted);

1494:                     getDefaultPhone().getContext().sendBroadcastAsUser(

1640:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1644:         synchronized (PhoneInterfaceManager.class) {

1646:                 sInstance = new PhoneInterfaceManager(app);

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

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

1666:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

1855:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1885:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

1890:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

1892:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1895:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2138:             if (defaultPhone != null) {

2139:                 defaultPhone.setRadioPower(turnOn);

2283:                 return PhoneConstantConversions.convertDataState(

2284:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

2967:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3003:             if (phoneAccountHandle == null) {

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

3091:         SmsController smsController = PhoneFactory.getSmsController();

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

3235:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4393:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4400:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4403:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4465:         if (phoneId == -1) {

4469:         return PhoneFactory.getPhone(phoneId);

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

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

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

4944:             return defaultPhone.getPcscfAddress(apnType);

5211:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

5719:             if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);

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

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

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

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

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

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

5943:             getPhone(phoneId), pkgName);

5960:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6557:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6572:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6679:               sendEraseModemConfig(getDefaultPhone());

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

6863:      * PhoneAccount.

6866:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6889:      * PhoneAccount.

6893:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

6899:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

6923:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

6946:      * specific PhoneAccount.

6950:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

6956:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7557:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

7748:             return list.get(phoneId);

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

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

8118:         PhoneCapability staticCapability =

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

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

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

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

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

8472:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8474:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8477:                             + imsPhone.getMsisdn());

8611:         // *  Inherited from PhoneWindowManager  *

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

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

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

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

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

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

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

836:                     getPhoneFromRequest(request).getCallForwardingOption(

893:                     getPhoneFromRequest(request).setCallForwardingOption(

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

959:                     getPhoneFromRequest(request).setCallWaiting(isEnable, onCompleted);

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

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

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

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

1255:                     getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);

1370:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1690:             return getPhoneFromSubId(request.subId);

2024:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2118:                 shutdownRadioUsingPhoneId(i);

2641:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2781:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2811:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2844:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2875:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3016:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3184:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3244:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3281:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3307:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3364:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3404:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3429:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3529:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3566:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3600:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3635:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3687:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3769:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3851:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3915:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4267:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4301:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4326:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4494:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4536:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4719:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5154:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5282:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5531:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5580:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5625:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5646:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

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

6015:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6101:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6128:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6151:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6360:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6410:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6429:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6580:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

6804:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7331:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7483:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7528:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7656:                         slot.getPhoneId(),

7792:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7800:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7809:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7849:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7876:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8059:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8094:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8119:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8159:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8199:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8206:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8473:                     ImsPhoneCallTracker imsPhoneCallTracker =

8475:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

378:         public Phone phone;

17: package com.android.phone;

199: public class PhoneInterfaceManager extends ITelephony.Stub {

1641:     /* package */ PhoneInterfaceManager(PhoneGlobals app) {

1657:     private Phone getDefaultPhone() {

1688:     private Phone getPhone(int subId) {

2296:     public String getNetworkCountryIsoForPhone(int phoneId) {

5783:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1668:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1676:     private Phone getPhoneFromSubId(int subId) {

2074:     private void shutdownRadioUsingPhoneId(int phoneId) {

2736:     public int getActivePhoneType() {

2741:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4418:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5850:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6390:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6400:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

388:             if (phone != null) {

389:                 this.phone = phone;

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

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

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

436:             final Phone defaultPhone = getDefaultPhone();

441:                     final Phone phone = getPhoneFromRequest(request);

460:                         request.result = phone != null

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

472:                     final Phone phone = getPhoneFromRequest(request);

473:                     request.result = phone != null ?

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

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

1300:                     Phone phone = getPhoneFromRequest(request);

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

1309:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1665:         ServiceManager.addService("phone", this);

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

1670:             return request.phone;

1682:         Phone phone = getPhoneFromRequest(request);

1683:         return phone == null ? null :

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

1687:     // returns phone associated with the subId.

1692:     private void sendEraseModemConfig(Phone phone) {

1693:         if (phone != null) {

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

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

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

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

1943:             final Phone phone = getPhone(subId);

1944:             if (phone != null) {

1945:                 phone.updateServiceLocation();

1989:             final Phone phone = getPhone(subId);

1990:             if (phone != null) {

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

2009:             final Phone phone = getPhone(subId);

2010:             if (phone != null) {

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

2027:             final Phone phone = getPhone(subId);

2028:             if (phone == null) {

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

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

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

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

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

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

2077:             phone.shutdownRadio();

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

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

2104:             final Phone phone = getPhone(subId);

2105:             if (phone != null) {

2106:                 phone.setRadioPower(turnOn);

2124:             final Phone phone = getPhone(subId);

2125:             if (phone != null) {

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

2144:             final Phone phone = getPhone(subId);

2145:             if (phone != null) {

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

2160:             final Phone phone = getPhone(subId);

2161:             if (phone != null) {

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

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

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

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

2228:             final Phone phone = getPhone(subId);

2229:             if (phone != null) {

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

2249:             final Phone phone = getPhone(subId);

2250:             if (phone != null) {

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

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

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

2302:                 // Get default phone in this case.

2303:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2308:             ServiceStateTracker sst = phone.getServiceStateTracker();

2313:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

2332:             final Phone phone = getPhone(subId);

2333:             if (phone != null) {

2334:                 phone.enableLocationUpdates();

2353:             final Phone phone = getPhone(subId);

2354:             if (phone != null) {

2355:                 phone.disableLocationUpdates();

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

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

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

2456:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2507:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2529:         if (phone == null) {

2532:         int subId = phone.getSubId();

2540:             return phone.getImei();

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

2550:         if (phone != null) {

2551:             String imei = phone.getImei();

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

2560:         if (phone == null) {

2564:         int subId = phone.getSubId();

2572:             return phone.getMeid();

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

2582:         if (phone != null) {

2583:             String meid = phone.getMeid();

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

2593:         if (phone == null) {

2596:         int subId = phone.getSubId();

2605:             return phone.getDeviceSvn();

2615:             final Phone phone = getPhone(subId);

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

2626:             final Phone phone = getPhone(subId);

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

2637:             final Phone phone = getPhone(subId);

2638:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2639:                     : phone.getSpecificCarrierId();

2649:             final Phone phone = getPhone(subId);

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

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

2662:         if (phone == null) {

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

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

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

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

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

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

2745:             if (phone == null) {

2746:                 return PhoneConstants.PHONE_TYPE_NONE;

2748:                 return phone.getPhoneType();

2775:             final Phone phone = getPhone(subId);

2776:             if (phone != null) {

2777:                 return phone.getCdmaEriIconIndex();

2808:             final Phone phone = getPhone(subId);

2809:             if (phone != null) {

2810:                 return phone.getCdmaEriIconMode();

2839:             final Phone phone = getPhone(subId);

2840:             if (phone != null) {

2841:                 return phone.getCdmaEriText();

2860:             final Phone phone = getPhone(subId);

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

2862:                 return phone.getLine1Number();

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

2882:             final Phone phone = getPhone(subId);

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

2884:                 return phone.getCdmaMin();

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

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

3062:             final Phone phone = getPhone(subId);

3063:             if (phone != null) {

3064:                 phone.setVoiceActivationState(activationState);

3083:             final Phone phone = getPhone(subId);

3084:             if (phone != null) {

3085:                 phone.setDataActivationState(activationState);

3101:         final Phone phone = getPhone(subId);

3104:             if (phone != null) {

3105:                 return phone.getVoiceActivationState();

3121:         final Phone phone = getPhone(subId);

3124:             if (phone != null) {

3125:                 return phone.getDataActivationState();

3147:             final Phone phone = getPhone(subId);

3148:             if (phone != null) {

3149:                 return phone.getVoiceMessageCount();

3166:             final Phone phone = getPhone(subId);

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

3180:         final Phone defaultPhone = getDefaultPhone();

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

3219:                 if (phone.isInEmergencySmsMode()) {

3230:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3257:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3295:             Phone phone = getPhone(subId);

3296:             if (phone == null) {

3301:             phone.getImsRegistrationState(regState -> {

3328:             Phone phone = getPhone(subId);

3329:             if (phone == null) {

3334:             phone.getImsRegistrationTech(regTech -> {

3353:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3379:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3430:             Phone phone = getPhone(subId);

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

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

3480:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3517:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3551:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3586:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3638:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3720:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3787:         Phone phone = getPhone(subId);

3788:         if (phone == null) {

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

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

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

4231:             final Phone phone = getPhone(subId);

4232:             if (phone != null) {

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

4265:             final Phone phone = getPhone(subId);

4266:             if (phone != null) {

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

4290:             final Phone phone = getPhone(subId);