377:         public Phone phone;

17: package com.android.phone;

198: public class PhoneInterfaceManager extends ITelephony.Stub {

1639:     private PhoneInterfaceManager(PhoneGlobals app) {

1655:     private Phone getDefaultPhone() {

1686:     private Phone getPhone(int subId) {

2288:     public String getNetworkCountryIsoForPhone(int phoneId) {

5809:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

307:     private PhoneConfigurationManager mPhoneConfigurationManager;

1666:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1674:     private Phone getPhoneFromSubId(int subId) {

2067:     private void shutdownRadioUsingPhoneId(int phoneId) {

2742:     public int getActivePhoneType() {

2747:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4424:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5876:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6416:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6426:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

387:             if (phone != null) {

388:                 this.phone = phone;

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

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

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

435:             final Phone defaultPhone = getDefaultPhone();

440:                     final Phone phone = getPhoneFromRequest(request);

459:                         request.result = phone != null

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

471:                     final Phone phone = getPhoneFromRequest(request);

472:                     request.result = phone != null ?

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

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

1299:                     Phone phone = getPhoneFromRequest(request);

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

1308:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1663:         ServiceManager.addService("phone", this);

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

1668:             return request.phone;

1680:         Phone phone = getPhoneFromRequest(request);

1681:         return phone == null ? null :

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

1685:     // returns phone associated with the subId.

1690:     private void sendEraseModemConfig(Phone phone) {

1691:         if (phone != null) {

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

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

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

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

1936:             final Phone phone = getPhone(subId);

1937:             if (phone != null) {

1938:                 phone.updateServiceLocation();

1982:             final Phone phone = getPhone(subId);

1983:             if (phone != null) {

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

2002:             final Phone phone = getPhone(subId);

2003:             if (phone != null) {

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

2020:             final Phone phone = getPhone(subId);

2021:             if (phone == null) {

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

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

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

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

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

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

2070:             phone.shutdownRadio();

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

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

2097:             final Phone phone = getPhone(subId);

2098:             if (phone != null) {

2099:                 phone.setRadioPower(turnOn);

2117:             final Phone phone = getPhone(subId);

2118:             if (phone != null) {

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

2137:             final Phone phone = getPhone(subId);

2138:             if (phone != null) {

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

2153:             final Phone phone = getPhone(subId);

2154:             if (phone != null) {

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

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

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

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

2221:             final Phone phone = getPhone(subId);

2222:             if (phone != null) {

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

2242:             final Phone phone = getPhone(subId);

2243:             if (phone != null) {

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

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

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

2294:                 // Get default phone in this case.

2295:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

2306:             if (phone != null) {

2307:                 ServiceStateTracker sst = phone.getServiceStateTracker();

2308:                 EmergencyNumberTracker emergencyNumberTracker = phone.getEmergencyNumberTracker();

2338:             final Phone phone = getPhone(subId);

2339:             if (phone != null) {

2340:                 phone.enableLocationUpdates();

2359:             final Phone phone = getPhone(subId);

2360:             if (phone != null) {

2361:                 phone.disableLocationUpdates();

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

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

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

2462:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2513:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2535:         if (phone == null) {

2538:         int subId = phone.getSubId();

2546:             return phone.getImei();

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

2556:         if (phone != null) {

2557:             String imei = phone.getImei();

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

2566:         if (phone == null) {

2570:         int subId = phone.getSubId();

2578:             return phone.getMeid();

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

2588:         if (phone != null) {

2589:             String meid = phone.getMeid();

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

2599:         if (phone == null) {

2602:         int subId = phone.getSubId();

2611:             return phone.getDeviceSvn();

2621:             final Phone phone = getPhone(subId);

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

2632:             final Phone phone = getPhone(subId);

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

2643:             final Phone phone = getPhone(subId);

2644:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2645:                     : phone.getSpecificCarrierId();

2655:             final Phone phone = getPhone(subId);

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

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

2668:         if (phone == null) {

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

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

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

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

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

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

2751:             if (phone == null) {

2752:                 return PhoneConstants.PHONE_TYPE_NONE;

2754:                 return phone.getPhoneType();

2781:             final Phone phone = getPhone(subId);

2782:             if (phone != null) {

2783:                 return phone.getCdmaEriIconIndex();

2814:             final Phone phone = getPhone(subId);

2815:             if (phone != null) {

2816:                 return phone.getCdmaEriIconMode();

2845:             final Phone phone = getPhone(subId);

2846:             if (phone != null) {

2847:                 return phone.getCdmaEriText();

2866:             final Phone phone = getPhone(subId);

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

2868:                 return phone.getLine1Number();

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

2888:             final Phone phone = getPhone(subId);

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

2890:                 return phone.getCdmaMin();

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

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

3068:             final Phone phone = getPhone(subId);

3069:             if (phone != null) {

3070:                 phone.setVoiceActivationState(activationState);

3089:             final Phone phone = getPhone(subId);

3090:             if (phone != null) {

3091:                 phone.setDataActivationState(activationState);

3107:         final Phone phone = getPhone(subId);

3110:             if (phone != null) {

3111:                 return phone.getVoiceActivationState();

3127:         final Phone phone = getPhone(subId);

3130:             if (phone != null) {

3131:                 return phone.getDataActivationState();

3153:             final Phone phone = getPhone(subId);

3154:             if (phone != null) {

3155:                 return phone.getVoiceMessageCount();

3172:             final Phone phone = getPhone(subId);

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

3186:         final Phone defaultPhone = getDefaultPhone();

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

3225:                 if (phone.isInEmergencySmsMode()) {

3236:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3263:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3301:             Phone phone = getPhone(subId);

3302:             if (phone == null) {

3307:             phone.getImsRegistrationState(regState -> {

3334:             Phone phone = getPhone(subId);

3335:             if (phone == null) {

3340:             phone.getImsRegistrationTech(regTech -> {

3359:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3385:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3436:             Phone phone = getPhone(subId);

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

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

3486:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3523:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3557:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3592:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3644:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3726:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3793:         Phone phone = getPhone(subId);

3794:         if (phone == null) {

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

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

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

4237:             final Phone phone = getPhone(subId);

4238:             if (phone != null) {

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

4271:             final Phone phone = getPhone(subId);

4272:             if (phone != null) {

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

4296:             final Phone phone = getPhone(subId);

4297:             if (phone != null) {

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

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

4324:             if (phone != null) {

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

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

4341:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4360:             final Phone phone = getPhone(subId);

4361:             if (phone == null) {

4364:                 return phone.getLteOnCdmaMode();

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

4459:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4853:         if (phone != null) {

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

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

4879:         if (phone != null) {

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

4897:         final Phone defaultPhone = getDefaultPhone();

5422:         final Phone defaultPhone = getDefaultPhone();

5560:         final Phone phone = getPhone(subId);

5562:             if (phone != null) {

5563:                 return phone.hasMatchedTetherApnSetting();

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

5588:             if (phone != null) {

5590:                 phone.getDataEnabledSettings().setUserDataEnabled(enable);

5592:                 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);

5610:         final Phone phone = getPhone(subId);

5612:             if (phone != null) {

5617:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

5667:             if (phone != null) {

5668:                 boolean retVal = phone.isUserDataEnabled();

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

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

5696:             if (phone != null) {

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

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

5710:             Phone phone) {

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

5721:             SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());

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

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

5744:             SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());

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

5756:         final Phone phone = getPhone(subId);

5757:         if (phone == null) {

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

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

5775:         final Phone phone = getPhone(subId);

5776:         if (phone == null) {

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

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

5893:         final Phone phone = getPhone(subId);

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

5916:             final Phone phone = getPhone(subId);

5917:             if (phone == null) {

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

6143:             final Phone phone = getPhone(subId);

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

6159:             final Phone phone = getPhone(subId);

6160:             if (phone == null) {

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

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

6216:         if (phone == null) {

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

6233:         final Phone defaultPhone = getDefaultPhone();

6247:         final Phone defaultPhone = getDefaultPhone();

6301:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6332:         final Phone phone = getPhone(subscriptionId);

6333:         if (phone == null) {

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

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

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

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

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

6383:         if (phone == null) {

6386:         int subId = phone.getSubId();

6394:             return phone.getDeviceId();

6407:         Phone phone = getPhone(subId);

6408:         if (phone != null) {

6409:             return phone.isImsRegistered();

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

6444:             Phone phone = getPhone(subscriptionId);

6445:             if (phone == null) {

6448:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6460:             Phone phone = getPhone(subId);

6461:             if (phone != null) {

6462:                 return phone.isWifiCallingEnabled();

6477:             Phone phone = getPhone(subId);

6478:             if (phone != null) {

6479:                 return phone.isVideoEnabled();

6495:             Phone phone = getPhone(subId);

6496:             if (phone != null) {

6497:                 return phone.getImsRegistrationTech();

6555:         final Phone phone = getPhone(subId);

6556:         if (phone == null) {

6563:                     phone.getContext().getOpPackageName(), null);

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

6700:             final Phone phone = getPhone(subId);

6701:             if (phone == null) {

6705:             ServiceState ss = phone.getServiceState();

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

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

6730:             if (phone == null) {

6731:                 phone = getDefaultPhone();

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

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

6754:         final Phone defaultPhone = getDefaultPhone();

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

6766:             if (phone == null) {

6767:                 phone = defaultPhone;

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

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

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

6787:             if (phone == null) {

6788:                 phone = getDefaultPhone();

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

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

6811:         final Phone defaultPhone = getDefaultPhone();

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

6823:             if (phone == null) {

6824:                 phone = defaultPhone;

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

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

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

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

6886:         Phone phone = getPhone(subId);

6890:             if (phone == null) {

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

6915:         Phone phone = getPhone(subId);

6919:             if (phone == null) {

6924:                 esn = phone.getEsn();

6943:         Phone phone = getPhone(subId);

6947:             if (phone == null) {

6952:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7046:         final Phone phone = getPhone(subId);

7049:         if (phone == null) {

7054:             phone.carrierActionSetMeteredApnsEnabled(enabled);

7071:         final Phone phone = getPhone(subId);

7074:         if (phone == null) {

7079:             phone.carrierActionSetRadioEnabled(enabled);

7099:         final Phone phone = getPhone(subId);

7102:         if (phone == null) {

7107:             phone.carrierActionReportDefaultNetworkStatus(report);

7123:         final Phone phone = getPhone(subId);

7124:         if (phone == null) {

7129:             phone.carrierActionResetAll();

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

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

7173:             Phone phone = getPhone(subId);

7174:             if (phone != null) {

7175:                 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);

7194:         Phone phone = getPhone(subId);

7198:             if (phone != null) {

7199:                 return phone.getClientRequestStats();

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

7232:             if (phone != null) {

7233:                 phone.setSimPowerState(state, workSource);

7255:      * Check if phone is in emergency callback mode

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

7262:         final Phone phone = getPhone(subId);

7266:             if (phone != null) {

7267:                 return phone.isInEcm();

7287:             Phone p = getPhone(subId);

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

7308:         if (phone != null) {

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

7316:                 return phone.getRadioPowerState();

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

7344:             Phone phone = getPhone(subId);

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

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

7373:             Phone phone = getPhone(subId);

7374:             if (phone != null) {

7375:                 phone.setDataRoamingEnabled(isEnabled);

7391:             Phone phone = getPhone(subId);

7392:             if (phone != null) {

7393:                 isAllowed = phone.isCspPlmnEnabled();

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

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

7554:             Phone phone = getPhone(subId);

7555:             if (phone == null) {

7558:             UiccCard uiccCard = phone.getUiccCard();

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

7603:         return Phone.PREFERRED_NT_MODE;

7613:             final Phone phone = getPhone(subId);

7614:             if (phone == null) {

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

7631:             final Phone phone = getPhone(subId);

7632:             if (phone == null) {

7636:             return phone.getCarrierIdListVersion();

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

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

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

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

7714:                             phone.getSubId(),

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

7726:         final Phone defaultPhone = getDefaultPhone();

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

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

7736:                         && phone.getEmergencyNumberTracker() != null) {

7737:                     if (phone.getEmergencyNumberTracker().isEmergencyNumber(

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

7760:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7782:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7801:             final Phone phone = getPhone(subId);

7802:             if (phone == null) {

7806:             return phone.getEmergencyNumberDbVersion();

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

7819:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7836:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7853:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7866:         Phone phone = getPhone(subId);

7867:         if (phone == null) {

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

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

7893:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8021:         Phone phone = getPhone(subId);

8022:         if (phone == null) {

8027:             UiccCard uiccCard = phone.getUiccCard();

8097:         Phone phone = getDefaultPhone();

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

8099:         HalVersion hv = phone.getHalVersion();

8129:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8135:             Phone phone = getPhone(subId);

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

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

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

8152:             Phone phone = getPhone(subId);

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

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

8167:             Phone phone = getPhone(subscriptionId);

8168:             if (phone == null) {

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

8258:             Phone phone = getPhone(subId);

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

8261:             return phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(allow);

8274:             Phone phone = getPhone(subId);

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

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

8290:             Phone phone = getPhone(subId);

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

8293:             return phone.getDataEnabledSettings().setAlwaysAllowMmsData(alwaysAllow);

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

8312:                 Phone defaultPhone = phone.getImsPhone();

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

8358:             Phone phone = getPhone(subId);

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

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

8380:         Phone phone = getPhone(subId);

8381:         if (phone == null) {

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

8410:         Phone phone = getPhone(subId);

8411:         if (phone == null) {

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

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

65: import android.telecom.PhoneAccount;

66: import android.telecom.PhoneAccountHandle;

85: import android.telephony.PhoneCapability;

86: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

297:     private static PhoneInterfaceManager sInstance;

299:     private PhoneGlobals mApp;

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

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

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

738:                     defaultPhone.resetModemConfig(onCompleted);

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

1022:                     if (defaultPhone != null) {

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

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

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

1320:                     defaultPhone.rebootModem(onCompleted);

1330:                     PhoneConfigurationManager.getInstance()

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

1351:                     PhoneConfigurationManager.getInstance()

1439:                     defaultPhone.eraseModemConfig(onCompleted);

1624:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1628:         synchronized (PhoneInterfaceManager.class) {

1630:                 sInstance = new PhoneInterfaceManager(app);

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

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

1650:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

1835:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1865:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

1867:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1870:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2080:             if (defaultPhone != null) {

2081:                 defaultPhone.setRadioPower(turnOn);

2225:                 return PhoneConstantConversions.convertDataState(

2226:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

2929:             return getDefaultPhone().needsOtaServiceProvisioning();

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

2965:             if (phoneAccountHandle == null) {

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

3053:         SmsController smsController = PhoneFactory.getSmsController();

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

3197:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4355:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4362:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

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

4426:         if (phoneId == -1) {

4430:         return PhoneFactory.getPhone(phoneId);

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

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

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

4905:             return defaultPhone.getPcscfAddress(apnType);

5156:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

5586:             if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);

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

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

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

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

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

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

5805:             getPhone(phoneId), pkgName);

5822:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6419:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6434:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6539:               sendEraseModemConfig(getDefaultPhone());

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

6723:      * PhoneAccount.

6726:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6749:      * PhoneAccount.

6753:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

6759:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

6783:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

6806:      * specific PhoneAccount.

6810:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

6816:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

7157:         (new TelephonyShellCommand(this, getDefaultPhone().getContext()))

7410:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

7601:             return list.get(phoneId);

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

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

7971:         PhoneCapability staticCapability =

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

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

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

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

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

8314:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8316:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8319:                             + imsPhone.getMsisdn());

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

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

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

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

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

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

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

827:                     getPhoneFromRequest(request).getCallForwardingOption(

884:                     getPhoneFromRequest(request).setCallForwardingOption(

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

950:                     getPhoneFromRequest(request).setCallWaiting(isEnable, onCompleted);

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

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

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

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

1246:                     getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);

1361:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1670:             return getPhoneFromSubId(request.subId);

1966:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2060:                 shutdownRadioUsingPhoneId(i);

2603:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2743:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2773:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2806:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2837:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2978:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3146:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3206:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3243:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3269:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3326:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3366:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3391:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3491:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3528:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3562:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3597:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3649:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3731:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3813:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3877:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4229:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4263:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4288:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4455:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4497:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4680:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5099:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5446:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5492:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5877:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

5963:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

5990:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6013:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6222:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6272:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6291:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6664:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7190:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7347:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7385:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7509:                         slot.getPhoneId(),

7645:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7653:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7662:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7702:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7729:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7912:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7947:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

7972:                 mPhoneConfigurationManager.getStaticPhoneCapability();

8012:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8052:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8059:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8315:                     ImsPhoneCallTracker imsPhoneCallTracker =

8317:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

116: public abstract class Phone extends Handler implements PhoneInternalInterface {

490:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,

507:     protected Phone(String name, PhoneNotifier notifier, Context context, CommandsInterface ci,

326:     protected Phone mImsPhone = null;

584:     public void createImsPhone() {

3476:     public Phone getImsPhone() {

4131:     public Phone getDefaultPhone() {

193:     protected static final int EVENT_UPDATE_PHONE_OBJECT            = 42;

293:     protected boolean mIsPhoneInEcmState = false;

323:     protected int mPhoneId;

430:     public String getPhoneName() {

434:     protected void setPhoneName(String name) {

1766:     public void updatePhoneObject(int voiceRadioTech) {

2587:     public abstract int getPhoneType();

3596:     public int getPhoneId() {

3604:     public int getVoicePhoneServiceState() {

106:  * A base implementation for the com.android.internal.telephony.Phone interface.

108:  * Note that implementations of Phone.java are expected to be used

117:     private static final String LOG_TAG = "Phone";

241:      * This method is invoked when the Phone exits Emergency Callback Mode.

291:     // Keep track of whether or not the phone is in Emergency Callback Mode for Phone and

425:      * Returns a string identifier for this phone interface for parties

426:      *  outside the phone app process.

481:      * Constructs a Phone in normal (non-unit test) mode.

492:         this(name, notifier, context, ci, unitTestMode, SubscriptionManager.DEFAULT_PHONE_INDEX,

497:      * Constructs a Phone in normal (non-unit test) mode.

505:      * @param phoneId the phone-id of this phone.

533:         * (i.e. voice) phone calls over the telephony network, and is allowed

558:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_IMS) {

573:         if (getPhoneType() != PhoneConstants.PHONE_TYPE_SIP) {

585:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_SIP) {

589:         synchronized(Phone.lockForRadioTechnologyChange) {

652:         // messages to be handled whether or not the phone is being destroyed

654:         // resources of the phone being destroyed

774:         Phone imsPhone = mImsPhone;

813:      * Gets the context for the phone, as set at initialization time.

869:      * Subclasses of Phone probably want to replace this with a

895:      * Subclasses of Phone probably want to replace this with a

919:      * Subclasses of Phone probably want to replace this with a

931:      * Notify the phone that an SMS has been sent. This will be used determine if the SMS was sent

945:      * Determine if the Phone has recently sent an emergency SMS and is still in the interval of

986:     protected void migrateFrom(Phone from) {

999:         // The emergency state of IMS phone will be cleared in ImsPhone#notifySrvccState after

1062:      *   Connection.getCall() == Phone.getRingingCall()

1082:      * Notifies when phone's video capabilities changes <p>

1087:      *  AsyncResult.result = true if phone supports video calling <p>

1226:      * Example: If Phone.dial is called with "*#31#", then the app will

1538:      * For unit tests; don't send notifications to "Phone"

1555:      * Subclasses of Phone probably want to replace this with a

1660:         // no need for regular phone

1664:      * Subclasses of Phone probably want to replace this with a

1675:      * If this is a simulated phone interface, returns a SimulatedRadioControl.

1689:      * the thread that originally obtained this Phone instance.

1694:                     "com.android.internal.telephony.Phone must be used from within one thread");

1726:      * If the phone has an active call and call waiting occurs,

1727:      * then the phone state is RINGING not OFFHOOK

1736:      * Retrieves the IccFileHandler of the Phone instance

1755:      * Retrieves the Handler of the Phone instance

1762:      * Update the phone object if the voice radio technology has changed

1770:     * Retrieves the ServiceStateTracker of the phone instance.

1778:      * Retrieves the EmergencyNumberTracker of the phone instance.

1841:      * Returns the ICC card interface for this phone, or null

1847:         //throw new Exception("getIccCard Shouldn't be called from Phone");

2026:         if (getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {

2178:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}

2179:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}

2180:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}

2181:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}

2192:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}

2193:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}

2194:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}

2195:      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}

2492:     // This property is used to handle phone process crashes, and is the same for CDMA and IMS

2499:      * @return {@code true} if we are in emergency call back mode. This is a period where the phone

2519:      * @return true if this Phone is in an emergency call that caused emergency callback mode to be

2527:      * Set whether or not this Phone has an active emergency call that was placed during emergency

2583:      * Return a numerical identifier for the phone radio interface.

2584:      * @return PHONE_TYPE_XXX as defined above.

2597:     /** sets the voice mail count of the phone and notifies listeners. */

3279:      * Subclasses of Phone probably want to replace this with a

3297:      * Notify registrants if phone is video capable.

3429:         Rlog.e(LOG_TAG, "Error! This function should never be executed, inactive Phone.");

3442:      * Gets the Uicc card corresponding to this phone.

3443:      * @return the UiccCard object corresponding to the phone ID.

3473:      * Return an instance of a IMS phone

3593:      * Returns the phone id.

3605:         Phone imsPhone = mImsPhone;

3679:         Phone imsPhone = mImsPhone;

3698:         Phone imsPhone = mImsPhone;

3712:         Phone imsPhone = mImsPhone;

3726:         Phone imsPhone = mImsPhone;

3736:      * @return the IMS MmTel Registration technology for this Phone, defined in

3740:         Phone imsPhone = mImsPhone;

3750:      * Get the IMS MmTel Registration technology for this Phone, defined in

3754:         Phone imsPhone = mImsPhone;

3763:      * Asynchronously get the IMS MmTel Registration state for this Phone.

3766:         Phone imsPhone = mImsPhone;

3824:      *  Set phone radio capability

3826:      *  @param rc the phone radio capability defined in

3835:      *  Get phone radio access family

3855:      *  Get phone radio capability

3869:      *  @param rc the phone radio capability currently in effect for this phone.

3902:      * Registers the handler when phone radio  capability is changed.

3913:      * Unregister for notifications when phone radio type and access technology is changed.

3948:      * Determines if video calling is enabled for the phone.

3954:         Phone imsPhone = mImsPhone;

4086:     public static void checkWfcWifiOnlyModeBeforeDial(Phone imsPhone, int phoneId, Context context)

4126:      * This function returns the parent phone of the current phone. It is applicable

4127:      * only for IMS phone (function is overridden by ImsPhone). For others the phone

4165:      * none of the phone is in service, and one of them has the capability to make the emergency

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

4173:             if (phone != null) {

4174:                 ServiceState ss = phone.getServiceStateTracker().getServiceState();

4175:                 // One of the phone is in service, hence the device is not emergency call only.

4228:         pw.println("Phone: subId=" + getSubId());

4386:         pw.println("Phone Local Log: ");

52: import android.telephony.PhoneStateListener;

80: import com.android.internal.telephony.imsphone.ImsPhoneCall;

110:  * originally called PhoneFactory to obtain the interface.

409:      * PhoneNotifier is an abstraction for all system-wide

414:     protected PhoneNotifier mNotifier;

439:      * Retrieves Nai for phones. Returns null if Nai is not set.

508:                     boolean unitTestMode, int phoneId,

510:         mPhoneId = phoneId;

547:          * By default old phones won't have the property set but do generate

581:      * Start setup of ImsPhone, which will start trying to connect to the ImsResolver. Will not be

590:             if (mImsPhone == null) {

591:                 mImsPhone = PhoneFactory.makeImsPhone(mNotifier, this);

592:                 CallManager.getInstance().registerPhone(mImsPhone);

593:                 mImsPhone.registerForSilentRedial(

668:                     PhoneConstants.State state = getState();

670:                             && ((state == PhoneConstants.State.RINGING) ||

671:                                     (state == PhoneConstants.State.IDLE))) {

682:                 if (getState() == PhoneConstants.State.RINGING) {

700:                         if (mImsPhone != null) {

702:                             mImsPhone.notifyRedialConnectionChanged(cn);

706:                         if (mImsPhone != null) {

707:                             mImsPhone.notifyRedialConnectionChanged(null);

781:                     if (imsPhone != null) {

782:                         conn = imsPhone.getHandoverConnection();

783:                         migrateFrom(imsPhone);

785:                         Rlog.d(LOG_TAG, "HANDOVER_STARTED: mImsPhone null");

790:                     if (imsPhone != null) {

791:                         imsPhone.notifySrvccState(srvccState);

793:                         Rlog.d(LOG_TAG, "HANDOVER_COMPLETED: mImsPhone null");

846:      * {@link PhoneConstants.State} which can be obtained using the {@link PhoneStateListener}

1016:             // Since CallManager has already registered with both CS and IMS phones,

1733:     public abstract PhoneConstants.State getState();

1917:      * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged

1918:      * PhoneStateListener.onCellInfoChanged} will be invoked.

1933:      * available on this interface. Use PhoneStateNotifier or similar instead.

2021:      * available on this interface. Use PhoneStateNotifier or similar instead.

2063:      * interface. Use <code>PhoneStateNotifier</code> or an equivalent.

2417:     public PhoneConstants.DataState getDataConnectionState(String apnType) {

2418:         return PhoneConstants.DataState.DISCONNECTED;

2493:     // phones

2573:         if (mImsPhone != null) {

2574:             isPresent = isVideoCallOrConference(mImsPhone.getForegroundCall()) ||

2575:                     isVideoCallOrConference(mImsPhone.getBackgroundCall()) ||

2576:                     isVideoCallOrConference(mImsPhone.getRingingCall());

2718:      * Retrieves the MIN for CDMA phones.

2734:      *  Retrieves PRL Version for CDMA phones

3373:      * Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to

3374:      * {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns

3375:      * the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones.

3383:      * Retrieves the EF_PNN from the UICC For GSM/UMTS phones.

3392:      * {@link android.telephony.PhoneStateListener} instead.

3395:     public PhoneConstants.DataState getDataConnectionState() {

3396:         return getDataConnectionState(PhoneConstants.APN_TYPE_DEFAULT);

3413:      * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE}

3414:      * or {@link PhoneConstants#LTE_ON_CDMA_TRUE}

3428:         // This function should be overridden by class GsmCdmaPhone.

3477:         return mImsPhone;

3543:      * Return if UT capability of ImsPhone is enabled or not

3547:         if (mImsPhone != null) {

3548:             return mImsPhone.isUtEnabled();

3567:         // dialInternal shall be overriden by GsmCdmaPhone

3572:      * This function is for CSFB SS. GsmCdmaPhone overrides this function.

3601:      * Return the service state of mImsPhone if it is STATE_IN_SERVICE

3606:         if (imsPhone != null

3607:                 && imsPhone.getServiceState().getState() == ServiceState.STATE_IN_SERVICE) {

3681:         if (imsPhone != null) {

3682:             isImsRegistered = imsPhone.isImsRegistered();

3700:         if (imsPhone != null) {

3701:             isWifiCallingEnabled = imsPhone.isWifiCallingEnabled();

3714:         if (imsPhone != null) {

3715:             isAvailable = imsPhone.isImsCapabilityAvailable(capability, regTech);

3728:         if (imsPhone != null) {

3729:             isVolteEnabled = imsPhone.isVolteEnabled();

3742:         if (imsPhone != null) {

3743:             regTech = imsPhone.getImsRegistrationTech();

3755:         if (imsPhone != null) {

3756:             imsPhone.getImsRegistrationTech(callback);

3767:         if (imsPhone != null) {

3768:             imsPhone.getImsRegistrationState(callback);

3885:         int type = PhoneFactory.calculatePreferredNetworkType(mContext, getSubId());

3896:             int type = PhoneFactory.calculatePreferredNetworkType(mContext, getSubId());

3940:         if (mImsPhone == null) {

3944:         return mImsPhone.isImsAvailable();

3955:         if (imsPhone != null) {

3956:             return imsPhone.isVideoEnabled();

4088:         if (imsPhone == null || !imsPhone.isWifiCallingEnabled()) {

4089:             ImsManager imsManager = ImsManager.getInstance(context, phoneId);

4267:         if (mImsPhone != null) {

4269:                 mImsPhone.dump(fd, pw, args);

410:      * state change notification. DefaultPhoneNotifier is

483:      * @param notifier An instance of DefaultPhoneNotifier,

499:      * @param notifier An instance of DefaultPhoneNotifier,

2374:         // This function is added to send the notification to DefaultPhoneNotifier.

2504:         return mIsPhoneInEcmState;

2515:         mIsPhoneInEcmState = isInEcm;

2559:         if (call instanceof ImsPhoneCall) {

2560:             ImsPhoneCall imsPhoneCall = (ImsPhoneCall) call;

2561:             ImsCall imsCall = imsPhoneCall.getImsCall();

2615:                 mPhoneId, UiccController.APP_FAM_3GPP);

3349:      * A fucntion of type getPhoneProp(propType) where propType is an

3447:         return mUiccController.getUiccCard(mPhoneId);

3589:         return SubscriptionController.getInstance().getSubIdUsingPhoneId(mPhoneId);

3597:         return mPhoneId;

3927:         ImsManager imsManager = ImsManager.getInstance(mContext, mPhoneId);

4229:         pw.println(" mPhoneId=" + mPhoneId);

4256:         pw.println(" getPhoneName()=" + getPhoneName());

4257:         pw.println(" getPhoneType()=" + getPhoneType());

3: public class Phone {

5591:         PHONE = 9;

2535:         HARDWARE_FAILED_MICROPHONE = 1;

2705: message PhoneSignalStrengthChanged {

2717: message PhoneServiceStateChanged {

2729: message PhoneStateChanged {

116:         PhoneSignalStrengthChanged phone_signal_strength_changed = 40;

171:         PhoneServiceStateChanged phone_service_state_changed = 94;

172:         PhoneStateChanged phone_state_changed = 95;

1290:  *   frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java

1295:         // The keyguard is hidden when the phone is unlocked.

1297:         // The keyguard is shown when the phone is locked (screen turns off).

1311:  *   frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java

2700:  * Logs phone signal strength changes.

2712:  * Logs when the phone state, sim state or signal strength changes

2724:  * Logs when the phone becomes on or off.

3261:  *      frameworks/base/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java

1458:     // For multi-sim phones, this distinguishes between the sim cards.

1480:     // For multi-sim phones, this distinguishes between the sim cards.

5386:  * time_in_state files not being present on some phones, have not been addressed. These should be

6599:  * Track how we arbitrate between microphone/input requests.

6614:  * Track how we arbitrate between microphone requests.

6629:  * Track how we arbitrate between microphone/input requests.

6644:  * Track how we arbitrate between microphone/input requests.

1643:   char phone[VKI_ISDN_MSNLEN];

1645: } vki_isdn_net_ioctl_phone;

101:         PHONE,

315:     public static class PhoneData implements EntryElement {

325:         public PhoneData(String data, int type, String label, boolean isPrimary) {

1779:     private void addPhone(int type, String data, String label, boolean isPrimary) {

143:         private String mPhoneticFamily;

144:         private String mPhoneticGiven;

145:         private String mPhoneticMiddle;

167:         public boolean emptyPhoneticStructuredName() {

750:         private final String mPhoneticName; // We won't have this in "TITLE" property.

870:         public String getPhoneticName() {

1555:     private List<PhoneData> mPhoneList;