Found 126919 results in 27240 files, showing top 50 files (show more).
android.googlesource.com/platform/packages/services/Telephony:src/com/android/phone/PhoneInterfaceManager.java: [ master, ]
487:         public Phone phone;
17: package com.android.phone;
249: public class PhoneInterfaceManager extends ITelephony.Stub {
2342:     private PhoneInterfaceManager(PhoneGlobals app) {
2363:     private Phone getDefaultPhone() {
2398:     private Phone getPhone(int subId) {
3078:     public String getNetworkCountryIsoForPhone(int phoneId) {
6776:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
6804:     public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
7405:     public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {
385:     private PhoneConfigurationManager mPhoneConfigurationManager;
2377:     private Phone getPhoneFromRequest(MainThreadRequest request) {
2385:     private Phone getPhoneFromSubId(int subId) {
2543:         private final int mPhoneId;
2822:     private void shutdownRadioUsingPhoneId(int phoneId) {
3532:     public int getActivePhoneType() {
3537:     public int getActivePhoneTypeForSlot(int slotIndex) {
4683:     private void checkModifyPhoneStatePermission(int subId, String message) {
5194:     private Phone getPhoneFromSlotPortIndexOrThrowException(int slotIndex, int portIndex) {
5217:     private Phone getPhoneFromValidIccLogicalChannelRequest(
6781:     private int checkCarrierPrivilegesForPackageAnyPhoneWithPermission(String pkgName) {
6832:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
7538:     public int getSubIdForPhoneAccountHandle(
7553:     public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
10233:     private boolean isAnyPhoneInEmergencyState() {
11106:     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;
174: import com.android.internal.telephony.Phone;
213: import com.android.phone.callcomposer.CallComposerPictureManager;
214: import com.android.phone.callcomposer.CallComposerPictureTransfer;
215: import com.android.phone.callcomposer.ImageData;
216: import com.android.phone.settings.PickSmsSubscriptionActivity;
217: import com.android.phone.vvm.PhoneAccountHandleConverter;
218: import com.android.phone.vvm.RemoteVvmTaskManager;
219: import com.android.phone.vvm.VisualVoicemailSettingsUtil;
220: import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
486:         // In cases where subId is unavailable, the caller needs to specify the phone.
495:         MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
497:             if (phone != null) {
498:                 this.phone = phone;
526:      * A handler that processes messages on the main thread in the phone process. Since many
527:      * of the Phone calls are not thread safe this is needed to shuttle the requests from the
528:      * inbound binder threads to the main thread in the phone process.  The Binder thread
545:             final Phone defaultPhone = getDefaultPhone();
550:                     final Phone phone = getPhoneFromRequest(request);
569:                         request.result = phone != null
570:                                 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
581:                     final Phone phone = getPhoneFromRequest(request);
582:                     request.result = phone != null ?
902:                     Phone phone = getPhoneFromRequest(request);
903:                     if (phone != null) {
904:                         phone.isNrDualConnectivityEnabled(onCompleted, request.workSource);
906:                         loge("isNRDualConnectivityEnabled: No phone object");
942:                     Phone phone = getPhoneFromRequest(request);
943:                     if (phone != null) {
944:                         phone.isVoNrEnabled(onCompleted, request.workSource);
946:                         loge("isVoNrEnabled: No phone object");
981:                     Phone phone = getPhoneFromRequest(request);
982:                     if (phone != null) {
983:                         phone.setNrDualConnectivityState((int) request.argument, onCompleted,
986:                         loge("enableNrDualConnectivity: No phone object");
1029:                     Phone phone = getPhoneFromRequest(request);
1030:                     if (phone != null) {
1031:                         phone.setVoNrEnabled((boolean) request.argument, onCompleted,
1034:                         loge("setVoNrEnabled: No phone object");
1162:                     request.phone.getCallForwardingOption(callForwardingReason, onCompleted);
1226:                     request.phone.setCallForwardingOption(
1670:                     request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
1684:                     request.phone.requestCellInfoUpdate(request.workSource,
1712:                     Phone phone = getPhoneFromRequest(request);
1713:                     phone.getCellIdentity(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1722:                         Phone phone = getPhoneFromRequest(request);
1723:                         request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1746:                             .enablePhone(request.phone, enable, onCompleted);
1752:                     int phoneId = request.phone.getPhoneId();
1768:                             .getPhoneStatusFromModem(request.phone, onCompleted);
1773:                     int id = request.phone.getPhoneId();
1796:                     request.phone.setSystemSelectionChannels(args.first, onCompleted);
1811:                     Phone phone = getPhoneFromRequest(request);
1812:                     if (phone != null) {
1813:                         phone.getSystemSelectionChannels(onCompleted);
1815:                         loge("getSystemSelectionChannels: No phone object");
1962:                     Phone phone = getPhoneFromRequest(request);
1963:                     if (phone != null) {
1964:                         phone.setDataThrottling(onCompleted,
1968:                         loge("setDataThrottling: No phone object");
2012:                     request.phone.setSimPowerState(stateToSet, onCompleted, request.workSource);
2056:                     final Phone phone = getPhoneFromRequest(request);
2057:                     if (phone == null || phone.getServiceStateTracker() == null) {
2058:                         request.result = new IllegalStateException("Phone or SST is null");
2067:                     phone.getSignalStrengthController().setSignalStrengthUpdateRequest(
2084:                     Phone phone = getPhoneFromRequest(request);
2085:                     if (phone == null || phone.getServiceStateTracker() == null) {
2086:                         request.result = new IllegalStateException("Phone or SST is null");
2095:                     phone.getSignalStrengthController().clearSignalStrengthUpdateRequest(
2111:                     request.phone.getSlicingConfig(onCompleted);
2235:     private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
2236:         return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone,
2246:     private @Nullable Object sendRequest(int command, Object argument, Integer subId, Phone phone,
2253:         if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
2254:             throw new IllegalArgumentException("subId and phone cannot both be specified!");
2255:         } else if (phone != null) {
2256:             request = new MainThreadRequest(argument, phone, workSource);
2316:      * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
2320:             int command, Object argument, Phone phone, WorkSource workSource) {
2321:         MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
2357:         PropertyInvalidatedCache.invalidateCache(TelephonyManager.CACHE_KEY_PHONE_ACCOUNT_TO_SUBID);
2364:         Phone thePhone = getPhone(getDefaultSubscription());
2378:         if (request.phone != null) {
2379:             return request.phone;
2392:         Phone phone = getPhoneFromRequest(request);
2393:         return phone == null ? null :
2394:                 UiccController.getInstance().getUiccPort(phone.getPhoneId());
2397:     // returns phone associated with the subId.
2402:     private void sendEraseModemConfig(@NonNull Phone phone) {
2407:     private void sendEraseDataInSharedPreferences(@NonNull Phone phone) {
2439:             // PENDING: should we just silently fail if phone is offhook or ringing?
2460:         // from the context of the phone app.
2463:         if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)
2513:             Phone phone = getPhone(subId);
2514:             final UnlockSim checkSimPin = new UnlockSim(phone.getPhoneId(), phone.getIccCard());
2527:             Phone phone = getPhone(subId);
2528:             final UnlockSim checkSimPuk = new UnlockSim(phone.getPhoneId(), phone.getIccCard());
2690:             final Phone phone = getPhone(getDefaultSubscription());
2691:             if (phone != null) {
2692:                 phone.updateServiceLocation(workSource);
2737:             final Phone phone = getPhone(subId);
2738:             if (phone != null) {
2739:                 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
2757:             final Phone phone = getPhone(subId);
2758:             if (phone != null) {
2759:                 phone.setRadioPower(!isRadioOnForSubscriber(subId));
2775:             final Phone phone = getPhone(subId);
2776:             if (phone == null) {
2779:             if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
2797:                 Phone phone = PhoneFactory.getPhone(i);
2798:                 if (phone != null && phone.isRadioAvailable()) return true;
2814:                 logv("Shutting down Phone " + i);
2823:         Phone phone = PhoneFactory.getPhone(phoneId);
2824:         if (phone != null && phone.isRadioAvailable()) {
2825:             phone.shutdownRadio();
2834:             final Phone defaultPhone = PhoneFactory.getDefaultPhone();
2839:                 loge("There's no default phone.");
2852:             final Phone phone = getPhone(subId);
2853:             if (phone != null) {
2854:                 phone.setRadioPower(turnOn);
2872:             final Phone phone = getPhone(subId);
2873:             if (phone != null) {
2874:                 phone.getDataSettingsManager().setDataEnabled(
2893:             final Phone phone = getPhone(subId);
2894:             if (phone != null) {
2895:                 phone.getDataSettingsManager().setDataEnabled(
2910:             final Phone phone = getPhone(subId);
2911:             if (phone != null) {
2912:                 return phone.isDataAllowed();
2971:             Phone phone = getPhone(getDefaultSubscription());
2972:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :
2973:                     PhoneConstantConversions.convertCallState(phone.getState());
2984:             // Check READ_PHONE_STATE for API version 31+
2987:                 throw new SecurityException("getCallState requires READ_PHONE_STATE for apps "
2993:             Phone phone = getPhone(subId);
2994:             return phone == null ? TelephonyManager.CALL_STATE_IDLE :
2995:                     PhoneConstantConversions.convertCallState(phone.getState());
3010:             final Phone phone = getPhone(subId);
3011:             if (phone != null) {
3012:                 return phone.getDataNetworkController().getInternetDataNetworkState();
3031:             final Phone phone = getPhone(subId);
3032:             if (phone != null) {
3033:                 return phone.getDataActivityState();
3062:                 return (getDefaultPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
3083:             if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
3084:                 // Get default phone in this case.
3085:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
3088:             Phone phone = PhoneFactory.getPhone(phoneId);
3089:             if (phone == null) return "";
3090:             ServiceStateTracker sst = phone.getServiceStateTracker();
3167:         for (Phone phone : PhoneFactory.getPhones()) {
3168:             List<CellInfo> info = phone.getAllCellInfo();
3207:             for (Phone phone : PhoneFactory.getPhones()) {
3209:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);
3271:         final Phone phone = getPhoneFromSubId(subId);
3272:         if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
3274:         sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
3292:         Phone phone = PhoneFactory.getPhone(slotIndex);
3293:         if (phone == null) {
3296:         int subId = phone.getSubId();
3305:             return phone.getImei();
3313:         Phone phone = PhoneFactory.getPhone(slotIndex);
3315:         if (phone != null) {
3316:             String imei = phone.getImei();
3336:         Phone phone = PhoneFactory.getPhone(slotIndex);
3337:         if (phone == null) {
3341:         int subId = phone.getSubId();
3349:             return phone.getMeid();
3357:         Phone phone = PhoneFactory.getPhone(slotIndex);
3359:         if (phone != null) {
3360:             String meid = phone.getMeid();
3375:         Phone phone = PhoneFactory.getPhone(slotIndex);
3376:         if (phone == null) {
3379:         int subId = phone.getSubId();
3388:             return phone.getDeviceSvn();
3398:             final Phone phone = getPhone(subId);
3399:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
3409:             final Phone phone = getPhone(subId);
3410:             return phone == null ? null : phone.getCarrierName();
3420:             final Phone phone = getPhone(subId);
3421:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
3422:                     : phone.getSpecificCarrierId();
3432:             final Phone phone = getPhone(subId);
3433:             return phone == null ? null : phone.getSpecificCarrierName();
3444:         final Phone phone = PhoneFactory.getPhone(slotIndex);
3445:         if (phone == null) {
3450:             return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
3481:      * Make sure the caller has the MODIFY_PHONE_STATE permission.
3486:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
3495:      * Make sure the caller has the CALL_PHONE permission.
3500:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
3540:             final Phone phone = PhoneFactory.getPhone(slotIndex);
3541:             if (phone == null) {
3542:                 return PhoneConstants.PHONE_TYPE_NONE;
3544:                 return phone.getPhoneType();
3571:             final Phone phone = getPhone(subId);
3572:             if (phone != null) {
3573:                 return phone.getCdmaEriIconIndex();
3604:             final Phone phone = getPhone(subId);
3605:             if (phone != null) {
3606:                 return phone.getCdmaEriIconMode();
3635:             final Phone phone = getPhone(subId);
3636:             if (phone != null) {
3637:                 return phone.getCdmaEriText();
3656:             final Phone phone = getPhone(subId);
3657:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
3658:                 return phone.getLine1Number();
3660:                 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
3678:             final Phone phone = getPhone(subId);
3679:             if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
3680:                 return phone.getCdmaMin();
3692:         if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
3694:             throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
3860:             final Phone phone = getPhone(subId);
3861:             if (phone != null) {
3862:                 phone.setVoiceActivationState(activationState);
3881:             final Phone phone = getPhone(subId);
3882:             if (phone != null) {
3883:                 phone.setDataActivationState(activationState);
3899:         final Phone phone = getPhone(subId);
3902:             if (phone != null) {
3903:                 return phone.getVoiceActivationState();
3919:         final Phone phone = getPhone(subId);
3922:             if (phone != null) {
3923:                 return phone.getDataActivationState();
3945:             final Phone phone = getPhone(subId);
3946:             if (phone != null) {
3947:                 return phone.getVoiceMessageCount();
3964:             final Phone phone = getPhone(subId);
3965:             return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
3978:         final Phone defaultPhone = getDefaultPhone();
4016:             for (Phone phone : PhoneFactory.getPhones()) {
4017:                 if (phone.isInEmergencySmsMode()) {
4028:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4055:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4092:             Phone phone = getPhone(subId);
4093:             if (phone == null) {
4098:             phone.getImsRegistrationState(regState -> {
4125:             Phone phone = getPhone(subId);
4126:             if (phone == null) {
4131:             phone.getImsRegistrationTech(regTech -> {
4150:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4176:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4226:             Phone phone = getPhone(subId);
4227:             if (phone == null) return false;
4228:             return phone.isImsCapabilityAvailable(capability, regTech);
4279:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4317:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4354:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4392:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4413:      * Requires MODIFY_PHONE_STATE permission.
4436:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4490:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4576:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
4996:             final Phone phone = getPhone(subId);
4997:             if (phone != null) {
4998:                 return phone.getServiceState().getDataNetworkType();
5033:             final Phone phone = getPhone(subId);
5034:             if (phone != null) {
5035:                 return phone.getServiceState().getDataNetworkType();
5061:             final Phone phone = getPhone(subId);
5062:             if (phone != null) {
5063:                 return phone.getServiceState().getVoiceNetworkType();
5088:             final Phone phone = PhoneFactory.getPhone(slotIndex);
5089:             if (phone != null) {
5090:                 return phone.getIccCard().hasIccCard();
5105:      * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
5106:      * or {@link Phone#LTE_ON_CDMA_TRUE}
5125:             final Phone phone = getPhone(subId);
5126:             if (phone == null) {
5199:                      + portIndex + " does not correspond to an active phone");
5207:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,
5214:         return iccOpenLogicalChannelWithPermission(phone, request);
5219:         Phone phone;
5223:             phone = getPhoneFromSubId(request.subId);
5226:             phone = getPhoneFromSlotPortIndexOrThrowException(request.slotIndex, request.portIndex);
5230:         return phone;
5233:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
5250:                     CMD_OPEN_CHANNEL, channelRequest, phone, null /* workSource */);
5260:         Phone phone = getPhoneFromValidIccLogicalChannelRequest(request,
5265:         return iccCloseLogicalChannelWithPermission(phone, request);
5268:     private boolean iccCloseLogicalChannelWithPermission(Phone phone,
5280:             Object result = sendRequest(CMD_CLOSE_CHANNEL, request.channel, phone,
5330:     private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
5339:                     new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
5386:     private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
5404:                     new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
5636:         Phone phone = PhoneFactory.getPhone(slotIndex);
5637:         if (phone != null) {
5639:                     mApp, phone.getSubId(), "resetModemConfig");
5662:         Phone phone = PhoneFactory.getPhone(slotIndex);
5663:         if (phone != null) {
5665:                     mApp, phone.getSubId(), "rebootModem");
5940:      * Sets the ims registration state on all valid {@link Phone}s.
5947:             // NOTE: Before S, this method only set the default phone.
5948:             for (final Phone phone : PhoneFactory.getPhones()) {
5949:                 if (SubscriptionManager.isValidSubscriptionId(phone.getSubId())) {
5950:                     phone.setImsRegistrationState(registered);
6033:             final Phone phone = getPhone(subId);
6034:             if (phone == null) {
6037:             OperatorInfo networkSelection = phone.getSavedNetworkSelection();
6039:                 ? phone.getManualNetworkSelectionPlmn() : networkSelection.getOperatorNumeric();
6096:             Phone phone = getPhone(subId);
6097:             if (phone == null) {
6127:             sendRequestAsync(CMD_GET_CALL_FORWARDING, argument, phone, null);
6148:             Phone phone = getPhone(subId);
6149:             if (phone == null) {
6162:             sendRequestAsync(CMD_SET_CALL_FORWARDING, arguments, phone, null);
6176:             Phone phone = getPhone(subId);
6177:             if (phone == null) {
6185:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
6192:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
6212:                 sendRequestAsync(CMD_GET_CALL_WAITING, argument, phone, null);
6229:             Phone phone = getPhone(subId);
6230:             if (phone == null) {
6239:             CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
6246:                 CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
6269:                 sendRequestAsync(CMD_SET_CALL_WAITING, arguments, phone, null);
6505:         if (mApp.checkCallingOrSelfPermission(Manifest.permission.MODIFY_PHONE_STATE)
6556:         final Phone phone = getPhone(subId);
6558:             if (phone != null) {
6559:                 return phone.hasMatchedTetherApnSetting();
6589:      * Accepts either READ_BASIC_PHONE_STATE, ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE
6599:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,
6614:             Phone phone = PhoneFactory.getPhone(phoneId);
6615:             if (phone != null) {
6616:                 boolean retVal = phone.isUserDataEnabled();
6620:                 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
6646:                             android.Manifest.permission.READ_PHONE_STATE,
6650:                             permission.READ_BASIC_PHONE_STATE, functionName);
6660:             Phone phone = PhoneFactory.getPhone(phoneId);
6661:             if (phone != null) {
6663:                 retVal = phone.getDataSettingsManager().isDataEnabled();
6667:                 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
6691:                 mApp.enforceCallingOrSelfPermission(permission.READ_BASIC_PHONE_STATE,
6696:                 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
6712:             Phone phone = PhoneFactory.getPhone(phoneId);
6713:             if (phone != null) {
6715:                 retVal = phone.getDataSettingsManager().isDataEnabledForReason(reason);
6720:                     loge("isDataEnabledForReason: no phone subId="
6743:         Phone phone = getPhone(subId);
6744:         if (phone == null) {
6748:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6762:         Phone phone = getPhone(subId);
6763:         if (phone == null) {
6767:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6787:             Phone phone = PhoneFactory.getPhone(phoneId);
6788:             if (phone == null) {
6791:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6806:         Phone phone = PhoneFactory.getPhone(phoneId);
6807:         if (phone == null) {
6810:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6820:         Phone phone = PhoneFactory.getPhone(phoneId);
6821:         if (phone == null) {
6824:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6850:         final Phone phone = PhoneFactory.getPhone(logicalSlotIndex);
6851:         if (phone == null) {
6854:         final CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
6862:         final Phone phone = getPhone(subId);
6863:         UiccPort port = phone == null ? null : phone.getUiccPort();
6880:             Phone phone = getPhone(subId);
6881:             if (phone != null) {
6882:                 Phone defaultPhone = phone.getImsPhone();
6883:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
6903:             Phone phone = getPhone(subId);
6904:             if (phone != null) {
6905:                 Phone defaultPhone = phone.getImsPhone();
6906:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
6926:             final Phone phone = getPhone(subId);
6927:             if (phone == null) {
6930:             final String subscriberId = phone.getSubscriberId();
7167:             final Phone phone = getPhone(subId);
7168:             return phone == null ? false : phone.setOperatorBrandOverride(brand);
7183:             final Phone phone = getPhone(subId);
7184:             if (phone == null) {
7187:             return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
7229:         Phone phone = PhoneFactory.getPhone(phoneId);
7233:                             mApp, phone.getSubId(), "getRadioAccessFamily");
7239:         if (phone == null) {
7246:                             mApp, phone.getSubId(), "getRadioAccessFamily");
7348:         final Phone defaultPhone = getDefaultPhone();
7362:         final Phone defaultPhone = getDefaultPhone();
7416:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
7447:         final Phone phone = getPhone(subscriptionId);
7448:         if (phone == null) {
7449:             loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
7456:                     phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
7489:      * Returns the unique device ID of phone, for example, the IMEI for
7493:      *   {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
7504:         final Phone phone = PhoneFactory.getPhone(0);
7505:         if (phone == null) {
7508:         int subId = phone.getSubId();
7516:             return phone.getDeviceId();
7529:         Phone phone = getPhone(subId);
7530:         if (phone != null) {
7531:             return phone.isImsRegistered();
7542:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
7561:             Phone phone = getPhone(subscriptionId);
7562:             if (phone == null) {
7565:             return PhoneUtils.makePstnPhoneAccountHandle(phone);
7577:             Phone phone = getPhone(subId);
7578:             if (phone != null) {
7579:                 return phone.isWifiCallingEnabled();
7594:             Phone phone = getPhone(subId);
7595:             if (phone != null) {
7596:                 return phone.isVideoEnabled();
7612:             Phone phone = getPhone(subId);
7613:             if (phone != null) {
7614:                 return phone.getImsRegistrationTech();
7629:         Phone defaultPhone = getDefaultPhone();
7642:                 Phone phone = getPhone(subId);
7643:                 cleanUpAllowedNetworkTypes(phone, subId);
7675:     void cleanUpAllowedNetworkTypes(Phone phone, int subId) {
7676:         if (phone == null || !SubscriptionManager.isUsableSubscriptionId(subId)) {
7684:         phone.loadAllowedNetworksFromSubscriptionDatabase();
7685:         phone.setAllowedNetworkTypes(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
7698:         final Phone phone = getPhone(subId);
7699:         if (phone == null) {
7708:                         phone.getContext().getOpPackageName(),
7709:                         phone.getContext().getAttributionTag());
7716:                         phone.getContext().getOpPackageName(),
7717:                         phone.getContext().getAttributionTag());
7727:             final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
7732:                     return matchLocaleFromSupportedLocaleList(phone, localeFromDefaultSim);
7745:                 return matchLocaleFromSupportedLocaleList(phone, mccLocale);
7756:     String matchLocaleFromSupportedLocaleList(Phone phone, @NonNull Locale inputLocale) {
7758:                 phone.getContext());
7977:         final Phone phone = getPhone(subId);
7978:         if (phone == null) {
7984:         boolean isCallingPackageDataService = phone.getDataServicePackages()
7987:             // isActiveSubId requires READ_PHONE_STATE, which we already check for above
8005:             ServiceState ss = phone.getServiceState();
8018:      * Returns the URI for the per-account voicemail ringtone set in Phone settings.
8029:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
8030:             if (phone == null) {
8031:                 phone = getDefaultPhone();
8034:             return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
8044:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
8054:         final Phone defaultPhone = getDefaultPhone();
8065:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
8066:             if (phone == null) {
8067:                 phone = defaultPhone;
8069:             VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
8076:      * Returns whether vibration is set for voicemail notification in Phone settings.
8086:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
8087:             if (phone == null) {
8088:                 phone = getDefaultPhone();
8091:             return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
8101:      * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
8111:         final Phone defaultPhone = getDefaultPhone();
8122:             Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
8123:             if (phone == null) {
8124:                 phone = defaultPhone;
8126:             VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
8133:      * Make sure either called from same process as self (phone) or IPC caller has read privilege.
8138:         mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
8143:      * Make sure either called from same process as self (phone) or IPC caller has send SMS
8185:         Phone phone = getPhone(subId);
8189:             if (phone == null) {
8194:                 aid = UiccController.getInstance().getUiccPort(phone.getPhoneId())
8214:         Phone phone = getPhone(subId);
8218:             if (phone == null) {
8223:                 esn = phone.getEsn();
8242:         Phone phone = getPhone(subId);
8246:             if (phone == null) {
8251:                 cdmaPrlVersion = phone.getCdmaPrlVersion();
8345:         final Phone phone = getPhone(subId);
8348:         if (phone == null) {
8353:             phone.carrierActionSetRadioEnabled(enabled);
8370:         final Phone phone = getPhone(subId);
8373:         if (phone == null) {
8374:             loge("setVoNrEnabled fails with no phone object for subId: " + subId);
8430:         final Phone phone = getPhone(subId);
8433:         if (phone == null) {
8438:             phone.carrierActionReportDefaultNetworkStatus(report);
8454:         final Phone phone = getPhone(subId);
8455:         if (phone == null) {
8460:             phone.carrierActionResetAll();
8467:      * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
8474:             writer.println("Permission Denial: can't dump Phone from pid="
8518:             Phone phone = getPhone(subId);
8519:             if (phone != null) {
8521:                     phone.carrierActionSetMeteredApnsEnabled(enabled);
8523:                     phone.getDataSettingsManager().setDataEnabled(
8544:         Phone phone = getPhone(subId);
8548:             if (phone != null) {
8549:                 return phone.getClientRequestStats();
8567:             // $ adb shell cmd phone ...
8586:         Phone phone = PhoneFactory.getPhone(slotIndex);
8592:             if (phone != null) {
8593:                 phone.setSimPowerState(state, null, workSource);
8615:         Phone phone = PhoneFactory.getPhone(slotIndex);
8621:             if (phone != null) {
8623:                 sendRequestAsync(CMD_SET_SIM_POWER, arguments, phone, workSource);
8645:      * Check if phone is in emergency callback mode
8646:      * @return true if phone is in emergency callback mode
8652:         final Phone phone = getPhone(subId);
8656:             if (phone != null) {
8657:                 return phone.isInEcm();
8677:             Phone p = getPhone(subId);
8697:         Phone phone = PhoneFactory.getPhone(slotIndex);
8698:         if (phone != null) {
8699:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, phone.getSubId(),
8706:                 return phone.getRadioPowerState();
8719:      * {@link android.Manifest.permission#READ_BASIC_PHONE_STATE},
8720:      * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
8737:                         permission.READ_BASIC_PHONE_STATE, functionName);
8747:             Phone phone = getPhone(subId);
8748:             isEnabled =  phone != null ? phone.getDataRoamingEnabled() : false;
8760:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
8773:             Phone phone = getPhone(subId);
8774:             if (phone != null) {
8775:                 phone.setDataRoamingEnabled(isEnabled);
8791:             Phone phone = getPhone(subId);
8792:             if (phone != null) {
8793:                 isAllowed = phone.isCspPlmnEnabled();
8806:         Phone phone = PhoneFactory.getPhone(profile.getPhoneId());
8807:         if (phone == null) {
8810:         CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
8827:             // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
8940:         // This will make sure caller has the READ_PRIVILEGED_PHONE_STATE. Do not remove this as
9061:     @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
9087:      * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
9096:             Phone phone = getPhone(subId);
9097:             if (phone == null) {
9100:             UiccPort uiccPort = phone.getUiccPort();
9137:      * not set, return {@link Phone#PREFERRED_NT_MODE}.
9145:         return Phone.PREFERRED_NT_MODE;
9155:             final Phone phone = getPhone(subId);
9156:             if (phone == null) {
9160:             CarrierPrivilegesTracker cpt = phone.getCarrierPrivilegesTracker();
9165:             phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
9183:             final Phone phone = getPhone(subId);
9184:             if (phone == null) {
9188:             return phone.getCarrierIdListVersion();
9271:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
9276:             for (Phone phone: PhoneFactory.getPhones()) {
9277:                 if (phone.getEmergencyNumberTracker() != null
9278:                         && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
9280:                             phone.getSubId(),
9281:                             phone.getEmergencyNumberTracker().getEmergencyNumberList());
9292:         final Phone defaultPhone = getDefaultPhone();
9300:             for (Phone phone: PhoneFactory.getPhones()) {
9301:                 if (phone.getEmergencyNumberTracker() != null
9302:                         && phone.getEmergencyNumberTracker()
9323:             for (Phone phone : PhoneFactory.getPhones()) {
9324:                 Rlog.d(LOG_TAG, "startEmergencyCallbackMode phone type: " + phone.getPhoneType());
9325:                 if (phone != null && ((phone.getPhoneType() == PHONE_TYPE_GSM)
9326:                         || (phone.getPhoneType() == PHONE_TYPE_CDMA))) {
9327:                     GsmCdmaPhone gsmCdmaPhone = (GsmCdmaPhone) phone;
9348:             for (Phone phone: PhoneFactory.getPhones()) {
9349:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
9370:             for (Phone phone: PhoneFactory.getPhones()) {
9371:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
9390:             final Phone phone = getPhone(subId);
9391:             if (phone == null) {
9395:             return phone.getEmergencyNumberDbVersion();
9407:             for (Phone phone: PhoneFactory.getPhones()) {
9408:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
9424:             for (Phone phone: PhoneFactory.getPhones()) {
9425:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
9441:             for (Phone phone: PhoneFactory.getPhones()) {
9442:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
9455:         Phone phone = getPhone(subId);
9456:         if (phone == null) {
9462:                     .getUiccProfileForPhone(phone.getPhoneId());
9481:             Phone phone = PhoneFactory.getPhone(slotIndex);
9482:             if (phone == null) {
9485:                 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
9498:         Phone phone = PhoneFactory.getPhone(slotIndex);
9499:         if (phone == null) return false;
9502:                 mApp, phone.getSubId(), callingPackage, callingFeatureId,
9504:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
9510:                 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
9512:                 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
9580:      * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
9581:      * permission, but the other way around is possible with either MODIFY_PHONE_STATE
9610:         Phone phone = getPhone(subId);
9611:         if (phone == null) {
9616:             UiccPort uiccPort = phone.getUiccPort();
9691:         Phone phone = getDefaultPhone();
9692:         if (phone == null) return -1;
9693:         HalVersion hv = phone.getHalVersion();
9723:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "
9729:             Phone phone = getPhone(subId);
9730:             if (phone == null) return false;
9734:             isMetered = phone.getDataNetworkController().getDataConfigManager()
9736:                             phone.getServiceState().getDataRoaming());
9737:             isDataEnabled = phone.getDataSettingsManager().isDataEnabled(apnType);
9751:             Phone phone = getPhone(subId);
9752:             if (phone == null) return true; // By default return true.
9753:             return phone.getDataNetworkController().getDataConfigManager().isMeteredCapability(
9755:                     phone.getServiceState().getDataRoaming());
9767:             Phone phone = getPhone(subscriptionId);
9768:             if (phone == null) {
9788:             sendRequestAsync(CMD_SET_SYSTEM_SELECTION_CHANNELS, argument, phone, null);
9882:             Phone phone = getPhone(subscriptionId);
9883:             if (phone == null) return false;
9885:             return phone.getDataSettingsManager().isMobileDataPolicyEnabled(policy);
9898:             Phone phone = getPhone(subscriptionId);
9899:             if (phone == null) return;
9901:             phone.getDataSettingsManager().setMobileDataPolicy(policy, enabled);
9919:             for (Phone phone : PhoneFactory.getPhones()) {
9920:                 Phone defaultPhone = phone.getImsPhone();
9921:                 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
9970:             Phone phone = getPhone(subId);
9971:             if (phone != null && phone.getIccCard() != null) {
9972:                 return phone.getIccCard().getIccLockEnabled();
9996:         Phone phone = getPhone(subId);
9997:         if (phone == null) {
10004:                     new Pair<Boolean, String>(enabled, password), phone, null);
10028:         Phone phone = getPhone(subId);
10029:         if (phone == null) {
10036:                     new Pair<String, String>(oldPassword, newPassword), phone, null);
10095:             throw new SecurityException("Requires READ_PHONE_STATE permission.");
10098:         Phone phone = getPhone(subId);
10099:         if (phone == null) {
10100:             throw new RuntimeException("phone is not available");
10105:             return phone.getEquivalentHomePlmns();
10129:                 Manifest.permission.MODIFY_PHONE_STATE);
10169:      * @return {@code true} if phone setRadioPowerForReason was called. Otherwise, returns {@code
10175:             Phone phone = PhoneFactory.getPhone(i);
10176:             if (phone != null) {
10177:                 phone.setRadioPowerForReason(enable, Phone.RADIO_POWER_REASON_THERMAL);
10182:         // return true if successfully informed the phone object about the thermal radio power
10196:         // Ensure that radio is on. If not able to power on due to phone being unavailable, return
10236:             Log.e(LOG_TAG , "Phone state is not valid. One of the phones is in an emergency call");
10239:         for (Phone phone : PhoneFactory.getPhones()) {
10240:             if (phone.isInEmergencySmsMode() || phone.isInEcm()) {
10241:                 Log.e(LOG_TAG, "Phone state is not valid. isInEmergencySmsMode = "
10242:                     + phone.isInEmergencySmsMode() + " isInEmergencyCallbackMode = "
10243:                     + phone.isInEcm());
10314:                     // Ensure that radio is on. If not able to power on due to phone being
10334:                         Phone phone = getPhone(subId);
10335:                         if (phone == null) {
10359:                     // Turn radio off. If not able to power off due to phone being unavailable,
10483:                 permission.READ_PRIVILEGED_PHONE_STATE);
10514:                 permission.READ_PRIVILEGED_PHONE_STATE);
10545:                 permission.READ_PRIVILEGED_PHONE_STATE);
10722:                         Phone thePhone = p.getImsPhone();
11061:         if (callingUid == Process.PHONE_UID || callingUid == Process.SYSTEM_UID) {
11062:             // phone/system process do not have further restriction on request
11098:      * Gets the current phone capability.
11100:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.
11102:      * It's used to evaluate possible phone config change, for example from single
11138:      * Requires carrier privileges or READ_PRIVILEGED_PHONE_STATE permission.
11148:             Phone phone = getDefaultPhone();
11149:             sendRequestAsync(CMD_GET_SLICING_CONFIG, callback, phone, null);
11163:             // The following also checks READ_PRIVILEGED_PHONE_STATE.
11171:                     Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
11172:                     Manifest.permission.READ_PRECISE_PHONE_STATE,
11228:      * com.android.phone.permission.ACCESS_LAST_KNOWN_CELL_ID, otherwise throws
11264:             Phone phone = getPhone(subId);
11265:             if (phone == null) return null;
11266:             ServiceStateTracker sst = phone.getServiceStateTracker();
11316:             Phone phone = getPhone(subId);
11317:             if (phone == null) return;
11318:             phone.setVoiceServiceStateOverride(hasService);
11373:             Phone phone = null;
11375:                 phone = PhoneFactory.getPhone(slotIndex);
11379:             if (phone == null) {
11382:                 IccCard icc = phone.getIccCard();
24: import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
73: import android.telecom.PhoneAccount;
74: import android.telecom.PhoneAccountHandle;
99: import android.telephony.PhoneCapability;
100: import android.telephony.PhoneNumberRange;
160: import com.android.internal.telephony.GsmCdmaPhone;
175: import com.android.internal.telephony.PhoneConfigurationManager;
176: import com.android.internal.telephony.PhoneConstantConversions;
177: import com.android.internal.telephony.PhoneConstants;
178: import com.android.internal.telephony.PhoneFactory;
193: import com.android.internal.telephony.imsphone.ImsPhone;
194: import com.android.internal.telephony.imsphone.ImsPhoneCallTracker;
250:     private static final String LOG_TAG = "PhoneInterfaceManager";
251:     private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
373:     private static PhoneInterfaceManager sInstance;
376:     private PhoneGlobals mApp;
843:                     defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
870:                     defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
881:                     defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
891:                     defaultPhone.resetModemConfig(onCompleted);
1116:                     defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
1405:                     if (defaultPhone != null) {
1406:                         defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
1483:                     defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
1511:                     defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
1735:                     defaultPhone.rebootModem(onCompleted);
1745:                     PhoneConfigurationManager.getInstance()
1755:                         mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1767:                     PhoneConfigurationManager.getInstance()
1884:                     defaultPhone.eraseModemConfig(onCompleted);
1892:                     request.result = defaultPhone.eraseDataInSharedPreferences();
1910:                         int phoneId = getPhoneFromRequest(request).getPhoneId();
1912:                                 .storePin(passwords.second, phoneId);
1934:                         int phoneId = getPhoneFromRequest(request).getPhoneId();
1937:                                     .storePin(enabled.second, phoneId);
1939:                             UiccController.getInstance().getPinStorage().clearPin(phoneId);
1953:                     getDefaultPhone().getContext().sendBroadcastAsUser(
2327:      * Initialize the singleton PhoneInterfaceManager instance.
2328:      * This is only done once, at startup, from PhoneApp.onCreate().
2330:     /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
2331:         synchronized (PhoneInterfaceManager.class) {
2333:                 sInstance = new PhoneInterfaceManager(app);
2344:         mCM = PhoneGlobals.getInstance().mCM;
2354:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
2365:         return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
2387:                 ? getDefaultPhone() : getPhone(subId);
2399:         return PhoneFactory.getPhone(SubscriptionManager.getPhoneId(subId));
2413:         PackageManager pm = getDefaultPhone().getContext().getPackageManager();
2440:             PhoneConstants.State state = mCM.getState(subId);
2441:             if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
2500:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
2505:         return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
2546:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
2555:         UnlockSim(int phoneId, IccCard simCard) {
2556:             mPhoneId = phoneId;
2577:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
2582:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;
2584:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;
2587:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;
2639:             if (mResult == PhoneConstants.PIN_RESULT_SUCCESS && pin.length() > 0) {
2800:             logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
2835:             if (defaultPhone != null) {
2836:                 defaultPhone.setRadioPower(turnOn);
3014:                 return PhoneConstantConversions.convertDataState(
3015:                         PhoneConstants.DataState.DISCONNECTED);
3087:             final int subId = SubscriptionManager.getSubscriptionId(phoneId);
3284:             getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
3520:         Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
3524:         Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
3528:         Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
3690:     public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
3721:             return getDefaultPhone().needsOtaServiceProvisioning();
3756:             PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
3757:             if (phoneAccountHandle == null) {
3760:             return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
3845:         SmsController smsController = PhoneFactory.getSmsController();
3980:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
3989:             defaultPhone.sendDialerSpecialCode(inputCode);
4817:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4857:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4884:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
4923:             // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
5120:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
5127:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
5130:                         .orElse(PhoneConstants.LTE_ON_CDMA_FALSE);
5154:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
5195:         int phoneId = UiccController.getInstance().getPhoneIdFromSlotPortIndex(slotIndex,
5197:         if (phoneId == -1) {
5201:         return PhoneFactory.getPhone(phoneId);
5239:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
5393:                 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
6326:                     renounceFineLocationAccess, request, messenger, binder, getPhone(subId),
6612:             int phoneId = SubscriptionManager.getPhoneId(subId);
6613:             if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
6659:             int phoneId = SubscriptionManager.getPhoneId(subId);
6707:             int phoneId = SubscriptionManager.getPhoneId(subId);
6709:                 log("isDataEnabledForReason: subId=" + subId + " phoneId=" + phoneId
6777:         enforceReadPrivilegedPermission("checkCarrierPrivilegesForPackageAnyPhone");
6786:         for (int phoneId = 0; phoneId < TelephonyManager.getDefault().getPhoneCount(); phoneId++) {
6805:         enforceReadPrivilegedPermission("getCarrierPackageNamesForIntentAndPhone");
6818:     public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
6884:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
6885:                     imsPhone.setCallComposerStatus(status);
6907:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
6908:                     return imsPhone.getCallComposerStatus();
7120:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
7137:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
7228:     public int getRadioAccessFamily(int phoneId, String callingPackage) {
7247:             raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
7353:             ImsManager.getInstance(defaultPhone.getContext(),
7354:                     defaultPhone.getPhoneId()).setVtSetting(enable);
7363:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
7375:                     ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
7490:      * GSM and the MEID for CDMA phones. Return null if device ID is not available.
7539:             PhoneAccountHandle phoneAccountHandle, String callingPackage, String callingFeatureId) {
7546:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);
7630:         if (defaultPhone != null) {
7632:                     mApp, getDefaultPhone().getSubId(), "factoryReset");
7645:                 getPhone(subId).resetCarrierKeysForImsiEncryption();
7651:             cleanUpSmsRawTable(getDefaultPhone().getContext());
7658:             if (defaultPhone == null) {
7665:                 sendEraseModemConfig(defaultPhone);
7668:             sendEraseDataInSharedPreferences(defaultPhone);
7706:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
7773:         if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
7988:             if (PhoneFactory.isSubscriptionManagerServiceEnabled()) {
8020:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
8023:      * PhoneAccount.
8026:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
8046:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
8049:      * PhoneAccount.
8053:             PhoneAccountHandle phoneAccountHandle, Uri uri) {
8056:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
8059:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
8078:      * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
8080:      * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
8083:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
8103:      * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
8106:      * specific PhoneAccount.
8110:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {
8113:         TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
8116:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
8488:         return new TelephonyShellCommand(this, getDefaultPhone().getContext()).exec(
9141:         int phoneId = SubscriptionManager.getPhoneId(subId);
9142:         if (phoneId >= 0 && phoneId < list.size() && list.get(phoneId) != null) {
9143:             return list.get(phoneId);
9296:                             mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
9314:      * Start emergency callback mode for GsmCdmaPhone for testing.
9328:                     gsmCdmaPhone.obtainMessage(
9329:                             GsmCdmaPhone.EVENT_EMERGENCY_CALLBACK_MODE_ENTER).sendToTarget();
9537:                 getDefaultPhone().getSubId(), callingPackage, callingFeatureId,
9560:         PhoneCapability staticCapability =
9826:         SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
9852:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
9869:             return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
9922:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;
9924:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();
9926:                     Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled + ", for imsPhone "
9927:                             + imsPhone.getMsisdn());
10065:         // *  Inherited from PhoneWindowManager  *
10163:      * Attempts to set the radio power state for all phones for thermal reason.
10166:      * PhoneInternalInterface#setRadioPowerForReason} for more details.
10289:         if (!getThermalMitigationAllowlist(getDefaultPhone().getContext())
10720:             Arrays.stream(PhoneFactory.getPhones()).forEach(
10723:                         if (thePhone != null && thePhone instanceof ImsPhone) {
10724:                             ImsPhone imsPhone = (ImsPhone) thePhone;
10725:                             CallTracker tracker = imsPhone.getCallTracker();
10805:             return getDefaultPhone().getMobileProvisioningUrl();
10820:             return EabUtil.getContactFromEab(getDefaultPhone().getContext(), contact);
10835:             return EabUtil.getCapabilityFromEab(getDefaultPhone().getContext(), contact);
10850:             return EabUtil.removeContactFromEab(subId, contacts, getDefaultPhone().getContext());
11101:      * @return the PhoneCapability which describes the data connection capability of modem.
583:                             getPhoneFromRequest(request).handlePinMmi((String) request.argument)
1073:                     getPhoneFromRequest(request).getAllowedNetworkTypesBitmask(onCompleted);
1103:                     getPhoneFromRequest(request).setAllowedNetworkTypes(
1130:                     getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
1142:                     getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
1152:                     getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
1267:                     getPhoneFromRequest(request).getCallWaiting(onCompleted);
1316:                     getPhoneFromRequest(request).setCallWaiting(enable, onCompleted);
1385:                     getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
1594:                     getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
1615:                     getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1631:                     getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1642:                     getPhoneFromRequest(request).queryCdmaSubscriptionMode(onCompleted);
1658:                     getPhoneFromRequest(request).setCdmaSubscriptionMode(
1777:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,
1900:                     getPhoneFromRequest(request).getIccCard().changeIccLockPassword(
1923:                     getPhoneFromRequest(request).getIccCard().setIccLockEnabled(
2381:             return getPhoneFromSubId(request.subId);
2640:                 UiccController.getInstance().getPinStorage().storePin(pin, mPhoneId);
2721:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2796:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2813:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2815:                 shutdownRadioUsingPhoneId(i);
2985:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,
3380:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3533:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
3563:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3596:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3627:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3770:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3938:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3998:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4035:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4061:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4117:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4157:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4182:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4284:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4322:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4359:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4397:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4442:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4495:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4581:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4640:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4663:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4691:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");
4710:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4731:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");
4749:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4769:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4789:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4812:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4852:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
4988:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(
5023:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(
5025:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5051:         if (!TelephonyPermissions.checkCallingOrSelfReadNonDangerousPhoneStateNoThrow(
5053:             if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5146:         return SubscriptionManager.getPhoneId(getDefaultSubscription());
5312:         return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
5326:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), channel, cla,
5365:         return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
5381:                 getPhoneFromSlotPortIndexOrThrowException(slotIndex, portIndex), callingPackage,
5466:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5885:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(mApp,
6024:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
6392:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
6417:         TelephonyPermissions.enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
6421:             return getPhoneFromSubId(subId).getAllowedNetworkTypes(reason);
6470:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
6527:         if (allowedNetworkTypes == getPhoneFromSubId(subId).getAllowedNetworkTypes(reason)) {
6778:         return checkCarrierPrivilegesForPackageAnyPhoneWithPermission(pkgName);
6833:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");
6837:             for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
6973:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
7000:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7023:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7232:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7245:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7387:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7406:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7540:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, getDefaultSubscription(),
7541:                 callingPackage, callingFeatureId, "getSubIdForPhoneAccountHandle")) {
7555:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
7558:                 "getPhoneAccountHandleForSubscriptionId, " + "subscriptionId: " + subscriptionId);
7934:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8540:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
8740:             TelephonyPermissions.enforceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
8785:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
8829:             if (checkCarrierPrivilegesForPackageAnyPhoneWithPermission(callingPackage)
9005:                             slot.getPhoneIdFromPortIndex(portIdx), slot.isPortActive(portIdx)));
9197:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
9205:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
9214:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
9241:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
9268:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
9295:                     .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
9501:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
9536:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
9561:                 mPhoneConfigurationManager.getStaticPhoneCapability();
9601:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
9641:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
9648:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
9657:         metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
9673:                         if (SubscriptionManager.isValidPhoneId(portInfo.getLogicalSlotIndex())) {
9797:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
9923:                     ImsPhoneCallTracker imsPhoneCallTracker =
9925:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);
10093:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
10173:         boolean isPhoneAvailable = false;
10178:                 isPhoneAvailable = true;
10184:         return isPhoneAvailable;
10348:                         } else if (isAnyPhoneInEmergencyState()) {
10726:                             if (tracker != null && tracker instanceof ImsPhoneCallTracker) {
10727:                                 ImsPhoneCallTracker imsPhoneCallTracker =
10728:                                         (ImsPhoneCallTracker) tracker;
10729:                                 imsPhoneCallTracker.setDeviceToDeviceForceEnabled(isForceEnabled);
11107:         enforceReadPrivilegedPermission("getPhoneCapability");
11110:             return mPhoneConfigurationManager.getCurrentPhoneCapability();
11143:                 .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
11165:                     .enforceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(
11286:         return mPhoneConfigurationManager.setModemService(serviceName);
11299:                         .enforceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
11302:         result = mPhoneConfigurationManager.getModemService();
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, ]
134: public abstract class Phone extends Handler implements PhoneInternalInterface {
538:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,
555:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,
345:     protected Phone mImsPhone = null;
641:     public void createImsPhone() {
3948:     public Phone getImsPhone() {
3953:     public void setImsPhone(ImsPhone imsPhone) {
4648:     public Phone getDefaultPhone() {
211:     protected static final int EVENT_UPDATE_PHONE_OBJECT            = 42;
311:     protected boolean mIsPhoneInEcmState = false;
342:     protected int mPhoneId;
478:     public String getPhoneName() {
482:     protected void setPhoneName(String name) {
1892:     public void updatePhoneObject(int voiceRadioTech) {
3067:     public abstract int getPhoneType();
4089:     public int getPhoneId() {
124:  * A base implementation for the com.android.internal.telephony.Phone interface.
126:  * Note that implementations of Phone.java are expected to be used
135:     private static final String LOG_TAG = "Phone";
263:      * This method is invoked when the Phone exits Emergency Callback Mode.
309:     // Keep track of whether or not the phone is in Emergency Callback Mode for Phone and
473:      * Returns a string identifier for this phone interface for parties
474:      *  outside the phone app process.
529:      * Constructs a Phone in normal (non-unit test) mode.
540:         this(name, notifier, context, ci, unitTestMode, SubscriptionManager.DEFAULT_PHONE_INDEX,
545:      * Constructs a Phone in normal (non-unit test) mode.
553:      * @param phoneId the phone-id of this phone.
577:         * (i.e. voice) phone calls over the telephony network, and is allowed
611:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_IMS) {
630:         if (getPhoneType() != PhoneConstants.PHONE_TYPE_SIP) {
642:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_SIP) {
646:         synchronized(Phone.lockForRadioTechnologyChange) {
709:         // messages to be handled whether or not the phone is being destroyed
711:         // resources of the phone being destroyed
763:                         // redial happened over that Phone so that it can be replaced with the
878:         Phone imsPhone = mImsPhone;
917:      * Gets the context for the phone, as set at initialization time.
973:      * Subclasses of Phone probably want to replace this with a
999:      * Subclasses of Phone probably want to replace this with a
1023:      * Subclasses of Phone probably want to replace this with a
1035:      * Notify the phone that an SMS has been sent. This will be used determine if the SMS was sent
1049:      * Determine if the Phone has recently sent an emergency SMS and is still in the interval of
1090:     protected void migrateFrom(Phone from) {
1103:         // The emergency state of IMS phone will be cleared in ImsPhone#notifySrvccState after
1166:      *   Connection.getCall() == Phone.getRingingCall()
1186:      * Notifies when phone's video capabilities changes <p>
1191:      *  AsyncResult.result = true if phone supports video calling <p>
1330:      * Example: If Phone.dial is called with "*#31#", then the app will
1653:      * For unit tests; don't send notifications to "Phone"
1670:      * Subclasses of Phone probably want to replace this with a
1775:         // no need for regular phone
1779:      * Subclasses of Phone probably want to replace this with a
1791:      * we send out a final ServiceState update when a phone's subId becomes invalid.
1801:      * If this is a simulated phone interface, returns a SimulatedRadioControl.
1815:      * the thread that originally obtained this Phone instance.
1820:                     "com.android.internal.telephony.Phone must be used from within one thread");
1852:      * If the phone has an active call and call waiting occurs,
1853:      * then the phone state is RINGING not OFFHOOK
1862:      * Retrieves the IccFileHandler of the Phone instance
1881:      * Retrieves the Handler of the Phone instance
1888:      * Update the phone object if the voice radio technology has changed
1896:     * Retrieves the ServiceStateTracker of the phone instance.
1920:                 .contains(Phone.RADIO_POWER_REASON_THERMAL);
1924:      * Retrieves the EmergencyNumberTracker of the phone instance.
1946:      * Retrieves the DeviceStateMonitor of the phone instance.
1953:      * Retrieves the DisplayInfoController of the phone instance.
1960:      * Retrieves the SignalStrengthController of the phone instance.
2009:      * Returns the ICC card interface for this phone, or null
2015:         //throw new Exception("getIccCard Shouldn't be called from Phone");
2202:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2632:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
2633:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
2634:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
2635:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
2646:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
2647:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
2648:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
2649:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
2967:     // This property is used to handle phone process crashes, and is the same for CDMA and IMS
2974:      * @return {@code true} if we are in emergency call back mode. This is a period where the phone
2987:         return getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA && isInEcm()
2999:      * @return true if this Phone is in an emergency call that caused emergency callback mode to be
3007:      * Set whether or not this Phone has an active emergency call that was placed during emergency
3063:      * Return a numerical identifier for the phone radio interface.
3064:      * @return PHONE_TYPE_XXX as defined above.
3077:     /** sets the voice mail count of the phone and notifies listeners. */
3703:         // Populate the iccid, imei and phone number in the provisioning url.
3712:                     phoneNumber /* Phone number */);
3771:      * Subclasses of Phone probably want to replace this with a
3805:      * Notify registrants if phone is video capable.
3909:         Rlog.e(LOG_TAG, "Error! This function should never be executed, inactive Phone.");
3922:      * Gets the Uicc card corresponding to this phone.
3923:      * @return the UiccCard object corresponding to the phone ID.
3931:      * Gets the Uicc port corresponding to this phone.
3932:      * @return the UiccPort object corresponding to the phone ID.
3945:      * Return an instance of a IMS phone
4086:      * Returns the phone id.
4159:         Phone imsPhone = mImsPhone;
4178:         Phone imsPhone = mImsPhone;
4192:         Phone imsPhone = mImsPhone;
4216:         Phone imsPhone = mImsPhone;
4226:      * @return the IMS MmTel Registration technology for this Phone, defined in
4230:         Phone imsPhone = mImsPhone;
4240:      * Get the IMS MmTel Registration technology for this Phone, defined in
4244:         Phone imsPhone = mImsPhone;
4253:      * Asynchronously get the IMS MmTel Registration state for this Phone.
4256:         Phone imsPhone = mImsPhone;
4315:      *  Set phone radio capability
4317:      *  @param rc the phone radio capability defined in
4326:      *  Get phone radio access family
4346:      *  Get phone radio capability
4360:      *  @param rc the phone radio capability currently in effect for this phone.
4375:         // When radio capability switch is done, query IMEI value and update it in Phone objects
4468:      * Registers the handler when phone radio  capability is changed.
4479:      * Unregister for notifications when phone radio type and access technology is changed.
4500:      * Determines if video calling is enabled for the phone.
4506:         Phone imsPhone = mImsPhone;
4603:     public static void checkWfcWifiOnlyModeBeforeDial(Phone imsPhone, int phoneId, Context context)
4643:      * This function returns the parent phone of the current phone. It is applicable
4644:      * only for IMS phone (function is overridden by ImsPhone). For others the phone
4697:      * none of the phone is in service, and one of them has the capability to make the emergency
4704:         for (Phone phone : PhoneFactory.getPhones()) {
4705:             if (phone != null) {
4706:                 ServiceStateTracker sst = phone.getServiceStateTracker();
4759:     /** Returns the {@link VoiceCallSessionStats} for this phone ID. */
4764:     /** Sets the {@link VoiceCallSessionStats} mock for this phone ID during unit testing. */
4770:     /** Returns the {@link SmsStats} for this phone ID. */
4775:     /** Sets the {@link SmsStats} mock for this phone ID during unit testing. */
4854:      * Returns the InboundSmsHandler object for this phone
4896:         pw.println("Phone: subId=" + getSubId());
5082:         pw.println("Phone Local Log: ");
51: import android.telephony.PhoneStateListener;
81: import com.android.internal.telephony.imsphone.ImsPhone;
82: import com.android.internal.telephony.imsphone.ImsPhoneCall;
128:  * originally called PhoneFactory to obtain the interface.
444:      * PhoneNotifier is an abstraction for all system-wide
449:     protected PhoneNotifier mNotifier;
487:      * Retrieves Nai for phones. Returns null if Nai is not set.
556:                     boolean unitTestMode, int phoneId,
558:         mPhoneId = phoneId;
591:          * By default old phones won't have the property set but do generate
638:      * Start setup of ImsPhone, which will start trying to connect to the ImsResolver. Will not be
647:             if (mImsPhone == null) {
648:                 mImsPhone = PhoneFactory.makeImsPhone(mNotifier, this);
649:                 CallManager.getInstance().registerPhone(mImsPhone);
650:                 mImsPhone.registerForSilentRedial(
725:                     PhoneConstants.State state = getState();
727:                             && ((state == PhoneConstants.State.RINGING) ||
728:                                     (state == PhoneConstants.State.IDLE))) {
739:                 if (getState() == PhoneConstants.State.RINGING) {
749:                 // This is an ImsPhone -> GsmCdmaPhone redial
750:                 // See ImsPhone#initiateSilentRedial
761:                         // The ImsPhoneConnection that is owned by the ImsPhone is currently the
766:                         if (mImsPhone != null) {
768:                             mImsPhone.notifyRedialConnectionChanged(cn);
772:                         if (mImsPhone != null) {
773:                             mImsPhone.notifyRedialConnectionChanged(null);
885:                     if (imsPhone != null) {
886:                         conn = imsPhone.getHandoverConnection();
887:                         migrateFrom(imsPhone);
889:                         Rlog.d(LOG_TAG, "HANDOVER_STARTED: mImsPhone null");
894:                     if (imsPhone != null) {
895:                         imsPhone.notifySrvccState(srvccState);
897:                         Rlog.d(LOG_TAG, "HANDOVER_COMPLETED: mImsPhone null");
950:      * {@link PhoneConstants.State} which can be obtained using the {@link PhoneStateListener}
1120:             // Since CallManager has already registered with both CS and IMS phones,
1859:     public abstract PhoneConstants.State getState();
2085:      * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged
2086:      * PhoneStateListener.onCellInfoChanged} will be invoked.
2101:      * available on this interface. Use PhoneStateNotifier or similar instead.
2197:      * available on this interface. Use PhoneStateNotifier or similar instead.
2248:      * interface. Use <code>PhoneStateNotifier</code> or an equivalent.
2884:     public PhoneConstants.DataState getDataConnectionState(String apnType) {
2885:         return PhoneConstants.DataState.DISCONNECTED;
2968:     // phones
2988:                 && (mImsPhone == null || !mImsPhone.isInImsEcm());
3053:         if (mImsPhone != null) {
3054:             isPresent = isVideoCallOrConference(mImsPhone.getForegroundCall()) ||
3055:                     isVideoCallOrConference(mImsPhone.getBackgroundCall()) ||
3056:                     isVideoCallOrConference(mImsPhone.getRingingCall());
3198:      * Retrieves the MIN for CDMA phones.
3214:      *  Retrieves PRL Version for CDMA phones
3705:             String phoneNumber = getLine1Number();
3706:             if (TextUtils.isEmpty(phoneNumber)) {
3707:                 phoneNumber = "0000000000";
3776:                 "notifyNewRingingConnection: phoneId=[%d], connection=[%s], registrants=[%s]",
3881:      * Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to
3882:      * {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns
3883:      * the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones.
3891:      * Retrieves the EF_PNN from the UICC For GSM/UMTS phones.
3908:         // This function should be overridden by class GsmCdmaPhone.
3949:         return mImsPhone;
3954:         mImsPhone = imsPhone;
4030:      * Return if UT capability of ImsPhone is enabled or not
4034:         if (mImsPhone != null) {
4035:             return mImsPhone.isUtEnabled();
4054:         // dialInternal shall be overriden by GsmCdmaPhone
4059:      * This function is for CSFB SS. GsmCdmaPhone overrides this function.
4161:         if (imsPhone != null) {
4162:             isImsRegistered = imsPhone.isImsRegistered();
4180:         if (imsPhone != null) {
4181:             isWifiCallingEnabled = imsPhone.isWifiCallingEnabled();
4194:         if (imsPhone != null) {
4195:             isAvailable = imsPhone.isImsCapabilityAvailable(capability, regTech);
4218:         if (imsPhone != null) {
4219:             isVolteEnabled = imsPhone.isVoiceOverCellularImsEnabled();
4232:         if (imsPhone != null) {
4233:             regTech = imsPhone.getImsRegistrationTech();
4245:         if (imsPhone != null) {
4246:             imsPhone.getImsRegistrationTech(callback);
4257:         if (imsPhone != null) {
4258:             imsPhone.getImsRegistrationState(callback);
4492:         if (mImsPhone == null) {
4496:         return mImsPhone.isImsAvailable();
4507:         if (imsPhone != null) {
4508:             return imsPhone.isVideoEnabled();
4605:         if (imsPhone == null || !imsPhone.isWifiCallingEnabled()) {
4606:             ImsManager imsManager = ImsManager.getInstance(context, phoneId);
4934:         if (mImsPhone != null) {
4936:                 mImsPhone.dump(fd, pw, args);
445:      * state change notification. DefaultPhoneNotifier is
531:      * @param notifier An instance of DefaultPhoneNotifier,
547:      * @param notifier An instance of DefaultPhoneNotifier,
2849:         // This function is added to send the notification to DefaultPhoneNotifier.
2979:         return mIsPhoneInEcmState;
2995:         mIsPhoneInEcmState = isInEcm;
3039:         if (call instanceof ImsPhoneCall) {
3040:             ImsPhoneCall imsPhoneCall = (ImsPhoneCall) call;
3041:             ImsCall imsCall = imsPhoneCall.getImsCall();
3095:                 mPhoneId, UiccController.APP_FAM_3GPP);
3777:                 getPhoneId(), cn, getNewRingingConnectionRegistrantsAsString()));
3857:      * A fucntion of type getPhoneProp(propType) where propType is an
3927:         return mUiccController.getUiccCard(mPhoneId);
3935:         return mUiccController.getUiccPort(mPhoneId);
4073:             return mSubscriptionManagerService.getSubId(mPhoneId);
4082:         return SubscriptionController.getInstance().getSubId(mPhoneId);
4090:         return mPhoneId;
4897:         pw.println(" mPhoneId=" + mPhoneId);
4924:         pw.println(" getPhoneName()=" + getPhoneName());
4925:         pw.println(" getPhoneType()=" + getPhoneType());
5095:         Rlog.d(LOG_TAG, "[" + mPhoneId + "] " + s);
5099:         Rlog.i(LOG_TAG, "[" + mPhoneId + "] " + s);
5103:         Rlog.e(LOG_TAG, "[" + mPhoneId + "] " + s);
android.googlesource.com/platform/external/guice:examples/src/example/xml/Phone.java: [ master, ]
3: public class Phone {
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/incubator-doris:regression-test/data/dynamic_table_p0/dynamic_bigint_contact_phone.json: [ master, ]
1: {"name":"name1", "age": 25, "name2": "xxx","contact": {"phone": 13966668888, "address": "address1"}}
2: {"name":"name2", "age": 30, "contact": {"phone": 13966668886}}
3: {"name":"name3", "age": 25, "name2": "xxx","contact": {"phone": 13966668889, "address": "address3", "fax": 12345}}
4: {"name":"name4", "age": 25, "contact": {"phone": 13966668880, "address": "address4"}}
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3_52.js: [ master, ]
9228: google.maps.TransitAgency.prototype.phone;
13844: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.phoneNumber;
6225:   PLACES_FIND_PLACE_FROM_PHONE_NUMBER: 'PLACES_FIND_PLACE_FROM_PHONE_NUMBER',
14879: google.maps.places.PlaceResult.prototype.formatted_phone_number;
14921: google.maps.places.PlaceResult.prototype.international_phone_number;
13809: google.maps.places.FindPlaceFromPhoneNumberRequest = function() {};
13821: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.fields;
14183: google.maps.places.Place.prototype.internationalPhoneNumber;
14205: google.maps.places.Place.prototype.nationalPhoneNumber;
14369: google.maps.places.Place.findPlaceFromPhoneNumber = function(request) {};
15273: google.maps.places.PlacesService.prototype.findPlaceFromPhoneNumber = function(
9225:  * The transit agency&#39;s phone number.
13840:  * The phone number of the place to look up. Format must be <a
14179:  * The Place’s phone number in international format. International format
14200:  * The Place’s phone number, formatted according to the <a
14363:  * Searches for a place based on the given phone number. Returns an array due to
14364:  * rare cases where multiple places may share a phone number.
14366:  *     request containing the phone number and requested fields.
14873:  * The Place’s phone number, formatted according to the <a
14916:  * The Place’s phone number in international format. International format
15260:  * Retrieves a list of places based on a phone number. In most cases there
14201:  * href="http://en.wikipedia.org/wiki/Local_conventions_for_writing_telephone_numbers">number&#39;s
14874:  * href="http://en.wikipedia.org/wiki/Local_conventions_for_writing_telephone_numbers">
6223:    * Identifies the findPlaceFromPhoneNumber API within the Places API.
13806:  * google.maps.places.PlacesService.findPlaceFromPhoneNumber}.
13830: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.language;
13837: google.maps.places.FindPlaceFromPhoneNumberRequest.prototype.locationBias;
14365:  * @param {!google.maps.places.FindPlaceFromPhoneNumberRequest} request The
15268:  * @param {!google.maps.places.FindPlaceFromPhoneNumberRequest} request
github.com/apache/incubator-shenyu:db/init/pg/create-table.sql: [ master, ]
122:   "phone" varchar(255) COLLATE "pg_catalog"."default",
134: COMMENT ON COLUMN "public"."app_auth"."phone" IS 'phone number when the user applies';
github.com/apache/incubator-shenyu:db/init/oracle/schema.sql: [ master, ]
481:     phone        VARCHAR2(255),
498: comment on column APP_AUTH.phone
499:   is 'phone number when the user applies';
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3_exp.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/google/end-to-end:lib/closure-compiler/contrib/externs/maps/google_maps_api_v3_19.js: [ master, ]
4951: google.maps.TransitAgency.prototype.phone;
6104: google.maps.places.PlaceResult.prototype.formatted_phone_number;
6124: google.maps.places.PlaceResult.prototype.international_phone_number;
github.com/google/earthenterprise:earth_enterprise/src/common/packet.h: [ master, ]
1005:   std::uint32_t phone;
1049:   char * phone;
1062:   char * phone;
1044:   std::uint32_t phone_OFFSET;
1083:     phone_OFFSET = reinterpret_cast<std::uint64_t>(phone);
1100:     num = phone_OFFSET;
1101:     phone = reinterpret_cast<char *>(num);
github.com/apache/netbeans:ide/html.parser/src/org/netbeans/modules/html/parser/model/NamedCharacterReference.java: [ master, ]
1559:     phone("phone", 0x0260E),
github.com/googlearchive/caja:src/com/google/caja/apitaming/google.maps.policyFactory.js: [ master, ]
4271: google.maps.TransitAgency.prototype.phone = 1;
5201: google.maps.places.PlaceResult.prototype.formatted_phone_number = 1;
5226: google.maps.places.PlaceResult.prototype.international_phone_number = 1;
github.com/googleapis/google-api-ruby-client:google-api-client/generated/google/apis/dfareporting_v3_4/classes.rb: [ master, ]
11544:         attr_accessor :phone
11541:         # Primary phone number of this site contact.
11542:         # Corresponds to the JSON property `phone`
11563:           @phone = args[:phone] if args.key?(:phone)
github.com/google/gopacket:layers/lldp.go: [ master, ]
167: 	Phone       bool
152: 	LLDPCapsPhone       uint16 = 1 << 5
573: 	LLDPappTypeSoftphoneVoice      LLDPApplicationType = 5
1224: 	c.Phone = (v&LLDPCapsPhone > 0)
1510: 		s = "Softphone Voice"
1509: 	case LLDPappTypeSoftphoneVoice:
github.com/PolymerElements/app-layout:demo/contacts.json: [ master, ]
21:     "phone": "(817) 426-2901",
43:     "phone": "(901) 441-2582",
65:     "phone": "(956) 428-2996",
87:     "phone": "(823) 415-2224",
109:     "phone": "(814) 488-2063",
131:     "phone": "(887) 497-3612",
153:     "phone": "(957) 412-3261",
175:     "phone": "(946) 404-2511",
197:     "phone": "(910) 533-3832",
219:     "phone": "(876) 584-3746",
241:     "phone": "(842) 503-2389",
263:     "phone": "(914) 461-3510",
285:     "phone": "(800) 559-2165",
307:     "phone": "(988) 478-3842",
329:     "phone": "(882) 531-2818",
351:     "phone": "(996) 557-3624",
373:     "phone": "(923) 461-2312",
395:     "phone": "(964) 543-3486",
417:     "phone": "(946) 414-3492",
439:     "phone": "(802) 539-3360",
461:     "phone": "(818) 424-2348",
483:     "phone": "(810) 406-3416",
505:     "phone": "(975) 451-3272",
527:     "phone": "(961) 443-3343",
549:     "phone": "(839) 591-3993",
571:     "phone": "(852) 538-3232",
593:     "phone": "(967) 410-2522",
615:     "phone": "(812) 540-2032",
637:     "phone": "(902) 544-3976",
659:     "phone": "(812) 545-2648",
681:     "phone": "(937) 481-3812",
703:     "phone": "(807) 556-3727",
725:     "phone": "(968) 546-3854",
747:     "phone": "(816) 465-3014",
769:     "phone": "(810) 510-3744",
791:     "phone": "(982) 438-3850",
813:     "phone": "(887) 500-3974",
835:     "phone": "(897) 481-2359",
857:     "phone": "(867) 520-2422",
879:     "phone": "(968) 541-2220",
901:     "phone": "(822) 493-3031",
923:     "phone": "(821) 517-2066",
945:     "phone": "(875) 561-3839",
967:     "phone": "(980) 527-2867",
989:     "phone": "(893) 423-2241",
1011:     "phone": "(916) 568-2718",
1033:     "phone": "(865) 596-2021",
1055:     "phone": "(829) 562-3502",
1077:     "phone": "(852) 558-3074",
1099:     "phone": "(891) 598-2904",
1121:     "phone": "(908) 488-3939",
1143:     "phone": "(828) 500-2593",
1165:     "phone": "(869) 544-3589",
1187:     "phone": "(808) 507-2955",
1209:     "phone": "(896) 543-3314",
1231:     "phone": "(852) 477-2611",
1253:     "phone": "(812) 415-2585",
1275:     "phone": "(890) 442-3503",
1297:     "phone": "(895) 528-2574",
1319:     "phone": "(944) 564-2803",
1341:     "phone": "(963) 428-3124",
1363:     "phone": "(947) 456-2663",
1385:     "phone": "(811) 480-2342",
1407:     "phone": "(838) 400-3578",
1429:     "phone": "(895) 420-2620",
1451:     "phone": "(857) 415-3707",
1473:     "phone": "(935) 548-2580",
1495:     "phone": "(905) 466-2231",
1517:     "phone": "(898) 517-3041",
1539:     "phone": "(867) 474-2146",
1561:     "phone": "(851) 582-2204",
1583:     "phone": "(819) 482-2099",
1605:     "phone": "(930) 570-3544",
1627:     "phone": "(959) 575-3680",
1649:     "phone": "(816) 520-2774",
1671:     "phone": "(995) 590-2366",
1693:     "phone": "(992) 548-3878",
1715:     "phone": "(861) 535-2683",
1737:     "phone": "(880) 590-3786",
1759:     "phone": "(868) 586-2207",
1781:     "phone": "(886) 401-2897",
1803:     "phone": "(814) 551-2487",
1825:     "phone": "(865) 413-3195",
1847:     "phone": "(823) 570-2457",
1869:     "phone": "(836) 524-2616",
1891:     "phone": "(974) 511-2460",
1913:     "phone": "(989) 558-3766",
1935:     "phone": "(974) 558-2625",
1957:     "phone": "(929) 559-3077",
1979:     "phone": "(967) 595-3876",
2001:     "phone": "(917) 515-3962",
2023:     "phone": "(902) 528-2051",
2045:     "phone": "(928) 557-3052",
2067:     "phone": "(942) 474-3822",
2089:     "phone": "(986) 580-3064",
2111:     "phone": "(955) 561-2349",
2133:     "phone": "(952) 423-2212",
2155:     "phone": "(997) 529-2688",
2177:     "phone": "(802) 512-3640",
2199:     "phone": "(901) 504-3233",
2221:     "phone": "(867) 576-3002",