Found 133308 results in 26870 files, showing top 50 files (show more).
android.googlesource.com/platform/packages/services/Telephony:src/com/android/phone/PhoneInterfaceManager.java: [ master, ]
437:         public Phone phone;
17: package com.android.phone;
225: public class PhoneInterfaceManager extends ITelephony.Stub {
2152:     private PhoneInterfaceManager(PhoneGlobals app) {
2170:     private Phone getDefaultPhone() {
2204:     private Phone getPhone(int subId) {
2857:     public String getNetworkCountryIsoForPhone(int phoneId) {
6612:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
6635:     public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
7133:     public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {
355:     private PhoneConfigurationManager mPhoneConfigurationManager;
2184:     private Phone getPhoneFromRequest(MainThreadRequest request) {
2192:     private Phone getPhoneFromSubId(int subId) {
2353:         private final int mPhoneId;
2633:     private void shutdownRadioUsingPhoneId(int phoneId) {
3275:     public int getActivePhoneType() {
3280:     public int getActivePhoneTypeForSlot(int slotIndex) {
4321:     private void checkModifyPhoneStatePermission(int subId, String message) {
4973:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
6679:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
7259:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
7269:     public int getSubIdForPhoneAccountHandle(
7284:     public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
9595:     private boolean isAnyPhoneInEmergencyState() {
10413:     public PhoneCapability getPhoneCapability() {
21: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_CDMA;
22: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_GSM;
23: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_IMS;
160: import com.android.internal.telephony.Phone;
197: import com.android.phone.settings.PickSmsSubscriptionActivity;
198: import com.android.phone.vvm.PhoneAccountHandleConverter;
199: import com.android.phone.vvm.RemoteVvmTaskManager;
200: import com.android.phone.vvm.VisualVoicemailSettingsUtil;
201: import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
436:         // In cases where subId is unavailable, the caller needs to specify the phone.
445:         MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
447:             if (phone != null) {
448:                 this.phone = phone;
476:      * A handler that processes messages on the main thread in the phone process. Since many
477:      * of the Phone calls are not thread safe this is needed to shuttle the requests from the
478:      * inbound binder threads to the main thread in the phone process.  The Binder thread
495:             final Phone defaultPhone = getDefaultPhone();
500:                     final Phone phone = getPhoneFromRequest(request);
519:                         request.result = phone != null
520:                                 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
531:                     final Phone phone = getPhoneFromRequest(request);
532:                     request.result = phone != null ?
809:                     Phone phone = getPhoneFromRequest(request);
810:                     if (phone != null) {
811:                         phone.isNrDualConnectivityEnabled(onCompleted, request.workSource);
813:                         loge("isNRDualConnectivityEnabled: No phone object");
848:                     Phone phone = getPhoneFromRequest(request);
849:                     if (phone != null) {
850:                         phone.setNrDualConnectivityState((int) request.argument, onCompleted,
853:                         loge("enableNrDualConnectivity: No phone object");
986:                     request.phone.getCallForwardingOption(callForwardingReason, onCompleted);
1048:                     request.phone.setCallForwardingOption(
1485:                     request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
1499:                     request.phone.requestCellInfoUpdate(request.workSource,
1527:                     Phone phone = getPhoneFromRequest(request);
1528:                     phone.getCellIdentity(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1537:                         Phone phone = getPhoneFromRequest(request);
1538:                         request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1561:                             .enablePhone(request.phone, enable, onCompleted);
1567:                     int phoneId = request.phone.getPhoneId();
1583:                             .getPhoneStatusFromModem(request.phone, onCompleted);
1588:                     int id = request.phone.getPhoneId();
1611:                     request.phone.setSystemSelectionChannels(args.first, onCompleted);
1626:                     Phone phone = getPhoneFromRequest(request);
1627:                     if (phone != null) {
1628:                         phone.getSystemSelectionChannels(onCompleted);
1630:                         loge("getSystemSelectionChannels: No phone object");
1773:                     Phone phone = getPhoneFromRequest(request);
1774:                     if (phone != null) {
1775:                         phone.setDataThrottling(onCompleted,
1779:                         loge("setDataThrottling: No phone object");
1823:                     request.phone.setSimPowerState(stateToSet, onCompleted, request.workSource);
1867:                     final Phone phone = getPhoneFromRequest(request);
1868:                     if (phone == null || phone.getServiceStateTracker() == null) {
1869:                         request.result = new IllegalStateException("Phone or SST is null");
1878:                     phone.getServiceStateTracker().setSignalStrengthUpdateRequest(
1895:                     Phone phone = getPhoneFromRequest(request);
1896:                     if (phone == null || phone.getServiceStateTracker() == null) {
1897:                         request.result = new IllegalStateException("Phone or SST is null");
1906:                     phone.getServiceStateTracker().clearSignalStrengthUpdateRequest(
1922:                     request.phone.getSlicingConfig(onCompleted);
2045:     private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
2046:         return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone,
2056:     private @Nullable Object sendRequest(int command, Object argument, Integer subId, Phone phone,
2063:         if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
2064:             throw new IllegalArgumentException("subId and phone cannot both be specified!");
2065:         } else if (phone != null) {
2066:             request = new MainThreadRequest(argument, phone, workSource);
2126:      * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
2130:             int command, Object argument, Phone phone, WorkSource workSource) {
2131:         MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
2171:         Phone thePhone = getPhone(getDefaultSubscription());
2185:         if (request.phone != null) {
2186:             return request.phone;
2198:         Phone phone = getPhoneFromRequest(request);
2199:         return phone == null ? null :
2200:                 UiccController.getInstance().getUiccCard(phone.getPhoneId());
2203:     // returns phone associated with the subId.
2208:     private void sendEraseModemConfig(Phone phone) {
2209:         if (phone != null) {
2211:                   mApp, phone.getSubId(), "eraseModemConfig");
2249:             // PENDING: should we just silently fail if phone is offhook or ringing?
2270:         // from the context of the phone app.
2273:         if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)
2323:             Phone phone = getPhone(subId);
2324:             final UnlockSim checkSimPin = new UnlockSim(phone.getPhoneId(), phone.getIccCard());
2337:             Phone phone = getPhone(subId);
2338:             final UnlockSim checkSimPuk = new UnlockSim(phone.getPhoneId(), phone.getIccCard());
2501:             final Phone phone = getPhone(getDefaultSubscription());
2502:             if (phone != null) {
2503:                 phone.updateServiceLocation(workSource);
2548:             final Phone phone = getPhone(subId);
2549:             if (phone != null) {
2550:                 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
2568:             final Phone phone = getPhone(subId);
2569:             if (phone != null) {
2570:                 phone.setRadioPower(!isRadioOnForSubscriber(subId));
2586:             final Phone phone = getPhone(subId);
2587:             if (phone == null) {
2590:             if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
2608:                 Phone phone = PhoneFactory.getPhone(i);
2609:                 if (phone != null && phone.isRadioAvailable()) return true;
2625:                 logv("Shutting down Phone " + i);
2634:         Phone phone = PhoneFactory.getPhone(phoneId);
2635:         if (phone != null && phone.isRadioAvailable()) {
2636:             phone.shutdownRadio();
2645:             final Phone defaultPhone = PhoneFactory.getDefaultPhone();
2650:                 loge("There's no default phone.");
2663:             final Phone phone = getPhone(subId);
2664:             if (phone != null) {
2665:                 phone.setRadioPower(turnOn);
2683:             final Phone phone = getPhone(subId);
2684:             if (phone != null) {
2685:                 phone.getDataEnabledSettings().setDataEnabled(
2704:             final Phone phone = getPhone(subId);
2705:             if (phone != null) {
2706:                 phone.getDataEnabledSettings().setDataEnabled(
2721:             final Phone phone = getPhone(subId);
2722:             if (phone != null) {
2723:                 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);
2772:             Phone phone = PhoneFactory.getPhone(slotIndex);
2773:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :
2774:                     PhoneConstantConversions.convertCallState(phone.getState());
2789:             final Phone phone = getPhone(subId);
2790:             if (phone != null) {
2791:                 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
2810:             final Phone phone = getPhone(subId);
2811:             if (phone != null) {
2812:                 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
2841:                 return (getDefaultPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
2862:             if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
2863:                 // Get default phone in this case.
2864:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
2867:             Phone phone = PhoneFactory.getPhone(phoneId);
2868:             if (phone == null) return "";
2869:             ServiceStateTracker sst = phone.getServiceStateTracker();
2938:         for (Phone phone : PhoneFactory.getPhones()) {
2939:             List<CellInfo> info = phone.getAllCellInfo();
2978:             for (Phone phone : PhoneFactory.getPhones()) {
2980:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);
3042:         final Phone phone = getPhoneFromSubId(subId);
3043:         if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
3045:         sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
3063:         Phone phone = PhoneFactory.getPhone(slotIndex);
3064:         if (phone == null) {
3067:         int subId = phone.getSubId();
3075:             return phone.getImei();
3083:         Phone phone = PhoneFactory.getPhone(slotIndex);
3085:         if (phone != null) {
3086:             String imei = phone.getImei();
3094:         Phone phone = PhoneFactory.getPhone(slotIndex);
3095:         if (phone == null) {
3099:         int subId = phone.getSubId();
3107:             return phone.getMeid();
3115:         Phone phone = PhoneFactory.getPhone(slotIndex);
3117:         if (phone != null) {
3118:             String meid = phone.getMeid();
3127:         Phone phone = PhoneFactory.getPhone(slotIndex);
3128:         if (phone == null) {
3131:         int subId = phone.getSubId();
3140:             return phone.getDeviceSvn();
3150:             final Phone phone = getPhone(subId);
3151:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
3161:             final Phone phone = getPhone(subId);
3162:             return phone == null ? null : phone.getCarrierName();
3172:             final Phone phone = getPhone(subId);
3173:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
3174:                     : phone.getSpecificCarrierId();
3184:             final Phone phone = getPhone(subId);
3185:             return phone == null ? null : phone.getSpecificCarrierName();
3196:         final Phone phone = PhoneFactory.getPhone(slotIndex);
3197:         if (phone == null) {
3202:             return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
3213:      * Make sure the caller has the MODIFY_PHONE_STATE permission.
3218:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
3238:      * Make sure the caller has the CALL_PHONE permission.
3243:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
3283:             final Phone phone = PhoneFactory.getPhone(slotIndex);
3284:             if (phone == null) {
3285:                 return PhoneConstants.PHONE_TYPE_NONE;
3287:                 return phone.getPhoneType();
3314:             final Phone phone = getPhone(subId);
3315:             if (phone != null) {
3316:                 return phone.getCdmaEriIconIndex();
3347:             final Phone phone = getPhone(subId);
3348:             if (phone != null) {
3349:                 return phone.getCdmaEriIconMode();
3378:             final Phone phone = getPhone(subId);
3379:             if (phone != null) {
3380:                 return phone.getCdmaEriText();
3399:             final Phone phone = getPhone(subId);
3400:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
3401:                 return phone.getLine1Number();
3403:                 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
3421:             final Phone phone = getPhone(subId);
3422:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
3423:                 return phone.getCdmaMin();
3435:         if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
3437:             throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
3603:             final Phone phone = getPhone(subId);
3604:             if (phone != null) {
3605:                 phone.setVoiceActivationState(activationState);
3624:             final Phone phone = getPhone(subId);
3625:             if (phone != null) {
3626:                 phone.setDataActivationState(activationState);
3642:         final Phone phone = getPhone(subId);
3645:             if (phone != null) {
3646:                 return phone.getVoiceActivationState();
3662:         final Phone phone = getPhone(subId);
3665:             if (phone != null) {
3666:                 return phone.getDataActivationState();
3688:             final Phone phone = getPhone(subId);
3689:             if (phone != null) {
3690:                 return phone.getVoiceMessageCount();
3707:             final Phone phone = getPhone(subId);
3708:             return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
3721:         final Phone defaultPhone = getDefaultPhone();
3759:             for (Phone phone : PhoneFactory.getPhones()) {
3760:                 if (phone.isInEmergencySmsMode()) {
3771:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3798:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3836:             Phone phone = getPhone(subId);
3837:             if (phone == null) {
3842:             phone.getImsRegistrationState(regState -> {
3869:             Phone phone = getPhone(subId);
3870:             if (phone == null) {
3875:             phone.getImsRegistrationTech(regTech -> {
3894:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3920:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3971:             Phone phone = getPhone(subId);
3972:             if (phone == null) return false;
3973:             return phone.isImsCapabilityAvailable(capability, regTech);
4021:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4058:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4092:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4127:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4179:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4261:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4328:         Phone phone = getPhone(subId);
4329:         if (phone == null) {
4330:             loge("phone instance null for subid " + subId);
4334:             if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
4338:             if (!doesRcsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
4785:             final Phone phone = getPhone(subId);
4786:             if (phone != null) {
4787:                 return phone.getServiceState().getDataNetworkType();
4819:             final Phone phone = getPhone(subId);
4820:             if (phone != null) {
4821:                 return phone.getServiceState().getDataNetworkType();
4844:             final Phone phone = getPhone(subId);
4845:             if (phone != null) {
4846:                 return phone.getServiceState().getVoiceNetworkType();
4871:             final Phone phone = PhoneFactory.getPhone(slotIndex);
4872:             if (phone != null) {
4873:                 return phone.getIccCard().hasIccCard();
4888:      * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
4889:      * or {@link Phone#LTE_ON_CDMA_TRUE}
4908:             final Phone phone = getPhone(subId);
4909:             if (phone == null) {
4977:                     + " does not correspond to an active phone");
5008:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
5025:                     CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
5050:     private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
5056:             Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
5093:     private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
5102:                     new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
5149:     private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
5167:                     new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
5401:         Phone phone = PhoneFactory.getPhone(slotIndex);
5402:         if (phone != null) {
5404:                     mApp, phone.getSubId(), "resetModemConfig");
5427:         Phone phone = PhoneFactory.getPhone(slotIndex);
5428:         if (phone != null) {
5430:                     mApp, phone.getSubId(), "rebootModem");
5446:         final Phone defaultPhone = getDefaultPhone();
5724:      * Sets the ims registration state on all valid {@link Phone}s.
5731:             // NOTE: Before S, this method only set the default phone.
5732:             for (final Phone phone : PhoneFactory.getPhones()) {
5733:                 if (SubscriptionManager.isValidSubscriptionId(phone.getSubId())) {
5734:                     phone.setImsRegistrationState(registered);
5817:             final Phone phone = getPhone(subId);
5818:             if (phone == null) {
5821:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();
5823:                 ? phone.getManualNetworkSelectionPlmn() : networkSelection.getOperatorNumeric();
5880:             Phone phone = getPhone(subId);
5881:             if (phone == null) {
5911:             sendRequestAsync(CMD_GET_CALL_FORWARDING, argument, phone, null);
5932:             Phone phone = getPhone(subId);
5933:             if (phone == null) {
5946:             sendRequestAsync(CMD_SET_CALL_FORWARDING, arguments, phone, null);
5960:             Phone phone = getPhone(subId);
5961:             if (phone == null) {
5969:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
5976:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
5996:                 sendRequestAsync(CMD_GET_CALL_WAITING, argument, phone, null);
6013:             Phone phone = getPhone(subId);
6014:             if (phone == null) {
6023:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
6030:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
6053:                 sendRequestAsync(CMD_SET_CALL_WAITING, arguments, phone, null);
6314:         final Phone phone = getPhone(subId);
6316:             if (phone != null) {
6317:                 return phone.hasMatchedTetherApnSetting();
6337:         final Phone phone = getPhone(subId);
6339:             if (phone != null) {
6344:                 phone.setAlwaysReportSignalStrength(isEnable);
6346:                 loge("setAlwaysReportSignalStrength: no phone found for subId="
6375:      * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
6393:             Phone phone = PhoneFactory.getPhone(phoneId);
6394:             if (phone != null) {
6395:                 boolean retVal = phone.isUserDataEnabled();
6399:                 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
6422:                 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
6433:             Phone phone = PhoneFactory.getPhone(phoneId);
6434:             if (phone != null) {
6435:                 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
6439:                 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
6460:             mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
6472:             Phone phone = PhoneFactory.getPhone(phoneId);
6473:             if (phone != null) {
6476:                     retVal = phone.isUserDataEnabled();
6478:                     retVal = phone.getDataEnabledSettings().isDataEnabledForReason(reason);
6484:                     loge("isDataEnabledForReason: no phone subId="
6495:             Phone phone) {
6496:         if (uid == Process.PHONE_UID) {
6497:             // Skip the check if it's the phone UID (system UID removed in b/184713596)
6498:             // TODO (b/184954344): Check for system/phone UID at call site instead of here
6507:         PackageManager pkgMgr = phone.getContext().getPackageManager();
6512:             int subId = phone.getSubId();
6520:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
6532:     private int getCarrierPrivilegeStatusFromCarrierConfigRules(int privilegeFromSim, Phone phone,
6541:             int subId = phone.getSubId();
6549:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
6559:         final Phone phone = getPhone(subId);
6560:         if (phone == null) {
6564:         UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
6572:                 phone.getContext().getPackageManager()), Binder.getCallingUid(), phone);
6578:         final Phone phone = getPhone(subId);
6579:         if (phone == null) {
6584:                 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
6591:                         phone.getContext().getPackageManager(), uid), uid, phone);
6696:         final Phone phone = getPhone(subId);
6697:         UiccCard card = phone == null ? null : phone.getUiccCard();
6714:             Phone phone = getPhone(subId);
6715:             if (phone != null) {
6716:                 Phone defaultPhone = phone.getImsPhone();
6717:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
6737:             Phone phone = getPhone(subId);
6738:             if (phone != null) {
6739:                 Phone defaultPhone = phone.getImsPhone();
6740:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
6760:             final Phone phone = getPhone(subId);
6761:             if (phone == null) {
6764:             final String subscriberId = phone.getSubscriberId();
6987:             final Phone phone = getPhone(subId);
6988:             return phone == null ? false : phone.setOperatorBrandOverride(brand);
7003:             final Phone phone = getPhone(subId);
7004:             if (phone == null) {
7007:             return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
7049:         Phone phone = PhoneFactory.getPhone(phoneId);
7053:                             mApp, phone.getSubId(), "getRadioAccessFamily");
7059:         if (phone == null) {
7066:                             mApp, phone.getSubId(), "getRadioAccessFamily");
7076:         final Phone defaultPhone = getDefaultPhone();
7090:         final Phone defaultPhone = getDefaultPhone();
7144:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
7175:         final Phone phone = getPhone(subscriptionId);
7176:         if (phone == null) {
7177:             loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
7184:                     phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
7217:      * Returns the unique device ID of phone, for example, the IMEI for
7221:      *   {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
7225:         final Phone phone = PhoneFactory.getPhone(0);
7226:         if (phone == null) {
7229:         int subId = phone.getSubId();
7237:             return phone.getDeviceId();
7250:         Phone phone = getPhone(subId);
7251:         if (phone != null) {
7252:             return phone.isImsRegistered();
7273:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
7289:             Phone phone = getPhone(subscriptionId);
7290:             if (phone == null) {
7293:             return PhoneUtils.makePstnPhoneAccountHandle(phone);
7305:             Phone phone = getPhone(subId);
7306:             if (phone != null) {
7307:                 return phone.isWifiCallingEnabled();
7322:             Phone phone = getPhone(subId);
7323:             if (phone != null) {
7324:                 return phone.isVideoEnabled();
7340:             Phone phone = getPhone(subId);
7341:             if (phone != null) {
7342:                 return phone.getImsRegistrationTech();
7366:                 Phone phone = getPhone(subId);
7367:                 cleanUpAllowedNetworkTypes(phone, subId);
7394:     void cleanUpAllowedNetworkTypes(Phone phone, int subId) {
7395:         if (phone == null || !SubscriptionManager.isUsableSubscriptionId(subId)) {
7403:         phone.loadAllowedNetworksFromSubscriptionDatabase();
7404:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
7417:         final Phone phone = getPhone(subId);
7418:         if (phone == null) {
7425:                     phone.getContext().getOpPackageName(), phone.getContext().getAttributionTag());
7434:             final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
7563:             // isActiveSubId requires READ_PHONE_STATE, which we already check for above
7570:             final Phone phone = getPhone(subId);
7571:             if (phone == null) {
7575:             ServiceState ss = phone.getServiceState();
7588:      * Returns the URI for the per-account voicemail ringtone set in Phone settings.
7599:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
7600:             if (phone == null) {
7601:                 phone = getDefaultPhone();
7604:             return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
7614:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
7624:         final Phone defaultPhone = getDefaultPhone();
7635:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
7636:             if (phone == null) {
7637:                 phone = defaultPhone;
7639:             VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
7646:      * Returns whether vibration is set for voicemail notification in Phone settings.
7656:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
7657:             if (phone == null) {
7658:                 phone = getDefaultPhone();
7661:             return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
7671:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
7681:         final Phone defaultPhone = getDefaultPhone();
7692:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
7693:             if (phone == null) {
7694:                 phone = defaultPhone;
7696:             VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
7703:      * Make sure either called from same process as self (phone) or IPC caller has read privilege.
7708:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
7713:      * Make sure either called from same process as self (phone) or IPC caller has send SMS
7756:         Phone phone = getPhone(subId);
7760:             if (phone == null) {
7765:                 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
7785:         Phone phone = getPhone(subId);
7789:             if (phone == null) {
7794:                 esn = phone.getEsn();
7813:         Phone phone = getPhone(subId);
7817:             if (phone == null) {
7822:                 cdmaPrlVersion = phone.getCdmaPrlVersion();
7916:         final Phone phone = getPhone(subId);
7919:         if (phone == null) {
7924:             phone.carrierActionSetRadioEnabled(enabled);
7944:         final Phone phone = getPhone(subId);
7947:         if (phone == null) {
7952:             phone.carrierActionReportDefaultNetworkStatus(report);
7968:         final Phone phone = getPhone(subId);
7969:         if (phone == null) {
7974:             phone.carrierActionResetAll();
7981:      * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
7988:             writer.println("Permission Denial: can't dump Phone from pid="
8031:             Phone phone = getPhone(subId);
8032:             if (phone != null) {
8034:                     phone.carrierActionSetMeteredApnsEnabled(enabled);
8036:                     phone.getDataEnabledSettings().setDataEnabled(reason, enabled);
8056:         Phone phone = getPhone(subId);
8060:             if (phone != null) {
8061:                 return phone.getClientRequestStats();
8088:         Phone phone = PhoneFactory.getPhone(slotIndex);
8094:             if (phone != null) {
8095:                 phone.setSimPowerState(state, null, workSource);
8117:         Phone phone = PhoneFactory.getPhone(slotIndex);
8123:             if (phone != null) {
8125:                 sendRequestAsync(CMD_SET_SIM_POWER, arguments, phone, workSource);
8147:      * Check if phone is in emergency callback mode
8148:      * @return true if phone is in emergency callback mode
8154:         final Phone phone = getPhone(subId);
8158:             if (phone != null) {
8159:                 return phone.isInEcm();
8179:             Phone p = getPhone(subId);
8199:         Phone phone = PhoneFactory.getPhone(slotIndex);
8200:         if (phone != null) {
8201:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, phone.getSubId(),
8208:                 return phone.getRadioPowerState();
8221:      * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
8241:             Phone phone = getPhone(subId);
8242:             isEnabled =  phone != null ? phone.getDataRoamingEnabled() : false;
8254:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
8267:             Phone phone = getPhone(subId);
8268:             if (phone != null) {
8269:                 phone.setDataRoamingEnabled(isEnabled);
8285:             Phone phone = getPhone(subId);
8286:             if (phone != null) {
8287:                 isAllowed = phone.isCspPlmnEnabled();
8306:             // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
8443:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
8452:             Phone phone = getPhone(subId);
8453:             if (phone == null) {
8456:             UiccCard uiccCard = phone.getUiccCard();
8493:      * not set, return {@link Phone#PREFERRED_NT_MODE}.
8501:         return Phone.PREFERRED_NT_MODE;
8511:             final Phone phone = getPhone(subId);
8512:             if (phone == null) {
8516:             phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
8534:             final Phone phone = getPhone(subId);
8535:             if (phone == null) {
8539:             return phone.getCarrierIdListVersion();
8622:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
8627:             for (Phone phone: PhoneFactory.getPhones()) {
8628:                 if (phone.getEmergencyNumberTracker() != null
8629:                         && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
8631:                             phone.getSubId(),
8632:                             phone.getEmergencyNumberTracker().getEmergencyNumberList());
8643:         final Phone defaultPhone = getDefaultPhone();
8651:             for (Phone phone: PhoneFactory.getPhones()) {
8652:                 if (phone.getEmergencyNumberTracker() != null
8653:                         && phone.getEmergencyNumberTracker()
8674:             for (Phone phone : PhoneFactory.getPhones()) {
8675:                 Rlog.d(LOG_TAG, "startEmergencyCallbackMode phone type: " + phone.getPhoneType());
8676:                 if (phone != null && ((phone.getPhoneType() == PHONE_TYPE_GSM)
8677:                         || (phone.getPhoneType() == PHONE_TYPE_CDMA))) {
8678:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;
8699:             for (Phone phone: PhoneFactory.getPhones()) {
8700:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8721:             for (Phone phone: PhoneFactory.getPhones()) {
8722:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8741:             final Phone phone = getPhone(subId);
8742:             if (phone == null) {
8746:             return phone.getEmergencyNumberDbVersion();
8758:             for (Phone phone: PhoneFactory.getPhones()) {
8759:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8775:             for (Phone phone: PhoneFactory.getPhones()) {
8776:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8792:             for (Phone phone: PhoneFactory.getPhones()) {
8793:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8806:         Phone phone = getPhone(subId);
8807:         if (phone == null) {
8813:                     .getUiccProfileForPhone(phone.getPhoneId());
8832:             Phone phone = PhoneFactory.getPhone(slotIndex);
8833:             if (phone == null) {
8836:                 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
8849:         Phone phone = PhoneFactory.getPhone(slotIndex);
8850:         if (phone == null) return false;
8853:                 mApp, phone.getSubId(), callingPackage, callingFeatureId,
8855:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
8861:                 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
8863:                 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
8931:      * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
8932:      * permission, but the other way around is possible with either MODIFY_PHONE_STATE
8961:         Phone phone = getPhone(subId);
8962:         if (phone == null) {
8967:             UiccCard uiccCard = phone.getUiccCard();
9037:         Phone phone = getDefaultPhone();
9038:         if (phone == null) return -1;
9039:         HalVersion hv = phone.getHalVersion();
9069:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "
9075:             Phone phone = getPhone(subId);
9076:             if (phone == null) return false;
9078:             boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);
9079:             return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
9092:             Phone phone = getPhone(subId);
9093:             if (phone == null) return true; // By default return true.
9095:             return ApnSettingUtils.isMeteredApnType(apnType, phone);
9107:             Phone phone = getPhone(subscriptionId);
9108:             if (phone == null) {
9128:             sendRequestAsync(CMD_SET_SYSTEM_SELECTION_CHANNELS, argument, phone, null);
9228:             Phone phone = getPhone(subscriptionId);
9229:             if (phone == null) return false;
9233:                     return phone.getDataEnabledSettings().isDataAllowedInVoiceCall();
9235:                     return phone.getDataEnabledSettings().isMmsAlwaysAllowed();
9251:             Phone phone = getPhone(subscriptionId);
9252:             if (phone == null) return;
9256:                     phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(enabled);
9259:                     phone.getDataEnabledSettings().setAlwaysAllowMmsData(enabled);
9281:             for (Phone phone : PhoneFactory.getPhones()) {
9282:                 Phone defaultPhone = phone.getImsPhone();
9283:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
9332:             Phone phone = getPhone(subId);
9333:             if (phone != null && phone.getIccCard() != null) {
9334:                 return phone.getIccCard().getIccLockEnabled();
9358:         Phone phone = getPhone(subId);
9359:         if (phone == null) {
9366:                     new Pair<Boolean, String>(enabled, password), phone, null);
9390:         Phone phone = getPhone(subId);
9391:         if (phone == null) {
9398:                     new Pair<String, String>(oldPassword, newPassword), phone, null);
9457:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
9460:         Phone phone = getPhone(subId);
9461:         if (phone == null) {
9462:             throw new RuntimeException("phone is not available");
9467:             return phone.getEquivalentHomePlmns();
9492:                 Manifest.permission.MODIFY_PHONE_STATE);
9532:      * @return {@code true} if phone setRadioPowerForReason was called. Otherwise, returns {@code
9538:             Phone phone = PhoneFactory.getPhone(i);
9539:             if (phone != null) {
9540:                 phone.setRadioPowerForReason(enable, Phone.RADIO_POWER_REASON_THERMAL);
9545:         // return true if successfully informed the phone object about the thermal radio power
9559:         // Ensure that radio is on. If not able to power on due to phone being unavailable, return
9598:             Log.e(LOG_TAG , "Phone state is not valid. One of the phones is in an emergency call");
9601:         for (Phone phone : PhoneFactory.getPhones()) {
9602:             if (phone.isInEmergencySmsMode() || phone.isInEcm()) {
9603:                 Log.e(LOG_TAG, "Phone state is not valid. isInEmergencySmsMode = "
9604:                     + phone.isInEmergencySmsMode() + " isInEmergencyCallbackMode = "
9605:                     + phone.isInEcm());
9675:                     // Ensure that radio is on. If not able to power on due to phone being
9695:                         Phone phone = getPhone(subId);
9696:                         if (phone == null) {
9720:                     // Turn radio off. If not able to power off due to phone being unavailable,
9844:                 permission.READ_PRIVILEGED_PHONE_STATE);
9875:                 permission.READ_PRIVILEGED_PHONE_STATE);
9906:                 permission.READ_PRIVILEGED_PHONE_STATE);
10351:         if (callingUid == Process.PHONE_UID || callingUid == Process.SYSTEM_UID) {
10352:             // phone/system process do not have further restriction on request
10405:      * Gets the current phone capability.
10407:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
10409:      * It's used to evaluate possible phone config change, for example from single
10427:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.
10435:             Phone phone = getDefaultPhone();
10436:             sendRequestAsync(CMD_GET_SLICING_CONFIG, callback, phone, null);
24: import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
66: import android.telecom.PhoneAccount;
67: import android.telecom.PhoneAccountHandle;
89: import android.telephony.PhoneCapability;
90: import android.telephony.PhoneNumberRange;
149: import com.android.internal.telephony.GsmCdmaPhone;
161: import com.android.internal.telephony.PhoneConfigurationManager;
162: import com.android.internal.telephony.PhoneConstantConversions;
163: import com.android.internal.telephony.PhoneConstants;
164: import com.android.internal.telephony.PhoneFactory;
179: import com.android.internal.telephony.imsphone.ImsPhone;
180: import com.android.internal.telephony.imsphone.ImsPhoneCallTracker;
226:     private static final String LOG_TAG = "PhoneInterfaceManager";
227:     private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
344:     private static PhoneInterfaceManager sInstance;
347:     private PhoneGlobals mApp;
750:                     defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
777:                     defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
788:                     defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
798:                     defaultPhone.resetModemConfig(onCompleted);
940:                     defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
1221:                     if (defaultPhone != null) {
1222:                         defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
1298:                     defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
1326:                     defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
1550:                     defaultPhone.rebootModem(onCompleted);
1560:                     PhoneConfigurationManager.getInstance()
1570:                         mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1582:                     PhoneConfigurationManager.getInstance()
1699:                     defaultPhone.eraseModemConfig(onCompleted);
1719:                         int phoneId = getPhoneFromRequest(request).getPhoneId();
1721:                         pinStorage.storePin(passwords.second, phoneId,
1722:                                 pinStorage.getIccid(phoneId));
1744:                         int phoneId = getPhoneFromRequest(request).getPhoneId();
1747:                             pinStorage.storePin(enabled.second, phoneId,
1748:                                     pinStorage.getIccid(phoneId));
1750:                             UiccController.getInstance().getPinStorage().clearPin(phoneId);
1764:                     getDefaultPhone().getContext().sendBroadcastAsUser(
2137:      * Initialize the singleton PhoneInterfaceManager instance.
2138:      * This is only done once, at startup, from PhoneApp.onCreate().
2140:     /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
2141:         synchronized (PhoneInterfaceManager.class) {
2143:                 sInstance = new PhoneInterfaceManager(app);
2154:         mCM = PhoneGlobals.getInstance().mCM;
2163:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
2172:         return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
2194:                 ? getDefaultPhone() : getPhone(subId);
2205:         return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
2223:         PackageManager pm = getDefaultPhone().getContext().getPackageManager();
2250:             PhoneConstants.State state = mCM.getState(subId);
2251:             if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
2310:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
2315:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
2356:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
2365:         UnlockSim(int phoneId, IccCard simCard) {
2366:             mPhoneId = phoneId;
2387:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
2392:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;
2394:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;
2397:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;
2449:             if (mResult == PhoneConstants.PIN_RESULT_SUCCESS && pin.length() > 0) {
2611:             logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
2646:             if (defaultPhone != null) {
2647:                 defaultPhone.setRadioPower(turnOn);
2793:                 return PhoneConstantConversions.convertDataState(
2794:                         PhoneConstants.DataState.DISCONNECTED);
2866:             final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
3055:             getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
3263:         Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
3267:         Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
3271:         Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
3433:     public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
3464:             return getDefaultPhone().needsOtaServiceProvisioning();
3499:             PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
3500:             if (phoneAccountHandle == null) {
3503:             return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
3588:         SmsController smsController = PhoneFactory.getSmsController();
3723:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
3732:             defaultPhone.sendDialerSpecialCode(inputCode);
3787:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3811:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3907:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3934:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3950:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4029:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4047:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4067:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4082:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4101:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4117:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4136:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4152:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4168:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4188:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4204:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4219:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4235:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4251:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4270:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4289:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4307:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4352:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4382:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4415:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4480:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4656:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4681:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4707:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4733:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4903:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
4910:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
4913:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);
4974:         int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
4975:         if (phoneId == -1) {
4979:         return PhoneFactory.getPhone(phoneId);
5014:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
5156:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
5447:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
5454:             return defaultPhone.getPcscfAddress(apnType);
6101:                     request, messenger, binder, getPhone(subId),
6391:             int phoneId = mSubscriptionController.getPhoneId(subId);
6392:             if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
6431:             int phoneId = mSubscriptionController.getPhoneId(subId);
6432:             if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
6467:             int phoneId = mSubscriptionController.getPhoneId(subId);
6469:                 log("isDataEnabledForReason: subId=" + subId + " phoneId=" + phoneId
6600:         int phoneId = SubscriptionManager.getPhoneId(subId);
6601:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
6608:             getPhone(phoneId), pkgName);
6625:                 getPhone(i), pkgName);
6636:         if (!SubscriptionManager.isValidPhoneId(phoneId)) {
6637:             loge("phoneId " + phoneId + " is not valid.");
6640:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
6642:             loge("getCarrierPackageNamesForIntentAndPhone: No UICC");
6649:     public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
6653:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
6718:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
6719:                     imsPhone.setCallComposerStatus(status);
6741:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
6742:                     return imsPhone.getCallComposerStatus();
7048:     public int getRadioAccessFamily(int phoneId, String callingPackage) {
7067:             raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
7081:             ImsManager.getInstance(defaultPhone.getContext(),
7082:                     defaultPhone.getPhoneId()).setVtSetting(enable);
7091:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
7103:                     ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
7218:      * GSM and the MEID for CDMA phones. Return null if device ID is not available.
7262:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
7270:             PhoneAccountHandle phoneAccountHandle, String callingPackage, String callingFeatureId) {
7277:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);
7375:             cleanUpSmsRawTable(getDefaultPhone().getContext());
7386:               sendEraseModemConfig(getDefaultPhone());
7590:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
7593:      * PhoneAccount.
7596:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
7616:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
7619:      * PhoneAccount.
7623:             PhoneAccountHandle phoneAccountHandle, Uri uri) {
7626:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
7629:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
7648:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
7650:      * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
7653:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
7673:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
7676:      * specific PhoneAccount.
7680:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {
7683:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
7686:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
8002:         return new TelephonyShellCommand(this, getDefaultPhone().getContext()).exec(
8308:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
8497:         int phoneId = mSubscriptionController.getPhoneId(subId);
8498:         if (phoneId >= 0 && phoneId < list.size() && list.get(phoneId) != null) {
8499:             return list.get(phoneId);
8647:                             mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
8665:      * Start emergency callback mode for GsmCdmaPhone for testing.
8679:                     gsmCdmaPhone.obtainMessage(
8680:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();
8888:                 getDefaultPhone().getSubId(), callingPackage, callingFeatureId,
8911:         PhoneCapability staticCapability =
9017:             int phoneCount = TelephonyManager.getDefault().getPhoneCount();
9019:             int[] logicalSlotsMapping = new int[phoneCount];
9172:         SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
9198:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
9215:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
9284:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
9286:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();
9288:                     Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled + ", for imsPhone "
9289:                             + imsPhone.getMsisdn());
9427:         // *  Inherited from PhoneWindowManager  *
9526:      * Attempts to set the radio power state for all phones for thermal reason.
9529:      * PhoneInternalInterface#setRadioPowerForReason} for more details.
9651:         if (!getThermalMitigationAllowlist(getDefaultPhone().getContext())
10110:             return getDefaultPhone().getMobileProvisioningUrl();
10125:             return EabUtil.getContactFromEab(getDefaultPhone().getContext(), contact);
10140:             return EabUtil.removeContactFromEab(subId, contacts, getDefaultPhone().getContext());
10408:      * @return the PhoneCapability which describes the data connection capability of modem.
147: import com.android.internal.telephony.DefaultPhoneNotifier;
533:                             getPhoneFromRequest(request).handlePinMmi((String) request.argument)
897:                     getPhoneFromRequest(request).getAllowedNetworkTypesBitmask(onCompleted);
927:                     getPhoneFromRequest(request).setAllowedNetworkTypes(
954:                     getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
966:                     getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
976:                     getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
1089:                     getPhoneFromRequest(request).getCallWaiting(onCompleted);
1135:                     getPhoneFromRequest(request).setCallWaiting(enable, onCompleted);
1201:                     getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
1409:                     getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
1430:                     getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1446:                     getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1457:                     getPhoneFromRequest(request).queryCdmaSubscriptionMode(onCompleted);
1473:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(
1592:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,
1709:                     getPhoneFromRequest(request).getIccCard().changeIccLockPassword(
1733:                     getPhoneFromRequest(request).getIccCard().setIccLockEnabled(
2188:             return getPhoneFromSubId(request.subId);
2451:                 pinStorage.storePin(pin, mPhoneId, pinStorage.getIccid(mPhoneId));
2532:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2607:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2624:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2626:                 shutdownRadioUsingPhoneId(i);
3132:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3276:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
3306:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3339:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3370:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3513:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3681:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3741:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3778:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3804:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3861:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3901:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3926:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4026:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4063:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4097:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4132:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4184:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4266:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4348:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");
4412:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");
4777:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(
4811:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4836:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4929:         return mSubscriptionController.getPhoneId(getDefaultSubscription());
4991:         return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
5004:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
5039:         return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
5046:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
5075:         return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
5089:                 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
5128:         return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
5144:                 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
5229:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5267:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,
5671:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5808:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
6161:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
6186:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
6190:             return getPhoneFromSubId(subId).getAllowedNetworkTypes(reason);
6239:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
6285:         if (allowedNetworkTypes == getPhoneFromSubId(subId).getAllowedNetworkTypes(reason)) {
6616:         for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
6680:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");
6686:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
6807:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
6834:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6857:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7052:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7065:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7115:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7134:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7271:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, getDefaultSubscription(),
7272:                 callingPackage, callingFeatureId, "getSubIdForPhoneAccountHandle")) {
7285:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "
7523:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8052:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8234:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
8279:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8407:                         slot.getPhoneId(),
8548:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8556:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
8565:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8592:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8619:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8646:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8852:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8887:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
8912:                 mPhoneConfigurationManager.getStaticPhoneCapability();
8952:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
8992:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8999:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
9008:         metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
9022:                 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
9137:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
9158:                 SubscriptionManager.getPhoneId(subId), UiccController.APP_FAM_3GPP);
9285:                     ImsPhoneCallTracker imsPhoneCallTracker =
9287:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);
9455:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
9536:         boolean isPhoneAvailable = false;
9541:                 isPhoneAvailable = true;
9547:         return isPhoneAvailable;
9709:                         } else if (isAnyPhoneInEmergencyState()) {
10414:         enforceReadPrivilegedPermission("getPhoneCapability");
10417:             return mPhoneConfigurationManager.getCurrentPhoneCapability();
android.googlesource.com/platform/superproject:packages/services/Telephony/src/com/android/phone/PhoneInterfaceManager.java: [ master, ]
384:         public Phone phone;
17: package com.android.phone;
198: public class PhoneInterfaceManager extends ITelephony.Stub {
1655:     private PhoneInterfaceManager(PhoneGlobals app) {
1672:     private Phone getDefaultPhone() {
1706:     private Phone getPhone(int subId) {
2347:     public String getNetworkCountryIsoForPhone(int phoneId) {
5936:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
5959:     public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
6417:     public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {
308:     private PhoneConfigurationManager mPhoneConfigurationManager;
1686:     private Phone getPhoneFromRequest(MainThreadRequest request) {
1694:     private Phone getPhoneFromSubId(int subId) {
2125:     private void shutdownRadioUsingPhoneId(int phoneId) {
2780:     public int getActivePhoneType() {
2785:     public int getActivePhoneTypeForSlot(int slotIndex) {
3824:     private void checkModifyPhoneStatePermission(int subId, String message) {
4463:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
6003:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
6543:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
6553:     public int getSubIdForPhoneAccountHandle(
6568:     public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
21: import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_IMS;
140: import com.android.internal.telephony.Phone;
174: import com.android.phone.settings.PickSmsSubscriptionActivity;
175: import com.android.phone.vvm.PhoneAccountHandleConverter;
176: import com.android.phone.vvm.RemoteVvmTaskManager;
177: import com.android.phone.vvm.VisualVoicemailSettingsUtil;
178: import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
383:         // In cases where subId is unavailable, the caller needs to specify the phone.
392:         MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
394:             if (phone != null) {
395:                 this.phone = phone;
423:      * A handler that processes messages on the main thread in the phone process. Since many
424:      * of the Phone calls are not thread safe this is needed to shuttle the requests from the
425:      * inbound binder threads to the main thread in the phone process.  The Binder thread
442:             final Phone defaultPhone = getDefaultPhone();
447:                     final Phone phone = getPhoneFromRequest(request);
466:                         request.result = phone != null
467:                                 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
478:                     final Phone phone = getPhoneFromRequest(request);
479:                     request.result = phone != null ?
1266:                     request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
1280:                     request.phone.requestCellInfoUpdate(request.workSource,
1308:                     Phone phone = getPhoneFromRequest(request);
1309:                     phone.getCellIdentity(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1317:                         phone = getPhoneFromRequest(request);
1318:                         request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1340:                             .enablePhone(request.phone, enable, onCompleted);
1346:                     int phoneId = request.phone.getPhoneId();
1361:                             .getPhoneStatusFromModem(request.phone, onCompleted);
1366:                     int id = request.phone.getPhoneId();
1389:                     request.phone.setSystemSelectionChannels(args.first, onCompleted);
1569:     private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
1571:                 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone, workSource);
1580:             int command, Object argument, Integer subId, Phone phone, WorkSource workSource) {
1586:         if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
1587:             throw new IllegalArgumentException("subId and phone cannot both be specified!");
1588:         } else if (phone != null) {
1589:             request = new MainThreadRequest(argument, phone, workSource);
1629:      * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
1633:             int command, Object argument, Phone phone, WorkSource workSource) {
1634:         MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
1673:         Phone thePhone = getPhone(getDefaultSubscription());
1687:         if (request.phone != null) {
1688:             return request.phone;
1700:         Phone phone = getPhoneFromRequest(request);
1701:         return phone == null ? null :
1702:                 UiccController.getInstance().getUiccCard(phone.getPhoneId());
1705:     // returns phone associated with the subId.
1710:     private void sendEraseModemConfig(Phone phone) {
1711:         if (phone != null) {
1713:                   mApp, phone.getSubId(), "eraseModemConfig");
1751:             // PENDING: should we just silently fail if phone is offhook or ringing?
1772:         // from the context of the phone app.
1775:         if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)
1993:             final Phone phone = getPhone(getDefaultSubscription());
1994:             if (phone != null) {
1995:                 phone.updateServiceLocation(workSource);
2040:             final Phone phone = getPhone(subId);
2041:             if (phone != null) {
2042:                 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
2060:             final Phone phone = getPhone(subId);
2061:             if (phone != null) {
2062:                 phone.setRadioPower(!isRadioOnForSubscriber(subId));
2078:             final Phone phone = getPhone(subId);
2079:             if (phone == null) {
2082:             if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
2100:                 Phone phone = PhoneFactory.getPhone(i);
2101:                 if (phone != null && phone.isRadioAvailable()) return true;
2117:                 logv("Shutting down Phone " + i);
2126:         Phone phone = PhoneFactory.getPhone(phoneId);
2127:         if (phone != null && phone.isRadioAvailable()) {
2128:             phone.shutdownRadio();
2137:             final Phone defaultPhone = PhoneFactory.getDefaultPhone();
2142:                 loge("There's no default phone.");
2155:             final Phone phone = getPhone(subId);
2156:             if (phone != null) {
2157:                 phone.setRadioPower(turnOn);
2175:             final Phone phone = getPhone(subId);
2176:             if (phone != null) {
2177:                 phone.getDataEnabledSettings().setUserDataEnabled(true);
2195:             final Phone phone = getPhone(subId);
2196:             if (phone != null) {
2197:                 phone.getDataEnabledSettings().setUserDataEnabled(false);
2211:             final Phone phone = getPhone(subId);
2212:             if (phone != null) {
2213:                 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);
2262:             Phone phone = PhoneFactory.getPhone(slotIndex);
2263:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :
2264:                     PhoneConstantConversions.convertCallState(phone.getState());
2279:             final Phone phone = getPhone(subId);
2280:             if (phone != null) {
2281:                 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
2300:             final Phone phone = getPhone(subId);
2301:             if (phone != null) {
2302:                 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
2331:                 return (getDefaultPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
2352:             if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
2353:                 // Get default phone in this case.
2354:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
2357:             Phone phone = PhoneFactory.getPhone(phoneId);
2358:             if (phone == null) return "";
2359:             ServiceStateTracker sst = phone.getServiceStateTracker();
2364:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();
2449:         for (Phone phone : PhoneFactory.getPhones()) {
2450:             List<CellInfo> info = phone.getAllCellInfo();
2489:             for (Phone phone : PhoneFactory.getPhones()) {
2491:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);
2551:         final Phone phone = getPhoneFromSubId(subId);
2552:         if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
2554:         sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
2572:         Phone phone = PhoneFactory.getPhone(slotIndex);
2573:         if (phone == null) {
2576:         int subId = phone.getSubId();
2584:             return phone.getImei();
2592:         Phone phone = PhoneFactory.getPhone(slotIndex);
2594:         if (phone != null) {
2595:             String imei = phone.getImei();
2603:         Phone phone = PhoneFactory.getPhone(slotIndex);
2604:         if (phone == null) {
2608:         int subId = phone.getSubId();
2616:             return phone.getMeid();
2624:         Phone phone = PhoneFactory.getPhone(slotIndex);
2626:         if (phone != null) {
2627:             String meid = phone.getMeid();
2636:         Phone phone = PhoneFactory.getPhone(slotIndex);
2637:         if (phone == null) {
2640:         int subId = phone.getSubId();
2649:             return phone.getDeviceSvn();
2659:             final Phone phone = getPhone(subId);
2660:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
2670:             final Phone phone = getPhone(subId);
2671:             return phone == null ? null : phone.getCarrierName();
2681:             final Phone phone = getPhone(subId);
2682:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
2683:                     : phone.getSpecificCarrierId();
2693:             final Phone phone = getPhone(subId);
2694:             return phone == null ? null : phone.getSpecificCarrierName();
2705:         final Phone phone = PhoneFactory.getPhone(slotIndex);
2706:         if (phone == null) {
2711:             return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
2722:      * Make sure the caller has the MODIFY_PHONE_STATE permission.
2727:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
2747:      * Make sure the caller has the CALL_PHONE permission.
2752:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
2788:             final Phone phone = PhoneFactory.getPhone(slotIndex);
2789:             if (phone == null) {
2790:                 return PhoneConstants.PHONE_TYPE_NONE;
2792:                 return phone.getPhoneType();
2819:             final Phone phone = getPhone(subId);
2820:             if (phone != null) {
2821:                 return phone.getCdmaEriIconIndex();
2852:             final Phone phone = getPhone(subId);
2853:             if (phone != null) {
2854:                 return phone.getCdmaEriIconMode();
2883:             final Phone phone = getPhone(subId);
2884:             if (phone != null) {
2885:                 return phone.getCdmaEriText();
2904:             final Phone phone = getPhone(subId);
2905:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2906:                 return phone.getLine1Number();
2908:                 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
2926:             final Phone phone = getPhone(subId);
2927:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2928:                 return phone.getCdmaMin();
2940:         if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
2942:             throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
3106:             final Phone phone = getPhone(subId);
3107:             if (phone != null) {
3108:                 phone.setVoiceActivationState(activationState);
3127:             final Phone phone = getPhone(subId);
3128:             if (phone != null) {
3129:                 phone.setDataActivationState(activationState);
3145:         final Phone phone = getPhone(subId);
3148:             if (phone != null) {
3149:                 return phone.getVoiceActivationState();
3165:         final Phone phone = getPhone(subId);
3168:             if (phone != null) {
3169:                 return phone.getDataActivationState();
3191:             final Phone phone = getPhone(subId);
3192:             if (phone != null) {
3193:                 return phone.getVoiceMessageCount();
3210:             final Phone phone = getPhone(subId);
3211:             return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
3224:         final Phone defaultPhone = getDefaultPhone();
3262:             for (Phone phone : PhoneFactory.getPhones()) {
3263:                 if (phone.isInEmergencySmsMode()) {
3274:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3301:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3339:             Phone phone = getPhone(subId);
3340:             if (phone == null) {
3345:             phone.getImsRegistrationState(regState -> {
3372:             Phone phone = getPhone(subId);
3373:             if (phone == null) {
3378:             phone.getImsRegistrationTech(regTech -> {
3397:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3423:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3474:             Phone phone = getPhone(subId);
3475:             if (phone == null) return false;
3476:             return phone.isImsCapabilityAvailable(capability, regTech);
3524:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3561:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3595:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3630:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3682:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3764:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
3831:         Phone phone = getPhone(subId);
3832:         if (phone == null) {
3833:             loge("phone instance null for subid " + subId);
3837:             if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3841:             if (!doesRcsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
4275:             final Phone phone = getPhone(subId);
4276:             if (phone != null) {
4277:                 return phone.getServiceState().getDataNetworkType();
4309:             final Phone phone = getPhone(subId);
4310:             if (phone != null) {
4311:                 return phone.getServiceState().getDataNetworkType();
4334:             final Phone phone = getPhone(subId);
4335:             if (phone != null) {
4336:                 return phone.getServiceState().getVoiceNetworkType();
4361:             final Phone phone = PhoneFactory.getPhone(slotIndex);
4362:             if (phone != null) {
4363:                 return phone.getIccCard().hasIccCard();
4378:      * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
4379:      * or {@link Phone#LTE_ON_CDMA_TRUE}
4398:             final Phone phone = getPhone(subId);
4399:             if (phone == null) {
4467:                     + " does not correspond to an active phone");
4498:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
4515:                     CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
4540:     private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
4546:             Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
4583:     private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
4592:                     new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
4639:     private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
4657:                     new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
4891:         Phone phone = PhoneFactory.getPhone(slotIndex);
4892:         if (phone != null) {
4894:                     mApp, phone.getSubId(), "resetModemConfig");
4917:         Phone phone = PhoneFactory.getPhone(slotIndex);
4918:         if (phone != null) {
4920:                     mApp, phone.getSubId(), "rebootModem");
4936:         final Phone defaultPhone = getDefaultPhone();
5268:             final Phone phone = getPhone(subId);
5269:             if (phone == null) {
5272:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();
5274:                 ? phone.getManualNetworkSelectionPlmn() : networkSelection.getOperatorNumeric();
5484:         final Phone defaultPhone = getDefaultPhone();
5670:         final Phone phone = getPhone(subId);
5672:             if (phone != null) {
5673:                 return phone.hasMatchedTetherApnSetting();
5697:             Phone phone = PhoneFactory.getPhone(phoneId);
5698:             if (phone != null) {
5700:                 phone.getDataEnabledSettings().setUserDataEnabled(enable);
5702:                 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);
5720:         final Phone phone = getPhone(subId);
5722:             if (phone != null) {
5727:                 phone.setAlwaysReportSignalStrength(isEnable);
5729:                 loge("setAlwaysReportSignalStrength: no phone found for subId="
5758:      * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
5776:             Phone phone = PhoneFactory.getPhone(phoneId);
5777:             if (phone != null) {
5778:                 boolean retVal = phone.isUserDataEnabled();
5782:                 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
5805:             Phone phone = PhoneFactory.getPhone(phoneId);
5806:             if (phone != null) {
5807:                 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
5811:                 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
5820:             Phone phone) {
5821:         if (uid == Process.SYSTEM_UID || uid == Process.PHONE_UID) {
5831:         PackageManager pkgMgr = phone.getContext().getPackageManager();
5836:             int subId = phone.getSubId();
5844:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
5856:     private int getCarrierPrivilegeStatusFromCarrierConfigRules(int privilegeFromSim, Phone phone,
5865:             int subId = phone.getSubId();
5873:                     phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
5883:         final Phone phone = getPhone(subId);
5884:         if (phone == null) {
5888:         UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
5896:                 phone.getContext().getPackageManager()), Binder.getCallingUid(), phone);
5902:         final Phone phone = getPhone(subId);
5903:         if (phone == null) {
5908:                 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
5915:                         phone.getContext().getPackageManager(), uid), uid, phone);
6020:         final Phone phone = getPhone(subId);
6021:         UiccCard card = phone == null ? null : phone.getUiccCard();
6043:             final Phone phone = getPhone(subId);
6044:             if (phone == null) {
6047:             final String subscriberId = phone.getSubscriberId();
6270:             final Phone phone = getPhone(subId);
6271:             return phone == null ? false : phone.setOperatorBrandOverride(brand);
6286:             final Phone phone = getPhone(subId);
6287:             if (phone == null) {
6290:             return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
6341:         Phone phone = PhoneFactory.getPhone(phoneId);
6343:         if (phone == null) {
6350:                             mApp, phone.getSubId(), "getRadioAccessFamily");
6360:         final Phone defaultPhone = getDefaultPhone();
6374:         final Phone defaultPhone = getDefaultPhone();
6428:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
6459:         final Phone phone = getPhone(subscriptionId);
6460:         if (phone == null) {
6461:             loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
6468:                     phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
6501:      * Returns the unique device ID of phone, for example, the IMEI for
6505:      *   {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
6509:         final Phone phone = PhoneFactory.getPhone(0);
6510:         if (phone == null) {
6513:         int subId = phone.getSubId();
6521:             return phone.getDeviceId();
6534:         Phone phone = getPhone(subId);
6535:         if (phone != null) {
6536:             return phone.isImsRegistered();
6557:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
6573:             Phone phone = getPhone(subscriptionId);
6574:             if (phone == null) {
6577:             return PhoneUtils.makePstnPhoneAccountHandle(phone);
6589:             Phone phone = getPhone(subId);
6590:             if (phone != null) {
6591:                 return phone.isWifiCallingEnabled();
6606:             Phone phone = getPhone(subId);
6607:             if (phone != null) {
6608:                 return phone.isVideoEnabled();
6624:             Phone phone = getPhone(subId);
6625:             if (phone != null) {
6626:                 return phone.getImsRegistrationTech();
6684:         final Phone phone = getPhone(subId);
6685:         if (phone == null) {
6692:                     phone.getContext().getOpPackageName(), phone.getContext().getAttributionTag());
6701:             final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
6829:             final Phone phone = getPhone(subId);
6830:             if (phone == null) {
6834:             ServiceState ss = phone.getServiceState();
6847:      * Returns the URI for the per-account voicemail ringtone set in Phone settings.
6858:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
6859:             if (phone == null) {
6860:                 phone = getDefaultPhone();
6863:             return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
6873:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6883:         final Phone defaultPhone = getDefaultPhone();
6894:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
6895:             if (phone == null) {
6896:                 phone = defaultPhone;
6898:             VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
6905:      * Returns whether vibration is set for voicemail notification in Phone settings.
6915:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
6916:             if (phone == null) {
6917:                 phone = getDefaultPhone();
6920:             return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
6930:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6940:         final Phone defaultPhone = getDefaultPhone();
6951:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
6952:             if (phone == null) {
6953:                 phone = defaultPhone;
6955:             VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
6962:      * Make sure either called from same process as self (phone) or IPC caller has read privilege.
6967:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
6972:      * Make sure either called from same process as self (phone) or IPC caller has send SMS
7015:         Phone phone = getPhone(subId);
7019:             if (phone == null) {
7024:                 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
7044:         Phone phone = getPhone(subId);
7048:             if (phone == null) {
7053:                 esn = phone.getEsn();
7072:         Phone phone = getPhone(subId);
7076:             if (phone == null) {
7081:                 cdmaPrlVersion = phone.getCdmaPrlVersion();
7175:         final Phone phone = getPhone(subId);
7178:         if (phone == null) {
7183:             phone.carrierActionSetMeteredApnsEnabled(enabled);
7200:         final Phone phone = getPhone(subId);
7203:         if (phone == null) {
7208:             phone.carrierActionSetRadioEnabled(enabled);
7228:         final Phone phone = getPhone(subId);
7231:         if (phone == null) {
7236:             phone.carrierActionReportDefaultNetworkStatus(report);
7252:         final Phone phone = getPhone(subId);
7253:         if (phone == null) {
7258:             phone.carrierActionResetAll();
7265:      * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
7272:             writer.println("Permission Denial: can't dump Phone from pid="
7303:             Phone phone = getPhone(subId);
7304:             if (phone != null) {
7305:                 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);
7324:         Phone phone = getPhone(subId);
7328:             if (phone != null) {
7329:                 return phone.getClientRequestStats();
7356:         Phone phone = PhoneFactory.getPhone(slotIndex);
7362:             if (phone != null) {
7363:                 phone.setSimPowerState(state, workSource);
7385:      * Check if phone is in emergency callback mode
7386:      * @return true if phone is in emergency callback mode
7392:         final Phone phone = getPhone(subId);
7396:             if (phone != null) {
7397:                 return phone.isInEcm();
7417:             Phone p = getPhone(subId);
7437:         Phone phone = PhoneFactory.getPhone(slotIndex);
7438:         if (phone != null) {
7439:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, phone.getSubId(),
7446:                 return phone.getRadioPowerState();
7459:      * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
7479:             Phone phone = getPhone(subId);
7480:             isEnabled =  phone != null ? phone.getDataRoamingEnabled() : false;
7492:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
7505:             Phone phone = getPhone(subId);
7506:             if (phone != null) {
7507:                 phone.setDataRoamingEnabled(isEnabled);
7523:             Phone phone = getPhone(subId);
7524:             if (phone != null) {
7525:                 isAllowed = phone.isCspPlmnEnabled();
7544:             // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
7681:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
7690:             Phone phone = getPhone(subId);
7691:             if (phone == null) {
7694:             UiccCard uiccCard = phone.getUiccCard();
7731:      * not set, return {@link Phone#PREFERRED_NT_MODE}.
7739:         return Phone.PREFERRED_NT_MODE;
7749:             final Phone phone = getPhone(subId);
7750:             if (phone == null) {
7754:             phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
7772:             final Phone phone = getPhone(subId);
7773:             if (phone == null) {
7777:             return phone.getCarrierIdListVersion();
7846:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
7851:             for (Phone phone: PhoneFactory.getPhones()) {
7852:                 if (phone.getEmergencyNumberTracker() != null
7853:                         && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
7855:                             phone.getSubId(),
7856:                             phone.getEmergencyNumberTracker().getEmergencyNumberList());
7867:         final Phone defaultPhone = getDefaultPhone();
7875:             for (Phone phone: PhoneFactory.getPhones()) {
7876:                 if (phone.getEmergencyNumberTracker() != null
7877:                         && phone.getEmergencyNumberTracker()
7898:             for (Phone phone: PhoneFactory.getPhones()) {
7899:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7920:             for (Phone phone: PhoneFactory.getPhones()) {
7921:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7940:             final Phone phone = getPhone(subId);
7941:             if (phone == null) {
7945:             return phone.getEmergencyNumberDbVersion();
7957:             for (Phone phone: PhoneFactory.getPhones()) {
7958:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7974:             for (Phone phone: PhoneFactory.getPhones()) {
7975:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7991:             for (Phone phone: PhoneFactory.getPhones()) {
7992:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
8005:         Phone phone = getPhone(subId);
8006:         if (phone == null) {
8012:                     .getUiccProfileForPhone(phone.getPhoneId());
8031:             Phone phone = PhoneFactory.getPhone(slotIndex);
8032:             if (phone == null) {
8035:                 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
8048:         Phone phone = PhoneFactory.getPhone(slotIndex);
8049:         if (phone == null) return false;
8052:                 mApp, phone.getSubId(), callingPackage, callingFeatureId,
8054:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
8060:                 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
8062:                 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
8130:      * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
8131:      * permission, but the other way around is possible with either MODIFY_PHONE_STATE
8160:         Phone phone = getPhone(subId);
8161:         if (phone == null) {
8166:             UiccCard uiccCard = phone.getUiccCard();
8236:         Phone phone = getDefaultPhone();
8237:         if (phone == null) return -1;
8238:         HalVersion hv = phone.getHalVersion();
8268:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "
8274:             Phone phone = getPhone(subId);
8275:             if (phone == null) return false;
8277:             boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);
8278:             return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
8291:             Phone phone = getPhone(subId);
8292:             if (phone == null) return true; // By default return true.
8294:             return ApnSettingUtils.isMeteredApnType(apnType, phone);
8306:             Phone phone = getPhone(subscriptionId);
8307:             if (phone == null) {
8327:             sendRequestAsync(CMD_SET_SYSTEM_SELECTION_CHANNELS, argument, phone, null);
8408:             Phone phone = getPhone(subId);
8409:             if (phone == null) return false;
8411:             return phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(allow);
8424:             Phone phone = getPhone(subId);
8425:             if (phone == null) return false;
8427:             return phone.getDataEnabledSettings().isDataAllowedInVoiceCall();
8440:             Phone phone = getPhone(subId);
8441:             if (phone == null) return false;
8443:             return phone.getDataEnabledSettings().setAlwaysAllowMmsData(alwaysAllow);
8461:             for (Phone phone : PhoneFactory.getPhones()) {
8462:                 Phone defaultPhone = phone.getImsPhone();
8463:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
8508:             Phone phone = getPhone(subId);
8509:             if (phone != null && phone.getIccCard() != null) {
8510:                 return phone.getIccCard().getIccLockEnabled();
8534:         Phone phone = getPhone(subId);
8535:         if (phone == null) {
8542:                     new Pair<Boolean, String>(enabled, password), phone, null);
8566:         Phone phone = getPhone(subId);
8567:         if (phone == null) {
8574:                     new Pair<String, String>(oldPassword, newPassword), phone, null);
8633:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
8636:         Phone phone = getPhone(subId);
8637:         if (phone == null) {
8638:             throw new RuntimeException("phone is not available");
8643:             return phone.getEquivalentHomePlmns();
22: import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
63: import android.telecom.PhoneAccount;
64: import android.telecom.PhoneAccountHandle;
83: import android.telephony.PhoneCapability;
84: import android.telephony.PhoneNumberRange;
141: import com.android.internal.telephony.PhoneConfigurationManager;
142: import com.android.internal.telephony.PhoneConstantConversions;
143: import com.android.internal.telephony.PhoneConstants;
144: import com.android.internal.telephony.PhoneFactory;
158: import com.android.internal.telephony.imsphone.ImsPhone;
159: import com.android.internal.telephony.imsphone.ImsPhoneCallTracker;
199:     private static final String LOG_TAG = "PhoneInterfaceManager";
200:     private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
298:     private static PhoneInterfaceManager sInstance;
300:     private PhoneGlobals mApp;
697:                     defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
724:                     defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
735:                     defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
745:                     defaultPhone.resetModemConfig(onCompleted);
793:                     defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
1031:                     if (defaultPhone != null) {
1032:                         defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
1095:                     defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
1123:                     defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
1329:                     defaultPhone.rebootModem(onCompleted);
1339:                     PhoneConfigurationManager.getInstance()
1349:                         mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1360:                     PhoneConfigurationManager.getInstance()
1448:                     defaultPhone.eraseModemConfig(onCompleted);
1494:                     getDefaultPhone().getContext().sendBroadcastAsUser(
1640:      * Initialize the singleton PhoneInterfaceManager instance.
1641:      * This is only done once, at startup, from PhoneApp.onCreate().
1643:     /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
1644:         synchronized (PhoneInterfaceManager.class) {
1646:                 sInstance = new PhoneInterfaceManager(app);
1657:         mCM = PhoneGlobals.getInstance().mCM;
1658:         mImsResolver = PhoneGlobals.getInstance().getImsResolver();
1666:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
1674:         return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
1696:                 ? getDefaultPhone() : getPhone(subId);
1707:         return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
1725:         PackageManager pm = getDefaultPhone().getContext().getPackageManager();
1752:             PhoneConstants.State state = mCM.getState(subId);
1753:             if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
1812:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1817:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1825:             final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
1838:             final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
1855:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1885:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1890:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;
1892:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1895:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;
2103:             logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
2138:             if (defaultPhone != null) {
2139:                 defaultPhone.setRadioPower(turnOn);
2283:                 return PhoneConstantConversions.convertDataState(
2284:                         PhoneConstants.DataState.DISCONNECTED);
2356:             final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
2564:             getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
2768:         Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
2772:         Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
2776:         Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
2938:     public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
2967:             return getDefaultPhone().needsOtaServiceProvisioning();
3002:             PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
3003:             if (phoneAccountHandle == null) {
3006:             return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
3091:         SmsController smsController = PhoneFactory.getSmsController();
3226:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
3235:             defaultPhone.sendDialerSpecialCode(inputCode);
3290:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3314:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3410:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3437:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3453:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3532:         // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3550:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3570:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3585:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3604:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3620:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3639:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3655:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3671:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3691:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3707:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3722:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3738:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3754:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3773:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3792:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3810:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3855:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3885:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3918:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3977:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4146:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4171:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4197:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4223:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4393:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
4400:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
4403:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);
4464:         int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
4465:         if (phoneId == -1) {
4469:         return PhoneFactory.getPhone(phoneId);
4504:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
4646:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
4937:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
4944:             return defaultPhone.getPcscfAddress(apnType);
5188:             getDefaultPhone().setImsRegistrationState(registered);
5424:                     request, messenger, binder, getPhone(subId),
5485:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
5493:             return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);
5695:             int phoneId = mSubscriptionController.getPhoneId(subId);
5696:             if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5774:             int phoneId = mSubscriptionController.getPhoneId(subId);
5775:             if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5803:             int phoneId = mSubscriptionController.getPhoneId(subId);
5804:             if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5924:         int phoneId = SubscriptionManager.getPhoneId(subId);
5925:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
5932:             getPhone(phoneId), pkgName);
5949:                 getPhone(i), pkgName);
5960:         if (!SubscriptionManager.isValidPhoneId(phoneId)) {
5961:             loge("phoneId " + phoneId + " is not valid.");
5964:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
5966:             loge("getCarrierPackageNamesForIntentAndPhone: No UICC");
5973:     public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
5977:         UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
6340:     public int getRadioAccessFamily(int phoneId, String callingPackage) {
6351:             raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
6365:             ImsManager.getInstance(defaultPhone.getContext(),
6366:                     defaultPhone.getPhoneId()).setVtSetting(enable);
6375:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
6387:                     ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
6502:      * GSM and the MEID for CDMA phones. Return null if device ID is not available.
6546:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
6554:             PhoneAccountHandle phoneAccountHandle, String callingPackage, String callingFeatureId) {
6561:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);
6657:             cleanUpSmsRawTable(getDefaultPhone().getContext());
6668:               sendEraseModemConfig(getDefaultPhone());
6849:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
6852:      * PhoneAccount.
6855:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
6875:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
6878:      * PhoneAccount.
6882:             PhoneAccountHandle phoneAccountHandle, Uri uri) {
6885:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
6888:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
6907:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
6909:      * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
6912:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
6932:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
6935:      * specific PhoneAccount.
6939:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {
6942:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
6945:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
7286:         return new TelephonyShellCommand(this, getDefaultPhone().getContext()).exec(
7546:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
7735:         int phoneId = mSubscriptionController.getPhoneId(subId);
7736:         if (phoneId >= 0 && phoneId < list.size() && list.get(phoneId) != null) {
7737:             return list.get(phoneId);
7871:                             mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
8087:                 getDefaultPhone().getSubId(), callingPackage, callingFeatureId,
8110:         PhoneCapability staticCapability =
8216:             int phoneCount = TelephonyManager.getDefault().getPhoneCount();
8218:             int[] logicalSlotsMapping = new int[phoneCount];
8351:         SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
8377:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
8394:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
8464:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
8466:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();
8468:                     Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled + ", for imsPhone "
8469:                             + imsPhone.getMsisdn());
8603:         // *  Inherited from PhoneWindowManager  *
130: import com.android.internal.telephony.DefaultPhoneNotifier;
480:                             getPhoneFromRequest(request).handlePinMmi((String) request.argument)
755:                     getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
783:                     getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
807:                     getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
819:                     getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
829:                     getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
836:                     getPhoneFromRequest(request).getCallForwardingOption(
893:                     getPhoneFromRequest(request).setCallForwardingOption(
915:                     getPhoneFromRequest(request).getCallWaiting(onCompleted);
959:                     getPhoneFromRequest(request).setCallWaiting(isEnable, onCompleted);
1011:                     getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
1206:                     getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
1227:                     getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1243:                     getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1255:                     getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);
1370:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,
1458:                     getPhoneFromRequest(request).getIccCard().changeIccLockPassword(
1476:                     getPhoneFromRequest(request).getIccCard().setIccLockEnabled(
1690:             return getPhoneFromSubId(request.subId);
2024:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2099:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2116:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2118:                 shutdownRadioUsingPhoneId(i);
2641:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2781:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
2811:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2844:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2875:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3016:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3184:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3244:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3281:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3307:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3364:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3404:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3429:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3529:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3566:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3600:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3635:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3687:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3769:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
3851:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");
3915:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");
4267:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(
4301:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4326:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4419:         return mSubscriptionController.getPhoneId(getDefaultSubscription());
4481:         return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
4494:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
4529:         return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
4536:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
4565:         return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
4579:                 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
4618:         return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
4634:                 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
4719:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4757:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,
5131:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5259:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
5508:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5557:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5602:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5606:             return getPhoneFromSubId(subId).getAllowedNetworkTypes(reason);
5623:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5627:             return getPhoneFromSubId(subId).getEffectiveAllowedNetworkTypes();
5649:             getPhoneFromSubId(subId).setAllowedNetworkTypes(reason, allowedNetworkTypes);
5940:         for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
6004:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");
6010:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
6090:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
6117:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6140:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6349:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
6399:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6418:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6555:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, getDefaultSubscription(),
6556:                 callingPackage, callingFeatureId, "getSubIdForPhoneAccountHandle")) {
6569:         enforceReadPrivilegedPermission("getPhoneAccountHandleForSubscriptionId, "
6793:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7320:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7472:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
7517:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7645:                         slot.getPhoneId(),
7786:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7794:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
7803:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7843:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7870:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8051:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8086:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
8111:                 mPhoneConfigurationManager.getStaticPhoneCapability();
8151:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
8191:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8198:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
8207:         metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
8221:                 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
8337:                 SubscriptionManager.getPhoneId(subId), UiccController.APP_FAM_3GPP);
8465:                     ImsPhoneCallTracker imsPhoneCallTracker =
8467:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);
8631:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
android.googlesource.com/platform/frameworks/opt/telephony:src/java/com/android/internal/telephony/Phone.java: [ master, ]
133: public abstract class Phone extends Handler implements PhoneInternalInterface {
530:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,
547:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,
349:     protected Phone mImsPhone = null;
627:     public void createImsPhone() {
3922:     public Phone getImsPhone() {
4593:     public Phone getDefaultPhone() {
212:     protected static final int EVENT_UPDATE_PHONE_OBJECT            = 42;
315:     protected boolean mIsPhoneInEcmState = false;
346:     protected int mPhoneId;
470:     public String getPhoneName() {
474:     protected void setPhoneName(String name) {
1834:     public void updatePhoneObject(int voiceRadioTech) {
2952:     public abstract int getPhoneType();
4054:     public int getPhoneId() {
4062:     public int getVoicePhoneServiceState() {
123:  * A base implementation for the com.android.internal.telephony.Phone interface.
125:  * Note that implementations of Phone.java are expected to be used
134:     private static final String LOG_TAG = "Phone";
263:      * This method is invoked when the Phone exits Emergency Callback Mode.
313:     // Keep track of whether or not the phone is in Emergency Callback Mode for Phone and
465:      * Returns a string identifier for this phone interface for parties
466:      *  outside the phone app process.
521:      * Constructs a Phone in normal (non-unit test) mode.
532:         this(name, notifier, context, ci, unitTestMode, SubscriptionManager.DEFAULT_PHONE_INDEX,
537:      * Constructs a Phone in normal (non-unit test) mode.
545:      * @param phoneId the phone-id of this phone.
573:         * (i.e. voice) phone calls over the telephony network, and is allowed
601:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_IMS) {
616:         if (getPhoneType() != PhoneConstants.PHONE_TYPE_SIP) {
628:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_SIP) {
632:         synchronized(Phone.lockForRadioTechnologyChange) {
695:         // messages to be handled whether or not the phone is being destroyed
697:         // resources of the phone being destroyed
820:         Phone imsPhone = mImsPhone;
859:      * Gets the context for the phone, as set at initialization time.
915:      * Subclasses of Phone probably want to replace this with a
941:      * Subclasses of Phone probably want to replace this with a
965:      * Subclasses of Phone probably want to replace this with a
977:      * Notify the phone that an SMS has been sent. This will be used determine if the SMS was sent
991:      * Determine if the Phone has recently sent an emergency SMS and is still in the interval of
1032:     protected void migrateFrom(Phone from) {
1045:         // The emergency state of IMS phone will be cleared in ImsPhone#notifySrvccState after
1108:      *   Connection.getCall() == Phone.getRingingCall()
1128:      * Notifies when phone's video capabilities changes <p>
1133:      *  AsyncResult.result = true if phone supports video calling <p>
1272:      * Example: If Phone.dial is called with "*#31#", then the app will
1595:      * For unit tests; don't send notifications to "Phone"
1612:      * Subclasses of Phone probably want to replace this with a
1717:         // no need for regular phone
1721:      * Subclasses of Phone probably want to replace this with a
1733:      * we send out a final ServiceState update when a phone's subId becomes invalid.
1743:      * If this is a simulated phone interface, returns a SimulatedRadioControl.
1757:      * the thread that originally obtained this Phone instance.
1762:                     "com.android.internal.telephony.Phone must be used from within one thread");
1794:      * If the phone has an active call and call waiting occurs,
1795:      * then the phone state is RINGING not OFFHOOK
1804:      * Retrieves the IccFileHandler of the Phone instance
1823:      * Retrieves the Handler of the Phone instance
1830:      * Update the phone object if the voice radio technology has changed
1838:     * Retrieves the ServiceStateTracker of the phone instance.
1853:                 .contains(Phone.RADIO_POWER_REASON_THERMAL);
1857:      * Retrieves the EmergencyNumberTracker of the phone instance.
1879:      * Retrieves the DeviceStateMonitor of the phone instance.
1886:      * Retrieves the DisplayInfoController of the phone instance.
1934:      * Returns the ICC card interface for this phone, or null
1940:         //throw new Exception("getIccCard Shouldn't be called from Phone");
2127:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2534:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
2535:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
2536:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
2537:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
2548:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
2549:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
2550:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
2551:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
2857:     // This property is used to handle phone process crashes, and is the same for CDMA and IMS
2864:      * @return {@code true} if we are in emergency call back mode. This is a period where the phone
2884:      * @return true if this Phone is in an emergency call that caused emergency callback mode to be
2892:      * Set whether or not this Phone has an active emergency call that was placed during emergency
2948:      * Return a numerical identifier for the phone radio interface.
2949:      * @return PHONE_TYPE_XXX as defined above.
2962:     /** sets the voice mail count of the phone and notifies listeners. */
3613:         // Populate the iccid, imei and phone number in the provisioning url.
3622:                     phoneNumber /* Phone number */);
3743:      * Subclasses of Phone probably want to replace this with a
3761:      * Notify registrants if phone is video capable.
3875:         Rlog.e(LOG_TAG, "Error! This function should never be executed, inactive Phone.");
3888:      * Gets the Uicc card corresponding to this phone.
3889:      * @return the UiccCard object corresponding to the phone ID.
3919:      * Return an instance of a IMS phone
4051:      * Returns the phone id.
4063:         Phone imsPhone = mImsPhone;
4137:         Phone imsPhone = mImsPhone;
4156:         Phone imsPhone = mImsPhone;
4170:         Phone imsPhone = mImsPhone;
4194:         Phone imsPhone = mImsPhone;
4204:      * @return the IMS MmTel Registration technology for this Phone, defined in
4208:         Phone imsPhone = mImsPhone;
4218:      * Get the IMS MmTel Registration technology for this Phone, defined in
4222:         Phone imsPhone = mImsPhone;
4231:      * Asynchronously get the IMS MmTel Registration state for this Phone.
4234:         Phone imsPhone = mImsPhone;
4292:      *  Set phone radio capability
4294:      *  @param rc the phone radio capability defined in
4303:      *  Get phone radio access family
4323:      *  Get phone radio capability
4337:      *  @param rc the phone radio capability currently in effect for this phone.
4352:         // When radio capability switch is done, query IMEI value and update it in Phone objects
4371:      * Registers the handler when phone radio  capability is changed.
4382:      * Unregister for notifications when phone radio type and access technology is changed.
4403:      * Determines if video calling is enabled for the phone.
4409:         Phone imsPhone = mImsPhone;
4548:     public static void checkWfcWifiOnlyModeBeforeDial(Phone imsPhone, int phoneId, Context context)
4588:      * This function returns the parent phone of the current phone. It is applicable
4589:      * only for IMS phone (function is overridden by ImsPhone). For others the phone
4627:      * none of the phone is in service, and one of them has the capability to make the emergency
4634:         for (Phone phone : PhoneFactory.getPhones()) {
4635:             if (phone != null) {
4636:                 ServiceStateTracker sst = phone.getServiceStateTracker();
4699:     /** Returns the {@link VoiceCallSessionStats} for this phone ID. */
4704:     /** Sets the {@link VoiceCallSessionStats} mock for this phone ID during unit testing. */
4710:     /** Returns the {@link SmsStats} for this phone ID. */
4715:     /** Sets the {@link SmsStats} mock for this phone ID during unit testing. */
4779:         pw.println("Phone: subId=" + getSubId());
4954:         pw.println("Phone Local Log: ");
53: import android.telephony.PhoneStateListener;
83: import com.android.internal.telephony.imsphone.ImsPhoneCall;
127:  * originally called PhoneFactory to obtain the interface.
438:      * PhoneNotifier is an abstraction for all system-wide
443:     protected PhoneNotifier mNotifier;
479:      * Retrieves Nai for phones. Returns null if Nai is not set.
548:                     boolean unitTestMode, int phoneId,
550:         mPhoneId = phoneId;
587:          * By default old phones won't have the property set but do generate
624:      * Start setup of ImsPhone, which will start trying to connect to the ImsResolver. Will not be
633:             if (mImsPhone == null) {
634:                 mImsPhone = PhoneFactory.makeImsPhone(mNotifier, this);
635:                 CallManager.getInstance().registerPhone(mImsPhone);
636:                 mImsPhone.registerForSilentRedial(
711:                     PhoneConstants.State state = getState();
713:                             && ((state == PhoneConstants.State.RINGING) ||
714:                                     (state == PhoneConstants.State.IDLE))) {
725:                 if (getState() == PhoneConstants.State.RINGING) {
746:                         if (mImsPhone != null) {
748:                             mImsPhone.notifyRedialConnectionChanged(cn);
752:                         if (mImsPhone != null) {
753:                             mImsPhone.notifyRedialConnectionChanged(null);
827:                     if (imsPhone != null) {
828:                         conn = imsPhone.getHandoverConnection();
829:                         migrateFrom(imsPhone);
831:                         Rlog.d(LOG_TAG, "HANDOVER_STARTED: mImsPhone null");
836:                     if (imsPhone != null) {
837:                         imsPhone.notifySrvccState(srvccState);
839:                         Rlog.d(LOG_TAG, "HANDOVER_COMPLETED: mImsPhone null");
892:      * {@link PhoneConstants.State} which can be obtained using the {@link PhoneStateListener}
1062:             // Since CallManager has already registered with both CS and IMS phones,
1801:     public abstract PhoneConstants.State getState();
2010:      * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged
2011:      * PhoneStateListener.onCellInfoChanged} will be invoked.
2026:      * available on this interface. Use PhoneStateNotifier or similar instead.
2122:      * available on this interface. Use PhoneStateNotifier or similar instead.
2173:      * interface. Use <code>PhoneStateNotifier</code> or an equivalent.
2774:     public PhoneConstants.DataState getDataConnectionState(String apnType) {
2775:         return PhoneConstants.DataState.DISCONNECTED;
2858:     // phones
2938:         if (mImsPhone != null) {
2939:             isPresent = isVideoCallOrConference(mImsPhone.getForegroundCall()) ||
2940:                     isVideoCallOrConference(mImsPhone.getBackgroundCall()) ||
2941:                     isVideoCallOrConference(mImsPhone.getRingingCall());
3083:      * Retrieves the MIN for CDMA phones.
3099:      *  Retrieves PRL Version for CDMA phones
3615:             String phoneNumber = getLine1Number();
3616:             if (TextUtils.isEmpty(phoneNumber)) {
3617:                 phoneNumber = "0000000000";
3837:      * Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to
3838:      * {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns
3839:      * the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones.
3847:      * Retrieves the EF_PNN from the UICC For GSM/UMTS phones.
3856:      * {@link android.telephony.PhoneStateListener} instead.
3859:     public PhoneConstants.DataState getDataConnectionState() {
3874:         // This function should be overridden by class GsmCdmaPhone.
3923:         return mImsPhone;
3998:      * Return if UT capability of ImsPhone is enabled or not
4002:         if (mImsPhone != null) {
4003:             return mImsPhone.isUtEnabled();
4022:         // dialInternal shall be overriden by GsmCdmaPhone
4027:      * This function is for CSFB SS. GsmCdmaPhone overrides this function.
4059:      * Return the service state of mImsPhone if it is STATE_IN_SERVICE
4064:         if (imsPhone != null
4065:                 && imsPhone.getServiceState().getState() == ServiceState.STATE_IN_SERVICE) {
4139:         if (imsPhone != null) {
4140:             isImsRegistered = imsPhone.isImsRegistered();
4158:         if (imsPhone != null) {
4159:             isWifiCallingEnabled = imsPhone.isWifiCallingEnabled();
4172:         if (imsPhone != null) {
4173:             isAvailable = imsPhone.isImsCapabilityAvailable(capability, regTech);
4196:         if (imsPhone != null) {
4197:             isVolteEnabled = imsPhone.isVoiceOverCellularImsEnabled();
4210:         if (imsPhone != null) {
4211:             regTech = imsPhone.getImsRegistrationTech();
4223:         if (imsPhone != null) {
4224:             imsPhone.getImsRegistrationTech(callback);
4235:         if (imsPhone != null) {
4236:             imsPhone.getImsRegistrationState(callback);
4395:         if (mImsPhone == null) {
4399:         return mImsPhone.isImsAvailable();
4410:         if (imsPhone != null) {
4411:             return imsPhone.isVideoEnabled();
4550:         if (imsPhone == null || !imsPhone.isWifiCallingEnabled()) {
4551:             ImsManager imsManager = ImsManager.getInstance(context, phoneId);
4818:         if (mImsPhone != null) {
4820:                 mImsPhone.dump(fd, pw, args);
439:      * state change notification. DefaultPhoneNotifier is
523:      * @param notifier An instance of DefaultPhoneNotifier,
539:      * @param notifier An instance of DefaultPhoneNotifier,
2739:         // This function is added to send the notification to DefaultPhoneNotifier.
2869:         return mIsPhoneInEcmState;
2880:         mIsPhoneInEcmState = isInEcm;
2924:         if (call instanceof ImsPhoneCall) {
2925:             ImsPhoneCall imsPhoneCall = (ImsPhoneCall) call;
2926:             ImsCall imsCall = imsPhoneCall.getImsCall();
2980:                 mPhoneId, UiccController.APP_FAM_3GPP);
3813:      * A fucntion of type getPhoneProp(propType) where propType is an
3893:         return mUiccController.getUiccCard(mPhoneId);
4047:         return SubscriptionController.getInstance().getSubIdUsingPhoneId(mPhoneId);
4055:         return mPhoneId;
4780:         pw.println(" mPhoneId=" + mPhoneId);
4807:         pw.println(" getPhoneName()=" + getPhoneName());
4808:         pw.println(" getPhoneType()=" + getPhoneType());
4967:         Rlog.d(LOG_TAG, "[" + mPhoneId + "] " + s);
4971:         Rlog.i(LOG_TAG, "[" + mPhoneId + "] " + s);
4975:         Rlog.e(LOG_TAG, "[" + mPhoneId + "] " + s);
github.com/apache/dubbo-samples:dubbo-samples-compatible/src/main/java/org/apache/dubbo/samples/basic/api/Phone.java: [ master, ]
23: public class Phone implements Serializable {
46:         return "Phone{" +
github.com/apache/openjpa:openjpa-examples/simple/src/main/java/embeddables/Phone.java: [ trunk, ]
25: public class Phone {
26:     public Phone() {
30:     public Phone(String n, String t) {
android.googlesource.com/platform/external/guice:examples/src/example/xml/Phone.java: [ master, ]
3: public class Phone {
github.com/google/guice:examples/src/example/xml/Phone.java: [ master, ] Duplicate result
github.com/googleapis/google-cloud-php-talent:src/V4beta1/Phone.php: [ master, ]
16: class Phone extends \Google\Protobuf\Internal\Message
14:  * Generated from protobuf message <code>google.cloud.talent.v4beta1.Phone</code>
19:      * The usage of the phone. For example, SCHOOL, WORK, PERSONAL.
25:      * The phone type. For example, LANDLINE, MOBILE, FAX.
27:      * Generated from protobuf field <code>.google.cloud.talent.v4beta1.Phone.PhoneType type = 2;</code>
31:      * Phone number.
32:      * Any phone formats are supported and only exact matches are performed on
33:      * searches. For example, if a phone number in profile is provided in the
34:      * format of "(xxx)xxx-xxxx", in profile searches the same phone format
56:      *           The usage of the phone. For example, SCHOOL, WORK, PERSONAL.
58:      *           The phone type. For example, LANDLINE, MOBILE, FAX.
60:      *           Phone number.
61:      *           Any phone formats are supported and only exact matches are performed on
62:      *           searches. For example, if a phone number in profile is provided in the
63:      *           format of "(xxx)xxx-xxxx", in profile searches the same phone format
77:      * The usage of the phone. For example, SCHOOL, WORK, PERSONAL.
88:      * The usage of the phone. For example, SCHOOL, WORK, PERSONAL.
103:      * The phone type. For example, LANDLINE, MOBILE, FAX.
105:      * Generated from protobuf field <code>.google.cloud.talent.v4beta1.Phone.PhoneType type = 2;</code>
114:      * The phone type. For example, LANDLINE, MOBILE, FAX.
116:      * Generated from protobuf field <code>.google.cloud.talent.v4beta1.Phone.PhoneType type = 2;</code>
122:         GPBUtil::checkEnum($var, \Google\Cloud\Talent\V4beta1\Phone\PhoneType::class);
129:      * Phone number.
130:      * Any phone formats are supported and only exact matches are performed on
131:      * searches. For example, if a phone number in profile is provided in the
132:      * format of "(xxx)xxx-xxxx", in profile searches the same phone format
145:      * Phone number.
146:      * Any phone formats are supported and only exact matches are performed on
147:      * searches. For example, if a phone number in profile is provided in the
148:      * format of "(xxx)xxx-xxxx", in profile searches the same phone format
12:  * Resource that represents a person's telephone number.
github.com/apache/dolphinscheduler:sql/dolphinscheduler_postgre.sql: [ dev, ]
757:   phone varchar(11) DEFAULT NULL ,
905: INSERT INTO t_ds_user(user_name, user_password, user_type, email, phone, tenant_id, state, create_time, update_time)
github.com/apache/dolphinscheduler:sql/dolphinscheduler_h2.sql: [ dev, ]
901:     phone         varchar(11) DEFAULT NULL,
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3.js: [ master, ]
7623: google.maps.TransitAgency.prototype.phone;
9484: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.phoneNumber;
9849: google.maps.places.PlaceResult.prototype.formatted_phone_number;
9891: google.maps.places.PlaceResult.prototype.international_phone_number;
9458: google.maps.places.FindPlaceFromPhoneNumberRequest = function() {};
9470: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.fields;
10227: google.maps.places.PlacesService.prototype.findPlaceFromPhoneNumber = function(
7620:  * The transit agency&#39;s phone number.
9480:  * The phone number of the place to look up. Format must be <a
9843:  * The Place’s phone number, formatted according to the <a
9886:  * The Place’s phone number in international format. International format
10214:  * Retrieves a list of places based on a phone number. In most cases there
9844:  * href="http://en.wikipedia.org/wiki/Local_conventions_for_writing_telephone_numbers">
9455:  * google.maps.places.PlacesService.findPlaceFromPhoneNumber}.
9477: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.locationBias;
10222:  * @param {!google.maps.places.FindPlaceFromPhoneNumberRequest} request
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3_45.js: [ master, ] Duplicate result
github.com/google/end-to-end:lib/closure-compiler/contrib/externs/maps/google_maps_api_v3_20.js: [ master, ]
5014: google.maps.TransitAgency.prototype.phone;
6167: google.maps.places.PlaceResult.prototype.formatted_phone_number;
6187: google.maps.places.PlaceResult.prototype.international_phone_number;
github.com/dart-lang/sdk:docs/newsletter/20171103/big.json: [ master, ]
15:     "phone": "+1 (837) 507-3693",
60:     "phone": "+1 (846) 514-2370",
105:     "phone": "+1 (857) 494-3093",
150:     "phone": "+1 (947) 569-2033",
195:     "phone": "+1 (999) 498-3915",
240:     "phone": "+1 (854) 470-3038",
285:     "phone": "+1 (909) 457-2305",
330:     "phone": "+1 (920) 553-2688",
375:     "phone": "+1 (834) 579-2186",
420:     "phone": "+1 (939) 525-2604",
465:     "phone": "+1 (849) 479-3879",
510:     "phone": "+1 (880) 463-3272",
555:     "phone": "+1 (900) 525-3365",
600:     "phone": "+1 (960) 432-3019",
645:     "phone": "+1 (890) 443-2377",
690:     "phone": "+1 (865) 600-2359",
735:     "phone": "+1 (956) 445-3197",
780:     "phone": "+1 (824) 526-2433",
825:     "phone": "+1 (869) 596-2230",
870:     "phone": "+1 (965) 400-3544",
915:     "phone": "+1 (829) 523-3522",
960:     "phone": "+1 (800) 414-2213",
1005:     "phone": "+1 (965) 477-2144",
1050:     "phone": "+1 (995) 545-3067",
1095:     "phone": "+1 (956) 459-3456",
1140:     "phone": "+1 (940) 518-2078",
1185:     "phone": "+1 (878) 478-2408",
1230:     "phone": "+1 (837) 511-3291",
1275:     "phone": "+1 (858) 487-2467",
1320:     "phone": "+1 (981) 553-2184",
1365:     "phone": "+1 (872) 596-3656",
1410:     "phone": "+1 (966) 543-3136",
1455:     "phone": "+1 (818) 508-2268",
1500:     "phone": "+1 (951) 420-2218",
1545:     "phone": "+1 (844) 555-2715",
1590:     "phone": "+1 (937) 565-2676",
1635:     "phone": "+1 (972) 576-3178",
1680:     "phone": "+1 (917) 450-3471",
1725:     "phone": "+1 (843) 423-3454",
1770:     "phone": "+1 (948) 509-3334",
1815:     "phone": "+1 (831) 416-2264",
1860:     "phone": "+1 (891) 400-3519",
1905:     "phone": "+1 (943) 479-2761",
1950:     "phone": "+1 (906) 480-2565",
1995:     "phone": "+1 (851) 497-3501",
2040:     "phone": "+1 (841) 418-3257",
2085:     "phone": "+1 (926) 512-3937",
2130:     "phone": "+1 (987) 421-2382",
2175:     "phone": "+1 (899) 580-3031",
2220:     "phone": "+1 (960) 427-2889",
2265:     "phone": "+1 (860) 507-2156",
2310:     "phone": "+1 (894) 511-3314",
2355:     "phone": "+1 (926) 591-3806",
2400:     "phone": "+1 (908) 518-2917",
2445:     "phone": "+1 (804) 531-2757",
2490:     "phone": "+1 (923) 584-2675",
2535:     "phone": "+1 (867) 565-3773",
2580:     "phone": "+1 (818) 596-3918",
2625:     "phone": "+1 (948) 499-3495",
2670:     "phone": "+1 (800) 586-3376",
2715:     "phone": "+1 (806) 466-2258",
2760:     "phone": "+1 (898) 448-2185",
2805:     "phone": "+1 (935) 589-2629",
2850:     "phone": "+1 (891) 512-3740",
2895:     "phone": "+1 (981) 551-3815",
2940:     "phone": "+1 (881) 538-3365",
2985:     "phone": "+1 (975) 589-3053",
3030:     "phone": "+1 (902) 562-2128",
3075:     "phone": "+1 (948) 410-2460",
3120:     "phone": "+1 (942) 561-2111",
3165:     "phone": "+1 (843) 425-3098",
3210:     "phone": "+1 (900) 580-3229",
3255:     "phone": "+1 (879) 551-3061",
3300:     "phone": "+1 (814) 582-3071",
3345:     "phone": "+1 (990) 512-2222",
3390:     "phone": "+1 (978) 573-3997",
3435:     "phone": "+1 (894) 433-3996",
3480:     "phone": "+1 (919) 515-3066",
3525:     "phone": "+1 (915) 421-2684",
3570:     "phone": "+1 (925) 529-2747",
3615:     "phone": "+1 (919) 426-2851",
3660:     "phone": "+1 (897) 513-3281",
3705:     "phone": "+1 (850) 539-3379",
3750:     "phone": "+1 (909) 478-2505",
3795:     "phone": "+1 (992) 523-2404",
3840:     "phone": "+1 (876) 463-3788",
3885:     "phone": "+1 (811) 505-2973",
3930:     "phone": "+1 (994) 521-2251",
3975:     "phone": "+1 (820) 448-2105",
4020:     "phone": "+1 (938) 516-3670",
4065:     "phone": "+1 (815) 551-3343",
4110:     "phone": "+1 (855) 469-2689",
4155:     "phone": "+1 (878) 582-3574",
4200:     "phone": "+1 (837) 573-2113",
4245:     "phone": "+1 (988) 541-3936",
4290:     "phone": "+1 (945) 600-2756",
4335:     "phone": "+1 (941) 551-2018",
4380:     "phone": "+1 (826) 564-2855",
4425:     "phone": "+1 (919) 596-3947",
4470:     "phone": "+1 (856) 408-2445",
4515:     "phone": "+1 (880) 472-3026",
4560:     "phone": "+1 (958) 545-2045",
4605:     "phone": "+1 (982) 534-3838",
4650:     "phone": "+1 (874) 433-3388",
4695:     "phone": "+1 (997) 598-3664",
4740:     "phone": "+1 (943) 552-3860",
4785:     "phone": "+1 (823) 536-3787",
4830:     "phone": "+1 (971) 483-3841",
4875:     "phone": "+1 (842) 550-3460",
4920:     "phone": "+1 (816) 457-2084",
4965:     "phone": "+1 (969) 432-2674",
5010:     "phone": "+1 (937) 574-2800",
5055:     "phone": "+1 (862) 584-3454",
5100:     "phone": "+1 (945) 538-2237",
5145:     "phone": "+1 (977) 463-3790",
5190:     "phone": "+1 (948) 511-2897",
5235:     "phone": "+1 (966) 548-3943",
5280:     "phone": "+1 (800) 513-2595",
5325:     "phone": "+1 (910) 515-3339",
5370:     "phone": "+1 (827) 584-3711",
5415:     "phone": "+1 (855) 555-2074",
5460:     "phone": "+1 (902) 494-2637",
5505:     "phone": "+1 (947) 598-3867",
5550:     "phone": "+1 (848) 515-2715",
5595:     "phone": "+1 (883) 424-3837",
5640:     "phone": "+1 (974) 415-3309",
5685:     "phone": "+1 (808) 592-3525",
5730:     "phone": "+1 (932) 446-3346",
5775:     "phone": "+1 (939) 444-3055",
5820:     "phone": "+1 (832) 410-3108",
5865:     "phone": "+1 (961) 557-2724",
5910:     "phone": "+1 (893) 426-3444",
5955:     "phone": "+1 (867) 491-3071",
6000:     "phone": "+1 (809) 510-2641",
6045:     "phone": "+1 (826) 592-3362",
6090:     "phone": "+1 (824) 497-2085",
6135:     "phone": "+1 (863) 543-3535",
6180:     "phone": "+1 (964) 450-3239",
6225:     "phone": "+1 (897) 595-3177",
6270:     "phone": "+1 (944) 451-2580",
6315:     "phone": "+1 (968) 450-3970",
6360:     "phone": "+1 (893) 439-2992",
6405:     "phone": "+1 (824) 548-3309",
6450:     "phone": "+1 (830) 503-3733",
6495:     "phone": "+1 (853) 551-3777",
6540:     "phone": "+1 (838) 587-3155",
6585:     "phone": "+1 (994) 584-3713",
6630:     "phone": "+1 (887) 456-2827",
6675:     "phone": "+1 (881) 585-3898",
6720:     "phone": "+1 (980) 532-3612",
6765:     "phone": "+1 (809) 401-2730",
6810:     "phone": "+1 (887) 567-3628",
6855:     "phone": "+1 (800) 486-2517",
6900:     "phone": "+1 (880) 540-2582",
6945:     "phone": "+1 (811) 444-2511",
6990:     "phone": "+1 (881) 569-3641",
7035:     "phone": "+1 (985) 453-3997",
7080:     "phone": "+1 (807) 542-3950",
7125:     "phone": "+1 (972) 503-2569",
7170:     "phone": "+1 (914) 485-2099",
7215:     "phone": "+1 (999) 440-3045",
7260:     "phone": "+1 (831) 495-3564",
7305:     "phone": "+1 (930) 502-2894",
7350:     "phone": "+1 (986) 487-3994",
7395:     "phone": "+1 (991) 423-2908",
7440:     "phone": "+1 (800) 557-3201",
7485:     "phone": "+1 (923) 569-3362",
7530:     "phone": "+1 (800) 450-3332",
7575:     "phone": "+1 (996) 492-2616",
7620:     "phone": "+1 (973) 501-2510",
7665:     "phone": "+1 (830) 474-3561",
7710:     "phone": "+1 (910) 556-2921",
7755:     "phone": "+1 (821) 581-2332",
7800:     "phone": "+1 (899) 548-2439",
7845:     "phone": "+1 (925) 551-3547",
7890:     "phone": "+1 (844) 552-2562",
7935:     "phone": "+1 (881) 524-2837",
7980:     "phone": "+1 (879) 433-2819",
8025:     "phone": "+1 (885) 412-2056",
8070:     "phone": "+1 (810) 508-2641",
8115:     "phone": "+1 (935) 507-2063",
8160:     "phone": "+1 (815) 477-3954",
8205:     "phone": "+1 (928) 431-3925",
8250:     "phone": "+1 (920) 574-2693",
8295:     "phone": "+1 (867) 418-3502",
8340:     "phone": "+1 (988) 400-3146",
8385:     "phone": "+1 (839) 418-3056",
8430:     "phone": "+1 (874) 505-3221",
8475:     "phone": "+1 (910) 478-3194",
8520:     "phone": "+1 (980) 571-3728",
8565:     "phone": "+1 (813) 495-2329",
8610:     "phone": "+1 (856) 454-3476",
8655:     "phone": "+1 (924) 495-2220",
8700:     "phone": "+1 (824) 597-3676",
8745:     "phone": "+1 (897) 524-2129",
8790:     "phone": "+1 (861) 407-3175",
8835:     "phone": "+1 (922) 534-3554",
8880:     "phone": "+1 (920) 492-2463",
8925:     "phone": "+1 (811) 463-2887",
8970:     "phone": "+1 (890) 494-2947",
9015:     "phone": "+1 (955) 567-3486",
9060:     "phone": "+1 (884) 428-2417",
9105:     "phone": "+1 (883) 538-2435",
9150:     "phone": "+1 (917) 563-3560",
9195:     "phone": "+1 (969) 582-2499",
9240:     "phone": "+1 (920) 418-2624",
9285:     "phone": "+1 (931) 573-2496",
9330:     "phone": "+1 (968) 539-2000",
9375:     "phone": "+1 (801) 452-2159",
9420:     "phone": "+1 (927) 557-3299",
9465:     "phone": "+1 (924) 535-3269",
9510:     "phone": "+1 (957) 477-3087",
9555:     "phone": "+1 (865) 585-3659",
9600:     "phone": "+1 (889) 419-2522",
9645:     "phone": "+1 (885) 476-3326",
9690:     "phone": "+1 (908) 458-3614",
9735:     "phone": "+1 (993) 507-3758",