433:         public Phone phone;

17: package com.android.phone;

223: public class PhoneInterfaceManager extends ITelephony.Stub {

2097:     private PhoneInterfaceManager(PhoneGlobals app) {

2115:     private Phone getDefaultPhone() {

2149:     private Phone getPhone(int subId) {

2801:     public String getNetworkCountryIsoForPhone(int phoneId) {

6556:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

351:     private PhoneConfigurationManager mPhoneConfigurationManager;

2129:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2137:     private Phone getPhoneFromSubId(int subId) {

2298:         private final int mPhoneId;

2577:     private void shutdownRadioUsingPhoneId(int phoneId) {

3219:     public int getActivePhoneType() {

3224:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4917:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6623:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7203:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7213:     public int getSubIdForPhoneAccountHandle(

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

9536:     private boolean isAnyPhoneInEmergencyState() {

10354:     public PhoneCapability getPhoneCapability() {

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

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

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

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

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

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

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

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

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

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

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

443:             if (phone != null) {

444:                 this.phone = phone;

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

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

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

491:             final Phone defaultPhone = getDefaultPhone();

496:                     final Phone phone = getPhoneFromRequest(request);

515:                         request.result = phone != null

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

527:                     final Phone phone = getPhoneFromRequest(request);

528:                     request.result = phone != null ?

805:                     Phone phone = getPhoneFromRequest(request);

806:                     if (phone != null) {

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

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

844:                     Phone phone = getPhoneFromRequest(request);

845:                     if (phone != null) {

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

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

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

1044:                     request.phone.setCallForwardingOption(

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

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

1510:                     Phone phone = getPhoneFromRequest(request);

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

1520:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1609:                     Phone phone = getPhoneFromRequest(request);

1610:                     if (phone != null) {

1611:                         phone.getSystemSelectionChannels(onCompleted);

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

1754:                     Phone phone = getPhoneFromRequest(request);

1755:                     if (phone != null) {

1756:                         phone.setDataThrottling(onCompleted,

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

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

1848:                     final Phone phone = getPhoneFromRequest(request);

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

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

1859:                     phone.getServiceStateTracker().setSignalStrengthUpdateRequest(

1876:                     Phone phone = getPhoneFromRequest(request);

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

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

1887:                     phone.getServiceStateTracker().clearSignalStrengthUpdateRequest(

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

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

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

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

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

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

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

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

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

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

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

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

2131:             return request.phone;

2143:         Phone phone = getPhoneFromRequest(request);

2144:         return phone == null ? null :

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

2148:     // returns phone associated with the subId.

2153:     private void sendEraseModemConfig(Phone phone) {

2154:         if (phone != null) {

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

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

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

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

2268:             Phone phone = getPhone(subId);

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

2282:             Phone phone = getPhone(subId);

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

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

2446:             if (phone != null) {

2447:                 phone.updateServiceLocation(workSource);

2492:             final Phone phone = getPhone(subId);

2493:             if (phone != null) {

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

2512:             final Phone phone = getPhone(subId);

2513:             if (phone != null) {

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

2530:             final Phone phone = getPhone(subId);

2531:             if (phone == null) {

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

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

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

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

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

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

2580:             phone.shutdownRadio();

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

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

2607:             final Phone phone = getPhone(subId);

2608:             if (phone != null) {

2609:                 phone.setRadioPower(turnOn);

2627:             final Phone phone = getPhone(subId);

2628:             if (phone != null) {

2629:                 phone.getDataEnabledSettings().setDataEnabled(

2648:             final Phone phone = getPhone(subId);

2649:             if (phone != null) {

2650:                 phone.getDataEnabledSettings().setDataEnabled(

2665:             final Phone phone = getPhone(subId);

2666:             if (phone != null) {

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

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

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

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

2733:             final Phone phone = getPhone(subId);

2734:             if (phone != null) {

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

2754:             final Phone phone = getPhone(subId);

2755:             if (phone != null) {

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

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

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

2807:                 // Get default phone in this case.

2808:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2813:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

2924:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2986:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3008:         if (phone == null) {

3011:         int subId = phone.getSubId();

3019:             return phone.getImei();

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

3029:         if (phone != null) {

3030:             String imei = phone.getImei();

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

3039:         if (phone == null) {

3043:         int subId = phone.getSubId();

3051:             return phone.getMeid();

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

3061:         if (phone != null) {

3062:             String meid = phone.getMeid();

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

3072:         if (phone == null) {

3075:         int subId = phone.getSubId();

3084:             return phone.getDeviceSvn();

3094:             final Phone phone = getPhone(subId);

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

3105:             final Phone phone = getPhone(subId);

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

3116:             final Phone phone = getPhone(subId);

3117:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3118:                     : phone.getSpecificCarrierId();

3128:             final Phone phone = getPhone(subId);

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

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

3141:         if (phone == null) {

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

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

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

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

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

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

3228:             if (phone == null) {

3229:                 return PhoneConstants.PHONE_TYPE_NONE;

3231:                 return phone.getPhoneType();

3258:             final Phone phone = getPhone(subId);

3259:             if (phone != null) {

3260:                 return phone.getCdmaEriIconIndex();

3291:             final Phone phone = getPhone(subId);

3292:             if (phone != null) {

3293:                 return phone.getCdmaEriIconMode();

3322:             final Phone phone = getPhone(subId);

3323:             if (phone != null) {

3324:                 return phone.getCdmaEriText();

3343:             final Phone phone = getPhone(subId);

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

3345:                 return phone.getLine1Number();

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

3365:             final Phone phone = getPhone(subId);

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

3367:                 return phone.getCdmaMin();

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

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

3547:             final Phone phone = getPhone(subId);

3548:             if (phone != null) {

3549:                 phone.setVoiceActivationState(activationState);

3568:             final Phone phone = getPhone(subId);

3569:             if (phone != null) {

3570:                 phone.setDataActivationState(activationState);

3586:         final Phone phone = getPhone(subId);

3589:             if (phone != null) {

3590:                 return phone.getVoiceActivationState();

3606:         final Phone phone = getPhone(subId);

3609:             if (phone != null) {

3610:                 return phone.getDataActivationState();

3632:             final Phone phone = getPhone(subId);

3633:             if (phone != null) {

3634:                 return phone.getVoiceMessageCount();

3651:             final Phone phone = getPhone(subId);

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

3665:         final Phone defaultPhone = getDefaultPhone();

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

3704:                 if (phone.isInEmergencySmsMode()) {

3715:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3742:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3780:             Phone phone = getPhone(subId);

3781:             if (phone == null) {

3786:             phone.getImsRegistrationState(regState -> {

3813:             Phone phone = getPhone(subId);

3814:             if (phone == null) {

3819:             phone.getImsRegistrationTech(regTech -> {

3838:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3864:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3915:             Phone phone = getPhone(subId);

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

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

3965:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4002:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4036:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4071:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4123:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4205:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4272:         Phone phone = getPhone(subId);

4273:         if (phone == null) {

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

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

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

4729:             final Phone phone = getPhone(subId);

4730:             if (phone != null) {

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

4763:             final Phone phone = getPhone(subId);

4764:             if (phone != null) {

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

4788:             final Phone phone = getPhone(subId);

4789:             if (phone != null) {

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

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

4816:             if (phone != null) {

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

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

4833:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4852:             final Phone phone = getPhone(subId);

4853:             if (phone == null) {

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

4952:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5346:         if (phone != null) {

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

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

5372:         if (phone != null) {

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

5390:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

5678:                     phone.setImsRegistrationState(registered);

5761:             final Phone phone = getPhone(subId);

5762:             if (phone == null) {

5765:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5824:             Phone phone = getPhone(subId);

5825:             if (phone == null) {

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

5876:             Phone phone = getPhone(subId);

5877:             if (phone == null) {

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

5904:             Phone phone = getPhone(subId);

5905:             if (phone == null) {

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

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

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

5957:             Phone phone = getPhone(subId);

5958:             if (phone == null) {

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

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

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

6258:         final Phone phone = getPhone(subId);

6260:             if (phone != null) {

6261:                 return phone.hasMatchedTetherApnSetting();

6281:         final Phone phone = getPhone(subId);

6283:             if (phone != null) {

6288:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

6338:             if (phone != null) {

6339:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6378:             if (phone != null) {

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

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

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

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

6417:             if (phone != null) {

6420:                     retVal = phone.isUserDataEnabled();

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

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

6439:             Phone phone) {

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

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

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

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

6456:             int subId = phone.getSubId();

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

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

6485:             int subId = phone.getSubId();

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

6503:         final Phone phone = getPhone(subId);

6504:         if (phone == null) {

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

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

6522:         final Phone phone = getPhone(subId);

6523:         if (phone == null) {

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

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

6640:         final Phone phone = getPhone(subId);

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

6658:             Phone phone = getPhone(subId);

6659:             if (phone != null) {

6660:                 Phone defaultPhone = phone.getImsPhone();

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

6681:             Phone phone = getPhone(subId);

6682:             if (phone != null) {

6683:                 Phone defaultPhone = phone.getImsPhone();

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

6704:             final Phone phone = getPhone(subId);

6705:             if (phone == null) {

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

6931:             final Phone phone = getPhone(subId);

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

6947:             final Phone phone = getPhone(subId);

6948:             if (phone == null) {

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

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

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

7003:         if (phone == null) {

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

7020:         final Phone defaultPhone = getDefaultPhone();

7034:         final Phone defaultPhone = getDefaultPhone();

7088:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7119:         final Phone phone = getPhone(subscriptionId);

7120:         if (phone == null) {

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

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

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

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

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

7170:         if (phone == null) {

7173:         int subId = phone.getSubId();

7181:             return phone.getDeviceId();

7194:         Phone phone = getPhone(subId);

7195:         if (phone != null) {

7196:             return phone.isImsRegistered();

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

7233:             Phone phone = getPhone(subscriptionId);

7234:             if (phone == null) {

7237:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7249:             Phone phone = getPhone(subId);

7250:             if (phone != null) {

7251:                 return phone.isWifiCallingEnabled();

7266:             Phone phone = getPhone(subId);

7267:             if (phone != null) {

7268:                 return phone.isVideoEnabled();

7284:             Phone phone = getPhone(subId);

7285:             if (phone != null) {

7286:                 return phone.getImsRegistrationTech();

7310:                 Phone phone = getPhone(subId);

7311:                 cleanUpAllowedNetworkTypes(phone, subId);

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

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

7347:         phone.loadAllowedNetworksFromSubscriptionDatabase();

7348:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

7361:         final Phone phone = getPhone(subId);

7362:         if (phone == null) {

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

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

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

7517:             final Phone phone = getPhone(subId);

7518:             if (phone == null) {

7522:             ServiceState ss = phone.getServiceState();

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

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

7547:             if (phone == null) {

7548:                 phone = getDefaultPhone();

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

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

7571:         final Phone defaultPhone = getDefaultPhone();

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

7583:             if (phone == null) {

7584:                 phone = defaultPhone;

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

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

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

7604:             if (phone == null) {

7605:                 phone = getDefaultPhone();

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

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

7628:         final Phone defaultPhone = getDefaultPhone();

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

7640:             if (phone == null) {

7641:                 phone = defaultPhone;

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

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

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

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

7703:         Phone phone = getPhone(subId);

7707:             if (phone == null) {

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

7732:         Phone phone = getPhone(subId);

7736:             if (phone == null) {

7741:                 esn = phone.getEsn();

7760:         Phone phone = getPhone(subId);

7764:             if (phone == null) {

7769:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7863:         final Phone phone = getPhone(subId);

7866:         if (phone == null) {

7871:             phone.carrierActionSetRadioEnabled(enabled);

7891:         final Phone phone = getPhone(subId);

7894:         if (phone == null) {

7899:             phone.carrierActionReportDefaultNetworkStatus(report);

7915:         final Phone phone = getPhone(subId);

7916:         if (phone == null) {

7921:             phone.carrierActionResetAll();

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

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

7978:             Phone phone = getPhone(subId);

7979:             if (phone != null) {

7981:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

8003:         Phone phone = getPhone(subId);

8007:             if (phone != null) {

8008:                 return phone.getClientRequestStats();

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

8041:             if (phone != null) {

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

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

8070:             if (phone != null) {

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

8094:      * Check if phone is in emergency callback mode

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

8101:         final Phone phone = getPhone(subId);

8105:             if (phone != null) {

8106:                 return phone.isInEcm();

8126:             Phone p = getPhone(subId);

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

8147:         if (phone != null) {

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

8155:                 return phone.getRadioPowerState();

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

8188:             Phone phone = getPhone(subId);

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

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

8214:             Phone phone = getPhone(subId);

8215:             if (phone != null) {

8216:                 phone.setDataRoamingEnabled(isEnabled);

8232:             Phone phone = getPhone(subId);

8233:             if (phone != null) {

8234:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8399:             Phone phone = getPhone(subId);

8400:             if (phone == null) {

8403:             UiccCard uiccCard = phone.getUiccCard();

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

8448:         return Phone.PREFERRED_NT_MODE;

8458:             final Phone phone = getPhone(subId);

8459:             if (phone == null) {

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

8481:             final Phone phone = getPhone(subId);

8482:             if (phone == null) {

8486:             return phone.getCarrierIdListVersion();

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

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

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

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

8578:                             phone.getSubId(),

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

8590:         final Phone defaultPhone = getDefaultPhone();

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

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

8600:                         && phone.getEmergencyNumberTracker()

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

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

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

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

8625:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;

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

8647:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8669:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8688:             final Phone phone = getPhone(subId);

8689:             if (phone == null) {

8693:             return phone.getEmergencyNumberDbVersion();

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

8706:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8723:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8740:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8753:         Phone phone = getPhone(subId);

8754:         if (phone == null) {

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

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

8780:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8908:         Phone phone = getPhone(subId);

8909:         if (phone == null) {

8914:             UiccCard uiccCard = phone.getUiccCard();

8984:         Phone phone = getDefaultPhone();

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

8986:         HalVersion hv = phone.getHalVersion();

9016:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

9022:             Phone phone = getPhone(subId);

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

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

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

9039:             Phone phone = getPhone(subId);

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

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

9054:             Phone phone = getPhone(subscriptionId);

9055:             if (phone == null) {

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

9175:             Phone phone = getPhone(subscriptionId);

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

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

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

9198:             Phone phone = getPhone(subscriptionId);

9199:             if (phone == null) return;

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

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

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

9229:                 Phone defaultPhone = phone.getImsPhone();

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

9279:             Phone phone = getPhone(subId);

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

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

9305:         Phone phone = getPhone(subId);

9306:         if (phone == null) {

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

9337:         Phone phone = getPhone(subId);

9338:         if (phone == null) {

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

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

9407:         Phone phone = getPhone(subId);

9408:         if (phone == null) {

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

9414:             return phone.getEquivalentHomePlmns();

9439:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

9483:         Phone phone = getPhone(subId);

9484:         if (phone != null) {

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

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

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

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

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

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

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

9546:                     + phone.isInEcm());

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

9636:                         Phone phone = getPhone(subId);

9637:                         if (phone == null) {

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

9785:                 permission.READ_PRIVILEGED_PHONE_STATE);

9816:                 permission.READ_PRIVILEGED_PHONE_STATE);

9847:                 permission.READ_PRIVILEGED_PHONE_STATE);

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

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

10346:      * Gets the current phone capability.

10348:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

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

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

66: import android.telecom.PhoneAccount;

67: import android.telecom.PhoneAccountHandle;

89: import android.telephony.PhoneCapability;

90: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

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

340:     private static PhoneInterfaceManager sInstance;

343:     private PhoneGlobals mApp;

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

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

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

794:                     defaultPhone.resetModemConfig(onCompleted);

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

1217:                     if (defaultPhone != null) {

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

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

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

1533:                     defaultPhone.rebootModem(onCompleted);

1543:                     PhoneConfigurationManager.getInstance()

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

1565:                     PhoneConfigurationManager.getInstance()

1682:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

1745:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2082:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2086:         synchronized (PhoneInterfaceManager.class) {

2088:                 sInstance = new PhoneInterfaceManager(app);

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

2108:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2301:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2310:         UnlockSim(int phoneId, IccCard simCard) {

2311:             mPhoneId = phoneId;

2332:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2337:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2339:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2342:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2590:             if (defaultPhone != null) {

2591:                 defaultPhone.setRadioPower(turnOn);

2737:                 return PhoneConstantConversions.convertDataState(

2738:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3408:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3444:             if (phoneAccountHandle == null) {

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

3532:         SmsController smsController = PhoneFactory.getSmsController();

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

3676:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4847:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4854:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4857:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4919:         if (phoneId == -1) {

4923:         return PhoneFactory.getPhone(phoneId);

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

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

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

5398:             return defaultPhone.getPcscfAddress(apnType);

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

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

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

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

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

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

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

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

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

6552:             getPhone(phoneId), pkgName);

6569:                 getPhone(i), pkgName);

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

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

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

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

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

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

6662:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6663:                     imsPhone.setCallComposerStatus(status);

6685:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6686:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7206:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7221:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7330:               sendEraseModemConfig(getDefaultPhone());

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

7540:      * PhoneAccount.

7543:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7566:      * PhoneAccount.

7570:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7576:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7600:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7623:      * specific PhoneAccount.

7627:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7633:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8255:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8446:             return list.get(phoneId);

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

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

8626:                     gsmCdmaPhone.obtainMessage(

8627:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();

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

8858:         PhoneCapability staticCapability =

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

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

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

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

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

9231:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9233:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9236:                             + imsPhone.getMsisdn());

9374:         // *  Inherited from PhoneWindowManager  *

9475:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

10051:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

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

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

923:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1456:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1575:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2133:             return getPhoneFromSubId(request.subId);

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

2476:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2570:                 shutdownRadioUsingPhoneId(i);

3076:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3220:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3250:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3283:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3314:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3457:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3625:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3685:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3722:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3748:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3805:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3845:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3870:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3970:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4007:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4041:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4076:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4128:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4210:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4292:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4356:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4721:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4755:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4780:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4948:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4990:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

5173:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5615:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5752:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6105:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6130:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6183:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

6624:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6751:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6778:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6801:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6996:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7009:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7059:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7078:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7229:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7470:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7999:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8181:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8226:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8354:                         slot.getPhoneId(),

8495:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8503:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8512:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8539:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8566:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8593:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8799:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8834:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8859:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8899:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8939:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8946:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9084:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9232:                     ImsPhoneCallTracker imsPhoneCallTracker =

9234:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

9402:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

9650:                         } else if (isAnyPhoneInEmergencyState()) {

10355:         enforceReadPrivilegedPermission("getPhoneCapability");

10358:             return mPhoneConfigurationManager.getCurrentPhoneCapability();

384:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1655:     private PhoneInterfaceManager(PhoneGlobals app) {

1672:     private Phone getDefaultPhone() {

1706:     private Phone getPhone(int subId) {

2347:     public String getNetworkCountryIsoForPhone(int phoneId) {

5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1694:     private Phone getPhoneFromSubId(int subId) {

2125:     private void shutdownRadioUsingPhoneId(int phoneId) {

2780:     public int getActivePhoneType() {

2785:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6553:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

394:             if (phone != null) {

395:                 this.phone = phone;

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

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

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

442:             final Phone defaultPhone = getDefaultPhone();

447:                     final Phone phone = getPhoneFromRequest(request);

466:                         request.result = phone != null

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

478:                     final Phone phone = getPhoneFromRequest(request);

479:                     request.result = phone != null ?

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

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

1308:                     Phone phone = getPhoneFromRequest(request);

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

1317:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1688:             return request.phone;

1700:         Phone phone = getPhoneFromRequest(request);

1701:         return phone == null ? null :

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

1705:     // returns phone associated with the subId.

1710:     private void sendEraseModemConfig(Phone phone) {

1711:         if (phone != null) {

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

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

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

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

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

1994:             if (phone != null) {

1995:                 phone.updateServiceLocation(workSource);

2040:             final Phone phone = getPhone(subId);

2041:             if (phone != null) {

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

2060:             final Phone phone = getPhone(subId);

2061:             if (phone != null) {

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

2078:             final Phone phone = getPhone(subId);

2079:             if (phone == null) {

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

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

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

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

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

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

2128:             phone.shutdownRadio();

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

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

2155:             final Phone phone = getPhone(subId);

2156:             if (phone != null) {

2157:                 phone.setRadioPower(turnOn);

2175:             final Phone phone = getPhone(subId);

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)