429:         public Phone phone;

17: package com.android.phone;

219: public class PhoneInterfaceManager extends ITelephony.Stub {

2093:     private PhoneInterfaceManager(PhoneGlobals app) {

2111:     private Phone getDefaultPhone() {

2145:     private Phone getPhone(int subId) {

2797:     public String getNetworkCountryIsoForPhone(int phoneId) {

6548:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

347:     private PhoneConfigurationManager mPhoneConfigurationManager;

2125:     private Phone getPhoneFromRequest(MainThreadRequest request) {

2133:     private Phone getPhoneFromSubId(int subId) {

2294:         private final int mPhoneId;

2573:     private void shutdownRadioUsingPhoneId(int phoneId) {

3215:     public int getActivePhoneType() {

3220:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4913:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6615:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7195:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7205:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

439:             if (phone != null) {

440:                 this.phone = phone;

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

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

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

487:             final Phone defaultPhone = getDefaultPhone();

492:                     final Phone phone = getPhoneFromRequest(request);

511:                         request.result = phone != null

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

523:                     final Phone phone = getPhoneFromRequest(request);

524:                     request.result = phone != null ?

801:                     Phone phone = getPhoneFromRequest(request);

802:                     if (phone != null) {

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

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

840:                     Phone phone = getPhoneFromRequest(request);

841:                     if (phone != null) {

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

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

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

1040:                     request.phone.setCallForwardingOption(

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

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

1506:                     Phone phone = getPhoneFromRequest(request);

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

1516:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1605:                     Phone phone = getPhoneFromRequest(request);

1606:                     if (phone != null) {

1607:                         phone.getSystemSelectionChannels(onCompleted);

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

1750:                     Phone phone = getPhoneFromRequest(request);

1751:                     if (phone != null) {

1752:                         phone.setDataThrottling(onCompleted,

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

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

1844:                     final Phone phone = getPhoneFromRequest(request);

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

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

1855:                     phone.getServiceStateTracker().setSignalStrengthUpdateRequest(

1872:                     Phone phone = getPhoneFromRequest(request);

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

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

1883:                     phone.getServiceStateTracker().clearSignalStrengthUpdateRequest(

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

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

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

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

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

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

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

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

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

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

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

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

2127:             return request.phone;

2139:         Phone phone = getPhoneFromRequest(request);

2140:         return phone == null ? null :

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

2144:     // returns phone associated with the subId.

2149:     private void sendEraseModemConfig(Phone phone) {

2150:         if (phone != null) {

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

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

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

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

2264:             Phone phone = getPhone(subId);

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

2278:             Phone phone = getPhone(subId);

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

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

2442:             if (phone != null) {

2443:                 phone.updateServiceLocation(workSource);

2488:             final Phone phone = getPhone(subId);

2489:             if (phone != null) {

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

2508:             final Phone phone = getPhone(subId);

2509:             if (phone != null) {

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

2526:             final Phone phone = getPhone(subId);

2527:             if (phone == null) {

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

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

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

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

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

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

2576:             phone.shutdownRadio();

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

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

2603:             final Phone phone = getPhone(subId);

2604:             if (phone != null) {

2605:                 phone.setRadioPower(turnOn);

2623:             final Phone phone = getPhone(subId);

2624:             if (phone != null) {

2625:                 phone.getDataEnabledSettings().setDataEnabled(

2644:             final Phone phone = getPhone(subId);

2645:             if (phone != null) {

2646:                 phone.getDataEnabledSettings().setDataEnabled(

2661:             final Phone phone = getPhone(subId);

2662:             if (phone != null) {

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

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

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

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

2729:             final Phone phone = getPhone(subId);

2730:             if (phone != null) {

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

2750:             final Phone phone = getPhone(subId);

2751:             if (phone != null) {

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

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

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

2803:                 // Get default phone in this case.

2804:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2809:             ServiceStateTracker sst = phone.getServiceStateTracker();

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

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

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

2920:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2982:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

3004:         if (phone == null) {

3007:         int subId = phone.getSubId();

3015:             return phone.getImei();

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

3025:         if (phone != null) {

3026:             String imei = phone.getImei();

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

3035:         if (phone == null) {

3039:         int subId = phone.getSubId();

3047:             return phone.getMeid();

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

3057:         if (phone != null) {

3058:             String meid = phone.getMeid();

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

3068:         if (phone == null) {

3071:         int subId = phone.getSubId();

3080:             return phone.getDeviceSvn();

3090:             final Phone phone = getPhone(subId);

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

3101:             final Phone phone = getPhone(subId);

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

3112:             final Phone phone = getPhone(subId);

3113:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

3114:                     : phone.getSpecificCarrierId();

3124:             final Phone phone = getPhone(subId);

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

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

3137:         if (phone == null) {

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

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

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

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

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

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

3224:             if (phone == null) {

3225:                 return PhoneConstants.PHONE_TYPE_NONE;

3227:                 return phone.getPhoneType();

3254:             final Phone phone = getPhone(subId);

3255:             if (phone != null) {

3256:                 return phone.getCdmaEriIconIndex();

3287:             final Phone phone = getPhone(subId);

3288:             if (phone != null) {

3289:                 return phone.getCdmaEriIconMode();

3318:             final Phone phone = getPhone(subId);

3319:             if (phone != null) {

3320:                 return phone.getCdmaEriText();

3339:             final Phone phone = getPhone(subId);

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

3341:                 return phone.getLine1Number();

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

3361:             final Phone phone = getPhone(subId);

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

3363:                 return phone.getCdmaMin();

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

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

3543:             final Phone phone = getPhone(subId);

3544:             if (phone != null) {

3545:                 phone.setVoiceActivationState(activationState);

3564:             final Phone phone = getPhone(subId);

3565:             if (phone != null) {

3566:                 phone.setDataActivationState(activationState);

3582:         final Phone phone = getPhone(subId);

3585:             if (phone != null) {

3586:                 return phone.getVoiceActivationState();

3602:         final Phone phone = getPhone(subId);

3605:             if (phone != null) {

3606:                 return phone.getDataActivationState();

3628:             final Phone phone = getPhone(subId);

3629:             if (phone != null) {

3630:                 return phone.getVoiceMessageCount();

3647:             final Phone phone = getPhone(subId);

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

3661:         final Phone defaultPhone = getDefaultPhone();

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

3700:                 if (phone.isInEmergencySmsMode()) {

3711:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3738:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3776:             Phone phone = getPhone(subId);

3777:             if (phone == null) {

3782:             phone.getImsRegistrationState(regState -> {

3809:             Phone phone = getPhone(subId);

3810:             if (phone == null) {

3815:             phone.getImsRegistrationTech(regTech -> {

3834:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3860:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3911:             Phone phone = getPhone(subId);

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

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

3961:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3998:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4032:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4067:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4119:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4201:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4268:         Phone phone = getPhone(subId);

4269:         if (phone == null) {

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

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

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

4725:             final Phone phone = getPhone(subId);

4726:             if (phone != null) {

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

4759:             final Phone phone = getPhone(subId);

4760:             if (phone != null) {

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

4784:             final Phone phone = getPhone(subId);

4785:             if (phone != null) {

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

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

4812:             if (phone != null) {

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

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

4829:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4848:             final Phone phone = getPhone(subId);

4849:             if (phone == null) {

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

4948:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5342:         if (phone != null) {

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

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

5368:         if (phone != null) {

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

5386:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

5674:                     phone.setImsRegistrationState(registered);

5757:             final Phone phone = getPhone(subId);

5758:             if (phone == null) {

5761:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5820:             Phone phone = getPhone(subId);

5821:             if (phone == null) {

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

5872:             Phone phone = getPhone(subId);

5873:             if (phone == null) {

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

5900:             Phone phone = getPhone(subId);

5901:             if (phone == null) {

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

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

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

5953:             Phone phone = getPhone(subId);

5954:             if (phone == null) {

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

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

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

6250:         final Phone phone = getPhone(subId);

6252:             if (phone != null) {

6253:                 return phone.hasMatchedTetherApnSetting();

6273:         final Phone phone = getPhone(subId);

6275:             if (phone != null) {

6280:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

6330:             if (phone != null) {

6331:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6370:             if (phone != null) {

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

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

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

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

6409:             if (phone != null) {

6412:                     retVal = phone.isUserDataEnabled();

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

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

6431:             Phone phone) {

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

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

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

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

6448:             int subId = phone.getSubId();

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

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

6477:             int subId = phone.getSubId();

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

6495:         final Phone phone = getPhone(subId);

6496:         if (phone == null) {

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

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

6514:         final Phone phone = getPhone(subId);

6515:         if (phone == null) {

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

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

6632:         final Phone phone = getPhone(subId);

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

6650:             Phone phone = getPhone(subId);

6651:             if (phone != null) {

6652:                 Phone defaultPhone = phone.getImsPhone();

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

6673:             Phone phone = getPhone(subId);

6674:             if (phone != null) {

6675:                 Phone defaultPhone = phone.getImsPhone();

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

6696:             final Phone phone = getPhone(subId);

6697:             if (phone == null) {

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

6923:             final Phone phone = getPhone(subId);

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

6939:             final Phone phone = getPhone(subId);

6940:             if (phone == null) {

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

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

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

6995:         if (phone == null) {

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

7012:         final Phone defaultPhone = getDefaultPhone();

7026:         final Phone defaultPhone = getDefaultPhone();

7080:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7111:         final Phone phone = getPhone(subscriptionId);

7112:         if (phone == null) {

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

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

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

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

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

7162:         if (phone == null) {

7165:         int subId = phone.getSubId();

7173:             return phone.getDeviceId();

7186:         Phone phone = getPhone(subId);

7187:         if (phone != null) {

7188:             return phone.isImsRegistered();

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

7225:             Phone phone = getPhone(subscriptionId);

7226:             if (phone == null) {

7229:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7241:             Phone phone = getPhone(subId);

7242:             if (phone != null) {

7243:                 return phone.isWifiCallingEnabled();

7258:             Phone phone = getPhone(subId);

7259:             if (phone != null) {

7260:                 return phone.isVideoEnabled();

7276:             Phone phone = getPhone(subId);

7277:             if (phone != null) {

7278:                 return phone.getImsRegistrationTech();

7302:                 Phone phone = getPhone(subId);

7303:                 if (phone != null) {

7308:                     phone.loadAllowedNetworksFromSubscriptionDatabase();

7344:         final Phone phone = getPhone(subId);

7345:         if (phone == null) {

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

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

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

7500:             final Phone phone = getPhone(subId);

7501:             if (phone == null) {

7505:             ServiceState ss = phone.getServiceState();

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

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

7530:             if (phone == null) {

7531:                 phone = getDefaultPhone();

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

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

7554:         final Phone defaultPhone = getDefaultPhone();

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

7566:             if (phone == null) {

7567:                 phone = defaultPhone;

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

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

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

7587:             if (phone == null) {

7588:                 phone = getDefaultPhone();

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

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

7611:         final Phone defaultPhone = getDefaultPhone();

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

7623:             if (phone == null) {

7624:                 phone = defaultPhone;

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

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

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

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

7686:         Phone phone = getPhone(subId);

7690:             if (phone == null) {

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

7715:         Phone phone = getPhone(subId);

7719:             if (phone == null) {

7724:                 esn = phone.getEsn();

7743:         Phone phone = getPhone(subId);

7747:             if (phone == null) {

7752:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7846:         final Phone phone = getPhone(subId);

7849:         if (phone == null) {

7854:             phone.carrierActionSetRadioEnabled(enabled);

7874:         final Phone phone = getPhone(subId);

7877:         if (phone == null) {

7882:             phone.carrierActionReportDefaultNetworkStatus(report);

7898:         final Phone phone = getPhone(subId);

7899:         if (phone == null) {

7904:             phone.carrierActionResetAll();

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

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

7961:             Phone phone = getPhone(subId);

7962:             if (phone != null) {

7964:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

7986:         Phone phone = getPhone(subId);

7990:             if (phone != null) {

7991:                 return phone.getClientRequestStats();

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

8024:             if (phone != null) {

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

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

8053:             if (phone != null) {

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

8077:      * Check if phone is in emergency callback mode

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

8084:         final Phone phone = getPhone(subId);

8088:             if (phone != null) {

8089:                 return phone.isInEcm();

8109:             Phone p = getPhone(subId);

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

8130:         if (phone != null) {

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

8138:                 return phone.getRadioPowerState();

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

8171:             Phone phone = getPhone(subId);

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

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

8197:             Phone phone = getPhone(subId);

8198:             if (phone != null) {

8199:                 phone.setDataRoamingEnabled(isEnabled);

8215:             Phone phone = getPhone(subId);

8216:             if (phone != null) {

8217:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8382:             Phone phone = getPhone(subId);

8383:             if (phone == null) {

8386:             UiccCard uiccCard = phone.getUiccCard();

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

8431:         return Phone.PREFERRED_NT_MODE;

8441:             final Phone phone = getPhone(subId);

8442:             if (phone == null) {

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

8464:             final Phone phone = getPhone(subId);

8465:             if (phone == null) {

8469:             return phone.getCarrierIdListVersion();

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

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

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

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

8561:                             phone.getSubId(),

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

8573:         final Phone defaultPhone = getDefaultPhone();

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

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

8583:                         && phone.getEmergencyNumberTracker()

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

8605:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8627:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8646:             final Phone phone = getPhone(subId);

8647:             if (phone == null) {

8651:             return phone.getEmergencyNumberDbVersion();

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

8664:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8681:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8698:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8711:         Phone phone = getPhone(subId);

8712:         if (phone == null) {

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

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

8738:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8866:         Phone phone = getPhone(subId);

8867:         if (phone == null) {

8872:             UiccCard uiccCard = phone.getUiccCard();

8942:         Phone phone = getDefaultPhone();

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

8944:         HalVersion hv = phone.getHalVersion();

8974:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8980:             Phone phone = getPhone(subId);

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

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

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

8997:             Phone phone = getPhone(subId);

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

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

9012:             Phone phone = getPhone(subscriptionId);

9013:             if (phone == null) {

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

9133:             Phone phone = getPhone(subscriptionId);

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

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

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

9156:             Phone phone = getPhone(subscriptionId);

9157:             if (phone == null) return;

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

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

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

9187:                 Phone defaultPhone = phone.getImsPhone();

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

9237:             Phone phone = getPhone(subId);

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

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

9263:         Phone phone = getPhone(subId);

9264:         if (phone == null) {

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

9295:         Phone phone = getPhone(subId);

9296:         if (phone == null) {

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

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

9365:         Phone phone = getPhone(subId);

9366:         if (phone == null) {

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

9372:             return phone.getEquivalentHomePlmns();

9397:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

9441:         Phone phone = getPhone(subId);

9442:         if (phone != null) {

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

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

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

9576:                         Phone phone = getPhone(subId);

9577:                         if (phone == null) {

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

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

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

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

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

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

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

9730:                 permission.READ_PRIVILEGED_PHONE_STATE);

9757:                 permission.READ_PRIVILEGED_PHONE_STATE);

9788:                 permission.READ_PRIVILEGED_PHONE_STATE);

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

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

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

64: import android.telecom.PhoneAccount;

65: import android.telecom.PhoneAccountHandle;

87: import android.telephony.PhoneCapability;

88: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

336:     private static PhoneInterfaceManager sInstance;

339:     private PhoneGlobals mApp;

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

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

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

790:                     defaultPhone.resetModemConfig(onCompleted);

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

1213:                     if (defaultPhone != null) {

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

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

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

1529:                     defaultPhone.rebootModem(onCompleted);

1539:                     PhoneConfigurationManager.getInstance()

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

1561:                     PhoneConfigurationManager.getInstance()

1678:                     defaultPhone.eraseModemConfig(onCompleted);

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

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

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

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

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

1741:                     getDefaultPhone().getContext().sendBroadcastAsUser(

2078:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

2082:         synchronized (PhoneInterfaceManager.class) {

2084:                 sInstance = new PhoneInterfaceManager(app);

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

2104:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

2297:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2306:         UnlockSim(int phoneId, IccCard simCard) {

2307:             mPhoneId = phoneId;

2328:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2333:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2335:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2338:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

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

2586:             if (defaultPhone != null) {

2587:                 defaultPhone.setRadioPower(turnOn);

2733:                 return PhoneConstantConversions.convertDataState(

2734:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3404:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3440:             if (phoneAccountHandle == null) {

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

3528:         SmsController smsController = PhoneFactory.getSmsController();

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

3672:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4843:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4850:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4853:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4915:         if (phoneId == -1) {

4919:         return PhoneFactory.getPhone(phoneId);

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

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

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

5394:             return defaultPhone.getPcscfAddress(apnType);

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

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

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

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

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

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

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

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

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

6544:             getPhone(phoneId), pkgName);

6561:                 getPhone(i), pkgName);

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

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

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

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

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

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

6654:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6655:                     imsPhone.setCallComposerStatus(status);

6677:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6678:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7198:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7213:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7328:               sendEraseModemConfig(getDefaultPhone());

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

7523:      * PhoneAccount.

7526:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7549:      * PhoneAccount.

7553:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7559:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7583:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7606:      * specific PhoneAccount.

7610:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7616:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8238:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8429:             return list.get(phoneId);

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

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

8816:         PhoneCapability staticCapability =

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

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

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

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

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

9189:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9191:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9194:                             + imsPhone.getMsisdn());

9332:         // *  Inherited from PhoneWindowManager  *

9433:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

9992:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

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

919:                     getPhoneFromRequest(request).setAllowedNetworkTypes(

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

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

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

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

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

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

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

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

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

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

1452:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1571:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

2129:             return getPhoneFromSubId(request.subId);

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

2472:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2566:                 shutdownRadioUsingPhoneId(i);

3072:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3216:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3246:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3279:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3310:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3453:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3621:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3681:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3718:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3744:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3801:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3841:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3866:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3966:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4003:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4037:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4072:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4124:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4206:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4288:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4352:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4717:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4751:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4776:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4944:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4986:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

5169:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5611:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5748:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

6101:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6126:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

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

6179:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

6616:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6743:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6770:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6793:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6988:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7001:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7051:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7070:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7221:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7453:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7982:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8164:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8209:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8337:                         slot.getPhoneId(),

8478:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8486:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8495:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8522:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8549:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8576:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8757:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8792:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8817:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8857:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8897:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8904:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9042:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9190:                     ImsPhoneCallTracker imsPhoneCallTracker =

9192:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

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