372:         public Phone phone;

17: package com.android.phone;

195: public class PhoneInterfaceManager extends ITelephony.Stub {

1585:     private PhoneInterfaceManager(PhoneGlobals app) {

1601:     private Phone getDefaultPhone() {

1632:     private Phone getPhone(int subId) {

2234:     public String getNetworkCountryIsoForPhone(int phoneId, String callingPackage,

5761:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

302:     private PhoneConfigurationManager mPhoneConfigurationManager;

1612:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1620:     private Phone getPhoneFromSubId(int subId) {

2013:     private void shutdownRadioUsingPhoneId(int phoneId) {

2697:     public int getActivePhoneType() {

2702:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4375:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5828:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6368:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6378:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

382:             if (phone != null) {

383:                 this.phone = phone;

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

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

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

430:             final Phone defaultPhone = getDefaultPhone();

435:                     final Phone phone = getPhoneFromRequest(request);

454:                         request.result = phone != null

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

466:                     final Phone phone = getPhoneFromRequest(request);

467:                     request.result = phone != null ?

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

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

1262:                     Phone phone = getPhoneFromRequest(request);

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

1271:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1614:             return request.phone;

1626:         Phone phone = getPhoneFromRequest(request);

1627:         return phone == null ? null :

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

1631:     // returns phone associated with the subId.

1636:     private void sendEraseModemConfig(Phone phone) {

1637:         if (phone != null) {

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

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

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

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

1882:             final Phone phone = getPhone(subId);

1883:             if (phone != null) {

1884:                 phone.updateServiceLocation();

1928:             final Phone phone = getPhone(subId);

1929:             if (phone != null) {

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

1948:             final Phone phone = getPhone(subId);

1949:             if (phone != null) {

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

1966:             final Phone phone = getPhone(subId);

1967:             if (phone == null) {

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

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

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

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

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

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

2016:             phone.shutdownRadio();

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

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

2043:             final Phone phone = getPhone(subId);

2044:             if (phone != null) {

2045:                 phone.setRadioPower(turnOn);

2063:             final Phone phone = getPhone(subId);

2064:             if (phone != null) {

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

2083:             final Phone phone = getPhone(subId);

2084:             if (phone != null) {

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

2099:             final Phone phone = getPhone(subId);

2100:             if (phone != null) {

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

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

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

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

2167:             final Phone phone = getPhone(subId);

2168:             if (phone != null) {

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

2188:             final Phone phone = getPhone(subId);

2189:             if (phone != null) {

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

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

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

2249:                 // Get default phone in this case.

2250:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

2261:             if (phone != null) {

2262:                 ServiceStateTracker sst = phone.getServiceStateTracker();

2263:                 EmergencyNumberTracker emergencyNumberTracker = phone.getEmergencyNumberTracker();

2293:             final Phone phone = getPhone(subId);

2294:             if (phone != null) {

2295:                 phone.enableLocationUpdates();

2314:             final Phone phone = getPhone(subId);

2315:             if (phone != null) {

2316:                 phone.disableLocationUpdates();

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

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

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

2417:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2468:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2490:         if (phone == null) {

2493:         int subId = phone.getSubId();

2501:             return phone.getImei();

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

2511:         if (phone != null) {

2512:             String imei = phone.getImei();

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

2521:         if (phone == null) {

2525:         int subId = phone.getSubId();

2533:             return phone.getMeid();

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

2543:         if (phone != null) {

2544:             String meid = phone.getMeid();

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

2554:         if (phone == null) {

2557:         int subId = phone.getSubId();

2566:             return phone.getDeviceSvn();

2576:             final Phone phone = getPhone(subId);

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

2587:             final Phone phone = getPhone(subId);

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

2598:             final Phone phone = getPhone(subId);

2599:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2600:                     : phone.getSpecificCarrierId();

2610:             final Phone phone = getPhone(subId);

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

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

2623:         if (phone == null) {

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

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

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

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

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

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

2706:             if (phone == null) {

2707:                 return PhoneConstants.PHONE_TYPE_NONE;

2709:                 return phone.getPhoneType();

2736:             final Phone phone = getPhone(subId);

2737:             if (phone != null) {

2738:                 return phone.getCdmaEriIconIndex();

2769:             final Phone phone = getPhone(subId);

2770:             if (phone != null) {

2771:                 return phone.getCdmaEriIconMode();

2800:             final Phone phone = getPhone(subId);

2801:             if (phone != null) {

2802:                 return phone.getCdmaEriText();

2821:             final Phone phone = getPhone(subId);

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

2823:                 return phone.getLine1Number();

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

2843:             final Phone phone = getPhone(subId);

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

2845:                 return phone.getCdmaMin();

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

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

3022:             final Phone phone = getPhone(subId);

3023:             if (phone != null) {

3024:                 phone.setVoiceActivationState(activationState);

3043:             final Phone phone = getPhone(subId);

3044:             if (phone != null) {

3045:                 phone.setDataActivationState(activationState);

3061:         final Phone phone = getPhone(subId);

3064:             if (phone != null) {

3065:                 return phone.getVoiceActivationState();

3081:         final Phone phone = getPhone(subId);

3084:             if (phone != null) {

3085:                 return phone.getDataActivationState();

3107:             final Phone phone = getPhone(subId);

3108:             if (phone != null) {

3109:                 return phone.getVoiceMessageCount();

3126:             final Phone phone = getPhone(subId);

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

3140:         final Phone defaultPhone = getDefaultPhone();

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

3179:                 if (phone.isInEmergencySmsMode()) {

3190:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3217:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3255:             Phone phone = getPhone(subId);

3256:             if (phone == null) {

3261:             phone.getImsRegistrationState(regState -> {

3288:             Phone phone = getPhone(subId);

3289:             if (phone == null) {

3294:             phone.getImsRegistrationTech(regTech -> {

3313:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3339:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3390:             Phone phone = getPhone(subId);

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

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

3437:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3474:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3508:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3543:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3595:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3677:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3744:         Phone phone = getPhone(subId);

3745:         if (phone == null) {

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

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

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

4188:             final Phone phone = getPhone(subId);

4189:             if (phone != null) {

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

4222:             final Phone phone = getPhone(subId);

4223:             if (phone != null) {

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

4247:             final Phone phone = getPhone(subId);

4248:             if (phone != null) {

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

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

4275:             if (phone != null) {

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

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

4292:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4311:             final Phone phone = getPhone(subId);

4312:             if (phone == null) {

4315:                 return phone.getLteOnCdmaMode();

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

4410:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4804:         if (phone != null) {

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

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

4830:         if (phone != null) {

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

4848:         final Phone defaultPhone = getDefaultPhone();

5373:         final Phone defaultPhone = getDefaultPhone();

5511:         final Phone phone = getPhone(subId);

5513:             if (phone != null) {

5514:                 return phone.hasMatchedTetherApnSetting();

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

5539:             if (phone != null) {

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

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

5561:         final Phone phone = getPhone(subId);

5563:             if (phone != null) {

5568:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

5618:             if (phone != null) {

5619:                 boolean retVal = phone.isUserDataEnabled();

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

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

5647:             if (phone != null) {

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

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

5661:             Phone phone) {

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

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

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

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

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

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

5708:         final Phone phone = getPhone(subId);

5709:         if (phone == null) {

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

5721:                 phone.getContext().getPackageManager()), phone);

5727:         final Phone phone = getPhone(subId);

5728:         if (phone == null) {

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

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

5845:         final Phone phone = getPhone(subId);

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

5868:             final Phone phone = getPhone(subId);

5869:             if (phone == null) {

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

6095:             final Phone phone = getPhone(subId);

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

6111:             final Phone phone = getPhone(subId);

6112:             if (phone == null) {

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

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

6168:         if (phone == null) {

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

6185:         final Phone defaultPhone = getDefaultPhone();

6199:         final Phone defaultPhone = getDefaultPhone();

6253:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6284:         final Phone phone = getPhone(subscriptionId);

6285:         if (phone == null) {

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

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

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

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

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

6335:         if (phone == null) {

6338:         int subId = phone.getSubId();

6346:             return phone.getDeviceId();

6359:         Phone phone = getPhone(subId);

6360:         if (phone != null) {

6361:             return phone.isImsRegistered();

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

6396:             Phone phone = getPhone(subscriptionId);

6397:             if (phone == null) {

6400:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6412:             Phone phone = getPhone(subId);

6413:             if (phone != null) {

6414:                 return phone.isWifiCallingEnabled();

6429:             Phone phone = getPhone(subId);

6430:             if (phone != null) {

6431:                 return phone.isVideoEnabled();

6447:             Phone phone = getPhone(subId);

6448:             if (phone != null) {

6449:                 return phone.getImsRegistrationTech();

6507:         final Phone phone = getPhone(subId);

6508:         if (phone == null) {

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

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

6683:             final Phone phone = getPhone(subId);

6684:             if (phone == null) {

6688:             ServiceState ss = phone.getServiceState();

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

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

6713:             if (phone == null) {

6714:                 phone = getDefaultPhone();

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

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

6737:         final Phone defaultPhone = getDefaultPhone();

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

6749:             if (phone == null) {

6750:                 phone = defaultPhone;

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

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

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

6770:             if (phone == null) {

6771:                 phone = getDefaultPhone();

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

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

6794:         final Phone defaultPhone = getDefaultPhone();

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

6806:             if (phone == null) {

6807:                 phone = defaultPhone;

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

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

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

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

6869:         Phone phone = getPhone(subId);

6873:             if (phone == null) {

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

6898:         Phone phone = getPhone(subId);

6902:             if (phone == null) {

6907:                 esn = phone.getEsn();

6926:         Phone phone = getPhone(subId);

6930:             if (phone == null) {

6935:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7029:         final Phone phone = getPhone(subId);

7032:         if (phone == null) {

7037:             phone.carrierActionSetMeteredApnsEnabled(enabled);

7054:         final Phone phone = getPhone(subId);

7057:         if (phone == null) {

7062:             phone.carrierActionSetRadioEnabled(enabled);

7082:         final Phone phone = getPhone(subId);

7085:         if (phone == null) {

7090:             phone.carrierActionReportDefaultNetworkStatus(report);

7106:         final Phone phone = getPhone(subId);

7107:         if (phone == null) {

7112:             phone.carrierActionResetAll();

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

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

7156:             Phone phone = getPhone(subId);

7157:             if (phone != null) {

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

7177:         Phone phone = getPhone(subId);

7181:             if (phone != null) {

7182:                 return phone.getClientRequestStats();

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

7215:             if (phone != null) {

7216:                 phone.setSimPowerState(state, workSource);

7238:      * Check if phone is in emergency callback mode

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

7245:         final Phone phone = getPhone(subId);

7249:             if (phone != null) {

7250:                 return phone.isInEcm();

7270:             Phone p = getPhone(subId);

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

7291:         if (phone != null) {

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

7299:                 return phone.getRadioPowerState();

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

7327:             Phone phone = getPhone(subId);

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

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

7356:             Phone phone = getPhone(subId);

7357:             if (phone != null) {

7358:                 phone.setDataRoamingEnabled(isEnabled);

7374:             Phone phone = getPhone(subId);

7375:             if (phone != null) {

7376:                 isAllowed = phone.isCspPlmnEnabled();

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

7527:         final Phone phone = getPhone(subId);

7528:         if (phone == null) {

7535:             phone.setRadioIndicationUpdateMode(filters, mode);

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();

7849:         Phone phone = getPhone(subId);

7850:         if (phone == null) {

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

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

7876:             if (phone == null) {

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

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

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

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

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

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

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

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

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

8004:         Phone phone = getPhone(subId);

8005:         if (phone == null) {

8010:             UiccCard uiccCard = phone.getUiccCard();

8080:         Phone phone = getDefaultPhone();

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

8082:         HalVersion hv = phone.getHalVersion();

8112:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8118:             Phone phone = getPhone(subId);

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

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

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

8135:             Phone phone = getPhone(subId);

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

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

8206:             Phone phone = getPhone(subId);

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

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

8222:             Phone phone = getPhone(subId);

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

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

8238:             Phone phone = getPhone(subId);

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

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

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

8260:                 Phone defaultPhone = phone.getImsPhone();

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

8306:             Phone phone = getPhone(subId);

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

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

8328:         Phone phone = getPhone(subId);

8329:         if (phone == null) {

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

8358:         Phone phone = getPhone(subId);

8359:         if (phone == null) {

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

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

64: import android.telecom.PhoneAccount;

65: import android.telecom.PhoneAccountHandle;

84: import android.telephony.PhoneCapability;

85: 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;

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

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

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

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

292:     private static PhoneInterfaceManager sInstance;

294:     private PhoneGlobals mApp;

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

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

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

733:                     defaultPhone.resetModemConfig(onCompleted);

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

1017:                     if (defaultPhone != null) {

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

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

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

1283:                     defaultPhone.rebootModem(onCompleted);

1293:                     PhoneConfigurationManager.getInstance()

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

1314:                     PhoneConfigurationManager.getInstance()

1385:                     defaultPhone.eraseModemConfig(onCompleted);

1570:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1574:         synchronized (PhoneInterfaceManager.class) {

1576:                 sInstance = new PhoneInterfaceManager(app);

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

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

1596:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

1781:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1811:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

1813:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1816:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2026:             if (defaultPhone != null) {

2027:                 defaultPhone.setRadioPower(turnOn);

2171:                 return PhoneConstantConversions.convertDataState(

2172:                         PhoneConstants.DataState.DISCONNECTED);

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

2239:                     callingFeatureId, "getNetworkCountryIsoForPhone")) {

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

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

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

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

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

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

2884:             return getDefaultPhone().needsOtaServiceProvisioning();

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

2920:             if (phoneAccountHandle == null) {

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

3007:         SmsController smsController = PhoneFactory.getSmsController();

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

3151:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

3584:             // 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4306:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4313:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

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

4377:         if (phoneId == -1) {

4381:         return PhoneFactory.getPhone(phoneId);

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

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

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

4856:             return defaultPhone.getPcscfAddress(apnType);

5107:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

5757:             getPhone(phoneId), pkgName);

5774:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6371:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6386:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6491:               sendEraseModemConfig(getDefaultPhone());

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

6706:      * PhoneAccount.

6709:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6732:      * PhoneAccount.

6736:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

6742:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

6766:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

6789:      * specific PhoneAccount.

6793:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

6799:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7393:             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)");

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

7954:         PhoneCapability staticCapability =

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

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

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

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

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

8262:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8264:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8267:                             + imsPhone.getMsisdn());

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

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

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

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

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

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

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

822:                     getPhoneFromRequest(request).getCallForwardingOption(

879:                     getPhoneFromRequest(request).setCallForwardingOption(

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

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

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

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

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

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

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

1324:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

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

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

1616:             return getPhoneFromSubId(request.subId);

1912:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2006:                 shutdownRadioUsingPhoneId(i);

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

2558:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2698:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2728:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2761:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2792:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2933:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3100:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3160:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3197:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3223:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3280:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3320:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3345:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3442:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3479:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3513:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3548:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3600:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3682:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3764:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3828:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4180:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4214:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4239:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4406:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4448:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4631:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5050:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5397:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5443:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5829:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

5915:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

5942:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5965:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6174:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6224:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6243:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6647:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7173:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7330:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7368:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7492:                         slot.getPhoneId(),

7645:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7653:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7662:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7702:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7729:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7895:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7930:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

7955:                 mPhoneConfigurationManager.getStaticPhoneCapability();

7995:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8035:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8042:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8263:                     ImsPhoneCallTracker imsPhoneCallTracker =

8265:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

113: public abstract class Phone extends Handler implements PhoneInternalInterface {

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

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

318:     protected Phone mImsPhone = null;

576:     public void createImsPhone() {

3443:     public Phone getImsPhone() {

4092:     public Phone getDefaultPhone() {

189:     protected static final int EVENT_UPDATE_PHONE_OBJECT            = 42;

288:     protected boolean mIsPhoneInEcmState = false;

315:     protected int mPhoneId;

422:     public String getPhoneName() {

426:     protected void setPhoneName(String name) {

1759:     public void updatePhoneObject(int voiceRadioTech) {

2552:     public abstract int getPhoneType();

3557:     public int getPhoneId() {

3565:     public int getVoicePhoneServiceState() {

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

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

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

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

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

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

418:      *  outside the phone app process.

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

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

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

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

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

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

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

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

581:         synchronized(Phone.lockForRadioTechnologyChange) {

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

646:         // resources of the phone being destroyed

772:         Phone imsPhone = mImsPhone;

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

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

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

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

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

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

984:     protected void migrateFrom(Phone from) {

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

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

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

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

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

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

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

1653:         // no need for regular phone

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

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

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

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

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

1720:      * then the phone state is RINGING not OFFHOOK

1729:      * Retrieves the IccFileHandler of the Phone instance

1748:      * Retrieves the Handler of the Phone instance

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

1763:     * Retrieves the ServiceStateTracker of the phone instance.

1771:      * Retrieves the EmergencyNumberTracker of the phone instance.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2549:      * @return PHONE_TYPE_XXX as defined above.

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

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

3264:      * Notify registrants if phone is video capable.

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

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

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

3440:      * Return an instance of a IMS phone

3554:      * Returns the phone id.

3566:         Phone imsPhone = mImsPhone;

3640:         Phone imsPhone = mImsPhone;

3659:         Phone imsPhone = mImsPhone;

3673:         Phone imsPhone = mImsPhone;

3687:         Phone imsPhone = mImsPhone;

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

3701:         Phone imsPhone = mImsPhone;

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

3715:         Phone imsPhone = mImsPhone;

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

3727:         Phone imsPhone = mImsPhone;

3785:      *  Set phone radio capability

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

3796:      *  Get phone radio access family

3816:      *  Get phone radio capability

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

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

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

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

3915:         Phone imsPhone = mImsPhone;

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

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

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

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

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

4140:             if (phone != null) {

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

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

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

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

51: import android.telephony.PhoneStateListener;

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

107:  * originally called PhoneFactory to obtain the interface.

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

406:     protected PhoneNotifier mNotifier;

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

500:                     boolean unitTestMode, int phoneId,

502:         mPhoneId = phoneId;

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

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

582:             if (mImsPhone == null) {

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

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

585:                 mImsPhone.registerForSilentRedial(

660:                     PhoneConstants.State state = getState();

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

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

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

692:                         if (mImsPhone != null) {

694:                             mImsPhone.notifyRedialConnectionChanged(cn);

698:                         if (mImsPhone != null) {

699:                             mImsPhone.notifyRedialConnectionChanged(null);

779:                     if (imsPhone != null) {

780:                         conn = imsPhone.getHandoverConnection();

781:                         migrateFrom(imsPhone);

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

788:                     if (imsPhone != null) {

789:                         imsPhone.notifySrvccState(srvccState);

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

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

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

1726:     public abstract PhoneConstants.State getState();

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

1911:      * PhoneStateListener.onCellInfoChanged} will be invoked.

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

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

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

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

2401:         return PhoneConstants.DataState.DISCONNECTED;

2476:     // phones

2538:         if (mImsPhone != null) {

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

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

2541:                     isVideoCallOrConference(mImsPhone.getRingingCall());

2685:      * Retrieves the MIN for CDMA phones.

2701:      *  Retrieves PRL Version for CDMA phones

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

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

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

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

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

3362:     public PhoneConstants.DataState getDataConnectionState() {

3363:         return getDataConnectionState(PhoneConstants.APN_TYPE_DEFAULT);

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

3381:      * or {@link PhoneConstants#LTE_ON_CDMA_TRUE}

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

3444:         return mImsPhone;

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

3514:         if (mImsPhone != null) {

3515:             return mImsPhone.isUtEnabled();

3534:         // dialInternal shall be overriden by GsmCdmaPhone

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

3567:         if (imsPhone != null

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

3642:         if (imsPhone != null) {

3643:             isImsRegistered = imsPhone.isImsRegistered();

3661:         if (imsPhone != null) {

3662:             isWifiCallingEnabled = imsPhone.isWifiCallingEnabled();

3675:         if (imsPhone != null) {

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

3689:         if (imsPhone != null) {

3690:             isVolteEnabled = imsPhone.isVolteEnabled();

3703:         if (imsPhone != null) {

3704:             regTech = imsPhone.getImsRegistrationTech();

3716:         if (imsPhone != null) {

3717:             imsPhone.getImsRegistrationTech(callback);

3728:         if (imsPhone != null) {

3729:             imsPhone.getImsRegistrationState(callback);

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

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

3901:         if (mImsPhone == null) {

3905:         return mImsPhone.isImsAvailable();

3916:         if (imsPhone != null) {

3917:             return imsPhone.isVideoEnabled();

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

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

4233:         if (mImsPhone != null) {

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

402:      * state change notification. DefaultPhoneNotifier is

475:      * @param notifier An instance of DefaultPhoneNotifier,

491:      * @param notifier An instance of DefaultPhoneNotifier,

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

2487:         return mIsPhoneInEcmState;

2498:         mIsPhoneInEcmState = isInEcm;

2524:         if (call instanceof ImsPhoneCall) {

2525:             ImsPhoneCall imsPhoneCall = (ImsPhoneCall) call;

2526:             ImsCall imsCall = imsPhoneCall.getImsCall();

2580:                 mPhoneId, UiccController.APP_FAM_3GPP);

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

3414:         return mUiccController.getUiccCard(mPhoneId);

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

3558:         return mPhoneId;

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

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

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

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

3: public class Phone {

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;

1865:     private String buildSinglePhoneticNameFromSortAsParam(Map<String, Collection<String>> paramMap) {

2078:     private void handlePhoneticNameFromSound(List<String> elems) {

2633:     public final List<PhoneData> getPhoneList() {

33: import android.provider.ContactsContract.CommonDataKinds.Phone;

337:             builder.withValueBackReference(Phone.RAW_CONTACT_ID, backReferenceIndex);

338:             builder.withValue(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);

340:             builder.withValue(Phone.TYPE, mType);

341:             if (mType == Phone.TYPE_CUSTOM) {

342:                 builder.withValue(Phone.LABEL, mLabel);

344:             builder.withValue(Phone.NUMBER, mNumber);

346:                 builder.withValue(Phone.IS_PRIMARY, 1);

388:             return EntryLabel.PHONE;

1786:         if (type == Phone.TYPE_PAGER || VCardConfig.refrainPhoneNumberFormatting(mVCardType)) {

1790:             // Note that some other codes (like the phone number formatter) or modules expect this

2307:                 // Given propValue is in URI format, not in phone number format used until

2315:                     // we may still have non-URI phone number. To keep given data as much as

2340:                     type = Phone.TYPE_CUSTOM;

2355:             // The phone number available via Skype.

2357:             final int type = Phone.TYPE_OTHER;

19: import com.android.vcard.VCardUtils.PhoneNumberUtilsPort;

42: import android.telephony.PhoneNumberUtils;

196:             boolean phoneticNameSpecified = false;

199:                 builder.withValue(StructuredName.PHONETIC_GIVEN_NAME, mPhoneticGiven);

200:                 phoneticNameSpecified = true;

203:                 builder.withValue(StructuredName.PHONETIC_FAMILY_NAME, mPhoneticFamily);

204:                 phoneticNameSpecified = true;

207:                 builder.withValue(StructuredName.PHONETIC_MIDDLE_NAME, mPhoneticMiddle);

208:                 phoneticNameSpecified = true;

211:             // SORT-STRING is used only when phonetic names aren't specified in