358:         public Phone phone;

17: package com.android.phone;

193: public class PhoneInterfaceManager extends ITelephony.Stub {

1392:     private PhoneInterfaceManager(PhoneGlobals app) {

1408:     private Phone getDefaultPhone() {

1439:     private Phone getPhone(int subId) {

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

5388:     public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {

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

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

288:     private PhoneConfigurationManager mPhoneConfigurationManager;

1419:     private Phone getPhoneFromRequest(MainThreadRequest request) {

1427:     private Phone getPhoneFromSubId(int subId) {

1820:     private void shutdownRadioUsingPhoneId(int phoneId) {

2493:     public int getActivePhoneType() {

2498:     public int getActivePhoneTypeForSlot(int slotIndex) {

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

4171:     private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {

5455:     public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {

5995:     public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {

6005:     public int getSubIdForPhoneAccountHandle(

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

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

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

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

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

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

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

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

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

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

368:             if (phone != null) {

369:                 this.phone = phone;

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

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

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

416:             final Phone defaultPhone = getDefaultPhone();

421:                     final Phone phone = getPhoneFromRequest(request);

440:                         request.result = phone != null

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

452:                     final Phone phone = getPhoneFromRequest(request);

453:                     request.result = phone != null ?

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

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

1106:                     Phone phone = getPhoneFromRequest(request);

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

1115:                         phone = getPhoneFromRequest(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1421:             return request.phone;

1433:         Phone phone = getPhoneFromRequest(request);

1434:         return phone == null ? null :

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

1438:     // returns phone associated with the subId.

1443:     private void sendEraseModemConfig(Phone phone) {

1444:         if (phone != null) {

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

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

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

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

1689:             final Phone phone = getPhone(subId);

1690:             if (phone != null) {

1691:                 phone.updateServiceLocation();

1735:             final Phone phone = getPhone(subId);

1736:             if (phone != null) {

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

1755:             final Phone phone = getPhone(subId);

1756:             if (phone != null) {

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

1773:             final Phone phone = getPhone(subId);

1774:             if (phone == null) {

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

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

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

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

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

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

1823:             phone.shutdownRadio();

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

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

1850:             final Phone phone = getPhone(subId);

1851:             if (phone != null) {

1852:                 phone.setRadioPower(turnOn);

1870:             final Phone phone = getPhone(subId);

1871:             if (phone != null) {

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

1890:             final Phone phone = getPhone(subId);

1891:             if (phone != null) {

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

1906:             final Phone phone = getPhone(subId);

1907:             if (phone != null) {

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

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

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

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

1974:             final Phone phone = getPhone(subId);

1975:             if (phone != null) {

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

1995:             final Phone phone = getPhone(subId);

1996:             if (phone != null) {

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

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

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

2056:                 // Get default phone in this case.

2057:                 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;

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

2068:             if (phone != null) {

2069:                 ServiceStateTracker sst = phone.getServiceStateTracker();

2070:                 EmergencyNumberTracker emergencyNumberTracker = phone.getEmergencyNumberTracker();

2100:             final Phone phone = getPhone(subId);

2101:             if (phone != null) {

2102:                 phone.enableLocationUpdates();

2121:             final Phone phone = getPhone(subId);

2122:             if (phone != null) {

2123:                 phone.disableLocationUpdates();

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

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

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

2224:                         CMD_GET_ALL_CELL_INFO, null, phone, workSource);

2275:         final Phone phone = getPhoneFromSubId(subId);

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

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

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

2297:         if (phone == null) {

2300:         int subId = phone.getSubId();

2308:             return phone.getImei();

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

2318:         if (phone != null) {

2319:             String imei = phone.getImei();

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

2328:         if (phone == null) {

2332:         int subId = phone.getSubId();

2340:             return phone.getMeid();

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

2350:         if (phone != null) {

2351:             String meid = phone.getMeid();

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

2361:         if (phone == null) {

2364:         int subId = phone.getSubId();

2373:             return phone.getDeviceSvn();

2383:             final Phone phone = getPhone(subId);

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

2394:             final Phone phone = getPhone(subId);

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

2405:             final Phone phone = getPhone(subId);

2406:             return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID

2407:                     : phone.getSpecificCarrierId();

2417:             final Phone phone = getPhone(subId);

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

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

2430:         if (phone == null) {

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

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

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

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

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

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

2502:             if (phone == null) {

2503:                 return PhoneConstants.PHONE_TYPE_NONE;

2505:                 return phone.getPhoneType();

2532:             final Phone phone = getPhone(subId);

2533:             if (phone != null) {

2534:                 return phone.getCdmaEriIconIndex();

2565:             final Phone phone = getPhone(subId);

2566:             if (phone != null) {

2567:                 return phone.getCdmaEriIconMode();

2596:             final Phone phone = getPhone(subId);

2597:             if (phone != null) {

2598:                 return phone.getCdmaEriText();

2617:             final Phone phone = getPhone(subId);

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

2619:                 return phone.getLine1Number();

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

2639:             final Phone phone = getPhone(subId);

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

2641:                 return phone.getCdmaMin();

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

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

2818:             final Phone phone = getPhone(subId);

2819:             if (phone != null) {

2820:                 phone.setVoiceActivationState(activationState);

2839:             final Phone phone = getPhone(subId);

2840:             if (phone != null) {

2841:                 phone.setDataActivationState(activationState);

2857:         final Phone phone = getPhone(subId);

2860:             if (phone != null) {

2861:                 return phone.getVoiceActivationState();

2877:         final Phone phone = getPhone(subId);

2880:             if (phone != null) {

2881:                 return phone.getDataActivationState();

2903:             final Phone phone = getPhone(subId);

2904:             if (phone != null) {

2905:                 return phone.getVoiceMessageCount();

2922:             final Phone phone = getPhone(subId);

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

2936:         final Phone defaultPhone = getDefaultPhone();

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

2975:                 if (phone.isInEmergencySmsMode()) {

2986:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3013:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3051:             Phone phone = getPhone(subId);

3052:             if (phone == null) {

3057:             phone.getImsRegistrationState(regState -> {

3084:             Phone phone = getPhone(subId);

3085:             if (phone == null) {

3090:             phone.getImsRegistrationTech(regTech -> {

3109:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3135:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3186:             Phone phone = getPhone(subId);

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

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

3233:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3270:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3304:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3339:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3391:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3473:      * Requires carrier privileges or READ_PRECISE_PHONE_STATE permission.

3540:         Phone phone = getPhone(subId);

3541:         if (phone == null) {

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

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

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

3984:             final Phone phone = getPhone(subId);

3985:             if (phone != null) {

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

4018:             final Phone phone = getPhone(subId);

4019:             if (phone != null) {

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

4043:             final Phone phone = getPhone(subId);

4044:             if (phone != null) {

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

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

4071:             if (phone != null) {

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

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

4088:      * or {@link Phone#LTE_ON_CDMA_TRUE}

4107:             final Phone phone = getPhone(subId);

4108:             if (phone == null) {

4111:                 return phone.getLteOnCdmaMode();

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

4206:     private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,

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

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

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

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

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

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

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

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

4600:         if (phone != null) {

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

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

4626:         if (phone != null) {

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

4644:         final Phone defaultPhone = getDefaultPhone();

5079:         final Phone defaultPhone = getDefaultPhone();

5157:         final Phone phone = getPhone(subId);

5159:             if (phone != null) {

5160:                 return phone.hasMatchedTetherApnSetting();

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

5185:             if (phone != null) {

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

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

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

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

5236:             if (phone != null) {

5237:                 boolean retVal = phone.isUserDataEnabled();

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

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

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

5274:             if (phone != null) {

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

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

5288:             Phone phone) {

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

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

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

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

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

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

5335:         final Phone phone = getPhone(subId);

5336:         if (phone == null) {

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

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

5354:         final Phone phone = getPhone(subId);

5355:         if (phone == null) {

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

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

5472:         final Phone phone = getPhone(subId);

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

5495:             final Phone phone = getPhone(subId);

5496:             if (phone == null) {

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

5722:             final Phone phone = getPhone(subId);

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

5738:             final Phone phone = getPhone(subId);

5739:             if (phone == null) {

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

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

5795:         if (phone == null) {

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

5812:         final Phone defaultPhone = getDefaultPhone();

5826:         final Phone defaultPhone = getDefaultPhone();

5880:                     .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);

5911:         final Phone phone = getPhone(subscriptionId);

5912:         if (phone == null) {

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

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

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

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

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

5962:         if (phone == null) {

5965:         int subId = phone.getSubId();

5973:             return phone.getDeviceId();

5986:         Phone phone = getPhone(subId);

5987:         if (phone != null) {

5988:             return phone.isImsRegistered();

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

6023:             Phone phone = getPhone(subscriptionId);

6024:             if (phone == null) {

6027:             return PhoneUtils.makePstnPhoneAccountHandle(phone);

6039:             Phone phone = getPhone(subId);

6040:             if (phone != null) {

6041:                 return phone.isWifiCallingEnabled();

6056:             Phone phone = getPhone(subId);

6057:             if (phone != null) {

6058:                 return phone.isVideoEnabled();

6074:             Phone phone = getPhone(subId);

6075:             if (phone != null) {

6076:                 return phone.getImsRegistrationTech();

6134:         final Phone phone = getPhone(subId);

6135:         if (phone == null) {

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

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

6310:             final Phone phone = getPhone(subId);

6311:             if (phone == null) {

6315:             ServiceState ss = phone.getServiceState();

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

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

6340:             if (phone == null) {

6341:                 phone = getDefaultPhone();

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

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

6364:         final Phone defaultPhone = getDefaultPhone();

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

6376:             if (phone == null) {

6377:                 phone = defaultPhone;

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

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

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

6397:             if (phone == null) {

6398:                 phone = getDefaultPhone();

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

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

6421:         final Phone defaultPhone = getDefaultPhone();

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

6433:             if (phone == null) {

6434:                 phone = defaultPhone;

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

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

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

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

6496:         Phone phone = getPhone(subId);

6500:             if (phone == null) {

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

6525:         Phone phone = getPhone(subId);

6529:             if (phone == null) {

6534:                 esn = phone.getEsn();

6553:         Phone phone = getPhone(subId);

6557:             if (phone == null) {

6562:                 cdmaPrlVersion = phone.getCdmaPrlVersion();

6656:         final Phone phone = getPhone(subId);

6659:         if (phone == null) {

6664:             phone.carrierActionSetMeteredApnsEnabled(enabled);

6681:         final Phone phone = getPhone(subId);

6684:         if (phone == null) {

6689:             phone.carrierActionSetRadioEnabled(enabled);

6709:         final Phone phone = getPhone(subId);

6712:         if (phone == null) {

6717:             phone.carrierActionReportDefaultNetworkStatus(report);

6733:         final Phone phone = getPhone(subId);

6734:         if (phone == null) {

6739:             phone.carrierActionResetAll();

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

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

6788:             Phone phone = getPhone(subId);

6789:             if (phone != null) {

6790:                 return phone.getVtDataUsage(perUidStats);

6810:             Phone phone = getPhone(subId);

6811:             if (phone != null) {

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

6831:         Phone phone = getPhone(subId);

6835:             if (phone != null) {

6836:                 return phone.getClientRequestStats();

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

6869:             if (phone != null) {

6870:                 phone.setSimPowerState(state, workSource);

6892:      * Check if phone is in emergency callback mode

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

6899:         final Phone phone = getPhone(subId);

6903:             if (phone != null) {

6904:                 return phone.isInEcm();

6924:             Phone p = getPhone(subId);

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

6945:         if (phone != null) {

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

6953:                 return phone.getRadioPowerState();

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

6981:             Phone phone = getPhone(subId);

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

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

7010:             Phone phone = getPhone(subId);

7011:             if (phone != null) {

7012:                 phone.setDataRoamingEnabled(isEnabled);

7028:             Phone phone = getPhone(subId);

7029:             if (phone != null) {

7030:                 isAllowed = phone.isCspPlmnEnabled();

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

7181:         final Phone phone = getPhone(subId);

7182:         if (phone == null) {

7189:             phone.setRadioIndicationUpdateMode(filters, mode);

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

7208:             Phone phone = getPhone(subId);

7209:             if (phone == null) {

7212:             UiccCard uiccCard = phone.getUiccCard();

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

7257:         return Phone.PREFERRED_NT_MODE;

7267:             final Phone phone = getPhone(subId);

7268:             if (phone == null) {

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

7285:             final Phone phone = getPhone(subId);

7286:             if (phone == null) {

7290:             return phone.getCarrierIdListVersion();

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

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

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

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

7367:                             phone.getSubId(),

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

7379:         final Phone defaultPhone = getDefaultPhone();

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

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

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

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

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

7413:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7435:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7454:             final Phone phone = getPhone(subId);

7455:             if (phone == null) {

7459:             return phone.getEmergencyNumberDbVersion();

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

7472:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

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

7489:                 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();

7502:         Phone phone = getPhone(subId);

7503:         if (phone == null) {

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

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

7529:             if (phone == null) {

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

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

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

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

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

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

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

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

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

7657:         Phone phone = getPhone(subId);

7658:         if (phone == null) {

7663:             UiccCard uiccCard = phone.getUiccCard();

7733:         Phone phone = getDefaultPhone();

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

7735:         HalVersion hv = phone.getHalVersion();

7756:         enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "

7762:             Phone phone = getPhone(subId);

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

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

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

7779:             Phone phone = getPhone(subId);

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

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

7847:             Phone phone = getPhone(subId);

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

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

7863:             Phone phone = getPhone(subId);

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

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

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

7885:                 Phone defaultPhone = phone.getImsPhone();

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

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

64: import android.telecom.PhoneAccount;

65: import android.telecom.PhoneAccountHandle;

83: import android.telephony.PhoneCapability;

84: import android.telephony.PhoneNumberRange;

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

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

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

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

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

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

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

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

278:     private static PhoneInterfaceManager sInstance;

280:     private PhoneGlobals mApp;

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

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

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

719:                     defaultPhone.resetModemConfig(onCompleted);

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

861:                     if (defaultPhone != null) {

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

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

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

1127:                     defaultPhone.rebootModem(onCompleted);

1137:                     PhoneConfigurationManager.getInstance()

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

1158:                     PhoneConfigurationManager.getInstance()

1229:                     defaultPhone.eraseModemConfig(onCompleted);

1377:      * Initialize the singleton PhoneInterfaceManager instance.

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

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

1381:         synchronized (PhoneInterfaceManager.class) {

1383:                 sInstance = new PhoneInterfaceManager(app);

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

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

1403:         mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();

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

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

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

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

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

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

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

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

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

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

1588:         private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1618:                                             mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;

1620:                                             mResult = PhoneConstants.PIN_GENERAL_FAILURE;

1623:                                         mResult = PhoneConstants.PIN_RESULT_SUCCESS;

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

1833:             if (defaultPhone != null) {

1834:                 defaultPhone.setRadioPower(turnOn);

1978:                 return PhoneConstantConversions.convertDataState(

1979:                         PhoneConstants.DataState.DISCONNECTED);

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

2046:                     callingFeatureId, "getNetworkCountryIsoForPhone")) {

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

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

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

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

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

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

2680:             return getDefaultPhone().needsOtaServiceProvisioning();

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

2716:             if (phoneAccountHandle == null) {

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

2803:         SmsController smsController = PhoneFactory.getSmsController();

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

2947:             defaultPhone.sendDialerSpecialCode(inputCode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4102:             return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

4109:                 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;

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

4173:         if (phoneId == -1) {

4177:         return PhoneFactory.getPhone(phoneId);

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

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

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

4652:             return defaultPhone.getPcscfAddress(apnType);

4882:             getDefaultPhone().setImsRegistrationState(registered);

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

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

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

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

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

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

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

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

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

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

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

5384:             getPhone(phoneId), pkgName);

5401:                 getPhone(i), pkgName);

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

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

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

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

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

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

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

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

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

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

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

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

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

5998:             return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);

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

6013:             return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);

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

6118:               sendEraseModemConfig(getDefaultPhone());

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

6333:      * PhoneAccount.

6336:     public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {

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

6359:      * PhoneAccount.

6363:             PhoneAccountHandle phoneAccountHandle, Uri uri) {

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

6369:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

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

6393:     public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {

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

6416:      * specific PhoneAccount.

6420:             PhoneAccountHandle phoneAccountHandle, boolean enabled) {

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

6426:                     mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),

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

7047:             if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)

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

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

7255:             return list.get(phoneId);

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

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

7607:         PhoneCapability staticCapability =

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

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

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

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

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

7887:                     ImsPhone imsPhone = (ImsPhone) defaultPhone;

7889:                             (ImsPhoneCallTracker) imsPhone.getCallTracker();

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

7892:                             + imsPhone.getMsisdn());

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

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

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

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

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

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

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

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

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

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

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

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

1168:                         mPhoneConfigurationManager.addToPhoneStatusCache(id,

1423:             return getPhoneFromSubId(request.subId);

1719:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

1813:                 shutdownRadioUsingPhoneId(i);

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

2365:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2494:         return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());

2524:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2557:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2588:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2729:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2896:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

2956:                     .enforeceCallingOrSelfReadPrecisePhoneStatePermissionOrCarrierPrivilege(

2993:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3019:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3076:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3116:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3141:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3238:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3275:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3309:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3344:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3396:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3478:         //TODO: b/147498511 will add TelephonyPermissions#checkCallingOrSelfReadPrecisePhoneState

3560:         checkModifyPhoneStatePermission(subId, "setRcsProvisioningStatusForCapability");

3624:         checkModifyPhoneStatePermission(subId, "setImsProvisioningStatusForCapability");

3976:                 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(

4010:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4035:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

4099:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

4202:         return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

4244:         return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),

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

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

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

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

4427:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

4825:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5103:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

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

5456:         enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");

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

5542:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(

5569:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5592:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5801:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

5851:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

5870:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

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

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

6274:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6827:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

6984:             TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(

7022:                 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7146:                         slot.getPhoneId(),

7299:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7307:             return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();

7355:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7382:                     .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(

7548:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7583:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,

7608:                 mPhoneConfigurationManager.getStaticPhoneCapability();

7648:             mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);

7688:         if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(

7695:             return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();

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

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

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

7888:                     ImsPhoneCallTracker imsPhoneCallTracker =

7890:                     imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);

114: public abstract class Phone extends Handler implements PhoneInternalInterface {

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

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

307:     protected Phone mImsPhone = null;

565:     public void createImsPhone() {

3407:     public Phone getImsPhone() {

4056:     public Phone getDefaultPhone() {

190:     protected static final int EVENT_UPDATE_PHONE_OBJECT            = 42;

277:     protected boolean mIsPhoneInEcmState = false;

304:     protected int mPhoneId;

411:     public String getPhoneName() {

415:     protected void setPhoneName(String name) {

1742:     public void updatePhoneObject(int voiceRadioTech) {

2527:     public abstract int getPhoneType();

3521:     public int getPhoneId() {

3529:     public int getVoicePhoneServiceState() {

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

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

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

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

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

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

407:      *  outside the phone app process.

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

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

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

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

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

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

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

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

570:         synchronized(Phone.lockForRadioTechnologyChange) {

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

635:         // resources of the phone being destroyed

755:         Phone imsPhone = mImsPhone;

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

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

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

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

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

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

967:     protected void migrateFrom(Phone from) {

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

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

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

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

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

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

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

1636:         // no need for regular phone

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

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

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

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

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

1703:      * then the phone state is RINGING not OFFHOOK

1712:      * Retrieves the IccFileHandler of the Phone instance

1731:      * Retrieves the Handler of the Phone instance

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

1746:     * Retrieves the ServiceStateTracker of the phone instance.

1754:      * Retrieves the EmergencyNumberTracker of the phone instance.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2524:      * @return PHONE_TYPE_XXX as defined above.

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

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

3239:      * Notify registrants if phone is video capable.

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

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

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

3404:      * Return an instance of a IMS phone

3518:      * Returns the phone id.

3530:         Phone imsPhone = mImsPhone;

3604:         Phone imsPhone = mImsPhone;

3623:         Phone imsPhone = mImsPhone;

3637:         Phone imsPhone = mImsPhone;

3651:         Phone imsPhone = mImsPhone;

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

3665:         Phone imsPhone = mImsPhone;

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

3679:         Phone imsPhone = mImsPhone;

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

3691:         Phone imsPhone = mImsPhone;

3749:      *  Set phone radio capability

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

3760:      *  Get phone radio access family

3780:      *  Get phone radio capability

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

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

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

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

3879:         Phone imsPhone = mImsPhone;

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

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

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

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

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

4116:             if (phone != null) {

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

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

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

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

52: import android.telephony.PhoneStateListener;

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

108:  * originally called PhoneFactory to obtain the interface.

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

395:     protected PhoneNotifier mNotifier;

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

489:                     boolean unitTestMode, int phoneId,

491:         mPhoneId = phoneId;

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

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

571:             if (mImsPhone == null) {

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

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

574:                 mImsPhone.registerForSilentRedial(

649:                     PhoneConstants.State state = getState();

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

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

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

681:                         if (mImsPhone != null) {

683:                             mImsPhone.notifyRedialConnectionChanged(cn);

687:                         if (mImsPhone != null) {

688:                             mImsPhone.notifyRedialConnectionChanged(null);

762:                     if (imsPhone != null) {

763:                         conn = imsPhone.getHandoverConnection();

764:                         migrateFrom(imsPhone);

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

771:                     if (imsPhone != null) {

772:                         imsPhone.notifySrvccState(srvccState);

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

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

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

1709:     public abstract PhoneConstants.State getState();

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

1894:      * PhoneStateListener.onCellInfoChanged} will be invoked.

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

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

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

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

2380:         return PhoneConstants.DataState.DISCONNECTED;

2455:     // phones

2513:         if (mImsPhone != null) {

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

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

2516:                     isVideoCallOrConference(mImsPhone.getRingingCall());

2660:      * Retrieves the MIN for CDMA phones.

2676:      *  Retrieves PRL Version for CDMA phones

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

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

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

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

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

3326:     public PhoneConstants.DataState getDataConnectionState() {

3327:         return getDataConnectionState(PhoneConstants.APN_TYPE_DEFAULT);

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

3345:      * or {@link PhoneConstants#LTE_ON_CDMA_TRUE}

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

3408:         return mImsPhone;

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

3478:         if (mImsPhone != null) {

3479:             return mImsPhone.isUtEnabled();

3498:         // dialInternal shall be overriden by GsmCdmaPhone

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

3531:         if (imsPhone != null

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

3606:         if (imsPhone != null) {

3607:             isImsRegistered = imsPhone.isImsRegistered();

3625:         if (imsPhone != null) {

3626:             isWifiCallingEnabled = imsPhone.isWifiCallingEnabled();

3639:         if (imsPhone != null) {

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

3653:         if (imsPhone != null) {

3654:             isVolteEnabled = imsPhone.isVolteEnabled();

3667:         if (imsPhone != null) {

3668:             regTech = imsPhone.getImsRegistrationTech();

3680:         if (imsPhone != null) {

3681:             imsPhone.getImsRegistrationTech(callback);

3692:         if (imsPhone != null) {

3693:             imsPhone.getImsRegistrationState(callback);

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

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

3865:         if (mImsPhone == null) {

3869:         return mImsPhone.isImsAvailable();

3880:         if (imsPhone != null) {

3881:             return imsPhone.isVideoEnabled();

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

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

4068:         if (mImsPhone == null) return null;

4069:         return mImsPhone.getVtDataUsage(perUidStats);

4209:         if (mImsPhone != null) {

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

391:      * state change notification. DefaultPhoneNotifier is

464:      * @param notifier An instance of DefaultPhoneNotifier,

480:      * @param notifier An instance of DefaultPhoneNotifier,

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

2466:         return mIsPhoneInEcmState;

2473:         mIsPhoneInEcmState = isInEcm;

2499:         if (call instanceof ImsPhoneCall) {

2500:             ImsPhoneCall imsPhoneCall = (ImsPhoneCall) call;

2501:             ImsCall imsCall = imsPhoneCall.getImsCall();

2555:                 mPhoneId, UiccController.APP_FAM_3GPP);

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

3378:         return mUiccController.getUiccCard(mPhoneId);

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

3522:         return mPhoneId;

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

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

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

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

3: public class Phone {

5072:         PHONE = 9;

2311:         HARDWARE_FAILED_MICROPHONE = 1;

2481: message PhoneSignalStrengthChanged {

2493: message PhoneServiceStateChanged {

2505: message PhoneStateChanged {

116:         PhoneSignalStrengthChanged phone_signal_strength_changed = 40;

170:         PhoneServiceStateChanged phone_service_state_changed = 94;

171:         PhoneStateChanged phone_state_changed = 95;

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

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

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

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

2476:  * Logs phone signal strength changes.

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

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

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

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

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

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

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

6095:  * Track how we arbitrate between microphone requests.

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

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

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