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) {

2294:     public String getNetworkCountryIsoForPhone(int phoneId) {

5781:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

6262:     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) {

2072:     private void shutdownRadioUsingPhoneId(int phoneId) {

2734:     public int getActivePhoneType() {

2739:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4416:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5848:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6388:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6398:     public int getSubIdForPhoneAccountHandle(

6413:     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)

1941:             final Phone phone = getPhone(subId);

1942:             if (phone != null) {

1943:                 phone.updateServiceLocation();

1987:             final Phone phone = getPhone(subId);

1988:             if (phone != null) {

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

2007:             final Phone phone = getPhone(subId);

2008:             if (phone != null) {

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

2025:             final Phone phone = getPhone(subId);

2026:             if (phone == null) {

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

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

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

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

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

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

2075:             phone.shutdownRadio();

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

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

2102:             final Phone phone = getPhone(subId);

2103:             if (phone != null) {

2104:                 phone.setRadioPower(turnOn);

2122:             final Phone phone = getPhone(subId);

2123:             if (phone != null) {

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

2142:             final Phone phone = getPhone(subId);

2143:             if (phone != null) {

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

2158:             final Phone phone = getPhone(subId);

2159:             if (phone != null) {

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

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

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

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

2226:             final Phone phone = getPhone(subId);

2227:             if (phone != null) {

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

2247:             final Phone phone = getPhone(subId);

2248:             if (phone != null) {

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

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

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

2300:                 // Get default phone in this case.

2301:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2306:             ServiceStateTracker sst = phone.getServiceStateTracker();

2311:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

2330:             final Phone phone = getPhone(subId);

2331:             if (phone != null) {

2332:                 phone.enableLocationUpdates();

2351:             final Phone phone = getPhone(subId);

2352:             if (phone != null) {

2353:                 phone.disableLocationUpdates();

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

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

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

2454:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2505:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2527:         if (phone == null) {

2530:         int subId = phone.getSubId();

2538:             return phone.getImei();

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

2548:         if (phone != null) {

2549:             String imei = phone.getImei();

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

2558:         if (phone == null) {

2562:         int subId = phone.getSubId();

2570:             return phone.getMeid();

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

2580:         if (phone != null) {

2581:             String meid = phone.getMeid();

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

2591:         if (phone == null) {

2594:         int subId = phone.getSubId();

2603:             return phone.getDeviceSvn();

2613:             final Phone phone = getPhone(subId);

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

2624:             final Phone phone = getPhone(subId);

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

2635:             final Phone phone = getPhone(subId);

2636:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2637:                     : phone.getSpecificCarrierId();

2647:             final Phone phone = getPhone(subId);

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

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

2660:         if (phone == null) {

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

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

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

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

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

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

2743:             if (phone == null) {

2744:                 return PhoneConstants.PHONE_TYPE_NONE;

2746:                 return phone.getPhoneType();

2773:             final Phone phone = getPhone(subId);

2774:             if (phone != null) {

2775:                 return phone.getCdmaEriIconIndex();

2806:             final Phone phone = getPhone(subId);

2807:             if (phone != null) {

2808:                 return phone.getCdmaEriIconMode();

2837:             final Phone phone = getPhone(subId);

2838:             if (phone != null) {

2839:                 return phone.getCdmaEriText();

2858:             final Phone phone = getPhone(subId);

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

2860:                 return phone.getLine1Number();

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

2880:             final Phone phone = getPhone(subId);

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

2882:                 return phone.getCdmaMin();

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

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

3060:             final Phone phone = getPhone(subId);

3061:             if (phone != null) {

3062:                 phone.setVoiceActivationState(activationState);

3081:             final Phone phone = getPhone(subId);

3082:             if (phone != null) {

3083:                 phone.setDataActivationState(activationState);

3099:         final Phone phone = getPhone(subId);

3102:             if (phone != null) {

3103:                 return phone.getVoiceActivationState();

3119:         final Phone phone = getPhone(subId);

3122:             if (phone != null) {

3123:                 return phone.getDataActivationState();

3145:             final Phone phone = getPhone(subId);

3146:             if (phone != null) {

3147:                 return phone.getVoiceMessageCount();

3164:             final Phone phone = getPhone(subId);

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

3178:         final Phone defaultPhone = getDefaultPhone();

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

3217:                 if (phone.isInEmergencySmsMode()) {

3228:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3255:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3293:             Phone phone = getPhone(subId);

3294:             if (phone == null) {

3299:             phone.getImsRegistrationState(regState -> {

3326:             Phone phone = getPhone(subId);

3327:             if (phone == null) {

3332:             phone.getImsRegistrationTech(regTech -> {

3351:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3377:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3428:             Phone phone = getPhone(subId);

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

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

3478:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3515:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3549:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3584:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3636:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3718:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3785:         Phone phone = getPhone(subId);

3786:         if (phone == null) {

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

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

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

4229:             final Phone phone = getPhone(subId);

4230:             if (phone != null) {

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

4263:             final Phone phone = getPhone(subId);

4264:             if (phone != null) {

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

4288:             final Phone phone = getPhone(subId);

4289:             if (phone != null) {

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

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

4316:             if (phone != null) {

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

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

4333:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4352:             final Phone phone = getPhone(subId);

4353:             if (phone == null) {

4356:                 return phone.getLteOnCdmaMode();

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

4451:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4845:         if (phone != null) {

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

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

4871:         if (phone != null) {

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

4889:         final Phone defaultPhone = getDefaultPhone();

5414:         final Phone defaultPhone = getDefaultPhone();

5532:         final Phone phone = getPhone(subId);

5534:             if (phone != null) {

5535:                 return phone.hasMatchedTetherApnSetting();

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

5560:             if (phone != null) {

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

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

5582:         final Phone phone = getPhone(subId);

5584:             if (phone != null) {

5589:                 phone.setAlwaysReportSignalStrength(isEnable);

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

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

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

5639:             if (phone != null) {

5640:                 boolean retVal = phone.isUserDataEnabled();

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

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

5668:             if (phone != null) {

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

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

5682:             Phone phone) {

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

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

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

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

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

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

5728:         final Phone phone = getPhone(subId);

5729:         if (phone == null) {

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

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

5747:         final Phone phone = getPhone(subId);

5748:         if (phone == null) {

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

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

5865:         final Phone phone = getPhone(subId);

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

5888:             final Phone phone = getPhone(subId);

5889:             if (phone == null) {

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

6115:             final Phone phone = getPhone(subId);

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

6131:             final Phone phone = getPhone(subId);

6132:             if (phone == null) {

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

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

6188:         if (phone == null) {

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

6205:         final Phone defaultPhone = getDefaultPhone();

6219:         final Phone defaultPhone = getDefaultPhone();

6273:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

6304:         final Phone phone = getPhone(subscriptionId);

6305:         if (phone == null) {

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

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

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

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

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

6355:         if (phone == null) {

6358:         int subId = phone.getSubId();

6366:             return phone.getDeviceId();

6379:         Phone phone = getPhone(subId);

6380:         if (phone != null) {

6381:             return phone.isImsRegistered();

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

6416:             Phone phone = getPhone(subscriptionId);

6417:             if (phone == null) {

6420:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6432:             Phone phone = getPhone(subId);

6433:             if (phone != null) {

6434:                 return phone.isWifiCallingEnabled();

6449:             Phone phone = getPhone(subId);

6450:             if (phone != null) {

6451:                 return phone.isVideoEnabled();

6467:             Phone phone = getPhone(subId);

6468:             if (phone != null) {

6469:                 return phone.getImsRegistrationTech();

6527:         final Phone phone = getPhone(subId);

6528:         if (phone == null) {

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

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

6672:             final Phone phone = getPhone(subId);

6673:             if (phone == null) {

6677:             ServiceState ss = phone.getServiceState();

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

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

6702:             if (phone == null) {

6703:                 phone = getDefaultPhone();

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

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

6726:         final Phone defaultPhone = getDefaultPhone();

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

6738:             if (phone == null) {

6739:                 phone = defaultPhone;

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

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

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

6759:             if (phone == null) {

6760:                 phone = getDefaultPhone();

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

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

6783:         final Phone defaultPhone = getDefaultPhone();

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

6795:             if (phone == null) {

6796:                 phone = defaultPhone;

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

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

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

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

6858:         Phone phone = getPhone(subId);

6862:             if (phone == null) {

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

6887:         Phone phone = getPhone(subId);

6891:             if (phone == null) {

6896:                 esn = phone.getEsn();

6915:         Phone phone = getPhone(subId);

6919:             if (phone == null) {

6924:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

7018:         final Phone phone = getPhone(subId);

7021:         if (phone == null) {

7026:             phone.carrierActionSetMeteredApnsEnabled(enabled);

7043:         final Phone phone = getPhone(subId);

7046:         if (phone == null) {

7051:             phone.carrierActionSetRadioEnabled(enabled);

7071:         final Phone phone = getPhone(subId);

7074:         if (phone == null) {

7079:             phone.carrierActionReportDefaultNetworkStatus(report);

7095:         final Phone phone = getPhone(subId);

7096:         if (phone == null) {

7101:             phone.carrierActionResetAll();

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

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

7145:             Phone phone = getPhone(subId);

7146:             if (phone != null) {

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

7166:         Phone phone = getPhone(subId);

7170:             if (phone != null) {

7171:                 return phone.getClientRequestStats();

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

7204:             if (phone != null) {

7205:                 phone.setSimPowerState(state, workSource);

7227:      * Check if phone is in emergency callback mode

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

7234:         final Phone phone = getPhone(subId);

7238:             if (phone != null) {

7239:                 return phone.isInEcm();

7259:             Phone p = getPhone(subId);

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

7280:         if (phone != null) {

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

7288:                 return phone.getRadioPowerState();

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

7316:             Phone phone = getPhone(subId);

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

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

7345:             Phone phone = getPhone(subId);

7346:             if (phone != null) {

7347:                 phone.setDataRoamingEnabled(isEnabled);

7363:             Phone phone = getPhone(subId);

7364:             if (phone != null) {

7365:                 isAllowed = phone.isCspPlmnEnabled();

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

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

7526:             Phone phone = getPhone(subId);

7527:             if (phone == null) {

7530:             UiccCard uiccCard = phone.getUiccCard();

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

7575:         return Phone.PREFERRED_NT_MODE;

7585:             final Phone phone = getPhone(subId);

7586:             if (phone == null) {

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

7603:             final Phone phone = getPhone(subId);

7604:             if (phone == null) {

7608:             return phone.getCarrierIdListVersion();

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

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

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

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

7686:                             phone.getSubId(),

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

7698:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

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

7732:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7754:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7773:             final Phone phone = getPhone(subId);

7774:             if (phone == null) {

7778:             return phone.getEmergencyNumberDbVersion();

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

7791:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7808:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7825:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7838:         Phone phone = getPhone(subId);

7839:         if (phone == null) {

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

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

7865:             if (phone == null) {

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

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

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

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

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

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

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

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

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

7993:         Phone phone = getPhone(subId);

7994:         if (phone == null) {

7999:             UiccCard uiccCard = phone.getUiccCard();

8069:         Phone phone = getDefaultPhone();

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

8071:         HalVersion hv = phone.getHalVersion();

8101:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

8107:             Phone phone = getPhone(subId);

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

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

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

8124:             Phone phone = getPhone(subId);

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

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

8139:             Phone phone = getPhone(subscriptionId);

8140:             if (phone == null) {

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

8230:             Phone phone = getPhone(subId);

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

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

8246:             Phone phone = getPhone(subId);

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

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

8262:             Phone phone = getPhone(subId);

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

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

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

8284:                 Phone defaultPhone = phone.getImsPhone();

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

8330:             Phone phone = getPhone(subId);

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

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

8352:         Phone phone = getPhone(subId);

8353:         if (phone == null) {

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

8382:         Phone phone = getPhone(subId);

8383:         if (phone == null) {

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

1870:                                             mResult = PhoneConstants.PIN_OPERATION_ABORTED;

1872:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1875:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

2085:             if (defaultPhone != null) {

2086:                 defaultPhone.setRadioPower(turnOn);

2230:                 return PhoneConstantConversions.convertDataState(

2231:                         PhoneConstants.DataState.DISCONNECTED);

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

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

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

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

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

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

2921:             return getDefaultPhone().needsOtaServiceProvisioning();

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

2957:             if (phoneAccountHandle == null) {

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

3045:         SmsController smsController = PhoneFactory.getSmsController();

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

3189:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4347:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4354:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

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

4418:         if (phoneId == -1) {

4422:         return PhoneFactory.getPhone(phoneId);

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

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

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

4897:             return defaultPhone.getPcscfAddress(apnType);

5148:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

5777:             getPhone(phoneId), pkgName);

5794:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

6391:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6406:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6511:               sendEraseModemConfig(getDefaultPhone());

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

6695:      * PhoneAccount.

6698:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6721:      * PhoneAccount.

6725:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

6731:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

6755:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

6778:      * specific PhoneAccount.

6782:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

6788:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7382:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

7573:             return list.get(phoneId);

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

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

7943:         PhoneCapability staticCapability =

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

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

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

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

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

8286:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

8288:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

8291:                             + 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);

1971:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

2065:                 shutdownRadioUsingPhoneId(i);

2595:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2735:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2765:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2798:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2829:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2970:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3138:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

3198:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3235:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3261:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3318:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3358:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3383:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3483:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3520:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3554:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3589:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3641:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3723:         TelephonyPermissions.enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

3805:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3869:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

4221:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4255:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4280:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4447:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4489:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4672:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

5091:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5438:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5487:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5849:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

5935:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

5962:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5985:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6194:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

6244:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6263:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6636:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7162:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7319:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7357:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7481:                         slot.getPhoneId(),

7617:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7625:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7634:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7674:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7701:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7884:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7919:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

7944:                 mPhoneConfigurationManager.getStaticPhoneCapability();

7984:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

8024:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

8031:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

8287:                     ImsPhoneCallTracker imsPhoneCallTracker =

8289:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

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) {

2289:     public String getNetworkCountryIsoForPhone(int phoneId) {

5776:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

6257:     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) {

2729:     public int getActivePhoneType() {

2734:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4411:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5843:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

6383:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6393:     public int getSubIdForPhoneAccountHandle(

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

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

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

2295:                 // Get default phone in this case.

2296:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

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

2301:             ServiceStateTracker sst = phone.getServiceStateTracker();

2306:             EmergencyNumberTracker ent = phone.getEmergencyNumberTracker();

2325:             final Phone phone = getPhone(subId);

2326:             if (phone != null) {

2327:                 phone.enableLocationUpdates();

2346:             final Phone phone = getPhone(subId);

2347:             if (phone != null) {

2348:                 phone.disableLocationUpdates();

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

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

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

2449:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2500:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2522:         if (phone == null) {

2525:         int subId = phone.getSubId();

2533:             return phone.getImei();

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

2543:         if (phone != null) {

2544:             String imei = phone.getImei();

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

2553:         if (phone == null) {

2557:         int subId = phone.getSubId();

2565:             return phone.getMeid();

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

2575:         if (phone != null) {

2576:             String meid = phone.getMeid();

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

2586:         if (phone == null) {

2589:         int subId = phone.getSubId();

2598:             return phone.getDeviceSvn();

2608:             final Phone phone = getPhone(subId);

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

2619:             final Phone phone = getPhone(subId);

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

2630:             final Phone phone = getPhone(subId);

2631:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2632:                     : phone.getSpecificCarrierId();

2642:             final Phone phone = getPhone(subId);

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

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

2655:         if (phone == null) {

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

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

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

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

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

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

2738:             if (phone == null) {

2739:                 return PhoneConstants.PHONE_TYPE_NONE;

2741:                 return phone.getPhoneType();

2768:             final Phone phone = getPhone(subId);

2769:             if (phone != null) {

2770:                 return phone.getCdmaEriIconIndex();

2801:             final Phone phone = getPhone(subId);

2802:             if (phone != null) {

2803:                 return phone.getCdmaEriIconMode();

2832:             final Phone phone = getPhone(subId);

2833:             if (phone != null) {

2834:                 return phone.getCdmaEriText();

2853:             final Phone phone = getPhone(subId);

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

2855:                 return phone.getLine1Number();

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

2875:             final Phone phone = getPhone(subId);

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

2877:                 return phone.getCdmaMin();

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

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

3055:             final Phone phone = getPhone(subId);

3056:             if (phone != null) {

3057:                 phone.setVoiceActivationState(activationState);

3076:             final Phone phone = getPhone(subId);

3077:             if (phone != null) {

3078:                 phone.setDataActivationState(activationState);

3094:         final Phone phone = getPhone(subId);

3097:             if (phone != null) {

3098:                 return phone.getVoiceActivationState();

3114:         final Phone phone = getPhone(subId);

3117:             if (phone != null) {

3118:                 return phone.getDataActivationState();

3140:             final Phone phone = getPhone(subId);

3141:             if (phone != null) {

3142:                 return phone.getVoiceMessageCount();

3159:             final Phone phone = getPhone(subId);

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

3173:         final Phone defaultPhone = getDefaultPhone();

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

3212:                 if (phone.isInEmergencySmsMode()) {

3223:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3250:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3288:             Phone phone = getPhone(subId);

3289:             if (phone == null) {

3294:             phone.getImsRegistrationState(regState -> {

3321:             Phone phone = getPhone(subId);

3322:             if (phone == null) {

3327:             phone.getImsRegistrationTech(regTech -> {

3346:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3372:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3423:             Phone phone = getPhone(subId);

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

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

3473:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3510:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3544:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3579:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3631:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3713:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3780:         Phone phone = getPhone(subId);

3781:         if (phone == null) {

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

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

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

4224:             final Phone phone = getPhone(subId);

4225:             if (phone != null) {

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

4258:             final Phone phone = getPhone(subId);

4259:             if (phone != null) {

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

4283:             final Phone phone = getPhone(subId);

4284:             if (phone != null) {

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

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

4311:             if (phone != null) {

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

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

4328:      * or {@link Phone#LTE_ON_CDMA_TRUE}