386:         public Phone phone;

17: package com.android.phone;

200: public class PhoneInterfaceManager extends ITelephony.Stub {

1701:     private PhoneInterfaceManager(PhoneGlobals app) {

1718:     private Phone getDefaultPhone() {

1752:     private Phone getPhone(int subId) {

2393:     public String getNetworkCountryIsoForPhone(int phoneId) {

6057:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

310:     private PhoneConfigurationManager mPhoneConfigurationManager;

1732:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1740:     private Phone getPhoneFromSubId(int subId) {

2171:     private void shutdownRadioUsingPhoneId(int phoneId) {

2826:     public int getActivePhoneType() {

2831:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4509:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6124:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6664:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6674:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

396:             if (phone != null) {

397:                 this.phone = phone;

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

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

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

444:             final Phone defaultPhone = getDefaultPhone();

449:                     final Phone phone = getPhoneFromRequest(request);

468:                         request.result = phone != null

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

480:                     final Phone phone = getPhoneFromRequest(request);

481:                     request.result = phone != null ?

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

903:                     request.phone.setCallForwardingOption(

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

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

1354:                     Phone phone = getPhoneFromRequest(request);

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

1363:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1734:             return request.phone;

1746:         Phone phone = getPhoneFromRequest(request);

1747:         return phone == null ? null :

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

1751:     // returns phone associated with the subId.

1756:     private void sendEraseModemConfig(Phone phone) {

1757:         if (phone != null) {

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

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

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

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

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

2040:             if (phone != null) {

2041:                 phone.updateServiceLocation(workSource);

2086:             final Phone phone = getPhone(subId);

2087:             if (phone != null) {

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

2106:             final Phone phone = getPhone(subId);

2107:             if (phone != null) {

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

2124:             final Phone phone = getPhone(subId);

2125:             if (phone == null) {

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

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

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

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

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

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

2174:             phone.shutdownRadio();

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

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

2201:             final Phone phone = getPhone(subId);

2202:             if (phone != null) {

2203:                 phone.setRadioPower(turnOn);

2221:             final Phone phone = getPhone(subId);

2222:             if (phone != null) {

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

2241:             final Phone phone = getPhone(subId);

2242:             if (phone != null) {

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

2257:             final Phone phone = getPhone(subId);

2258:             if (phone != null) {

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

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

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

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

2325:             final Phone phone = getPhone(subId);

2326:             if (phone != null) {

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

2346:             final Phone phone = getPhone(subId);

2347:             if (phone != null) {

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

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

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

2399:                 // Get default phone in this case.

2400:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2405:             ServiceStateTracker sst = phone.getServiceStateTracker();

2410:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2537:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2597:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2619:         if (phone == null) {

2622:         int subId = phone.getSubId();

2630:             return phone.getImei();

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

2640:         if (phone != null) {

2641:             String imei = phone.getImei();

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

2650:         if (phone == null) {

2654:         int subId = phone.getSubId();

2662:             return phone.getMeid();

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

2672:         if (phone != null) {

2673:             String meid = phone.getMeid();

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

2683:         if (phone == null) {

2686:         int subId = phone.getSubId();

2695:             return phone.getDeviceSvn();

2705:             final Phone phone = getPhone(subId);

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

2716:             final Phone phone = getPhone(subId);

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

2727:             final Phone phone = getPhone(subId);

2728:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2729:                     : phone.getSpecificCarrierId();

2739:             final Phone phone = getPhone(subId);

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

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

2752:         if (phone == null) {

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

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

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

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

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

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

2835:             if (phone == null) {

2836:                 return PhoneConstants.PHONE_TYPE_NONE;

2838:                 return phone.getPhoneType();

2865:             final Phone phone = getPhone(subId);

2866:             if (phone != null) {

2867:                 return phone.getCdmaEriIconIndex();

2898:             final Phone phone = getPhone(subId);

2899:             if (phone != null) {

2900:                 return phone.getCdmaEriIconMode();

2929:             final Phone phone = getPhone(subId);

2930:             if (phone != null) {

2931:                 return phone.getCdmaEriText();

2950:             final Phone phone = getPhone(subId);

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

2952:                 return phone.getLine1Number();

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

2972:             final Phone phone = getPhone(subId);

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

2974:                 return phone.getCdmaMin();

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

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

3152:             final Phone phone = getPhone(subId);

3153:             if (phone != null) {

3154:                 phone.setVoiceActivationState(activationState);

3173:             final Phone phone = getPhone(subId);

3174:             if (phone != null) {

3175:                 phone.setDataActivationState(activationState);

3191:         final Phone phone = getPhone(subId);

3194:             if (phone != null) {

3195:                 return phone.getVoiceActivationState();

3211:         final Phone phone = getPhone(subId);

3214:             if (phone != null) {

3215:                 return phone.getDataActivationState();

3237:             final Phone phone = getPhone(subId);

3238:             if (phone != null) {

3239:                 return phone.getVoiceMessageCount();

3256:             final Phone phone = getPhone(subId);

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

3270:         final Phone defaultPhone = getDefaultPhone();

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

3309:                 if (phone.isInEmergencySmsMode()) {

3320:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3347:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3385:             Phone phone = getPhone(subId);

3386:             if (phone == null) {

3391:             phone.getImsRegistrationState(regState -> {

3418:             Phone phone = getPhone(subId);

3419:             if (phone == null) {

3424:             phone.getImsRegistrationTech(regTech -> {

3443:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3469:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3520:             Phone phone = getPhone(subId);

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

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

3570:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3607:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3641:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3676:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3728:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3810:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3877:         Phone phone = getPhone(subId);

3878:         if (phone == null) {

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

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

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

4321:             final Phone phone = getPhone(subId);

4322:             if (phone != null) {

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

4355:             final Phone phone = getPhone(subId);

4356:             if (phone != null) {

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

4380:             final Phone phone = getPhone(subId);

4381:             if (phone != null) {

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

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

4408:             if (phone != null) {

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

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

4425:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4444:             final Phone phone = getPhone(subId);

4445:             if (phone == null) {

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

4544:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4938:         if (phone != null) {

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

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

4964:         if (phone != null) {

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

4982:         final Phone defaultPhone = getDefaultPhone();

5314:             final Phone phone = getPhone(subId);

5315:             if (phone == null) {

5318:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5375:             Phone phone = getPhone(subId);

5376:             if (phone == null) {

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

5427:             Phone phone = getPhone(subId);

5428:             if (phone == null) {

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

5456:             Phone phone = getPhone(subId);

5457:             if (phone == null) {

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

5485:             Phone phone = getPhone(subId);

5486:             if (phone == null) {

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

5605:         final Phone defaultPhone = getDefaultPhone();

5791:         final Phone phone = getPhone(subId);

5793:             if (phone != null) {

5794:                 return phone.hasMatchedTetherApnSetting();

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

5819:             if (phone != null) {

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

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

5841:         final Phone phone = getPhone(subId);

5843:             if (phone != null) {

5848:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

5898:             if (phone != null) {

5899:                 boolean retVal = phone.isUserDataEnabled();

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

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

5927:             if (phone != null) {

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

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

5941:             Phone phone) {

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

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

5957:             int subId = phone.getSubId();

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

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

5986:             int subId = phone.getSubId();

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

6004:         final Phone phone = getPhone(subId);

6005:         if (phone == null) {

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

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

6023:         final Phone phone = getPhone(subId);

6024:         if (phone == null) {

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

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

6141:         final Phone phone = getPhone(subId);

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

6164:             final Phone phone = getPhone(subId);

6165:             if (phone == null) {

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

6391:             final Phone phone = getPhone(subId);

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

6407:             final Phone phone = getPhone(subId);

6408:             if (phone == null) {

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

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

6464:         if (phone == null) {

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

6481:         final Phone defaultPhone = getDefaultPhone();

6495:         final Phone defaultPhone = getDefaultPhone();

6549:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6580:         final Phone phone = getPhone(subscriptionId);

6581:         if (phone == null) {

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

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

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

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

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

6631:         if (phone == null) {

6634:         int subId = phone.getSubId();

6642:             return phone.getDeviceId();

6655:         Phone phone = getPhone(subId);

6656:         if (phone != null) {

6657:             return phone.isImsRegistered();

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

6694:             Phone phone = getPhone(subscriptionId);

6695:             if (phone == null) {

6698:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6710:             Phone phone = getPhone(subId);

6711:             if (phone != null) {

6712:                 return phone.isWifiCallingEnabled();

6727:             Phone phone = getPhone(subId);

6728:             if (phone != null) {

6729:                 return phone.isVideoEnabled();

6745:             Phone phone = getPhone(subId);

6746:             if (phone != null) {

6747:                 return phone.getImsRegistrationTech();

6805:         final Phone phone = getPhone(subId);

6806:         if (phone == null) {

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

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

6950:             final Phone phone = getPhone(subId);

6951:             if (phone == null) {

6955:             ServiceState ss = phone.getServiceState();

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

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

6980:             if (phone == null) {

6981:                 phone = getDefaultPhone();

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

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

7004:         final Phone defaultPhone = getDefaultPhone();

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

7016:             if (phone == null) {

7017:                 phone = defaultPhone;

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

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

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

7037:             if (phone == null) {

7038:                 phone = getDefaultPhone();

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

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

7061:         final Phone defaultPhone = getDefaultPhone();

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

7073:             if (phone == null) {

7074:                 phone = defaultPhone;

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

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

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

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

7136:         Phone phone = getPhone(subId);

7140:             if (phone == null) {

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

7165:         Phone phone = getPhone(subId);

7169:             if (phone == null) {

7174:                 esn = phone.getEsn();

7193:         Phone phone = getPhone(subId);

7197:             if (phone == null) {

7202:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7296:         final Phone phone = getPhone(subId);

7299:         if (phone == null) {

7304:             phone.carrierActionSetMeteredApnsEnabled(enabled);

7321:         final Phone phone = getPhone(subId);

7324:         if (phone == null) {

7329:             phone.carrierActionSetRadioEnabled(enabled);

7349:         final Phone phone = getPhone(subId);

7352:         if (phone == null) {

7357:             phone.carrierActionReportDefaultNetworkStatus(report);

7373:         final Phone phone = getPhone(subId);

7374:         if (phone == null) {

7379:             phone.carrierActionResetAll();

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

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

7424:             Phone phone = getPhone(subId);

7425:             if (phone != null) {

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

7445:         Phone phone = getPhone(subId);

7449:             if (phone != null) {

7450:                 return phone.getClientRequestStats();

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

7483:             if (phone != null) {

7484:                 phone.setSimPowerState(state, workSource);

7506:      * Check if phone is in emergency callback mode

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

7513:         final Phone phone = getPhone(subId);

7517:             if (phone != null) {

7518:                 return phone.isInEcm();

7538:             Phone p = getPhone(subId);

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

7559:         if (phone != null) {

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

7567:                 return phone.getRadioPowerState();

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

7600:             Phone phone = getPhone(subId);

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

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

7626:             Phone phone = getPhone(subId);

7627:             if (phone != null) {

7628:                 phone.setDataRoamingEnabled(isEnabled);

7644:             Phone phone = getPhone(subId);

7645:             if (phone != null) {

7646:                 isAllowed = phone.isCspPlmnEnabled();

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

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

7811:             Phone phone = getPhone(subId);

7812:             if (phone == null) {

7815:             UiccCard uiccCard = phone.getUiccCard();

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

7860:         return Phone.PREFERRED_NT_MODE;

7870:             final Phone phone = getPhone(subId);

7871:             if (phone == null) {

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

7893:             final Phone phone = getPhone(subId);

7894:             if (phone == null) {

7898:             return phone.getCarrierIdListVersion();

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

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

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

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

7976:                             phone.getSubId(),

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

7988:         final Phone defaultPhone = getDefaultPhone();

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

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

7998:                         && phone.getEmergencyNumberTracker()

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

8020:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8042:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8061:             final Phone phone = getPhone(subId);

8062:             if (phone == null) {

8066:             return phone.getEmergencyNumberDbVersion();

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

8079:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8096:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8113:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8126:         Phone phone = getPhone(subId);

8127:         if (phone == null) {

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

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

8153:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8281:         Phone phone = getPhone(subId);

8282:         if (phone == null) {

8287:             UiccCard uiccCard = phone.getUiccCard();

8357:         Phone phone = getDefaultPhone();

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

8359:         HalVersion hv = phone.getHalVersion();

8389:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8395:             Phone phone = getPhone(subId);

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

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

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

8412:             Phone phone = getPhone(subId);

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

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

8427:             Phone phone = getPhone(subscriptionId);

8428:             if (phone == null) {

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

8528:             Phone phone = getPhone(subscriptionId);

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

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

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

8551:             Phone phone = getPhone(subscriptionId);

8552:             if (phone == null) return;

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

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

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

8582:                 Phone defaultPhone = phone.getImsPhone();

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

8628:             Phone phone = getPhone(subId);

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

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

8654:         Phone phone = getPhone(subId);

8655:         if (phone == null) {

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

8686:         Phone phone = getPhone(subId);

8687:         if (phone == null) {

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

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

8756:         Phone phone = getPhone(subId);

8757:         if (phone == null) {

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

8763:             return phone.getEquivalentHomePlmns();

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;

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

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

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

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

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

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

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

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

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

747:                     defaultPhone.resetModemConfig(onCompleted);

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

1077:                     if (defaultPhone != null) {

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

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

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

1375:                     defaultPhone.rebootModem(onCompleted);

1385:                     PhoneConfigurationManager.getInstance()

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

1406:                     PhoneConfigurationManager.getInstance()

1494:                     defaultPhone.eraseModemConfig(onCompleted);

1540:                     getDefaultPhone().getContext().sendBroadcastAsUser(

1686:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1690:         synchronized (PhoneInterfaceManager.class) {

1692:                 sInstance = new PhoneInterfaceManager(app);

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

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

1712:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

1901:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1931:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

1936:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

1938:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1941:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2184:             if (defaultPhone != null) {

2185:                 defaultPhone.setRadioPower(turnOn);

2329:                 return PhoneConstantConversions.convertDataState(

2330:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3013:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3049:             if (phoneAccountHandle == null) {

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

3137:         SmsController smsController = PhoneFactory.getSmsController();

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

3281:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4439:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4446:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4449:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4511:         if (phoneId == -1) {

4515:         return PhoneFactory.getPhone(phoneId);

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

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

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

4990:             return defaultPhone.getPcscfAddress(apnType);

5234:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

6053:             getPhone(phoneId), pkgName);

6070:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6667:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6682:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6789:               sendEraseModemConfig(getDefaultPhone());

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

6973:      * PhoneAccount.

6976:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6999:      * PhoneAccount.

7003:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7009:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7033:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7056:      * specific PhoneAccount.

7060:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7066:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7667:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

7858:             return list.get(phoneId);

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

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

8231:         PhoneCapability staticCapability =

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

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

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

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

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

8584:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8586:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8589:                             + imsPhone.getMsisdn());

8723:         // *  Inherited from PhoneWindowManager  *

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1416:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1736:             return getPhoneFromSubId(request.subId);

2070:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2164:                 shutdownRadioUsingPhoneId(i);

2687:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2827:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2857:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2890:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2921:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3062:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3230:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3290:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3327:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3353:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3410:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3450:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3475:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3575:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3612:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3646:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3681:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3733:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3815:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3897:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3961:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4313:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4347:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4372:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4540:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4582:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4765:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5177:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5305:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5629:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5678:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5723:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5744:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

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

6125:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6211:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6238:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6261:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6470:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6520:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6539:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6690:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

6914:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7441:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7593:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7638:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7766:                         slot.getPhoneId(),

7907:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7915:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7924:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7964:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7991:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8172:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8207:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8232:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8272:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8312:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8319:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8585:                     ImsPhoneCallTracker imsPhoneCallTracker =

8587:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

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

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