411:         public Phone phone;

17: package com.android.phone;

211: public class PhoneInterfaceManager extends ITelephony.Stub {

1953:     private PhoneInterfaceManager(PhoneGlobals app) {

1970:     private Phone getDefaultPhone() {

2004:     private Phone getPhone(int subId) {

2647:     public String getNetworkCountryIsoForPhone(int phoneId) {

6433:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

333:     private PhoneConfigurationManager mPhoneConfigurationManager;

1984:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1992:     private Phone getPhoneFromSubId(int subId) {

2423:     private void shutdownRadioUsingPhoneId(int phoneId) {

3063:     public int getActivePhoneType() {

3068:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4748:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6500:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

7089:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

7099:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

421:             if (phone != null) {

422:                 this.phone = phone;

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

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

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

469:             final Phone defaultPhone = getDefaultPhone();

474:                     final Phone phone = getPhoneFromRequest(request);

493:                         request.result = phone != null

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

505:                     final Phone phone = getPhoneFromRequest(request);

506:                     request.result = phone != null ?

783:                     Phone phone = getPhoneFromRequest(request);

784:                     if (phone != null) {

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

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

822:                     Phone phone = getPhoneFromRequest(request);

823:                     if (phone != null) {

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

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

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

1012:                     request.phone.setCallForwardingOption(

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

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

1479:                     Phone phone = getPhoneFromRequest(request);

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

1489:                         Phone phone = getPhoneFromRequest(request);

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

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

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

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

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

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

1577:                     Phone phone = getPhoneFromRequest(request);

1578:                     if (phone != null) {

1579:                         phone.getSystemSelectionChannels(onCompleted);

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

1705:                     Phone phone = getPhoneFromRequest(request);

1706:                     if (phone != null) {

1707:                         phone.setDataThrottling(onCompleted,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1986:             return request.phone;

1998:         Phone phone = getPhoneFromRequest(request);

1999:         return phone == null ? null :

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

2003:     // returns phone associated with the subId.

2008:     private void sendEraseModemConfig(Phone phone) {

2009:         if (phone != null) {

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

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

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

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

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

2292:             if (phone != null) {

2293:                 phone.updateServiceLocation(workSource);

2338:             final Phone phone = getPhone(subId);

2339:             if (phone != null) {

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

2358:             final Phone phone = getPhone(subId);

2359:             if (phone != null) {

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

2376:             final Phone phone = getPhone(subId);

2377:             if (phone == null) {

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

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

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

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

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

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

2426:             phone.shutdownRadio();

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

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

2453:             final Phone phone = getPhone(subId);

2454:             if (phone != null) {

2455:                 phone.setRadioPower(turnOn);

2473:             final Phone phone = getPhone(subId);

2474:             if (phone != null) {

2475:                 phone.getDataEnabledSettings().setDataEnabled(

2494:             final Phone phone = getPhone(subId);

2495:             if (phone != null) {

2496:                 phone.getDataEnabledSettings().setDataEnabled(

2511:             final Phone phone = getPhone(subId);

2512:             if (phone != null) {

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

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

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

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

2579:             final Phone phone = getPhone(subId);

2580:             if (phone != null) {

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

2600:             final Phone phone = getPhone(subId);

2601:             if (phone != null) {

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

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

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

2653:                 // Get default phone in this case.

2654:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2659:             ServiceStateTracker sst = phone.getServiceStateTracker();

2664:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2772:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2834:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2856:         if (phone == null) {

2859:         int subId = phone.getSubId();

2867:             return phone.getImei();

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

2877:         if (phone != null) {

2878:             String imei = phone.getImei();

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

2887:         if (phone == null) {

2891:         int subId = phone.getSubId();

2899:             return phone.getMeid();

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

2909:         if (phone != null) {

2910:             String meid = phone.getMeid();

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

2920:         if (phone == null) {

2923:         int subId = phone.getSubId();

2932:             return phone.getDeviceSvn();

2942:             final Phone phone = getPhone(subId);

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

2953:             final Phone phone = getPhone(subId);

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

2964:             final Phone phone = getPhone(subId);

2965:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2966:                     : phone.getSpecificCarrierId();

2976:             final Phone phone = getPhone(subId);

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

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

2989:         if (phone == null) {

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

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

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

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

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

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

3072:             if (phone == null) {

3073:                 return PhoneConstants.PHONE_TYPE_NONE;

3075:                 return phone.getPhoneType();

3102:             final Phone phone = getPhone(subId);

3103:             if (phone != null) {

3104:                 return phone.getCdmaEriIconIndex();

3135:             final Phone phone = getPhone(subId);

3136:             if (phone != null) {

3137:                 return phone.getCdmaEriIconMode();

3166:             final Phone phone = getPhone(subId);

3167:             if (phone != null) {

3168:                 return phone.getCdmaEriText();

3187:             final Phone phone = getPhone(subId);

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

3189:                 return phone.getLine1Number();

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

3209:             final Phone phone = getPhone(subId);

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

3211:                 return phone.getCdmaMin();

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

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

3391:             final Phone phone = getPhone(subId);

3392:             if (phone != null) {

3393:                 phone.setVoiceActivationState(activationState);

3412:             final Phone phone = getPhone(subId);

3413:             if (phone != null) {

3414:                 phone.setDataActivationState(activationState);

3430:         final Phone phone = getPhone(subId);

3433:             if (phone != null) {

3434:                 return phone.getVoiceActivationState();

3450:         final Phone phone = getPhone(subId);

3453:             if (phone != null) {

3454:                 return phone.getDataActivationState();

3476:             final Phone phone = getPhone(subId);

3477:             if (phone != null) {

3478:                 return phone.getVoiceMessageCount();

3495:             final Phone phone = getPhone(subId);

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

3509:         final Phone defaultPhone = getDefaultPhone();

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

3548:                 if (phone.isInEmergencySmsMode()) {

3559:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3586:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3624:             Phone phone = getPhone(subId);

3625:             if (phone == null) {

3630:             phone.getImsRegistrationState(regState -> {

3657:             Phone phone = getPhone(subId);

3658:             if (phone == null) {

3663:             phone.getImsRegistrationTech(regTech -> {

3682:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3708:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3759:             Phone phone = getPhone(subId);

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

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

3809:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3846:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3880:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3915:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3967:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4049:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

4116:         Phone phone = getPhone(subId);

4117:         if (phone == null) {

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

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

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

4560:             final Phone phone = getPhone(subId);

4561:             if (phone != null) {

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

4594:             final Phone phone = getPhone(subId);

4595:             if (phone != null) {

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

4619:             final Phone phone = getPhone(subId);

4620:             if (phone != null) {

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

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

4647:             if (phone != null) {

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

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

4664:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4683:             final Phone phone = getPhone(subId);

4684:             if (phone == null) {

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

4783:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

5177:         if (phone != null) {

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

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

5203:         if (phone != null) {

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

5221:         final Phone defaultPhone = getDefaultPhone();

5583:             final Phone phone = getPhone(subId);

5584:             if (phone == null) {

5587:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();

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

5644:             Phone phone = getPhone(subId);

5645:             if (phone == null) {

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

5696:             Phone phone = getPhone(subId);

5697:             if (phone == null) {

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

5725:             Phone phone = getPhone(subId);

5726:             if (phone == null) {

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

5754:             Phone phone = getPhone(subId);

5755:             if (phone == null) {

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

5874:         final Phone defaultPhone = getDefaultPhone();

6136:         final Phone phone = getPhone(subId);

6138:             if (phone != null) {

6139:                 return phone.hasMatchedTetherApnSetting();

6159:         final Phone phone = getPhone(subId);

6161:             if (phone != null) {

6166:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

6216:             if (phone != null) {

6217:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

6256:             if (phone != null) {

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

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

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

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

6295:             if (phone != null) {

6298:                     retVal = phone.isUserDataEnabled();

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

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

6317:             Phone phone) {

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

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

6333:             int subId = phone.getSubId();

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

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

6362:             int subId = phone.getSubId();

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

6380:         final Phone phone = getPhone(subId);

6381:         if (phone == null) {

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

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

6399:         final Phone phone = getPhone(subId);

6400:         if (phone == null) {

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

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

6517:         final Phone phone = getPhone(subId);

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

6535:             Phone phone = getPhone(subId);

6536:             if (phone != null) {

6537:                 Phone defaultPhone = phone.getImsPhone();

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

6558:             Phone phone = getPhone(subId);

6559:             if (phone != null) {

6560:                 Phone defaultPhone = phone.getImsPhone();

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

6581:             final Phone phone = getPhone(subId);

6582:             if (phone == null) {

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

6808:             final Phone phone = getPhone(subId);

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

6824:             final Phone phone = getPhone(subId);

6825:             if (phone == null) {

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

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

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

6889:         if (phone == null) {

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

6906:         final Phone defaultPhone = getDefaultPhone();

6920:         final Phone defaultPhone = getDefaultPhone();

6974:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

7005:         final Phone phone = getPhone(subscriptionId);

7006:         if (phone == null) {

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

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

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

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

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

7056:         if (phone == null) {

7059:         int subId = phone.getSubId();

7067:             return phone.getDeviceId();

7080:         Phone phone = getPhone(subId);

7081:         if (phone != null) {

7082:             return phone.isImsRegistered();

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

7119:             Phone phone = getPhone(subscriptionId);

7120:             if (phone == null) {

7123:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

7135:             Phone phone = getPhone(subId);

7136:             if (phone != null) {

7137:                 return phone.isWifiCallingEnabled();

7152:             Phone phone = getPhone(subId);

7153:             if (phone != null) {

7154:                 return phone.isVideoEnabled();

7170:             Phone phone = getPhone(subId);

7171:             if (phone != null) {

7172:                 return phone.getImsRegistrationTech();

7231:         final Phone phone = getPhone(subId);

7232:         if (phone == null) {

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

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

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

7383:             final Phone phone = getPhone(subId);

7384:             if (phone == null) {

7388:             ServiceState ss = phone.getServiceState();

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

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

7413:             if (phone == null) {

7414:                 phone = getDefaultPhone();

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

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

7437:         final Phone defaultPhone = getDefaultPhone();

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

7449:             if (phone == null) {

7450:                 phone = defaultPhone;

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

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

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

7470:             if (phone == null) {

7471:                 phone = getDefaultPhone();

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

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

7494:         final Phone defaultPhone = getDefaultPhone();

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

7506:             if (phone == null) {

7507:                 phone = defaultPhone;

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

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

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

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

7569:         Phone phone = getPhone(subId);

7573:             if (phone == null) {

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

7598:         Phone phone = getPhone(subId);

7602:             if (phone == null) {

7607:                 esn = phone.getEsn();

7626:         Phone phone = getPhone(subId);

7630:             if (phone == null) {

7635:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7729:         final Phone phone = getPhone(subId);

7732:         if (phone == null) {

7737:             phone.carrierActionSetRadioEnabled(enabled);

7757:         final Phone phone = getPhone(subId);

7760:         if (phone == null) {

7765:             phone.carrierActionReportDefaultNetworkStatus(report);

7781:         final Phone phone = getPhone(subId);

7782:         if (phone == null) {

7787:             phone.carrierActionResetAll();

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

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

7844:             Phone phone = getPhone(subId);

7845:             if (phone != null) {

7847:                     phone.carrierActionSetMeteredApnsEnabled(enabled);

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

7869:         Phone phone = getPhone(subId);

7873:             if (phone != null) {

7874:                 return phone.getClientRequestStats();

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

7907:             if (phone != null) {

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

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

7936:             if (phone != null) {

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

7960:      * Check if phone is in emergency callback mode

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

7967:         final Phone phone = getPhone(subId);

7971:             if (phone != null) {

7972:                 return phone.isInEcm();

7992:             Phone p = getPhone(subId);

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

8013:         if (phone != null) {

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

8021:                 return phone.getRadioPowerState();

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

8054:             Phone phone = getPhone(subId);

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

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

8080:             Phone phone = getPhone(subId);

8081:             if (phone != null) {

8082:                 phone.setDataRoamingEnabled(isEnabled);

8098:             Phone phone = getPhone(subId);

8099:             if (phone != null) {

8100:                 isAllowed = phone.isCspPlmnEnabled();

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

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

8265:             Phone phone = getPhone(subId);

8266:             if (phone == null) {

8269:             UiccCard uiccCard = phone.getUiccCard();

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

8314:         return Phone.PREFERRED_NT_MODE;

8324:             final Phone phone = getPhone(subId);

8325:             if (phone == null) {

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

8347:             final Phone phone = getPhone(subId);

8348:             if (phone == null) {

8352:             return phone.getCarrierIdListVersion();

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

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

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

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

8444:                             phone.getSubId(),

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

8456:         final Phone defaultPhone = getDefaultPhone();

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

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

8466:                         && phone.getEmergencyNumberTracker()

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

8488:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8510:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8529:             final Phone phone = getPhone(subId);

8530:             if (phone == null) {

8534:             return phone.getEmergencyNumberDbVersion();

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

8547:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8564:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

8581:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

8594:         Phone phone = getPhone(subId);

8595:         if (phone == null) {

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

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

8621:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8749:         Phone phone = getPhone(subId);

8750:         if (phone == null) {

8755:             UiccCard uiccCard = phone.getUiccCard();

8825:         Phone phone = getDefaultPhone();

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

8827:         HalVersion hv = phone.getHalVersion();

8857:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8863:             Phone phone = getPhone(subId);

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

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

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

8880:             Phone phone = getPhone(subId);

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

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

8895:             Phone phone = getPhone(subscriptionId);

8896:             if (phone == null) {

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

9014:             Phone phone = getPhone(subscriptionId);

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

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

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

9037:             Phone phone = getPhone(subscriptionId);

9038:             if (phone == null) return;

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

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

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

9068:                 Phone defaultPhone = phone.getImsPhone();

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

9118:             Phone phone = getPhone(subId);

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

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

9144:         Phone phone = getPhone(subId);

9145:         if (phone == null) {

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

9176:         Phone phone = getPhone(subId);

9177:         if (phone == null) {

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

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

9246:         Phone phone = getPhone(subId);

9247:         if (phone == null) {

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

9253:             return phone.getEquivalentHomePlmns();

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

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

9308:         Phone phone = getPhone(subId);

9309:         if (phone != null) {

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

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

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

9389:                         Phone phone = getPhone(subId);

9390:                         if (phone == null) {

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

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

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

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

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

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

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

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

62: import android.telecom.PhoneAccount;

63: import android.telecom.PhoneAccountHandle;

86: import android.telephony.PhoneCapability;

87: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

323:     private static PhoneInterfaceManager sInstance;

325:     private PhoneGlobals mApp;

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

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

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

772:                     defaultPhone.resetModemConfig(onCompleted);

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

1186:                     if (defaultPhone != null) {

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

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

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

1502:                     defaultPhone.rebootModem(onCompleted);

1512:                     PhoneConfigurationManager.getInstance()

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

1533:                     PhoneConfigurationManager.getInstance()

1650:                     defaultPhone.eraseModemConfig(onCompleted);

1696:                     getDefaultPhone().getContext().sendBroadcastAsUser(

1938:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1942:         synchronized (PhoneInterfaceManager.class) {

1944:                 sInstance = new PhoneInterfaceManager(app);

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

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

1964:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

2153:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2183:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

2188:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

2190:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

2193:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2436:             if (defaultPhone != null) {

2437:                 defaultPhone.setRadioPower(turnOn);

2583:                 return PhoneConstantConversions.convertDataState(

2584:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

3252:             return getDefaultPhone().needsOtaServiceProvisioning();

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

3288:             if (phoneAccountHandle == null) {

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

3376:         SmsController smsController = PhoneFactory.getSmsController();

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

3520:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4678:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4685:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4688:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);

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

4750:         if (phoneId == -1) {

4754:         return PhoneFactory.getPhone(phoneId);

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

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

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

5229:             return defaultPhone.getPcscfAddress(apnType);

5503:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

6429:             getPhone(phoneId), pkgName);

6446:                 getPhone(i), pkgName);

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

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

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

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

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

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

6539:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6540:                     imsPhone.setCallComposerStatus(status);

6562:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

6563:                     return imsPhone.getCallComposerStatus();

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

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

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

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

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

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

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

7092:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

7107:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

7215:               sendEraseModemConfig(getDefaultPhone());

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

7406:      * PhoneAccount.

7409:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

7432:      * PhoneAccount.

7436:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

7442:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

7466:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

7489:      * specific PhoneAccount.

7493:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

7499:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

8121:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

8312:             return list.get(phoneId);

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

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

8699:         PhoneCapability staticCapability =

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

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

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

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

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

9070:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

9072:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

9075:                             + imsPhone.getMsisdn());

9213:         // *  Inherited from PhoneWindowManager  *

9300:      * PhoneInternalInterface#setRadioPowerForReason} for more details.

9721:             return getDefaultPhone().getMobileProvisioningUrl();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1425:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(

1543:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1988:             return getPhoneFromSubId(request.subId);

2322:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2416:                 shutdownRadioUsingPhoneId(i);

2924:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3064:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

3094:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3127:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3158:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3301:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3469:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3529:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3566:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3592:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3649:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3689:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3714:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3814:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3851:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3885:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3920:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3972:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4054:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

4136:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

4200:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4552:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4586:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4611:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4779:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4821:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

5004:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5446:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5574:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

5898:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5949:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5994:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

6042:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6064:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6070:                     getPhoneFromSubId(subId).getCarrierBandwidth();

6089:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

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

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

6501:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

6628:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

6655:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6678:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6882:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6895:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6945:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6964:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

7115:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "

7340:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7865:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8047:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

8092:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8220:                         slot.getPhoneId(),

8361:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8369:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

8378:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8405:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8432:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8459:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

8640:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8675:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

8700:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8740:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8780:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8787:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

8925:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

9071:                     ImsPhoneCallTracker imsPhoneCallTracker =

9073:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

9241:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

384:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1655:     private PhoneInterfaceManager(PhoneGlobals app) {

1672:     private Phone getDefaultPhone() {

1706:     private Phone getPhone(int subId) {

2347:     public String getNetworkCountryIsoForPhone(int phoneId) {

5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

308:     private PhoneConfigurationManager mPhoneConfigurationManager;

1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1694:     private Phone getPhoneFromSubId(int subId) {

2125:     private void shutdownRadioUsingPhoneId(int phoneId) {

2780:     public int getActivePhoneType() {

2785:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6553:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

394:             if (phone != null) {

395:                 this.phone = phone;

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

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

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

442:             final Phone defaultPhone = getDefaultPhone();

447:                     final Phone phone = getPhoneFromRequest(request);

466:                         request.result = phone != null

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

478:                     final Phone phone = getPhoneFromRequest(request);

479:                     request.result = phone != null ?

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

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

1308:                     Phone phone = getPhoneFromRequest(request);

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

1317:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1688:             return request.phone;

1700:         Phone phone = getPhoneFromRequest(request);

1701:         return phone == null ? null :

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

1705:     // returns phone associated with the subId.

1710:     private void sendEraseModemConfig(Phone phone) {

1711:         if (phone != null) {

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

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

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

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

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

1994:             if (phone != null) {

1995:                 phone.updateServiceLocation(workSource);

2040:             final Phone phone = getPhone(subId);

2041:             if (phone != null) {

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

2060:             final Phone phone = getPhone(subId);

2061:             if (phone != null) {

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

2078:             final Phone phone = getPhone(subId);

2079:             if (phone == null) {

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

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

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

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

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

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

2128:             phone.shutdownRadio();

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

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

2155:             final Phone phone = getPhone(subId);

2156:             if (phone != null) {

2157:                 phone.setRadioPower(turnOn);

2175:             final Phone phone = getPhone(subId);

2176:             if (phone != null) {

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

2195:             final Phone phone = getPhone(subId);

2196:             if (phone != null) {

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

2211:             final Phone phone = getPhone(subId);

2212:             if (phone != null) {

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

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

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

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

2279:             final Phone phone = getPhone(subId);

2280:             if (phone != null) {

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

2300:             final Phone phone = getPhone(subId);

2301:             if (phone != null) {

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

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

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

2353:                 // Get default phone in this case.

2354:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2359:             ServiceStateTracker sst = phone.getServiceStateTracker();

2364:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

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

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

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

2491:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2551:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2573:         if (phone == null) {

2576:         int subId = phone.getSubId();

2584:             return phone.getImei();

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

2594:         if (phone != null) {

2595:             String imei = phone.getImei();

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

2604:         if (phone == null) {

2608:         int subId = phone.getSubId();

2616:             return phone.getMeid();

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

2626:         if (phone != null) {

2627:             String meid = phone.getMeid();

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

2637:         if (phone == null) {

2640:         int subId = phone.getSubId();

2649:             return phone.getDeviceSvn();

2659:             final Phone phone = getPhone(subId);

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

2670:             final Phone phone = getPhone(subId);

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

2681:             final Phone phone = getPhone(subId);

2682:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2683:                     : phone.getSpecificCarrierId();

2693:             final Phone phone = getPhone(subId);

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

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

2706:         if (phone == null) {

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

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

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

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

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

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

2789:             if (phone == null) {

2790:                 return PhoneConstants.PHONE_TYPE_NONE;

2792:                 return phone.getPhoneType();

2819:             final Phone phone = getPhone(subId);