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

6547:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

6614:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7194:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7204:     public int getSubIdForPhoneAccountHandle(

7219:     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.SYSTEM_UID || uid == Process.PHONE_UID) {

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

6447:             int subId = phone.getSubId();

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

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

6476:             int subId = phone.getSubId();

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

6494:         final Phone phone = getPhone(subId);

6495:         if (phone == null) {

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

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

6513:         final Phone phone = getPhone(subId);

6514:         if (phone == null) {

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

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

6631:         final Phone phone = getPhone(subId);

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

6649:             Phone phone = getPhone(subId);

6650:             if (phone != null) {

6651:                 Phone defaultPhone = phone.getImsPhone();

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

6672:             Phone phone = getPhone(subId);

6673:             if (phone != null) {

6674:                 Phone defaultPhone = phone.getImsPhone();

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

6695:             final Phone phone = getPhone(subId);

6696:             if (phone == null) {

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

6922:             final Phone phone = getPhone(subId);

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

6938:             final Phone phone = getPhone(subId);

6939:             if (phone == null) {

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

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

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

6994:         if (phone == null) {

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

7011:         final Phone defaultPhone = getDefaultPhone();

7025:         final Phone defaultPhone = getDefaultPhone();

7079:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7110:         final Phone phone = getPhone(subscriptionId);

7111:         if (phone == null) {

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

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

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

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

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

7161:         if (phone == null) {

7164:         int subId = phone.getSubId();

7172:             return phone.getDeviceId();

7185:         Phone phone = getPhone(subId);

7186:         if (phone != null) {

7187:             return phone.isImsRegistered();

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

7224:             Phone phone = getPhone(subscriptionId);

7225:             if (phone == null) {

7228:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7240:             Phone phone = getPhone(subId);

7241:             if (phone != null) {

7242:                 return phone.isWifiCallingEnabled();

7257:             Phone phone = getPhone(subId);

7258:             if (phone != null) {

7259:                 return phone.isVideoEnabled();

7275:             Phone phone = getPhone(subId);

7276:             if (phone != null) {

7277:                 return phone.getImsRegistrationTech();

7301:                 Phone phone = getPhone(subId);

7302:                 if (phone != null) {

7307:                     phone.loadAllowedNetworksFromSubscriptionDatabase();

7343:         final Phone phone = getPhone(subId);

7344:         if (phone == null) {

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

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

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

7499:             final Phone phone = getPhone(subId);

7500:             if (phone == null) {

7504:             ServiceState ss = phone.getServiceState();

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

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

7529:             if (phone == null) {

7530:                 phone = getDefaultPhone();

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

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

7553:         final Phone defaultPhone = getDefaultPhone();

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

7565:             if (phone == null) {

7566:                 phone = defaultPhone;

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

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

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

7586:             if (phone == null) {

7587:                 phone = getDefaultPhone();

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

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

7610:         final Phone defaultPhone = getDefaultPhone();

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

7622:             if (phone == null) {

7623:                 phone = defaultPhone;

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

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

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

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

7685:         Phone phone = getPhone(subId);

7689:             if (phone == null) {

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

7714:         Phone phone = getPhone(subId);

7718:             if (phone == null) {

7723:                 esn = phone.getEsn();

7742:         Phone phone = getPhone(subId);

7746:             if (phone == null) {

7751:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7845:         final Phone phone = getPhone(subId);

7848:         if (phone == null) {

7853:             phone.carrierActionSetRadioEnabled(enabled);

7873:         final Phone phone = getPhone(subId);

7876:         if (phone == null) {

7881:             phone.carrierActionReportDefaultNetworkStatus(report);

7897:         final Phone phone = getPhone(subId);

7898:         if (phone == null) {

7903:             phone.carrierActionResetAll();

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

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

7960:             Phone phone = getPhone(subId);

7961:             if (phone != null) {

7963:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

7985:         Phone phone = getPhone(subId);

7989:             if (phone != null) {

7990:                 return phone.getClientRequestStats();

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

8023:             if (phone != null) {

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

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

8052:             if (phone != null) {

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

8076:      * Check if phone is in emergency callback mode

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

8083:         final Phone phone = getPhone(subId);

8087:             if (phone != null) {

8088:                 return phone.isInEcm();

8108:             Phone p = getPhone(subId);

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

8129:         if (phone != null) {

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

8137:                 return phone.getRadioPowerState();

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

8170:             Phone phone = getPhone(subId);

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

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

8196:             Phone phone = getPhone(subId);

8197:             if (phone != null) {

8198:                 phone.setDataRoamingEnabled(isEnabled);

8214:             Phone phone = getPhone(subId);

8215:             if (phone != null) {

8216:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8381:             Phone phone = getPhone(subId);

8382:             if (phone == null) {

8385:             UiccCard uiccCard = phone.getUiccCard();

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

8430:         return Phone.PREFERRED_NT_MODE;

8440:             final Phone phone = getPhone(subId);

8441:             if (phone == null) {

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

8463:             final Phone phone = getPhone(subId);

8464:             if (phone == null) {

8468:             return phone.getCarrierIdListVersion();

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

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

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

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

8560:                             phone.getSubId(),

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

8572:         final Phone defaultPhone = getDefaultPhone();

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

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

8582:                         && phone.getEmergencyNumberTracker()

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

8604:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8626:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8645:             final Phone phone = getPhone(subId);

8646:             if (phone == null) {

8650:             return phone.getEmergencyNumberDbVersion();

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

8663:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8680:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8697:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8710:         Phone phone = getPhone(subId);

8711:         if (phone == null) {

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

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

8737:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8865:         Phone phone = getPhone(subId);

8866:         if (phone == null) {

8871:             UiccCard uiccCard = phone.getUiccCard();

8941:         Phone phone = getDefaultPhone();

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

8943:         HalVersion hv = phone.getHalVersion();

8973:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8979:             Phone phone = getPhone(subId);

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

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

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

8996:             Phone phone = getPhone(subId);

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

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

9011:             Phone phone = getPhone(subscriptionId);

9012:             if (phone == null) {

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

9130:             Phone phone = getPhone(subscriptionId);

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

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

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

9153:             Phone phone = getPhone(subscriptionId);

9154:             if (phone == null) return;

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

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

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

9184:                 Phone defaultPhone = phone.getImsPhone();

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

9234:             Phone phone = getPhone(subId);

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

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

9260:         Phone phone = getPhone(subId);

9261:         if (phone == null) {

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

9292:         Phone phone = getPhone(subId);

9293:         if (phone == null) {

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

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

9362:         Phone phone = getPhone(subId);

9363:         if (phone == null) {

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

9369:             return phone.getEquivalentHomePlmns();

9394:                 Manifest.permission.MODIFY_PHONE_STATE);

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

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

9438:         Phone phone = getPhone(subId);

9439:         if (phone != null) {

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

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

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

9573:                         Phone phone = getPhone(subId);

9574:                         if (phone == null) {

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

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

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

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

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

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

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

9727:                 permission.READ_PRIVILEGED_PHONE_STATE);

9754:                 permission.READ_PRIVILEGED_PHONE_STATE);

9785:                 permission.READ_PRIVILEGED_PHONE_STATE);

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

10215:             // 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;

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

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

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

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

6543:             getPhone(phoneId), pkgName);

6560:                 getPhone(i), pkgName);

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

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

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

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

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

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

6653:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6654:                     imsPhone.setCallComposerStatus(status);

6676:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6677:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7197:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7212:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7327:               sendEraseModemConfig(getDefaultPhone());

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

7522:      * PhoneAccount.

7525:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7548:      * PhoneAccount.

7552:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7558:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7582:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7605:      * specific PhoneAccount.

7609:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7615:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8237:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8428:             return list.get(phoneId);

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

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

8815:         PhoneCapability staticCapability =

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

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

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

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

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

9186:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9188:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9191:                             + imsPhone.getMsisdn());

9329:         // *  Inherited from PhoneWindowManager  *

9430:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

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

9989:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

6615:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6742:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6769:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6792:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6987:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7000:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7050:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7069:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7220:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7452:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7981:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8163:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8208:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8336:                         slot.getPhoneId(),

8477:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8485:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8494:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8521:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8548:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8575:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8756:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8791:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8816:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8856:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8896:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8903:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

9041:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9187:                     ImsPhoneCallTracker imsPhoneCallTracker =

9189:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

9357:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

384:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1655:     private PhoneInterfaceManager(PhoneGlobals app) {

1672:     private Phone getDefaultPhone() {

1706:     private Phone getPhone(int subId) {

2347:     public String getNetworkCountryIsoForPhone(int phoneId) {

5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1694:     private Phone getPhoneFromSubId(int subId) {

2125:     private void shutdownRadioUsingPhoneId(int phoneId) {

2780:     public int getActivePhoneType() {

2785:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6553:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

394:             if (phone != null) {

395:                 this.phone = phone;

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

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

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

442:             final Phone defaultPhone = getDefaultPhone();

447:                     final Phone phone = getPhoneFromRequest(request);

466:                         request.result = phone != null

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

478:                     final Phone phone = getPhoneFromRequest(request);

479:                     request.result = phone != null ?

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

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

1308:                     Phone phone = getPhoneFromRequest(request);

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

1317:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1688:             return request.phone;

1700:         Phone phone = getPhoneFromRequest(request);

1701:         return phone == null ? null :

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

1705:     // returns phone associated with the subId.

1710:     private void sendEraseModemConfig(Phone phone) {

1711:         if (phone != null) {

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

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

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

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

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

1994:             if (phone != null) {

1995:                 phone.updateServiceLocation(workSource);

2040:             final Phone phone = getPhone(subId);

2041:             if (phone != null) {

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

2060:             final Phone phone = getPhone(subId);

2061:             if (phone != null) {

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

2078:             final Phone phone = getPhone(subId);

2079:             if (phone == null) {

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

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

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

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

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

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

2128:             phone.shutdownRadio();

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

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

2155:             final Phone phone = getPhone(subId);

2156:             if (phone != null) {

2157:                 phone.setRadioPower(turnOn);

2175:             final Phone phone = getPhone(subId);

2176:             if (phone != null) {

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

2195:             final Phone phone = getPhone(subId);

2196:             if (phone != null) {

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

2211:             final Phone phone = getPhone(subId);

2212:             if (phone != null) {

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

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

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

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

2279:             final Phone phone = getPhone(subId);

2280:             if (phone != null) {

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

2300:             final Phone phone = getPhone(subId);

2301:             if (phone != null) {

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

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

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

2353:                 // Get default phone in this case.

2354:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2359:             ServiceStateTracker sst = phone.getServiceStateTracker();

2364:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2491:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2551:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2573:         if (phone == null) {

2576:         int subId = phone.getSubId();

2584:             return phone.getImei();

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

2594:         if (phone != null) {

2595:             String imei = phone.getImei();

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

2604:         if (phone == null) {