blob: 9d6cc837e0a88546bcd249a40ceebd82ff2cb6ee [file] [log] [blame]
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.phone;
18
Hall Liud892bec2018-11-30 14:51:45 -080019import static android.content.pm.PackageManager.PERMISSION_GRANTED;
20
Tyler Gunn7bcdc742019-10-04 15:56:59 -070021import static com.android.internal.telephony.PhoneConstants.PHONE_TYPE_IMS;
Ta-wei Yen87c49842016-05-13 21:19:52 -070022import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
23
Ta-wei Yen30a69c82016-12-27 14:52:32 -080024import android.Manifest.permission;
Tyler Gunnf70ed162019-04-03 15:28:53 -070025import android.annotation.Nullable;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070026import android.app.AppOpsManager;
Ta-wei Yen30a69c82016-12-27 14:52:32 -080027import android.app.PendingIntent;
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -070028import android.content.ComponentName;
Amit Mahajan7dbbd822019-03-13 17:33:47 -070029import android.content.ContentResolver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070030import android.content.Context;
31import android.content.Intent;
Derek Tan97ebb422014-09-05 16:55:38 -070032import android.content.SharedPreferences;
Nathan Harold31d7ff32018-10-15 20:20:30 -070033import android.content.pm.ApplicationInfo;
Derek Tan740e1672017-06-27 14:56:27 -070034import android.content.pm.ComponentInfo;
Amith Yamasani6e118872016-02-19 12:53:51 -080035import android.content.pm.PackageInfo;
Shishir Agrawal60f9c952014-06-23 12:00:43 -070036import android.content.pm.PackageManager;
Jack Yu84291ec2017-05-26 16:07:50 -070037import android.net.NetworkStats;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070038import android.net.Uri;
39import android.os.AsyncResult;
40import android.os.Binder;
Hall Liuf19c44f2018-11-27 14:38:17 -080041import android.os.Build;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070042import android.os.Bundle;
43import android.os.Handler;
yinxu504e1392017-04-12 16:03:22 -070044import android.os.IBinder;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070045import android.os.Looper;
46import android.os.Message;
yinxu504e1392017-04-12 16:03:22 -070047import android.os.Messenger;
Malcolm Chen6ca97372019-07-01 16:28:21 -070048import android.os.ParcelUuid;
Tyler Gunn65d45c22017-06-05 11:22:26 -070049import android.os.PersistableBundle;
Brad Ebinger5f64b052017-12-14 14:26:15 -080050import android.os.RemoteException;
Adam Lesinski903a54c2016-04-11 14:49:52 -070051import android.os.ResultReceiver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070052import android.os.ServiceManager;
Brad Ebinger1ce9c432019-07-16 13:19:44 -070053import android.os.ServiceSpecificException;
Brad Ebingerdac2f002018-04-03 15:17:52 -070054import android.os.ShellCallback;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070055import android.os.UserHandle;
Stuart Scott981d8582015-04-21 14:09:50 -070056import android.os.UserManager;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070057import android.os.WorkSource;
Derek Tan97ebb422014-09-05 16:55:38 -070058import android.preference.PreferenceManager;
Naina Nallurid63128d2019-09-17 14:10:30 -070059import android.provider.DeviceConfig;
Ihab Awadf2177b72013-11-25 13:33:23 -080060import android.provider.Settings;
Amit Mahajan7dbbd822019-03-13 17:33:47 -070061import android.provider.Telephony;
Inseob Kim14bb3d02018-12-13 17:11:34 +090062import android.sysprop.TelephonyProperties;
Santos Cordon7a1885b2015-02-03 11:15:19 -080063import android.telecom.PhoneAccount;
Nancy Chen31f9ba12016-01-06 11:42:12 -080064import android.telecom.PhoneAccountHandle;
Andrew Lee9431b832015-03-09 18:46:45 -070065import android.telecom.TelecomManager;
Chen Xu227e06f2019-09-26 22:48:11 -070066import android.telephony.Annotation.ApnType;
Junda Liu12f7d802015-05-01 12:06:44 -070067import android.telephony.CarrierConfigManager;
Michele Berionne482f8202018-11-27 18:57:59 -080068import android.telephony.CarrierRestrictionRules;
yincheng zhao2737e882019-09-06 17:06:54 -070069import android.telephony.CellIdentity;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070070import android.telephony.CellInfo;
Nathan Haroldf180aac2018-06-01 18:43:55 -070071import android.telephony.CellInfoGsm;
72import android.telephony.CellInfoWcdma;
Nathan Harold3ff88932018-08-14 10:19:49 -070073import android.telephony.CellLocation;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070074import android.telephony.ClientRequestStats;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -070075import android.telephony.ICellInfoCallback;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -070076import android.telephony.IccOpenLogicalChannelResponse;
Hall Liu1aa510f2017-11-22 17:40:08 -080077import android.telephony.LocationAccessPolicy;
Ta-wei Yen87c49842016-05-13 21:19:52 -070078import android.telephony.ModemActivityInfo;
Jake Hambye994d462014-02-03 13:10:13 -080079import android.telephony.NeighboringCellInfo;
yinxu504e1392017-04-12 16:03:22 -070080import android.telephony.NetworkScanRequest;
Michele4245e952019-02-04 11:36:23 -080081import android.telephony.PhoneCapability;
Hall Liud892bec2018-11-30 14:51:45 -080082import android.telephony.PhoneNumberRange;
Wink Saville5d475dd2014-10-17 15:00:58 -070083import android.telephony.RadioAccessFamily;
Hall Liub2ac8ef2019-02-28 15:56:23 -080084import android.telephony.RadioAccessSpecifier;
Tyler Gunn65d45c22017-06-05 11:22:26 -070085import android.telephony.Rlog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070086import android.telephony.ServiceState;
Nathan Harold46b42aa2017-03-10 19:38:22 -080087import android.telephony.SignalStrength;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080088import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080089import android.telephony.SubscriptionManager;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070090import android.telephony.TelephonyHistogram;
Ta-wei Yenb6929602016-05-24 15:48:27 -070091import android.telephony.TelephonyManager;
Hall Liub2ac8ef2019-02-28 15:56:23 -080092import android.telephony.TelephonyScanManager;
Jordan Liu5aa07002018-12-18 15:44:48 -080093import android.telephony.UiccCardInfo;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +000094import android.telephony.UiccSlotInfo;
Tyler Gunn65d45c22017-06-05 11:22:26 -070095import android.telephony.UssdResponse;
Ta-wei Yenb6929602016-05-24 15:48:27 -070096import android.telephony.VisualVoicemailSmsFilterSettings;
Nathan Harold3ff88932018-08-14 10:19:49 -070097import android.telephony.cdma.CdmaCellLocation;
Jack Yub5d8f642018-11-26 11:20:48 -080098import android.telephony.data.ApnSetting;
99import android.telephony.emergency.EmergencyNumber;
Nathan Harold3ff88932018-08-14 10:19:49 -0700100import android.telephony.gsm.GsmCellLocation;
Brad Ebinger1ce9c432019-07-16 13:19:44 -0700101import android.telephony.ims.ImsException;
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800102import android.telephony.ims.ProvisioningManager;
Brad Ebingera34a6c22019-10-22 17:36:18 -0700103import android.telephony.ims.RegistrationManager;
Brad Ebinger35c841c2018-10-01 10:40:55 -0700104import android.telephony.ims.aidl.IImsCapabilityCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -0800105import android.telephony.ims.aidl.IImsConfig;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -0700106import android.telephony.ims.aidl.IImsConfigCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -0800107import android.telephony.ims.aidl.IImsMmTelFeature;
108import android.telephony.ims.aidl.IImsRcsFeature;
109import android.telephony.ims.aidl.IImsRegistration;
Brad Ebinger35c841c2018-10-01 10:40:55 -0700110import android.telephony.ims.aidl.IImsRegistrationCallback;
Brad Ebingerbc7dd582019-10-17 17:03:22 -0700111import android.telephony.ims.feature.ImsFeature;
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800112import android.telephony.ims.feature.MmTelFeature;
113import android.telephony.ims.stub.ImsConfigImplBase;
Brad Ebinger1f2b5082018-02-08 16:11:32 -0800114import android.telephony.ims.stub.ImsRegistrationImplBase;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700115import android.text.TextUtils;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800116import android.util.ArraySet;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700117import android.util.Log;
Jake Hambye994d462014-02-03 13:10:13 -0800118import android.util.Pair;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800119import android.util.Slog;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800120
Andrew Lee312e8172014-10-23 17:01:36 -0700121import com.android.ims.ImsManager;
Brad Ebinger34bef922017-11-09 10:27:08 -0800122import com.android.ims.internal.IImsServiceFeatureCallback;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700123import com.android.internal.telephony.CallManager;
Tyler Gunn52dcf772017-04-26 11:30:31 -0700124import com.android.internal.telephony.CallStateException;
pkanwar79ec0542017-07-31 14:10:01 -0700125import com.android.internal.telephony.CarrierInfoManager;
chen xu651eec72018-11-11 19:03:44 -0800126import com.android.internal.telephony.CarrierResolver;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700127import com.android.internal.telephony.CellNetworkScanResult;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700128import com.android.internal.telephony.CommandException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700129import com.android.internal.telephony.DefaultPhoneNotifier;
Nathan Harold48d6fd52019-02-06 19:01:40 -0800130import com.android.internal.telephony.HalVersion;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700131import com.android.internal.telephony.IIntegerConsumer;
Hall Liud892bec2018-11-30 14:51:45 -0800132import com.android.internal.telephony.INumberVerificationCallback;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700133import com.android.internal.telephony.ITelephony;
Jake Hambye994d462014-02-03 13:10:13 -0800134import com.android.internal.telephony.IccCard;
Jack Yu5f7092c2018-04-13 14:05:37 -0700135import com.android.internal.telephony.LocaleTracker;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100136import com.android.internal.telephony.MccTable;
yinxub1bed742017-04-17 11:45:04 -0700137import com.android.internal.telephony.NetworkScanRequestTracker;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700138import com.android.internal.telephony.OperatorInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700139import com.android.internal.telephony.Phone;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700140import com.android.internal.telephony.PhoneConfigurationManager;
Nathan Harolda667c152016-12-14 11:27:20 -0800141import com.android.internal.telephony.PhoneConstantConversions;
Ta-wei Yen87c49842016-05-13 21:19:52 -0700142import com.android.internal.telephony.PhoneConstants;
Wink Saville36469e72014-06-11 15:17:00 -0700143import com.android.internal.telephony.PhoneFactory;
Wink Saville5d475dd2014-10-17 15:00:58 -0700144import com.android.internal.telephony.ProxyController;
Sanket Padawe99ef1e32016-05-18 16:12:33 -0700145import com.android.internal.telephony.RIL;
Svet Ganovb320e182015-04-16 12:30:10 -0700146import com.android.internal.telephony.RILConstants;
Jack Yu5f7092c2018-04-13 14:05:37 -0700147import com.android.internal.telephony.ServiceStateTracker;
Amit Mahajandccb3f12019-05-13 13:48:32 -0700148import com.android.internal.telephony.SmsController;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700149import com.android.internal.telephony.SmsPermissions;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800150import com.android.internal.telephony.SubscriptionController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800151import com.android.internal.telephony.TelephonyPermissions;
Malcolm Chendc8c10e2019-04-10 18:25:07 -0700152import com.android.internal.telephony.dataconnection.ApnSettingUtils;
sqianf4ca7ed2019-01-15 18:32:07 -0800153import com.android.internal.telephony.emergency.EmergencyNumberTracker;
Derek Tan740e1672017-06-27 14:56:27 -0700154import com.android.internal.telephony.euicc.EuiccConnector;
Brad Ebinger9c0eb502019-01-23 15:06:19 -0800155import com.android.internal.telephony.ims.ImsResolver;
Tyler Gunn7bcdc742019-10-04 15:56:59 -0700156import com.android.internal.telephony.imsphone.ImsPhone;
157import com.android.internal.telephony.imsphone.ImsPhoneCallTracker;
Pengquan Meng6c2dc9f2019-02-06 11:12:53 -0800158import com.android.internal.telephony.metrics.TelephonyMetrics;
Meng Wangafbc5852019-09-19 17:37:13 -0700159import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppType;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700160import com.android.internal.telephony.uicc.IccIoResult;
161import com.android.internal.telephony.uicc.IccUtils;
Nathan Haroldb3014052017-01-25 15:57:32 -0800162import com.android.internal.telephony.uicc.SIMRecords;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700163import com.android.internal.telephony.uicc.UiccCard;
Nathan Haroldb3014052017-01-25 15:57:32 -0800164import com.android.internal.telephony.uicc.UiccCardApplication;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700165import com.android.internal.telephony.uicc.UiccController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800166import com.android.internal.telephony.uicc.UiccProfile;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000167import com.android.internal.telephony.uicc.UiccSlot;
fionaxu7ed723d2017-05-30 18:58:54 -0700168import com.android.internal.telephony.util.VoicemailNotificationSettingsUtil;
Jake Hambye994d462014-02-03 13:10:13 -0800169import com.android.internal.util.HexDump;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700170import com.android.phone.settings.PickSmsSubscriptionActivity;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700171import com.android.phone.vvm.PhoneAccountHandleConverter;
Ta-wei Yen527a9c02017-01-06 15:29:25 -0800172import com.android.phone.vvm.RemoteVvmTaskManager;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700173import com.android.phone.vvm.VisualVoicemailSettingsUtil;
Ta-wei Yenc8905312017-03-28 11:14:45 -0700174import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800175
Ta-wei Yenc236d6b2016-06-21 13:33:12 -0700176import java.io.FileDescriptor;
177import java.io.PrintWriter;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700178import java.util.ArrayList;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800179import java.util.Arrays;
sqian11b7a0e2018-12-05 18:48:28 -0800180import java.util.HashMap;
sqianf4ca7ed2019-01-15 18:32:07 -0800181import java.util.HashSet;
Jake Hambye994d462014-02-03 13:10:13 -0800182import java.util.List;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100183import java.util.Locale;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800184import java.util.Map;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700185import java.util.NoSuchElementException;
sqianf4ca7ed2019-01-15 18:32:07 -0800186import java.util.Set;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700187
188/**
189 * Implementation of the ITelephony interface.
190 */
Santos Cordon117fee72014-05-16 17:56:12 -0700191public class PhoneInterfaceManager extends ITelephony.Stub {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700192 private static final String LOG_TAG = "PhoneInterfaceManager";
193 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
194 private static final boolean DBG_LOC = false;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800195 private static final boolean DBG_MERGE = false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700196
197 // Message codes used with mMainThreadHandler
198 private static final int CMD_HANDLE_PIN_MMI = 1;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700199 private static final int CMD_TRANSMIT_APDU_LOGICAL_CHANNEL = 7;
200 private static final int EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE = 8;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700201 private static final int CMD_OPEN_CHANNEL = 9;
202 private static final int EVENT_OPEN_CHANNEL_DONE = 10;
203 private static final int CMD_CLOSE_CHANNEL = 11;
204 private static final int EVENT_CLOSE_CHANNEL_DONE = 12;
Jake Hambye994d462014-02-03 13:10:13 -0800205 private static final int CMD_NV_READ_ITEM = 13;
206 private static final int EVENT_NV_READ_ITEM_DONE = 14;
207 private static final int CMD_NV_WRITE_ITEM = 15;
208 private static final int EVENT_NV_WRITE_ITEM_DONE = 16;
209 private static final int CMD_NV_WRITE_CDMA_PRL = 17;
210 private static final int EVENT_NV_WRITE_CDMA_PRL_DONE = 18;
chen xu6dac5ab2018-10-26 17:39:23 -0700211 private static final int CMD_RESET_MODEM_CONFIG = 19;
212 private static final int EVENT_RESET_MODEM_CONFIG_DONE = 20;
Jake Hamby7c27be32014-03-03 13:25:59 -0800213 private static final int CMD_GET_PREFERRED_NETWORK_TYPE = 21;
214 private static final int EVENT_GET_PREFERRED_NETWORK_TYPE_DONE = 22;
215 private static final int CMD_SET_PREFERRED_NETWORK_TYPE = 23;
216 private static final int EVENT_SET_PREFERRED_NETWORK_TYPE_DONE = 24;
Sailesh Nepal35b59452014-03-06 09:26:56 -0800217 private static final int CMD_SEND_ENVELOPE = 25;
218 private static final int EVENT_SEND_ENVELOPE_DONE = 26;
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000219 private static final int CMD_INVOKE_OEM_RIL_REQUEST_RAW = 27;
220 private static final int EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE = 28;
Derek Tan6b088ee2014-09-05 14:15:18 -0700221 private static final int CMD_TRANSMIT_APDU_BASIC_CHANNEL = 29;
222 private static final int EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE = 30;
223 private static final int CMD_EXCHANGE_SIM_IO = 31;
224 private static final int EVENT_EXCHANGE_SIM_IO_DONE = 32;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800225 private static final int CMD_SET_VOICEMAIL_NUMBER = 33;
226 private static final int EVENT_SET_VOICEMAIL_NUMBER_DONE = 34;
Stuart Scott54788802015-03-30 13:18:01 -0700227 private static final int CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC = 35;
228 private static final int EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE = 36;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700229 private static final int CMD_GET_MODEM_ACTIVITY_INFO = 37;
230 private static final int EVENT_GET_MODEM_ACTIVITY_INFO_DONE = 38;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700231 private static final int CMD_PERFORM_NETWORK_SCAN = 39;
232 private static final int EVENT_PERFORM_NETWORK_SCAN_DONE = 40;
233 private static final int CMD_SET_NETWORK_SELECTION_MODE_MANUAL = 41;
234 private static final int EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE = 42;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700235 private static final int CMD_SET_ALLOWED_CARRIERS = 43;
236 private static final int EVENT_SET_ALLOWED_CARRIERS_DONE = 44;
237 private static final int CMD_GET_ALLOWED_CARRIERS = 45;
238 private static final int EVENT_GET_ALLOWED_CARRIERS_DONE = 46;
pkanwar32d516d2016-10-14 19:37:38 -0700239 private static final int CMD_HANDLE_USSD_REQUEST = 47;
Nathan Haroldb3014052017-01-25 15:57:32 -0800240 private static final int CMD_GET_FORBIDDEN_PLMNS = 48;
241 private static final int EVENT_GET_FORBIDDEN_PLMNS_DONE = 49;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000242 private static final int CMD_SWITCH_SLOTS = 50;
243 private static final int EVENT_SWITCH_SLOTS_DONE = 51;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700244 private static final int CMD_GET_NETWORK_SELECTION_MODE = 52;
245 private static final int EVENT_GET_NETWORK_SELECTION_MODE_DONE = 53;
246 private static final int CMD_GET_CDMA_ROAMING_MODE = 54;
247 private static final int EVENT_GET_CDMA_ROAMING_MODE_DONE = 55;
248 private static final int CMD_SET_CDMA_ROAMING_MODE = 56;
249 private static final int EVENT_SET_CDMA_ROAMING_MODE_DONE = 57;
250 private static final int CMD_SET_CDMA_SUBSCRIPTION_MODE = 58;
251 private static final int EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE = 59;
Nathan Harold3ff88932018-08-14 10:19:49 -0700252 private static final int CMD_GET_ALL_CELL_INFO = 60;
253 private static final int EVENT_GET_ALL_CELL_INFO_DONE = 61;
254 private static final int CMD_GET_CELL_LOCATION = 62;
255 private static final int EVENT_GET_CELL_LOCATION_DONE = 63;
chen xu6dac5ab2018-10-26 17:39:23 -0700256 private static final int CMD_MODEM_REBOOT = 64;
257 private static final int EVENT_CMD_MODEM_REBOOT_DONE = 65;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -0700258 private static final int CMD_REQUEST_CELL_INFO_UPDATE = 66;
259 private static final int EVENT_REQUEST_CELL_INFO_UPDATE_DONE = 67;
Malcolm Chen8e4ed912019-01-15 20:22:16 -0800260 private static final int CMD_REQUEST_ENABLE_MODEM = 68;
261 private static final int EVENT_ENABLE_MODEM_DONE = 69;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700262 private static final int CMD_GET_MODEM_STATUS = 70;
263 private static final int EVENT_GET_MODEM_STATUS_DONE = 71;
yincheng zhao2737e882019-09-06 17:06:54 -0700264 private static final int CMD_SET_FORBIDDEN_PLMNS = 72;
265 private static final int EVENT_SET_FORBIDDEN_PLMNS_DONE = 73;
Naina Nallurid63128d2019-09-17 14:10:30 -0700266 private static final int CMD_ERASE_MODEM_CONFIG = 74;
267 private static final int EVENT_ERASE_MODEM_CONFIG_DONE = 75;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700268
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -0800269 // Parameters of select command.
270 private static final int SELECT_COMMAND = 0xA4;
271 private static final int SELECT_P1 = 0x04;
272 private static final int SELECT_P2 = 0;
273 private static final int SELECT_P3 = 0x10;
274
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700275 /** The singleton instance. */
276 private static PhoneInterfaceManager sInstance;
277
Wink Saville3ab207e2014-11-20 13:07:20 -0800278 private PhoneGlobals mApp;
Wink Saville3ab207e2014-11-20 13:07:20 -0800279 private CallManager mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700280 private UserManager mUserManager;
Wink Saville3ab207e2014-11-20 13:07:20 -0800281 private AppOpsManager mAppOps;
282 private MainThreadHandler mMainThreadHandler;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800283 private SubscriptionController mSubscriptionController;
Wink Saville3ab207e2014-11-20 13:07:20 -0800284 private SharedPreferences mTelephonySharedPreferences;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700285 private PhoneConfigurationManager mPhoneConfigurationManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700286
Derek Tan97ebb422014-09-05 16:55:38 -0700287 private static final String PREF_CARRIERS_ALPHATAG_PREFIX = "carrier_alphtag_";
288 private static final String PREF_CARRIERS_NUMBER_PREFIX = "carrier_number_";
Jeff Sharkey85190e62014-12-05 09:40:12 -0800289 private static final String PREF_CARRIERS_SUBSCRIBER_PREFIX = "carrier_subscriber_";
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800290 private static final String PREF_PROVISION_IMS_MMTEL_PREFIX = "provision_ims_mmtel_";
Derek Tan89e89d42014-07-08 17:00:10 -0700291
Michelecea4cf22018-12-21 15:00:11 -0800292 // String to store multi SIM allowed
293 private static final String PREF_MULTI_SIM_RESTRICTED = "multisim_restricted";
294
Derek Tan740e1672017-06-27 14:56:27 -0700295 // The AID of ISD-R.
296 private static final String ISDR_AID = "A0000005591010FFFFFFFF8900000100";
297
yinxub1bed742017-04-17 11:45:04 -0700298 private NetworkScanRequestTracker mNetworkScanRequestTracker;
299
David Kelly5e06a7f2018-03-12 14:10:59 +0000300 private static final int TYPE_ALLOCATION_CODE_LENGTH = 8;
301 private static final int MANUFACTURER_CODE_LENGTH = 8;
302
Derek Tan89e89d42014-07-08 17:00:10 -0700303 /**
Naina Nallurid63128d2019-09-17 14:10:30 -0700304 * Experiment flag to enable erase modem config on reset network, default value is false
305 */
306 public static final String RESET_NETWORK_ERASE_MODEM_CONFIG_ENABLED =
307 "reset_network_erase_modem_config_enabled";
308
309 /**
Shishir Agrawal566b7612013-10-28 14:41:00 -0700310 * A request object to use for transmitting data to an ICC.
311 */
312 private static final class IccAPDUArgument {
313 public int channel, cla, command, p1, p2, p3;
314 public String data;
315
316 public IccAPDUArgument(int channel, int cla, int command,
317 int p1, int p2, int p3, String data) {
318 this.channel = channel;
319 this.cla = cla;
320 this.command = command;
321 this.p1 = p1;
322 this.p2 = p2;
323 this.p3 = p3;
324 this.data = data;
325 }
326 }
327
328 /**
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700329 * A request object to use for transmitting data to an ICC.
330 */
331 private static final class ManualNetworkSelectionArgument {
332 public OperatorInfo operatorInfo;
333 public boolean persistSelection;
334
335 public ManualNetworkSelectionArgument(OperatorInfo operatorInfo, boolean persistSelection) {
336 this.operatorInfo = operatorInfo;
337 this.persistSelection = persistSelection;
338 }
339 }
340
341 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700342 * A request object for use with {@link MainThreadHandler}. Requesters should wait() on the
343 * request after sending. The main thread will notify the request when it is complete.
344 */
345 private static final class MainThreadRequest {
346 /** The argument to use for the request */
347 public Object argument;
348 /** The result of the request that is run on the main thread */
349 public Object result;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800350 // The subscriber id that this request applies to. Defaults to
351 // SubscriptionManager.INVALID_SUBSCRIPTION_ID
352 public Integer subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700353
Nathan Harold92bed182018-10-12 18:16:49 -0700354 // In cases where subId is unavailable, the caller needs to specify the phone.
355 public Phone phone;
356
vagdeviaf9a5b92018-08-15 16:01:53 -0700357 public WorkSource workSource;
358
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700359 public MainThreadRequest(Object argument) {
360 this.argument = argument;
361 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800362
Nathan Harold92bed182018-10-12 18:16:49 -0700363 MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
364 this.argument = argument;
365 if (phone != null) {
366 this.phone = phone;
367 }
368 this.workSource = workSource;
369 }
370
vagdeviaf9a5b92018-08-15 16:01:53 -0700371 MainThreadRequest(Object argument, Integer subId, WorkSource workSource) {
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800372 this.argument = argument;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800373 if (subId != null) {
374 this.subId = subId;
375 }
vagdeviaf9a5b92018-08-15 16:01:53 -0700376 this.workSource = workSource;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800377 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700378 }
379
Sailesh Nepalcc0375f2013-11-13 09:15:18 -0800380 private static final class IncomingThirdPartyCallArgs {
381 public final ComponentName component;
382 public final String callId;
383 public final String callerDisplayName;
384
385 public IncomingThirdPartyCallArgs(ComponentName component, String callId,
386 String callerDisplayName) {
387 this.component = component;
388 this.callId = callId;
389 this.callerDisplayName = callerDisplayName;
390 }
391 }
392
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700393 /**
394 * A handler that processes messages on the main thread in the phone process. Since many
395 * of the Phone calls are not thread safe this is needed to shuttle the requests from the
396 * inbound binder threads to the main thread in the phone process. The Binder thread
397 * may provide a {@link MainThreadRequest} object in the msg.obj field that they are waiting
398 * on, which will be notified when the operation completes and will contain the result of the
399 * request.
400 *
401 * <p>If a MainThreadRequest object is provided in the msg.obj field,
402 * note that request.result must be set to something non-null for the calling thread to
403 * unblock.
404 */
405 private final class MainThreadHandler extends Handler {
406 @Override
407 public void handleMessage(Message msg) {
408 MainThreadRequest request;
409 Message onCompleted;
410 AsyncResult ar;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800411 UiccCard uiccCard;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700412 IccAPDUArgument iccArgument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800413 final Phone defaultPhone = getDefaultPhone();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700414
415 switch (msg.what) {
Pengquan Menga1bb6272018-09-06 09:59:22 -0700416 case CMD_HANDLE_USSD_REQUEST: {
417 request = (MainThreadRequest) msg.obj;
418 final Phone phone = getPhoneFromRequest(request);
419 Pair<String, ResultReceiver> ussdObject = (Pair) request.argument;
420 String ussdRequest = ussdObject.first;
421 ResultReceiver wrappedCallback = ussdObject.second;
Tyler Gunn65d45c22017-06-05 11:22:26 -0700422
Pengquan Menga1bb6272018-09-06 09:59:22 -0700423 if (!isUssdApiAllowed(request.subId)) {
424 // Carrier does not support use of this API, return failure.
425 Rlog.w(LOG_TAG, "handleUssdRequest: carrier does not support USSD apis.");
426 UssdResponse response = new UssdResponse(ussdRequest, null);
427 Bundle returnData = new Bundle();
428 returnData.putParcelable(TelephonyManager.USSD_RESPONSE, response);
429 wrappedCallback.send(TelephonyManager.USSD_RETURN_FAILURE, returnData);
Tyler Gunn65d45c22017-06-05 11:22:26 -0700430
Pengquan Menga1bb6272018-09-06 09:59:22 -0700431 request.result = true;
432 notifyRequester(request);
433 return;
434 }
Tyler Gunn65d45c22017-06-05 11:22:26 -0700435
Pengquan Menga1bb6272018-09-06 09:59:22 -0700436 try {
437 request.result = phone != null
438 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
439 } catch (CallStateException cse) {
440 request.result = false;
441 }
442 // Wake up the requesting thread
443 notifyRequester(request);
444 break;
pkanwar32d516d2016-10-14 19:37:38 -0700445 }
446
Yorke Lee716f67e2015-06-17 15:39:16 -0700447 case CMD_HANDLE_PIN_MMI: {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700448 request = (MainThreadRequest) msg.obj;
Yorke Lee716f67e2015-06-17 15:39:16 -0700449 final Phone phone = getPhoneFromRequest(request);
450 request.result = phone != null ?
451 getPhoneFromRequest(request).handlePinMmi((String) request.argument)
452 : false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700453 // Wake up the requesting thread
Pengquan Menga1bb6272018-09-06 09:59:22 -0700454 notifyRequester(request);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700455 break;
Yorke Lee716f67e2015-06-17 15:39:16 -0700456 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700457
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700458 case CMD_TRANSMIT_APDU_LOGICAL_CHANNEL:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700459 request = (MainThreadRequest) msg.obj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700460 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800461 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700462 if (uiccCard == null) {
463 loge("iccTransmitApduLogicalChannel: No UICC");
464 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700465 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700466 } else {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700467 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE,
468 request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700469 uiccCard.iccTransmitApduLogicalChannel(
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700470 iccArgument.channel, iccArgument.cla, iccArgument.command,
471 iccArgument.p1, iccArgument.p2, iccArgument.p3, iccArgument.data,
Shishir Agrawal566b7612013-10-28 14:41:00 -0700472 onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700473 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700474 break;
475
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700476 case EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700477 ar = (AsyncResult) msg.obj;
478 request = (MainThreadRequest) ar.userObj;
479 if (ar.exception == null && ar.result != null) {
480 request.result = ar.result;
481 } else {
482 request.result = new IccIoResult(0x6F, 0, (byte[])null);
483 if (ar.result == null) {
484 loge("iccTransmitApduLogicalChannel: Empty response");
Jake Hambye994d462014-02-03 13:10:13 -0800485 } else if (ar.exception instanceof CommandException) {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700486 loge("iccTransmitApduLogicalChannel: CommandException: " +
Jake Hambye994d462014-02-03 13:10:13 -0800487 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700488 } else {
489 loge("iccTransmitApduLogicalChannel: Unknown exception");
490 }
491 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700492 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700493 break;
494
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700495 case CMD_TRANSMIT_APDU_BASIC_CHANNEL:
496 request = (MainThreadRequest) msg.obj;
497 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800498 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700499 if (uiccCard == null) {
500 loge("iccTransmitApduBasicChannel: No UICC");
501 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700502 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700503 } else {
504 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE,
505 request);
506 uiccCard.iccTransmitApduBasicChannel(
507 iccArgument.cla, iccArgument.command, iccArgument.p1, iccArgument.p2,
508 iccArgument.p3, iccArgument.data, onCompleted);
509 }
510 break;
511
512 case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
513 ar = (AsyncResult) msg.obj;
514 request = (MainThreadRequest) ar.userObj;
515 if (ar.exception == null && ar.result != null) {
516 request.result = ar.result;
517 } else {
518 request.result = new IccIoResult(0x6F, 0, (byte[])null);
519 if (ar.result == null) {
520 loge("iccTransmitApduBasicChannel: Empty response");
521 } else if (ar.exception instanceof CommandException) {
522 loge("iccTransmitApduBasicChannel: CommandException: " +
523 ar.exception);
524 } else {
525 loge("iccTransmitApduBasicChannel: Unknown exception");
526 }
527 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700528 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700529 break;
530
531 case CMD_EXCHANGE_SIM_IO:
532 request = (MainThreadRequest) msg.obj;
533 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800534 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700535 if (uiccCard == null) {
536 loge("iccExchangeSimIO: No UICC");
537 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700538 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700539 } else {
540 onCompleted = obtainMessage(EVENT_EXCHANGE_SIM_IO_DONE,
541 request);
542 uiccCard.iccExchangeSimIO(iccArgument.cla, /* fileID */
543 iccArgument.command, iccArgument.p1, iccArgument.p2, iccArgument.p3,
544 iccArgument.data, onCompleted);
545 }
546 break;
547
548 case EVENT_EXCHANGE_SIM_IO_DONE:
549 ar = (AsyncResult) msg.obj;
550 request = (MainThreadRequest) ar.userObj;
551 if (ar.exception == null && ar.result != null) {
552 request.result = ar.result;
553 } else {
554 request.result = new IccIoResult(0x6f, 0, (byte[])null);
555 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700556 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700557 break;
558
Derek Tan4d5e5c12014-02-04 11:54:58 -0800559 case CMD_SEND_ENVELOPE:
560 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800561 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700562 if (uiccCard == null) {
563 loge("sendEnvelopeWithStatus: No UICC");
564 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700565 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700566 } else {
567 onCompleted = obtainMessage(EVENT_SEND_ENVELOPE_DONE, request);
568 uiccCard.sendEnvelopeWithStatus((String)request.argument, onCompleted);
569 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800570 break;
571
572 case EVENT_SEND_ENVELOPE_DONE:
573 ar = (AsyncResult) msg.obj;
574 request = (MainThreadRequest) ar.userObj;
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700575 if (ar.exception == null && ar.result != null) {
576 request.result = ar.result;
Derek Tan4d5e5c12014-02-04 11:54:58 -0800577 } else {
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700578 request.result = new IccIoResult(0x6F, 0, (byte[])null);
579 if (ar.result == null) {
580 loge("sendEnvelopeWithStatus: Empty response");
581 } else if (ar.exception instanceof CommandException) {
582 loge("sendEnvelopeWithStatus: CommandException: " +
583 ar.exception);
584 } else {
585 loge("sendEnvelopeWithStatus: exception:" + ar.exception);
586 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800587 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700588 notifyRequester(request);
Derek Tan4d5e5c12014-02-04 11:54:58 -0800589 break;
590
Shishir Agrawal566b7612013-10-28 14:41:00 -0700591 case CMD_OPEN_CHANNEL:
592 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800593 uiccCard = getUiccCardFromRequest(request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800594 Pair<String, Integer> openChannelArgs = (Pair<String, Integer>) request.argument;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700595 if (uiccCard == null) {
596 loge("iccOpenLogicalChannel: No UICC");
Shishir Agrawalfc0492a2016-02-17 11:15:33 -0800597 request.result = new IccOpenLogicalChannelResponse(-1,
598 IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE, null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700599 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700600 } else {
601 onCompleted = obtainMessage(EVENT_OPEN_CHANNEL_DONE, request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800602 uiccCard.iccOpenLogicalChannel(openChannelArgs.first,
603 openChannelArgs.second, onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700604 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700605 break;
606
607 case EVENT_OPEN_CHANNEL_DONE:
608 ar = (AsyncResult) msg.obj;
609 request = (MainThreadRequest) ar.userObj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700610 IccOpenLogicalChannelResponse openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700611 if (ar.exception == null && ar.result != null) {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700612 int[] result = (int[]) ar.result;
613 int channelId = result[0];
614 byte[] selectResponse = null;
615 if (result.length > 1) {
616 selectResponse = new byte[result.length - 1];
617 for (int i = 1; i < result.length; ++i) {
618 selectResponse[i - 1] = (byte) result[i];
619 }
620 }
621 openChannelResp = new IccOpenLogicalChannelResponse(channelId,
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700622 IccOpenLogicalChannelResponse.STATUS_NO_ERROR, selectResponse);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700623 } else {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700624 if (ar.result == null) {
625 loge("iccOpenLogicalChannel: Empty response");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700626 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700627 if (ar.exception != null) {
628 loge("iccOpenLogicalChannel: Exception: " + ar.exception);
629 }
630
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700631 int errorCode = IccOpenLogicalChannelResponse.STATUS_UNKNOWN_ERROR;
Junda Liua754ba12015-05-20 01:17:52 -0700632 if (ar.exception instanceof CommandException) {
633 CommandException.Error error =
634 ((CommandException) (ar.exception)).getCommandError();
635 if (error == CommandException.Error.MISSING_RESOURCE) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700636 errorCode = IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
Junda Liua754ba12015-05-20 01:17:52 -0700637 } else if (error == CommandException.Error.NO_SUCH_ELEMENT) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700638 errorCode = IccOpenLogicalChannelResponse.STATUS_NO_SUCH_ELEMENT;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700639 }
640 }
641 openChannelResp = new IccOpenLogicalChannelResponse(
642 IccOpenLogicalChannelResponse.INVALID_CHANNEL, errorCode, null);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700643 }
Shishir Agrawal82c8a462014-07-31 18:13:17 -0700644 request.result = openChannelResp;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700645 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700646 break;
647
648 case CMD_CLOSE_CHANNEL:
649 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800650 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700651 if (uiccCard == null) {
652 loge("iccCloseLogicalChannel: No UICC");
Yoshiaki Naka2e29d822016-09-02 19:27:39 +0900653 request.result = false;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700654 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700655 } else {
656 onCompleted = obtainMessage(EVENT_CLOSE_CHANNEL_DONE, request);
657 uiccCard.iccCloseLogicalChannel((Integer) request.argument, onCompleted);
658 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700659 break;
660
661 case EVENT_CLOSE_CHANNEL_DONE:
Jake Hambye994d462014-02-03 13:10:13 -0800662 handleNullReturnEvent(msg, "iccCloseLogicalChannel");
663 break;
664
665 case CMD_NV_READ_ITEM:
666 request = (MainThreadRequest) msg.obj;
667 onCompleted = obtainMessage(EVENT_NV_READ_ITEM_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800668 defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
669 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800670 break;
671
672 case EVENT_NV_READ_ITEM_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700673 ar = (AsyncResult) msg.obj;
674 request = (MainThreadRequest) ar.userObj;
Jake Hambye994d462014-02-03 13:10:13 -0800675 if (ar.exception == null && ar.result != null) {
676 request.result = ar.result; // String
Shishir Agrawal566b7612013-10-28 14:41:00 -0700677 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800678 request.result = "";
679 if (ar.result == null) {
680 loge("nvReadItem: Empty response");
681 } else if (ar.exception instanceof CommandException) {
682 loge("nvReadItem: CommandException: " +
683 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700684 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800685 loge("nvReadItem: Unknown exception");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700686 }
687 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700688 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700689 break;
690
Jake Hambye994d462014-02-03 13:10:13 -0800691 case CMD_NV_WRITE_ITEM:
692 request = (MainThreadRequest) msg.obj;
693 onCompleted = obtainMessage(EVENT_NV_WRITE_ITEM_DONE, request);
694 Pair<Integer, String> idValue = (Pair<Integer, String>) request.argument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800695 defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
vagdeviaf9a5b92018-08-15 16:01:53 -0700696 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800697 break;
698
699 case EVENT_NV_WRITE_ITEM_DONE:
700 handleNullReturnEvent(msg, "nvWriteItem");
701 break;
702
703 case CMD_NV_WRITE_CDMA_PRL:
704 request = (MainThreadRequest) msg.obj;
705 onCompleted = obtainMessage(EVENT_NV_WRITE_CDMA_PRL_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800706 defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800707 break;
708
709 case EVENT_NV_WRITE_CDMA_PRL_DONE:
710 handleNullReturnEvent(msg, "nvWriteCdmaPrl");
711 break;
712
chen xu6dac5ab2018-10-26 17:39:23 -0700713 case CMD_RESET_MODEM_CONFIG:
Jake Hambye994d462014-02-03 13:10:13 -0800714 request = (MainThreadRequest) msg.obj;
chen xu6dac5ab2018-10-26 17:39:23 -0700715 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800716 defaultPhone.resetModemConfig(onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800717 break;
718
chen xu6dac5ab2018-10-26 17:39:23 -0700719 case EVENT_RESET_MODEM_CONFIG_DONE:
720 handleNullReturnEvent(msg, "resetModemConfig");
Jake Hambye994d462014-02-03 13:10:13 -0800721 break;
722
Jake Hamby7c27be32014-03-03 13:25:59 -0800723 case CMD_GET_PREFERRED_NETWORK_TYPE:
724 request = (MainThreadRequest) msg.obj;
725 onCompleted = obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE_DONE, request);
Stuart Scott54788802015-03-30 13:18:01 -0700726 getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800727 break;
728
729 case EVENT_GET_PREFERRED_NETWORK_TYPE_DONE:
730 ar = (AsyncResult) msg.obj;
731 request = (MainThreadRequest) ar.userObj;
732 if (ar.exception == null && ar.result != null) {
733 request.result = ar.result; // Integer
734 } else {
Sanket Padawecfc2d352016-01-05 19:52:14 -0800735 request.result = null;
Jake Hamby7c27be32014-03-03 13:25:59 -0800736 if (ar.result == null) {
737 loge("getPreferredNetworkType: Empty response");
738 } else if (ar.exception instanceof CommandException) {
739 loge("getPreferredNetworkType: CommandException: " +
740 ar.exception);
741 } else {
742 loge("getPreferredNetworkType: Unknown exception");
743 }
744 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700745 notifyRequester(request);
Jake Hamby7c27be32014-03-03 13:25:59 -0800746 break;
747
748 case CMD_SET_PREFERRED_NETWORK_TYPE:
749 request = (MainThreadRequest) msg.obj;
750 onCompleted = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE_DONE, request);
751 int networkType = (Integer) request.argument;
Stuart Scott54788802015-03-30 13:18:01 -0700752 getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800753 break;
754
755 case EVENT_SET_PREFERRED_NETWORK_TYPE_DONE:
756 handleNullReturnEvent(msg, "setPreferredNetworkType");
757 break;
758
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000759 case CMD_INVOKE_OEM_RIL_REQUEST_RAW:
760 request = (MainThreadRequest)msg.obj;
761 onCompleted = obtainMessage(EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800762 defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000763 break;
764
765 case EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE:
766 ar = (AsyncResult)msg.obj;
767 request = (MainThreadRequest)ar.userObj;
768 request.result = ar;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700769 notifyRequester(request);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000770 break;
771
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800772 case CMD_SET_VOICEMAIL_NUMBER:
773 request = (MainThreadRequest) msg.obj;
774 onCompleted = obtainMessage(EVENT_SET_VOICEMAIL_NUMBER_DONE, request);
775 Pair<String, String> tagNum = (Pair<String, String>) request.argument;
Stuart Scott584921c2015-01-15 17:10:34 -0800776 getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
777 onCompleted);
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800778 break;
779
780 case EVENT_SET_VOICEMAIL_NUMBER_DONE:
781 handleNullReturnEvent(msg, "setVoicemailNumber");
782 break;
783
Stuart Scott54788802015-03-30 13:18:01 -0700784 case CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC:
785 request = (MainThreadRequest) msg.obj;
786 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE,
787 request);
788 getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
789 break;
790
791 case EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE:
792 handleNullReturnEvent(msg, "setNetworkSelectionModeAutomatic");
793 break;
794
Shishir Agrawal302c8692015-06-19 13:49:39 -0700795 case CMD_PERFORM_NETWORK_SCAN:
796 request = (MainThreadRequest) msg.obj;
797 onCompleted = obtainMessage(EVENT_PERFORM_NETWORK_SCAN_DONE, request);
798 getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
799 break;
800
801 case EVENT_PERFORM_NETWORK_SCAN_DONE:
802 ar = (AsyncResult) msg.obj;
803 request = (MainThreadRequest) ar.userObj;
804 CellNetworkScanResult cellScanResult;
805 if (ar.exception == null && ar.result != null) {
806 cellScanResult = new CellNetworkScanResult(
807 CellNetworkScanResult.STATUS_SUCCESS,
808 (List<OperatorInfo>) ar.result);
809 } else {
810 if (ar.result == null) {
811 loge("getCellNetworkScanResults: Empty response");
812 }
813 if (ar.exception != null) {
814 loge("getCellNetworkScanResults: Exception: " + ar.exception);
815 }
816 int errorCode = CellNetworkScanResult.STATUS_UNKNOWN_ERROR;
817 if (ar.exception instanceof CommandException) {
818 CommandException.Error error =
819 ((CommandException) (ar.exception)).getCommandError();
820 if (error == CommandException.Error.RADIO_NOT_AVAILABLE) {
821 errorCode = CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE;
822 } else if (error == CommandException.Error.GENERIC_FAILURE) {
823 errorCode = CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE;
824 }
825 }
826 cellScanResult = new CellNetworkScanResult(errorCode, null);
827 }
828 request.result = cellScanResult;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700829 notifyRequester(request);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700830 break;
831
832 case CMD_SET_NETWORK_SELECTION_MODE_MANUAL:
833 request = (MainThreadRequest) msg.obj;
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700834 ManualNetworkSelectionArgument selArg =
835 (ManualNetworkSelectionArgument) request.argument;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700836 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE,
837 request);
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700838 getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
839 selArg.persistSelection, onCompleted);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700840 break;
841
842 case EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE:
Pengquan Menge3d01e22018-09-20 15:25:35 -0700843 ar = (AsyncResult) msg.obj;
844 request = (MainThreadRequest) ar.userObj;
845 if (ar.exception == null) {
846 request.result = true;
847 } else {
848 request.result = false;
849 loge("setNetworkSelectionModeManual " + ar.exception);
850 }
851 notifyRequester(request);
852 mApp.onNetworkSelectionChanged(request.subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700853 break;
854
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700855 case CMD_GET_MODEM_ACTIVITY_INFO:
856 request = (MainThreadRequest) msg.obj;
857 onCompleted = obtainMessage(EVENT_GET_MODEM_ACTIVITY_INFO_DONE, request);
James Mattisab947702019-04-03 14:18:34 -0700858 if (defaultPhone != null) {
859 defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
860 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700861 break;
862
863 case EVENT_GET_MODEM_ACTIVITY_INFO_DONE:
864 ar = (AsyncResult) msg.obj;
865 request = (MainThreadRequest) ar.userObj;
866 if (ar.exception == null && ar.result != null) {
867 request.result = ar.result;
868 } else {
869 if (ar.result == null) {
870 loge("queryModemActivityInfo: Empty response");
871 } else if (ar.exception instanceof CommandException) {
872 loge("queryModemActivityInfo: CommandException: " +
873 ar.exception);
874 } else {
875 loge("queryModemActivityInfo: Unknown exception");
876 }
877 }
Amit Mahajand4766222016-01-28 15:28:28 -0800878 // Result cannot be null. Return ModemActivityInfo with all fields set to 0.
879 if (request.result == null) {
Peter Collingbournec00e9022019-11-26 09:56:26 -0800880 request.result = new ModemActivityInfo(0, 0, 0, new int[0], 0);
Amit Mahajand4766222016-01-28 15:28:28 -0800881 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700882 notifyRequester(request);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700883 break;
884
Meng Wang1a7c35a2016-05-05 20:56:15 -0700885 case CMD_SET_ALLOWED_CARRIERS:
886 request = (MainThreadRequest) msg.obj;
Michele Berionne482f8202018-11-27 18:57:59 -0800887 CarrierRestrictionRules argument =
888 (CarrierRestrictionRules) request.argument;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700889 onCompleted = obtainMessage(EVENT_SET_ALLOWED_CARRIERS_DONE, request);
Michele Berionne482f8202018-11-27 18:57:59 -0800890 defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700891 break;
892
893 case EVENT_SET_ALLOWED_CARRIERS_DONE:
894 ar = (AsyncResult) msg.obj;
895 request = (MainThreadRequest) ar.userObj;
896 if (ar.exception == null && ar.result != null) {
897 request.result = ar.result;
898 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800899 request.result = TelephonyManager.SET_CARRIER_RESTRICTION_ERROR;
900 if (ar.exception instanceof CommandException) {
901 loge("setAllowedCarriers: CommandException: " + ar.exception);
902 CommandException.Error error =
903 ((CommandException) (ar.exception)).getCommandError();
904 if (error == CommandException.Error.REQUEST_NOT_SUPPORTED) {
905 request.result =
906 TelephonyManager.SET_CARRIER_RESTRICTION_NOT_SUPPORTED;
907 }
Meng Wang1a7c35a2016-05-05 20:56:15 -0700908 } else {
909 loge("setAllowedCarriers: Unknown exception");
910 }
911 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700912 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700913 break;
914
915 case CMD_GET_ALLOWED_CARRIERS:
916 request = (MainThreadRequest) msg.obj;
917 onCompleted = obtainMessage(EVENT_GET_ALLOWED_CARRIERS_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800918 defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700919 break;
920
921 case EVENT_GET_ALLOWED_CARRIERS_DONE:
922 ar = (AsyncResult) msg.obj;
923 request = (MainThreadRequest) ar.userObj;
924 if (ar.exception == null && ar.result != null) {
925 request.result = ar.result;
926 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800927 request.result = new IllegalStateException(
928 "Failed to get carrier restrictions");
Meng Wang1a7c35a2016-05-05 20:56:15 -0700929 if (ar.result == null) {
930 loge("getAllowedCarriers: Empty response");
931 } else if (ar.exception instanceof CommandException) {
932 loge("getAllowedCarriers: CommandException: " +
933 ar.exception);
934 } else {
935 loge("getAllowedCarriers: Unknown exception");
936 }
937 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700938 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700939 break;
940
Nathan Haroldb3014052017-01-25 15:57:32 -0800941 case EVENT_GET_FORBIDDEN_PLMNS_DONE:
942 ar = (AsyncResult) msg.obj;
943 request = (MainThreadRequest) ar.userObj;
944 if (ar.exception == null && ar.result != null) {
945 request.result = ar.result;
946 } else {
947 request.result = new IllegalArgumentException(
948 "Failed to retrieve Forbidden Plmns");
949 if (ar.result == null) {
950 loge("getForbiddenPlmns: Empty response");
951 } else {
952 loge("getForbiddenPlmns: Unknown exception");
953 }
954 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700955 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800956 break;
957
958 case CMD_GET_FORBIDDEN_PLMNS:
959 request = (MainThreadRequest) msg.obj;
960 uiccCard = getUiccCardFromRequest(request);
961 if (uiccCard == null) {
962 loge("getForbiddenPlmns() UiccCard is null");
963 request.result = new IllegalArgumentException(
964 "getForbiddenPlmns() UiccCard is null");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700965 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800966 break;
967 }
968 Integer appType = (Integer) request.argument;
969 UiccCardApplication uiccApp = uiccCard.getApplicationByType(appType);
970 if (uiccApp == null) {
971 loge("getForbiddenPlmns() no app with specified type -- "
972 + appType);
973 request.result = new IllegalArgumentException("Failed to get UICC App");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700974 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800975 break;
976 } else {
977 if (DBG) logv("getForbiddenPlmns() found app " + uiccApp.getAid()
978 + " specified type -- " + appType);
979 }
980 onCompleted = obtainMessage(EVENT_GET_FORBIDDEN_PLMNS_DONE, request);
981 ((SIMRecords) uiccApp.getIccRecords()).getForbiddenPlmns(
982 onCompleted);
983 break;
984
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000985 case CMD_SWITCH_SLOTS:
986 request = (MainThreadRequest) msg.obj;
987 int[] physicalSlots = (int[]) request.argument;
988 onCompleted = obtainMessage(EVENT_SWITCH_SLOTS_DONE, request);
989 UiccController.getInstance().switchSlots(physicalSlots, onCompleted);
990 break;
991
992 case EVENT_SWITCH_SLOTS_DONE:
993 ar = (AsyncResult) msg.obj;
994 request = (MainThreadRequest) ar.userObj;
995 request.result = (ar.exception == null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700996 notifyRequester(request);
997 break;
998 case CMD_GET_NETWORK_SELECTION_MODE:
999 request = (MainThreadRequest) msg.obj;
1000 onCompleted = obtainMessage(EVENT_GET_NETWORK_SELECTION_MODE_DONE, request);
1001 getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
1002 break;
1003
1004 case EVENT_GET_NETWORK_SELECTION_MODE_DONE:
1005 ar = (AsyncResult) msg.obj;
1006 request = (MainThreadRequest) ar.userObj;
1007 if (ar.exception != null) {
1008 request.result = TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
1009 } else {
1010 int mode = ((int[]) ar.result)[0];
1011 if (mode == 0) {
1012 request.result = TelephonyManager.NETWORK_SELECTION_MODE_AUTO;
1013 } else {
1014 request.result = TelephonyManager.NETWORK_SELECTION_MODE_MANUAL;
1015 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001016 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001017 notifyRequester(request);
1018 break;
1019 case CMD_GET_CDMA_ROAMING_MODE:
1020 request = (MainThreadRequest) msg.obj;
1021 onCompleted = obtainMessage(EVENT_GET_CDMA_ROAMING_MODE_DONE, request);
1022 getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1023 break;
1024 case EVENT_GET_CDMA_ROAMING_MODE_DONE:
1025 ar = (AsyncResult) msg.obj;
1026 request = (MainThreadRequest) ar.userObj;
1027 if (ar.exception != null) {
1028 request.result = TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT;
1029 } else {
1030 request.result = ((int[]) ar.result)[0];
1031 }
1032 notifyRequester(request);
1033 break;
1034 case CMD_SET_CDMA_ROAMING_MODE:
1035 request = (MainThreadRequest) msg.obj;
1036 onCompleted = obtainMessage(EVENT_SET_CDMA_ROAMING_MODE_DONE, request);
1037 int mode = (int) request.argument;
1038 getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1039 break;
1040 case EVENT_SET_CDMA_ROAMING_MODE_DONE:
1041 ar = (AsyncResult) msg.obj;
1042 request = (MainThreadRequest) ar.userObj;
1043 request.result = ar.exception == null;
1044 notifyRequester(request);
1045 break;
1046 case CMD_SET_CDMA_SUBSCRIPTION_MODE:
1047 request = (MainThreadRequest) msg.obj;
1048 onCompleted = obtainMessage(EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE, request);
1049 int subscriptionMode = (int) request.argument;
1050 getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);
1051 break;
1052 case EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE:
1053 ar = (AsyncResult) msg.obj;
1054 request = (MainThreadRequest) ar.userObj;
1055 request.result = ar.exception == null;
1056 notifyRequester(request);
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001057 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001058 case CMD_GET_ALL_CELL_INFO:
1059 request = (MainThreadRequest) msg.obj;
Nathan Harold3ff88932018-08-14 10:19:49 -07001060 onCompleted = obtainMessage(EVENT_GET_ALL_CELL_INFO_DONE, request);
Nathan Harold92bed182018-10-12 18:16:49 -07001061 request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
Nathan Harold3ff88932018-08-14 10:19:49 -07001062 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001063 case EVENT_GET_ALL_CELL_INFO_DONE:
1064 ar = (AsyncResult) msg.obj;
1065 request = (MainThreadRequest) ar.userObj;
Nathan Harold8d0f1742018-10-02 12:14:47 -07001066 // If a timeout occurs, the response will be null
1067 request.result = (ar.exception == null && ar.result != null)
1068 ? ar.result : new ArrayList<CellInfo>();
Nathan Harold3ff88932018-08-14 10:19:49 -07001069 synchronized (request) {
1070 request.notifyAll();
1071 }
1072 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001073 case CMD_REQUEST_CELL_INFO_UPDATE:
1074 request = (MainThreadRequest) msg.obj;
1075 request.phone.requestCellInfoUpdate(request.workSource,
1076 obtainMessage(EVENT_REQUEST_CELL_INFO_UPDATE_DONE, request));
1077 break;
1078 case EVENT_REQUEST_CELL_INFO_UPDATE_DONE:
1079 ar = (AsyncResult) msg.obj;
1080 request = (MainThreadRequest) ar.userObj;
1081 ICellInfoCallback cb = (ICellInfoCallback) request.argument;
1082 try {
1083 if (ar.exception != null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001084 Log.e(LOG_TAG, "Exception retrieving CellInfo=" + ar.exception);
Meng Wangd8921f42019-09-30 17:13:54 -07001085 cb.onError(
1086 TelephonyManager.CellInfoCallback.ERROR_MODEM_ERROR,
1087 ar.exception.getClass().getName(),
1088 ar.exception.toString());
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001089 } else if (ar.result == null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001090 Log.w(LOG_TAG, "Timeout Waiting for CellInfo!");
Meng Wangd8921f42019-09-30 17:13:54 -07001091 cb.onError(TelephonyManager.CellInfoCallback.ERROR_TIMEOUT, null, null);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001092 } else {
1093 // use the result as returned
1094 cb.onCellInfo((List<CellInfo>) ar.result);
1095 }
1096 } catch (RemoteException re) {
1097 Log.w(LOG_TAG, "Discarded CellInfo due to Callback RemoteException");
1098 }
1099 break;
1100 case CMD_GET_CELL_LOCATION:
Nathan Harold3ff88932018-08-14 10:19:49 -07001101 request = (MainThreadRequest) msg.obj;
1102 WorkSource ws = (WorkSource) request.argument;
1103 Phone phone = getPhoneFromRequest(request);
1104 phone.getCellLocation(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1105 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001106 case EVENT_GET_CELL_LOCATION_DONE:
Nathan Harold3ff88932018-08-14 10:19:49 -07001107 ar = (AsyncResult) msg.obj;
1108 request = (MainThreadRequest) ar.userObj;
1109 if (ar.exception == null) {
1110 request.result = ar.result;
1111 } else {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001112 phone = getPhoneFromRequest(request);
Nathan Harold3ff88932018-08-14 10:19:49 -07001113 request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1114 ? new CdmaCellLocation() : new GsmCellLocation();
1115 }
1116
1117 synchronized (request) {
1118 request.notifyAll();
1119 }
1120 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001121 case CMD_MODEM_REBOOT:
1122 request = (MainThreadRequest) msg.obj;
1123 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001124 defaultPhone.rebootModem(onCompleted);
chen xu6dac5ab2018-10-26 17:39:23 -07001125 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001126 case EVENT_CMD_MODEM_REBOOT_DONE:
1127 handleNullReturnEvent(msg, "rebootModem");
1128 break;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001129 case CMD_REQUEST_ENABLE_MODEM:
1130 request = (MainThreadRequest) msg.obj;
1131 boolean enable = (boolean) request.argument;
1132 onCompleted = obtainMessage(EVENT_ENABLE_MODEM_DONE, request);
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001133 onCompleted.arg1 = enable ? 1 : 0;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001134 PhoneConfigurationManager.getInstance()
1135 .enablePhone(request.phone, enable, onCompleted);
1136 break;
1137 case EVENT_ENABLE_MODEM_DONE:
1138 ar = (AsyncResult) msg.obj;
1139 request = (MainThreadRequest) ar.userObj;
1140 request.result = (ar.exception == null);
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001141 int phoneId = request.phone.getPhoneId();
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001142 //update the cache as modem status has changed
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001143 if ((boolean) request.result) {
1144 mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1145 updateModemStateMetrics();
1146 } else {
1147 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1148 + ar.exception);
1149 }
1150 notifyRequester(request);
1151 break;
1152 case CMD_GET_MODEM_STATUS:
1153 request = (MainThreadRequest) msg.obj;
1154 onCompleted = obtainMessage(EVENT_GET_MODEM_STATUS_DONE, request);
1155 PhoneConfigurationManager.getInstance()
1156 .getPhoneStatusFromModem(request.phone, onCompleted);
1157 break;
1158 case EVENT_GET_MODEM_STATUS_DONE:
1159 ar = (AsyncResult) msg.obj;
1160 request = (MainThreadRequest) ar.userObj;
1161 int id = request.phone.getPhoneId();
1162 if (ar.exception == null && ar.result != null) {
1163 request.result = ar.result;
1164 //update the cache as modem status has changed
1165 mPhoneConfigurationManager.addToPhoneStatusCache(id,
1166 (boolean) request.result);
1167 } else {
1168 // Return true if modem status cannot be retrieved. For most cases,
1169 // modem status is on. And for older version modems, GET_MODEM_STATUS
1170 // and disable modem are not supported. Modem is always on.
1171 // TODO: this should be fixed in R to support a third
1172 // status UNKNOWN b/131631629
1173 request.result = true;
1174 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1175 + ar.exception);
1176 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001177 notifyRequester(request);
1178 break;
yincheng zhao2737e882019-09-06 17:06:54 -07001179 case EVENT_SET_FORBIDDEN_PLMNS_DONE:
1180 ar = (AsyncResult) msg.obj;
1181 request = (MainThreadRequest) ar.userObj;
1182 if (ar.exception == null && ar.result != null) {
1183 request.result = ar.result;
1184 } else {
1185 request.result = -1;
1186 loge("Failed to set Forbidden Plmns");
1187 if (ar.result == null) {
1188 loge("setForbidenPlmns: Empty response");
1189 } else if (ar.exception != null) {
1190 loge("setForbiddenPlmns: Exception: " + ar.exception);
1191 request.result = -1;
1192 } else {
1193 loge("setForbiddenPlmns: Unknown exception");
1194 }
1195 }
1196 notifyRequester(request);
1197 break;
1198 case CMD_SET_FORBIDDEN_PLMNS:
1199 request = (MainThreadRequest) msg.obj;
1200 uiccCard = getUiccCardFromRequest(request);
1201 if (uiccCard == null) {
1202 loge("setForbiddenPlmns: UiccCard is null");
1203 request.result = -1;
1204 notifyRequester(request);
1205 break;
1206 }
1207 Pair<Integer, List<String>> setFplmnsArgs =
1208 (Pair<Integer, List<String>>) request.argument;
1209 appType = setFplmnsArgs.first;
1210 List<String> fplmns = setFplmnsArgs.second;
1211 uiccApp = uiccCard.getApplicationByType(appType);
1212 if (uiccApp == null) {
1213 loge("setForbiddenPlmns: no app with specified type -- " + appType);
1214 request.result = -1;
1215 loge("Failed to get UICC App");
1216 notifyRequester(request);
1217 } else {
1218 onCompleted = obtainMessage(EVENT_SET_FORBIDDEN_PLMNS_DONE, request);
1219 ((SIMRecords) uiccApp.getIccRecords())
1220 .setForbiddenPlmns(onCompleted, fplmns);
1221 }
Naina Nallurid63128d2019-09-17 14:10:30 -07001222 case CMD_ERASE_MODEM_CONFIG:
1223 request = (MainThreadRequest) msg.obj;
1224 onCompleted = obtainMessage(EVENT_ERASE_MODEM_CONFIG_DONE, request);
1225 defaultPhone.eraseModemConfig(onCompleted);
1226 break;
1227 case EVENT_ERASE_MODEM_CONFIG_DONE:
1228 handleNullReturnEvent(msg, "eraseModemConfig");
yincheng zhao2737e882019-09-06 17:06:54 -07001229 break;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001230 default:
1231 Log.w(LOG_TAG, "MainThreadHandler: unexpected message code: " + msg.what);
1232 break;
1233 }
1234 }
Jake Hambye994d462014-02-03 13:10:13 -08001235
Pengquan Menga1bb6272018-09-06 09:59:22 -07001236 private void notifyRequester(MainThreadRequest request) {
1237 synchronized (request) {
1238 request.notifyAll();
1239 }
1240 }
1241
Jake Hambye994d462014-02-03 13:10:13 -08001242 private void handleNullReturnEvent(Message msg, String command) {
1243 AsyncResult ar = (AsyncResult) msg.obj;
1244 MainThreadRequest request = (MainThreadRequest) ar.userObj;
1245 if (ar.exception == null) {
1246 request.result = true;
1247 } else {
1248 request.result = false;
1249 if (ar.exception instanceof CommandException) {
1250 loge(command + ": CommandException: " + ar.exception);
1251 } else {
1252 loge(command + ": Unknown exception");
1253 }
1254 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001255 notifyRequester(request);
Jake Hambye994d462014-02-03 13:10:13 -08001256 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001257 }
1258
1259 /**
1260 * Posts the specified command to be executed on the main thread,
1261 * waits for the request to complete, and returns the result.
1262 * @see #sendRequestAsync
1263 */
1264 private Object sendRequest(int command, Object argument) {
Nathan Harold92bed182018-10-12 18:16:49 -07001265 return sendRequest(
1266 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001267 }
1268
1269 /**
1270 * Posts the specified command to be executed on the main thread,
1271 * waits for the request to complete, and returns the result.
1272 * @see #sendRequestAsync
1273 */
1274 private Object sendRequest(int command, Object argument, WorkSource workSource) {
1275 return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID,
Nathan Harold92bed182018-10-12 18:16:49 -07001276 null, workSource);
Wink Saville36469e72014-06-11 15:17:00 -07001277 }
1278
1279 /**
1280 * Posts the specified command to be executed on the main thread,
1281 * waits for the request to complete, and returns the result.
1282 * @see #sendRequestAsync
1283 */
Shishir Agrawal76d5da92014-11-09 16:17:25 -08001284 private Object sendRequest(int command, Object argument, Integer subId) {
Nathan Harold92bed182018-10-12 18:16:49 -07001285 return sendRequest(command, argument, subId, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001286 }
1287
1288 /**
1289 * Posts the specified command to be executed on the main thread,
1290 * waits for the request to complete, and returns the result.
1291 * @see #sendRequestAsync
1292 */
Nathan Harold92bed182018-10-12 18:16:49 -07001293 private Object sendRequest(int command, Object argument, int subId, WorkSource workSource) {
1294 return sendRequest(command, argument, subId, null, workSource);
1295 }
1296
1297 /**
1298 * Posts the specified command to be executed on the main thread,
1299 * waits for the request to complete, and returns the result.
1300 * @see #sendRequestAsync
1301 */
1302 private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
1303 return sendRequest(
1304 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone, workSource);
1305 }
1306
1307 /**
1308 * Posts the specified command to be executed on the main thread,
1309 * waits for the request to complete, and returns the result.
1310 * @see #sendRequestAsync
1311 */
1312 private Object sendRequest(
1313 int command, Object argument, Integer subId, Phone phone, WorkSource workSource) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001314 if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
1315 throw new RuntimeException("This method will deadlock if called from the main thread.");
1316 }
1317
Nathan Harold92bed182018-10-12 18:16:49 -07001318 MainThreadRequest request = null;
1319 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
1320 throw new IllegalArgumentException("subId and phone cannot both be specified!");
1321 } else if (phone != null) {
1322 request = new MainThreadRequest(argument, phone, workSource);
1323 } else {
1324 request = new MainThreadRequest(argument, subId, workSource);
1325 }
1326
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001327 Message msg = mMainThreadHandler.obtainMessage(command, request);
1328 msg.sendToTarget();
1329
1330 // Wait for the request to complete
1331 synchronized (request) {
1332 while (request.result == null) {
1333 try {
1334 request.wait();
1335 } catch (InterruptedException e) {
1336 // Do nothing, go back and wait until the request is complete
1337 }
1338 }
1339 }
1340 return request.result;
1341 }
1342
1343 /**
1344 * Asynchronous ("fire and forget") version of sendRequest():
1345 * Posts the specified command to be executed on the main thread, and
1346 * returns immediately.
1347 * @see #sendRequest
1348 */
1349 private void sendRequestAsync(int command) {
1350 mMainThreadHandler.sendEmptyMessage(command);
1351 }
1352
1353 /**
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001354 * Same as {@link #sendRequestAsync(int)} except it takes an argument.
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001355 * @see {@link #sendRequest(int)}
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001356 */
1357 private void sendRequestAsync(int command, Object argument) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001358 sendRequestAsync(command, argument, null, null);
1359 }
1360
1361 /**
1362 * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
1363 * @see {@link #sendRequest(int,Object)}
1364 */
1365 private void sendRequestAsync(
1366 int command, Object argument, Phone phone, WorkSource workSource) {
1367 MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001368 Message msg = mMainThreadHandler.obtainMessage(command, request);
1369 msg.sendToTarget();
1370 }
1371
1372 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001373 * Initialize the singleton PhoneInterfaceManager instance.
1374 * This is only done once, at startup, from PhoneApp.onCreate().
1375 */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001376 /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001377 synchronized (PhoneInterfaceManager.class) {
1378 if (sInstance == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001379 sInstance = new PhoneInterfaceManager(app);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001380 } else {
1381 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
1382 }
1383 return sInstance;
1384 }
1385 }
1386
1387 /** Private constructor; @see init() */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001388 private PhoneInterfaceManager(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001389 mApp = app;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001390 mCM = PhoneGlobals.getInstance().mCM;
Stuart Scott981d8582015-04-21 14:09:50 -07001391 mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001392 mAppOps = (AppOpsManager)app.getSystemService(Context.APP_OPS_SERVICE);
1393 mMainThreadHandler = new MainThreadHandler();
Tobias Thiererb19e1f12018-12-11 17:54:03 +00001394 mSubscriptionController = SubscriptionController.getInstance();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001395 mTelephonySharedPreferences =
1396 PreferenceManager.getDefaultSharedPreferences(mApp);
yinxub1bed742017-04-17 11:45:04 -07001397 mNetworkScanRequestTracker = new NetworkScanRequestTracker();
Malcolm Chen2c63d402018-08-14 16:00:53 -07001398 mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
Wink Saville3ab207e2014-11-20 13:07:20 -08001399
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001400 publish();
1401 }
1402
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001403 private Phone getDefaultPhone() {
1404 Phone thePhone = getPhone(getDefaultSubscription());
1405 return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
1406 }
1407
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001408 private void publish() {
1409 if (DBG) log("publish: " + this);
1410
1411 ServiceManager.addService("phone", this);
1412 }
1413
Stuart Scott584921c2015-01-15 17:10:34 -08001414 private Phone getPhoneFromRequest(MainThreadRequest request) {
Jordan Liu4c733742019-02-28 12:03:40 -08001415 if (request.phone != null) {
1416 return request.phone;
1417 } else {
1418 return getPhoneFromSubId(request.subId);
1419 }
1420 }
1421
1422 private Phone getPhoneFromSubId(int subId) {
1423 return (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID)
1424 ? getDefaultPhone() : getPhone(subId);
Stuart Scott584921c2015-01-15 17:10:34 -08001425 }
1426
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001427 private UiccCard getUiccCardFromRequest(MainThreadRequest request) {
1428 Phone phone = getPhoneFromRequest(request);
1429 return phone == null ? null :
1430 UiccController.getInstance().getUiccCard(phone.getPhoneId());
1431 }
1432
Wink Saville36469e72014-06-11 15:17:00 -07001433 // returns phone associated with the subId.
Wink Savilleb564aae2014-10-23 10:18:09 -07001434 private Phone getPhone(int subId) {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001435 return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
Wink Saville36469e72014-06-11 15:17:00 -07001436 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001437
Naina Nallurid63128d2019-09-17 14:10:30 -07001438 private void sendEraseModemConfig(Phone phone) {
1439 if (phone != null) {
1440 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
1441 mApp, phone.getSubId(), "eraseModemConfig");
1442 final long identity = Binder.clearCallingIdentity();
1443 try {
1444 Boolean success = (Boolean) sendRequest(CMD_ERASE_MODEM_CONFIG, null);
1445 if (DBG) log("eraseModemConfig:" + ' ' + (success ? "ok" : "fail"));
1446 } finally {
1447 Binder.restoreCallingIdentity(identity);
1448 }
1449 }
1450 }
1451
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001452 public void dial(String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001453 dialForSubscriber(getPreferredVoiceSubscription(), number);
Wink Saville36469e72014-06-11 15:17:00 -07001454 }
1455
Wink Savilleb564aae2014-10-23 10:18:09 -07001456 public void dialForSubscriber(int subId, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001457 if (DBG) log("dial: " + number);
1458 // No permission check needed here: This is just a wrapper around the
1459 // ACTION_DIAL intent, which is available to any app since it puts up
1460 // the UI before it does anything.
1461
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001462 final long identity = Binder.clearCallingIdentity();
1463 try {
1464 String url = createTelUrl(number);
1465 if (url == null) {
1466 return;
1467 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001468
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001469 // PENDING: should we just silently fail if phone is offhook or ringing?
1470 PhoneConstants.State state = mCM.getState(subId);
1471 if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
1472 Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
1473 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1474 mApp.startActivity(intent);
1475 }
1476 } finally {
1477 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001478 }
1479 }
1480
1481 public void call(String callingPackage, String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001482 callForSubscriber(getPreferredVoiceSubscription(), callingPackage, number);
Wink Saville36469e72014-06-11 15:17:00 -07001483 }
1484
Wink Savilleb564aae2014-10-23 10:18:09 -07001485 public void callForSubscriber(int subId, String callingPackage, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001486 if (DBG) log("call: " + number);
1487
1488 // This is just a wrapper around the ACTION_CALL intent, but we still
1489 // need to do a permission check since we're calling startActivity()
1490 // from the context of the phone app.
1491 enforceCallPermission();
1492
Jordan Liu1617b712019-07-10 15:06:26 -07001493 if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001494 != AppOpsManager.MODE_ALLOWED) {
1495 return;
1496 }
1497
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001498 final long identity = Binder.clearCallingIdentity();
1499 try {
1500 String url = createTelUrl(number);
1501 if (url == null) {
1502 return;
1503 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001504
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001505 boolean isValid = false;
1506 final List<SubscriptionInfo> slist = getActiveSubscriptionInfoListPrivileged();
1507 if (slist != null) {
1508 for (SubscriptionInfo subInfoRecord : slist) {
1509 if (subInfoRecord.getSubscriptionId() == subId) {
1510 isValid = true;
1511 break;
1512 }
Wink Saville3ab207e2014-11-20 13:07:20 -08001513 }
Wink Saville08874612014-08-31 19:19:58 -07001514 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001515 if (!isValid) {
1516 return;
1517 }
Wink Saville08874612014-08-31 19:19:58 -07001518
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001519 Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
1520 intent.putExtra(SUBSCRIPTION_KEY, subId);
1521 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1522 mApp.startActivity(intent);
1523 } finally {
1524 Binder.restoreCallingIdentity(identity);
1525 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001526 }
1527
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001528 public boolean supplyPin(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001529 return supplyPinForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001530 }
1531
Wink Savilleb564aae2014-10-23 10:18:09 -07001532 public boolean supplyPinForSubscriber(int subId, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001533 int [] resultArray = supplyPinReportResultForSubscriber(subId, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001534 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1535 }
1536
1537 public boolean supplyPuk(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001538 return supplyPukForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001539 }
1540
Wink Savilleb564aae2014-10-23 10:18:09 -07001541 public boolean supplyPukForSubscriber(int subId, String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001542 int [] resultArray = supplyPukReportResultForSubscriber(subId, puk, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001543 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1544 }
1545
1546 /** {@hide} */
1547 public int[] supplyPinReportResult(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001548 return supplyPinReportResultForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001549 }
1550
Wink Savilleb564aae2014-10-23 10:18:09 -07001551 public int[] supplyPinReportResultForSubscriber(int subId, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001552 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001553
1554 final long identity = Binder.clearCallingIdentity();
1555 try {
1556 final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
1557 checkSimPin.start();
1558 return checkSimPin.unlockSim(null, pin);
1559 } finally {
1560 Binder.restoreCallingIdentity(identity);
1561 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001562 }
1563
Wink Saville9de0f752013-10-22 19:04:03 -07001564 /** {@hide} */
1565 public int[] supplyPukReportResult(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001566 return supplyPukReportResultForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001567 }
1568
Wink Savilleb564aae2014-10-23 10:18:09 -07001569 public int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001570 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001571
1572 final long identity = Binder.clearCallingIdentity();
1573 try {
1574 final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
1575 checkSimPuk.start();
1576 return checkSimPuk.unlockSim(puk, pin);
1577 } finally {
1578 Binder.restoreCallingIdentity(identity);
1579 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001580 }
1581
1582 /**
Wink Saville9de0f752013-10-22 19:04:03 -07001583 * Helper thread to turn async call to SimCard#supplyPin into
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001584 * a synchronous one.
1585 */
1586 private static class UnlockSim extends Thread {
1587
1588 private final IccCard mSimCard;
1589
1590 private boolean mDone = false;
Wink Saville9de0f752013-10-22 19:04:03 -07001591 private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1592 private int mRetryCount = -1;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001593
1594 // For replies from SimCard interface
1595 private Handler mHandler;
1596
1597 // For async handler to identify request type
1598 private static final int SUPPLY_PIN_COMPLETE = 100;
1599
1600 public UnlockSim(IccCard simCard) {
1601 mSimCard = simCard;
1602 }
1603
1604 @Override
1605 public void run() {
1606 Looper.prepare();
1607 synchronized (UnlockSim.this) {
1608 mHandler = new Handler() {
1609 @Override
1610 public void handleMessage(Message msg) {
1611 AsyncResult ar = (AsyncResult) msg.obj;
1612 switch (msg.what) {
1613 case SUPPLY_PIN_COMPLETE:
1614 Log.d(LOG_TAG, "SUPPLY_PIN_COMPLETE");
1615 synchronized (UnlockSim.this) {
Wink Saville9de0f752013-10-22 19:04:03 -07001616 mRetryCount = msg.arg1;
1617 if (ar.exception != null) {
1618 if (ar.exception instanceof CommandException &&
1619 ((CommandException)(ar.exception)).getCommandError()
1620 == CommandException.Error.PASSWORD_INCORRECT) {
1621 mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1622 } else {
1623 mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1624 }
1625 } else {
1626 mResult = PhoneConstants.PIN_RESULT_SUCCESS;
1627 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001628 mDone = true;
1629 UnlockSim.this.notifyAll();
1630 }
1631 break;
1632 }
1633 }
1634 };
1635 UnlockSim.this.notifyAll();
1636 }
1637 Looper.loop();
1638 }
1639
1640 /*
1641 * Use PIN or PUK to unlock SIM card
1642 *
1643 * If PUK is null, unlock SIM card with PIN
1644 *
1645 * If PUK is not null, unlock SIM card with PUK and set PIN code
1646 */
Wink Saville9de0f752013-10-22 19:04:03 -07001647 synchronized int[] unlockSim(String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001648
1649 while (mHandler == null) {
1650 try {
1651 wait();
1652 } catch (InterruptedException e) {
1653 Thread.currentThread().interrupt();
1654 }
1655 }
1656 Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
1657
1658 if (puk == null) {
1659 mSimCard.supplyPin(pin, callback);
1660 } else {
1661 mSimCard.supplyPuk(puk, pin, callback);
1662 }
1663
1664 while (!mDone) {
1665 try {
1666 Log.d(LOG_TAG, "wait for done");
1667 wait();
1668 } catch (InterruptedException e) {
1669 // Restore the interrupted status
1670 Thread.currentThread().interrupt();
1671 }
1672 }
1673 Log.d(LOG_TAG, "done");
Wink Saville9de0f752013-10-22 19:04:03 -07001674 int[] resultArray = new int[2];
1675 resultArray[0] = mResult;
1676 resultArray[1] = mRetryCount;
1677 return resultArray;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001678 }
1679 }
1680
1681 public void updateServiceLocation() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001682 updateServiceLocationForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001683
1684 }
1685
Wink Savilleb564aae2014-10-23 10:18:09 -07001686 public void updateServiceLocationForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001687 // No permission check needed here: this call is harmless, and it's
1688 // needed for the ServiceState.requestStateUpdate() call (which is
1689 // already intentionally exposed to 3rd parties.)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001690 final long identity = Binder.clearCallingIdentity();
1691 try {
1692 final Phone phone = getPhone(subId);
1693 if (phone != null) {
1694 phone.updateServiceLocation();
1695 }
1696 } finally {
1697 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001698 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001699 }
1700
Philip P. Moltmann700a9592019-10-03 11:53:50 -07001701 @Deprecated
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001702 @Override
1703 public boolean isRadioOn(String callingPackage) {
Philip P. Moltmann700a9592019-10-03 11:53:50 -07001704 return isRadioOnWithFeature(callingPackage, null);
1705 }
1706
1707
1708 @Override
1709 public boolean isRadioOnWithFeature(String callingPackage, String callingFeatureId) {
1710 return isRadioOnForSubscriberWithFeature(getDefaultSubscription(), callingPackage,
1711 callingFeatureId);
1712 }
1713
1714 @Deprecated
1715 @Override
1716 public boolean isRadioOnForSubscriber(int subId, String callingPackage) {
1717 return isRadioOnForSubscriberWithFeature(subId, callingPackage, null);
Wink Saville36469e72014-06-11 15:17:00 -07001718 }
1719
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001720 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07001721 public boolean isRadioOnForSubscriberWithFeature(int subId, String callingPackage,
1722 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08001723 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07001724 mApp, subId, callingPackage, callingFeatureId, "isRadioOnForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001725 return false;
1726 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001727
1728 final long identity = Binder.clearCallingIdentity();
1729 try {
1730 return isRadioOnForSubscriber(subId);
1731 } finally {
1732 Binder.restoreCallingIdentity(identity);
1733 }
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001734 }
1735
1736 private boolean isRadioOnForSubscriber(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001737 final long identity = Binder.clearCallingIdentity();
1738 try {
1739 final Phone phone = getPhone(subId);
1740 if (phone != null) {
1741 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
1742 } else {
1743 return false;
1744 }
1745 } finally {
1746 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001747 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001748 }
1749
1750 public void toggleRadioOnOff() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001751 toggleRadioOnOffForSubscriber(getDefaultSubscription());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001752 }
Wink Saville36469e72014-06-11 15:17:00 -07001753
Wink Savilleb564aae2014-10-23 10:18:09 -07001754 public void toggleRadioOnOffForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001755 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001756
1757 final long identity = Binder.clearCallingIdentity();
1758 try {
1759 final Phone phone = getPhone(subId);
1760 if (phone != null) {
1761 phone.setRadioPower(!isRadioOnForSubscriber(subId));
1762 }
1763 } finally {
1764 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001765 }
Wink Saville36469e72014-06-11 15:17:00 -07001766 }
1767
1768 public boolean setRadio(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001769 return setRadioForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001770 }
1771
Wink Savilleb564aae2014-10-23 10:18:09 -07001772 public boolean setRadioForSubscriber(int subId, boolean turnOn) {
Wink Saville36469e72014-06-11 15:17:00 -07001773 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001774
1775 final long identity = Binder.clearCallingIdentity();
1776 try {
1777 final Phone phone = getPhone(subId);
1778 if (phone == null) {
1779 return false;
1780 }
1781 if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
1782 toggleRadioOnOffForSubscriber(subId);
1783 }
1784 return true;
1785 } finally {
1786 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001787 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001788 }
Wink Saville36469e72014-06-11 15:17:00 -07001789
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001790 public boolean needMobileRadioShutdown() {
1791 /*
1792 * If any of the Radios are available, it will need to be
1793 * shutdown. So return true if any Radio is available.
1794 */
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001795 final long identity = Binder.clearCallingIdentity();
1796 try {
1797 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1798 Phone phone = PhoneFactory.getPhone(i);
1799 if (phone != null && phone.isRadioAvailable()) return true;
1800 }
1801 logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
1802 return false;
1803 } finally {
1804 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001805 }
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001806 }
1807
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001808 @Override
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001809 public void shutdownMobileRadios() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001810 enforceModifyPermission();
1811
1812 final long identity = Binder.clearCallingIdentity();
1813 try {
1814 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1815 logv("Shutting down Phone " + i);
1816 shutdownRadioUsingPhoneId(i);
1817 }
1818 } finally {
1819 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001820 }
1821 }
1822
1823 private void shutdownRadioUsingPhoneId(int phoneId) {
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001824 Phone phone = PhoneFactory.getPhone(phoneId);
1825 if (phone != null && phone.isRadioAvailable()) {
1826 phone.shutdownRadio();
1827 }
1828 }
1829
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001830 public boolean setRadioPower(boolean turnOn) {
Jack Yub4e16162017-05-15 12:48:40 -07001831 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001832
1833 final long identity = Binder.clearCallingIdentity();
1834 try {
1835 final Phone defaultPhone = PhoneFactory.getDefaultPhone();
1836 if (defaultPhone != null) {
1837 defaultPhone.setRadioPower(turnOn);
1838 return true;
1839 } else {
1840 loge("There's no default phone.");
1841 return false;
1842 }
1843 } finally {
1844 Binder.restoreCallingIdentity(identity);
Wei Liu9ae2a062016-08-08 11:09:34 -07001845 }
Wink Saville36469e72014-06-11 15:17:00 -07001846 }
1847
Wink Savilleb564aae2014-10-23 10:18:09 -07001848 public boolean setRadioPowerForSubscriber(int subId, boolean turnOn) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001849 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001850
1851 final long identity = Binder.clearCallingIdentity();
1852 try {
1853 final Phone phone = getPhone(subId);
1854 if (phone != null) {
1855 phone.setRadioPower(turnOn);
1856 return true;
1857 } else {
1858 return false;
1859 }
1860 } finally {
1861 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001862 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001863 }
1864
Wink Saville36469e72014-06-11 15:17:00 -07001865 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001866 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001867 public boolean enableDataConnectivity() {
1868 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001869
1870 final long identity = Binder.clearCallingIdentity();
1871 try {
1872 int subId = mSubscriptionController.getDefaultDataSubId();
1873 final Phone phone = getPhone(subId);
1874 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001875 phone.getDataEnabledSettings().setUserDataEnabled(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001876 return true;
1877 } else {
1878 return false;
1879 }
1880 } finally {
1881 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001882 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001883 }
1884
Wink Saville36469e72014-06-11 15:17:00 -07001885 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001886 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001887 public boolean disableDataConnectivity() {
1888 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001889
1890 final long identity = Binder.clearCallingIdentity();
1891 try {
1892 int subId = mSubscriptionController.getDefaultDataSubId();
1893 final Phone phone = getPhone(subId);
1894 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001895 phone.getDataEnabledSettings().setUserDataEnabled(false);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001896 return true;
1897 } else {
1898 return false;
1899 }
1900 } finally {
1901 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001902 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001903 }
1904
Sanket Padawe356d7632015-06-22 14:03:32 -07001905 @Override
Jack Yuacf8a132017-05-01 17:00:48 -07001906 public boolean isDataConnectivityPossible(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001907 final long identity = Binder.clearCallingIdentity();
1908 try {
1909 final Phone phone = getPhone(subId);
1910 if (phone != null) {
Jack Yub5d8f642018-11-26 11:20:48 -08001911 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001912 } else {
1913 return false;
1914 }
1915 } finally {
1916 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001917 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001918 }
1919
1920 public boolean handlePinMmi(String dialString) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001921 return handlePinMmiForSubscriber(getDefaultSubscription(), dialString);
Wink Saville36469e72014-06-11 15:17:00 -07001922 }
1923
pkanwarae03a6b2016-11-06 20:37:09 -08001924 public void handleUssdRequest(int subId, String ussdRequest, ResultReceiver wrappedCallback) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001925 enforceCallPermission();
1926
1927 final long identity = Binder.clearCallingIdentity();
1928 try {
1929 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1930 return;
1931 }
1932 Pair<String, ResultReceiver> ussdObject = new Pair(ussdRequest, wrappedCallback);
1933 sendRequest(CMD_HANDLE_USSD_REQUEST, ussdObject, subId);
1934 } finally {
1935 Binder.restoreCallingIdentity(identity);
1936 }
pkanwar32d516d2016-10-14 19:37:38 -07001937 };
1938
Wink Savilleb564aae2014-10-23 10:18:09 -07001939 public boolean handlePinMmiForSubscriber(int subId, String dialString) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001940 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001941
1942 final long identity = Binder.clearCallingIdentity();
1943 try {
1944 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1945 return false;
1946 }
1947 return (Boolean) sendRequest(CMD_HANDLE_PIN_MMI, dialString, subId);
1948 } finally {
1949 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001950 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001951 }
1952
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001953 public int getCallState() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001954 return getCallStateForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001955 }
1956
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001957 public int getCallStateForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001958 final long identity = Binder.clearCallingIdentity();
1959 try {
1960 Phone phone = PhoneFactory.getPhone(slotIndex);
1961 return phone == null ? TelephonyManager.CALL_STATE_IDLE :
1962 PhoneConstantConversions.convertCallState(phone.getState());
1963 } finally {
1964 Binder.restoreCallingIdentity(identity);
1965 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001966 }
1967
Sanket Padawe356d7632015-06-22 14:03:32 -07001968 @Override
Nathan Harolde037c472019-06-26 00:41:07 +00001969 public int getDataState() {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001970 return getDataStateForSubId(mSubscriptionController.getDefaultDataSubId());
1971 }
1972
1973 @Override
1974 public int getDataStateForSubId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001975 final long identity = Binder.clearCallingIdentity();
1976 try {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001977 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001978 if (phone != null) {
1979 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
1980 } else {
1981 return PhoneConstantConversions.convertDataState(
1982 PhoneConstants.DataState.DISCONNECTED);
1983 }
1984 } finally {
1985 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001986 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001987 }
1988
Sanket Padawe356d7632015-06-22 14:03:32 -07001989 @Override
Nathan Harolde037c472019-06-26 00:41:07 +00001990 public int getDataActivity() {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001991 return getDataActivityForSubId(mSubscriptionController.getDefaultDataSubId());
1992 }
1993
1994 @Override
1995 public int getDataActivityForSubId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001996 final long identity = Binder.clearCallingIdentity();
1997 try {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001998 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001999 if (phone != null) {
2000 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
2001 } else {
2002 return TelephonyManager.DATA_ACTIVITY_NONE;
2003 }
2004 } finally {
2005 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002006 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002007 }
2008
2009 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002010 public Bundle getCellLocation(String callingPackage, String callingFeatureId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002011 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08002012 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002013
2014 LocationAccessPolicy.LocationPermissionResult locationResult =
2015 LocationAccessPolicy.checkLocationPermission(mApp,
2016 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2017 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002018 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08002019 .setCallingPid(Binder.getCallingPid())
2020 .setCallingUid(Binder.getCallingUid())
2021 .setMethod("getCellLocation")
2022 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2023 .build());
2024 switch (locationResult) {
2025 case DENIED_HARD:
2026 throw new SecurityException("Not allowed to access cell location");
2027 case DENIED_SOFT:
2028 return new Bundle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002029 }
2030
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002031 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002032 final long identity = Binder.clearCallingIdentity();
2033 try {
2034 if (DBG_LOC) log("getCellLocation: is active user");
2035 Bundle data = new Bundle();
Nathan Harold3ff88932018-08-14 10:19:49 -07002036 int subId = mSubscriptionController.getDefaultDataSubId();
2037 CellLocation cl = (CellLocation) sendRequest(CMD_GET_CELL_LOCATION, workSource, subId);
2038 cl.fillInNotifierBundle(data);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002039 return data;
2040 } finally {
2041 Binder.restoreCallingIdentity(identity);
2042 }
Svetoslav64fad262015-04-14 14:35:21 -07002043 }
2044
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002045 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002046 public String getNetworkCountryIsoForPhone(int phoneId, String callingPackage,
2047 String callingFeatureId) {
Jack Yu1e81ccd2019-09-26 11:48:33 -07002048 if (!TextUtils.isEmpty(callingPackage)) {
2049 final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002050 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,
2051 callingFeatureId, "getNetworkCountryIsoForPhone")) {
Jack Yu1e81ccd2019-09-26 11:48:33 -07002052 return "";
2053 }
2054 }
2055
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002056 // Reporting the correct network country is ambiguous when IWLAN could conflict with
2057 // registered cell info, so return a NULL country instead.
2058 final long identity = Binder.clearCallingIdentity();
2059 try {
Malcolm Chen3732c2b2018-07-18 20:15:24 -07002060 if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
2061 // Get default phone in this case.
2062 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
2063 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002064 final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
Jack Yu5f7092c2018-04-13 14:05:37 -07002065 // Todo: fix this when we can get the actual cellular network info when the device
2066 // is on IWLAN.
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002067 if (TelephonyManager.NETWORK_TYPE_IWLAN
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002068 == getVoiceNetworkTypeForSubscriber(subId, mApp.getPackageName(),
2069 mApp.getFeatureId())) {
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002070 return "";
2071 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002072 Phone phone = PhoneFactory.getPhone(phoneId);
2073 if (phone != null) {
2074 ServiceStateTracker sst = phone.getServiceStateTracker();
sqianb9d961a2019-07-31 20:23:45 -07002075 EmergencyNumberTracker emergencyNumberTracker = phone.getEmergencyNumberTracker();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002076 if (sst != null) {
2077 LocaleTracker lt = sst.getLocaleTracker();
2078 if (lt != null) {
sqianb9d961a2019-07-31 20:23:45 -07002079 if (!TextUtils.isEmpty(lt.getCurrentCountry())) {
2080 return lt.getCurrentCountry();
2081 } else if (emergencyNumberTracker != null) {
2082 return emergencyNumberTracker.getEmergencyCountryIso();
2083 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002084 }
2085 }
2086 }
2087 return "";
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002088 } finally {
2089 Binder.restoreCallingIdentity(identity);
2090 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07002091 }
2092
2093 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002094 public void enableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07002095 enableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002096 }
2097
Sanket Padawe356d7632015-06-22 14:03:32 -07002098 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002099 public void enableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002100 mApp.enforceCallingOrSelfPermission(
2101 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002102
2103 final long identity = Binder.clearCallingIdentity();
2104 try {
2105 final Phone phone = getPhone(subId);
2106 if (phone != null) {
2107 phone.enableLocationUpdates();
2108 }
2109 } finally {
2110 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002111 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002112 }
2113
2114 @Override
2115 public void disableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07002116 disableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002117 }
2118
Sanket Padawe356d7632015-06-22 14:03:32 -07002119 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002120 public void disableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002121 mApp.enforceCallingOrSelfPermission(
2122 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002123
2124 final long identity = Binder.clearCallingIdentity();
2125 try {
2126 final Phone phone = getPhone(subId);
2127 if (phone != null) {
2128 phone.disableLocationUpdates();
2129 }
2130 } finally {
2131 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002132 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002133 }
2134
Nathan Harold31d7ff32018-10-15 20:20:30 -07002135 /**
2136 * Returns the target SDK version number for a given package name.
2137 *
Nathan Haroldec184742019-07-10 17:04:16 -07002138 * This call MUST be invoked before clearing the calling UID.
2139 *
Nathan Harold31d7ff32018-10-15 20:20:30 -07002140 * @return target SDK if the package is found or INT_MAX.
2141 */
2142 private int getTargetSdk(String packageName) {
2143 try {
Nathan Haroldec184742019-07-10 17:04:16 -07002144 final ApplicationInfo ai = mApp.getPackageManager().getApplicationInfoAsUser(
Chen Xu0150f0e2019-07-30 15:12:06 -07002145 packageName, 0, UserHandle.getUserHandleForUid(Binder.getCallingUid()));
Nathan Harold31d7ff32018-10-15 20:20:30 -07002146 if (ai != null) return ai.targetSdkVersion;
2147 } catch (PackageManager.NameNotFoundException unexpected) {
Nathan Haroldec184742019-07-10 17:04:16 -07002148 loge("Failed to get package info for pkg="
2149 + packageName + ", uid=" + Binder.getCallingUid());
Nathan Harold31d7ff32018-10-15 20:20:30 -07002150 }
2151 return Integer.MAX_VALUE;
2152 }
2153
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002154 @Override
2155 @SuppressWarnings("unchecked")
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002156 public List<NeighboringCellInfo> getNeighboringCellInfo(String callingPackage,
2157 String callingFeatureId) {
Nathan Harold31d7ff32018-10-15 20:20:30 -07002158 final int targetSdk = getTargetSdk(callingPackage);
Nathan Harolddbea45a2018-08-30 14:35:07 -07002159 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2160 throw new SecurityException(
2161 "getNeighboringCellInfo() is unavailable to callers targeting Q+ SDK levels.");
2162 }
Nathan Haroldb4d55612018-07-20 13:13:08 -07002163
Jordan Liu1617b712019-07-10 15:06:26 -07002164 if (mAppOps.noteOp(AppOpsManager.OPSTR_NEIGHBORING_CELLS, Binder.getCallingUid(),
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002165 callingPackage) != AppOpsManager.MODE_ALLOWED) {
2166 return null;
2167 }
Svetoslav64fad262015-04-14 14:35:21 -07002168
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002169 if (DBG_LOC) log("getNeighboringCellInfo: is active user");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002170
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002171 List<CellInfo> info = getAllCellInfo(callingPackage, callingFeatureId);
Nathan Haroldf180aac2018-06-01 18:43:55 -07002172 if (info == null) return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002173
Nathan Haroldf180aac2018-06-01 18:43:55 -07002174 List<NeighboringCellInfo> neighbors = new ArrayList<NeighboringCellInfo>();
2175 for (CellInfo ci : info) {
2176 if (ci instanceof CellInfoGsm) {
2177 neighbors.add(new NeighboringCellInfo((CellInfoGsm) ci));
2178 } else if (ci instanceof CellInfoWcdma) {
2179 neighbors.add(new NeighboringCellInfo((CellInfoWcdma) ci));
2180 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002181 }
Nathan Haroldf180aac2018-06-01 18:43:55 -07002182 return (neighbors.size()) > 0 ? neighbors : null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002183 }
2184
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002185 private List<CellInfo> getCachedCellInfo() {
2186 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2187 for (Phone phone : PhoneFactory.getPhones()) {
2188 List<CellInfo> info = phone.getAllCellInfo();
2189 if (info != null) cellInfos.addAll(info);
2190 }
2191 return cellInfos;
2192 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002193
2194 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002195 public List<CellInfo> getAllCellInfo(String callingPackage, String callingFeatureId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002196 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08002197 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002198
2199 LocationAccessPolicy.LocationPermissionResult locationResult =
2200 LocationAccessPolicy.checkLocationPermission(mApp,
2201 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2202 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002203 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08002204 .setCallingPid(Binder.getCallingPid())
2205 .setCallingUid(Binder.getCallingUid())
2206 .setMethod("getAllCellInfo")
Nathan Harold5ae50b52019-02-20 15:46:36 -08002207 .setMinSdkVersionForCoarse(Build.VERSION_CODES.BASE)
Hall Liuf19c44f2018-11-27 14:38:17 -08002208 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2209 .build());
2210 switch (locationResult) {
2211 case DENIED_HARD:
2212 throw new SecurityException("Not allowed to access cell info");
2213 case DENIED_SOFT:
2214 return new ArrayList<>();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002215 }
2216
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002217 final int targetSdk = getTargetSdk(callingPackage);
2218 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2219 return getCachedCellInfo();
2220 }
2221
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002222 if (DBG_LOC) log("getAllCellInfo: is active user");
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002223 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002224 final long identity = Binder.clearCallingIdentity();
2225 try {
2226 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2227 for (Phone phone : PhoneFactory.getPhones()) {
Nathan Harold3ff88932018-08-14 10:19:49 -07002228 final List<CellInfo> info = (List<CellInfo>) sendRequest(
Nathan Harold92bed182018-10-12 18:16:49 -07002229 CMD_GET_ALL_CELL_INFO, null, phone, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002230 if (info != null) cellInfos.addAll(info);
2231 }
2232 return cellInfos;
2233 } finally {
2234 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002235 }
2236 }
2237
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07002238 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002239 public void requestCellInfoUpdate(int subId, ICellInfoCallback cb, String callingPackage,
2240 String callingFeatureId) {
2241 requestCellInfoUpdateInternal(subId, cb, callingPackage, callingFeatureId,
2242 getWorkSource(Binder.getCallingUid()));
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002243 }
2244
2245 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002246 public void requestCellInfoUpdateWithWorkSource(int subId, ICellInfoCallback cb,
2247 String callingPackage, String callingFeatureId, WorkSource workSource) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002248 enforceModifyPermission();
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002249 requestCellInfoUpdateInternal(subId, cb, callingPackage, callingFeatureId, workSource);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002250 }
2251
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002252 private void requestCellInfoUpdateInternal(int subId, ICellInfoCallback cb,
2253 String callingPackage, String callingFeatureId, WorkSource workSource) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002254 mApp.getSystemService(AppOpsManager.class)
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002255 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002256
2257 LocationAccessPolicy.LocationPermissionResult locationResult =
2258 LocationAccessPolicy.checkLocationPermission(mApp,
2259 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2260 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07002261 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08002262 .setCallingPid(Binder.getCallingPid())
2263 .setCallingUid(Binder.getCallingUid())
2264 .setMethod("requestCellInfoUpdate")
2265 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2266 .build());
2267 switch (locationResult) {
2268 case DENIED_HARD:
2269 throw new SecurityException("Not allowed to access cell info");
2270 case DENIED_SOFT:
Nathan Harold5320c422019-05-09 10:26:08 -07002271 try {
2272 cb.onCellInfo(new ArrayList<CellInfo>());
2273 } catch (RemoteException re) {
2274 // Drop without consequences
2275 }
Hall Liuf19c44f2018-11-27 14:38:17 -08002276 return;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002277 }
2278
Nathan Harolda939a962019-05-09 10:13:47 -07002279
2280 final Phone phone = getPhoneFromSubId(subId);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002281 if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
2282
2283 sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
2284 }
2285
2286 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002287 public void setCellInfoListRate(int rateInMillis) {
Jack Yua8d8cb82017-01-16 10:15:34 -08002288 enforceModifyPermission();
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002289 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002290
2291 final long identity = Binder.clearCallingIdentity();
2292 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002293 getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002294 } finally {
2295 Binder.restoreCallingIdentity(identity);
2296 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002297 }
2298
Shishir Agrawala9f32182016-04-12 12:00:16 -07002299 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002300 public String getImeiForSlot(int slotIndex, String callingPackage, String callingFeatureId) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002301 Phone phone = PhoneFactory.getPhone(slotIndex);
2302 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002303 return null;
2304 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002305 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002306 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002307 callingPackage, callingFeatureId, "getImeiForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002308 return null;
2309 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002310
2311 final long identity = Binder.clearCallingIdentity();
2312 try {
2313 return phone.getImei();
2314 } finally {
2315 Binder.restoreCallingIdentity(identity);
2316 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002317 }
2318
2319 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002320 public String getTypeAllocationCodeForSlot(int slotIndex) {
2321 Phone phone = PhoneFactory.getPhone(slotIndex);
2322 String tac = null;
2323 if (phone != null) {
2324 String imei = phone.getImei();
2325 tac = imei == null ? null : imei.substring(0, TYPE_ALLOCATION_CODE_LENGTH);
2326 }
2327 return tac;
2328 }
2329
2330 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002331 public String getMeidForSlot(int slotIndex, String callingPackage, String callingFeatureId) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002332 Phone phone = PhoneFactory.getPhone(slotIndex);
2333 if (phone == null) {
Jack Yu2af8d712017-03-15 17:14:14 -07002334 return null;
2335 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002336
Jeff Davidson913390f2018-02-23 17:11:49 -08002337 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002338 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002339 callingPackage, callingFeatureId, "getMeidForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002340 return null;
2341 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002342
2343 final long identity = Binder.clearCallingIdentity();
2344 try {
2345 return phone.getMeid();
2346 } finally {
2347 Binder.restoreCallingIdentity(identity);
2348 }
Jack Yu2af8d712017-03-15 17:14:14 -07002349 }
2350
2351 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002352 public String getManufacturerCodeForSlot(int slotIndex) {
2353 Phone phone = PhoneFactory.getPhone(slotIndex);
2354 String manufacturerCode = null;
2355 if (phone != null) {
2356 String meid = phone.getMeid();
2357 manufacturerCode = meid == null ? null : meid.substring(0, MANUFACTURER_CODE_LENGTH);
2358 }
2359 return manufacturerCode;
2360 }
2361
2362 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002363 public String getDeviceSoftwareVersionForSlot(int slotIndex, String callingPackage,
2364 String callingFeatureId) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002365 Phone phone = PhoneFactory.getPhone(slotIndex);
2366 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002367 return null;
2368 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002369 int subId = phone.getSubId();
2370 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002371 mApp, subId, callingPackage, callingFeatureId,
2372 "getDeviceSoftwareVersionForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002373 return null;
2374 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002375
2376 final long identity = Binder.clearCallingIdentity();
2377 try {
2378 return phone.getDeviceSvn();
2379 } finally {
2380 Binder.restoreCallingIdentity(identity);
2381 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002382 }
2383
fionaxu43304da2017-11-27 22:51:16 -08002384 @Override
2385 public int getSubscriptionCarrierId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002386 final long identity = Binder.clearCallingIdentity();
2387 try {
2388 final Phone phone = getPhone(subId);
2389 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
2390 } finally {
2391 Binder.restoreCallingIdentity(identity);
2392 }
fionaxu43304da2017-11-27 22:51:16 -08002393 }
2394
2395 @Override
2396 public String getSubscriptionCarrierName(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002397 final long identity = Binder.clearCallingIdentity();
2398 try {
2399 final Phone phone = getPhone(subId);
2400 return phone == null ? null : phone.getCarrierName();
2401 } finally {
2402 Binder.restoreCallingIdentity(identity);
2403 }
fionaxu43304da2017-11-27 22:51:16 -08002404 }
2405
calvinpanffe225e2018-11-01 19:43:06 +08002406 @Override
chen xu0026ca62019-03-06 15:28:50 -08002407 public int getSubscriptionSpecificCarrierId(int subId) {
chen xu25637222018-11-04 17:17:00 -08002408 final long identity = Binder.clearCallingIdentity();
2409 try {
2410 final Phone phone = getPhone(subId);
2411 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
chen xu0026ca62019-03-06 15:28:50 -08002412 : phone.getSpecificCarrierId();
chen xu25637222018-11-04 17:17:00 -08002413 } finally {
2414 Binder.restoreCallingIdentity(identity);
2415 }
2416 }
2417
2418 @Override
chen xu0026ca62019-03-06 15:28:50 -08002419 public String getSubscriptionSpecificCarrierName(int subId) {
chen xu25637222018-11-04 17:17:00 -08002420 final long identity = Binder.clearCallingIdentity();
2421 try {
2422 final Phone phone = getPhone(subId);
chen xu0026ca62019-03-06 15:28:50 -08002423 return phone == null ? null : phone.getSpecificCarrierName();
chen xu25637222018-11-04 17:17:00 -08002424 } finally {
2425 Binder.restoreCallingIdentity(identity);
2426 }
2427 }
2428
chen xu651eec72018-11-11 19:03:44 -08002429 @Override
chen xu864e11c2018-12-06 22:10:03 -08002430 public int getCarrierIdFromMccMnc(int slotIndex, String mccmnc, boolean isSubscriptionMccMnc) {
2431 if (!isSubscriptionMccMnc) {
2432 enforceReadPrivilegedPermission("getCarrierIdFromMccMnc");
2433 }
chen xu651eec72018-11-11 19:03:44 -08002434 final Phone phone = PhoneFactory.getPhone(slotIndex);
2435 if (phone == null) {
2436 return TelephonyManager.UNKNOWN_CARRIER_ID;
2437 }
2438 final long identity = Binder.clearCallingIdentity();
2439 try {
2440 return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
2441 } finally {
2442 Binder.restoreCallingIdentity(identity);
2443 }
2444 }
2445
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002446 //
2447 // Internal helper methods.
2448 //
2449
Sanket Padaweee13a9b2016-03-08 17:30:28 -08002450 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002451 * Make sure the caller has the MODIFY_PHONE_STATE permission.
2452 *
2453 * @throws SecurityException if the caller does not have the required permission
2454 */
2455 private void enforceModifyPermission() {
2456 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
2457 }
2458
Shuo Qian3b6ee772019-11-13 17:43:31 -08002459 private void enforceActiveEmergencySessionPermission() {
2460 mApp.enforceCallingOrSelfPermission(
2461 android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION, null);
2462 }
2463
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002464 /**
2465 * Make sure the caller has the CALL_PHONE permission.
2466 *
2467 * @throws SecurityException if the caller does not have the required permission
2468 */
2469 private void enforceCallPermission() {
2470 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
2471 }
2472
Stuart Scott8eef64f2015-04-08 15:13:54 -07002473 private void enforceConnectivityInternalPermission() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002474 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL,
Stuart Scott8eef64f2015-04-08 15:13:54 -07002475 "ConnectivityService");
2476 }
2477
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002478 private String createTelUrl(String number) {
2479 if (TextUtils.isEmpty(number)) {
2480 return null;
2481 }
2482
Jake Hambye994d462014-02-03 13:10:13 -08002483 return "tel:" + number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002484 }
2485
Ihab Awadf9e92732013-12-05 18:02:52 -08002486 private static void log(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002487 Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
2488 }
2489
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07002490 private static void logv(String msg) {
2491 Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
2492 }
2493
Ihab Awadf9e92732013-12-05 18:02:52 -08002494 private static void loge(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002495 Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
2496 }
2497
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002498 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002499 public int getActivePhoneType() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07002500 return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002501 }
2502
Sanket Padawe356d7632015-06-22 14:03:32 -07002503 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002504 public int getActivePhoneTypeForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002505 final long identity = Binder.clearCallingIdentity();
2506 try {
2507 final Phone phone = PhoneFactory.getPhone(slotIndex);
2508 if (phone == null) {
2509 return PhoneConstants.PHONE_TYPE_NONE;
2510 } else {
2511 return phone.getPhoneType();
2512 }
2513 } finally {
2514 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002515 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002516 }
2517
2518 /**
2519 * Returns the CDMA ERI icon index to display
2520 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002521 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002522 public int getCdmaEriIconIndex(String callingPackage, String callingFeatureId) {
2523 return getCdmaEriIconIndexForSubscriber(getDefaultSubscription(), callingPackage,
2524 callingFeatureId);
Wink Saville36469e72014-06-11 15:17:00 -07002525 }
2526
Sanket Padawe356d7632015-06-22 14:03:32 -07002527 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002528 public int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage,
2529 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002530 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002531 mApp, subId, callingPackage, callingFeatureId,
2532 "getCdmaEriIconIndexForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002533 return -1;
2534 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002535
2536 final long identity = Binder.clearCallingIdentity();
2537 try {
2538 final Phone phone = getPhone(subId);
2539 if (phone != null) {
2540 return phone.getCdmaEriIconIndex();
2541 } else {
2542 return -1;
2543 }
2544 } finally {
2545 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002546 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002547 }
2548
2549 /**
2550 * Returns the CDMA ERI icon mode,
2551 * 0 - ON
2552 * 1 - FLASHING
2553 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002554 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002555 public int getCdmaEriIconMode(String callingPackage, String callingFeatureId) {
2556 return getCdmaEriIconModeForSubscriber(getDefaultSubscription(), callingPackage,
2557 callingFeatureId);
Wink Saville36469e72014-06-11 15:17:00 -07002558 }
2559
Sanket Padawe356d7632015-06-22 14:03:32 -07002560 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002561 public int getCdmaEriIconModeForSubscriber(int subId, String callingPackage,
2562 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002563 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002564 mApp, subId, callingPackage, callingFeatureId,
2565 "getCdmaEriIconModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002566 return -1;
2567 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002568
2569 final long identity = Binder.clearCallingIdentity();
2570 try {
2571 final Phone phone = getPhone(subId);
2572 if (phone != null) {
2573 return phone.getCdmaEriIconMode();
2574 } else {
2575 return -1;
2576 }
2577 } finally {
2578 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002579 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002580 }
2581
2582 /**
2583 * Returns the CDMA ERI text,
2584 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002585 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002586 public String getCdmaEriText(String callingPackage, String callingFeatureId) {
2587 return getCdmaEriTextForSubscriber(getDefaultSubscription(), callingPackage,
2588 callingFeatureId);
Wink Saville36469e72014-06-11 15:17:00 -07002589 }
2590
Sanket Padawe356d7632015-06-22 14:03:32 -07002591 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002592 public String getCdmaEriTextForSubscriber(int subId, String callingPackage,
2593 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002594 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002595 mApp, subId, callingPackage, callingFeatureId,
2596 "getCdmaEriIconTextForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002597 return null;
2598 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002599
2600 final long identity = Binder.clearCallingIdentity();
2601 try {
2602 final Phone phone = getPhone(subId);
2603 if (phone != null) {
2604 return phone.getCdmaEriText();
2605 } else {
2606 return null;
2607 }
2608 } finally {
2609 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002610 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002611 }
2612
2613 /**
Junda Liuca05d5d2014-08-14 22:36:34 -07002614 * Returns the CDMA MDN.
2615 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002616 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002617 public String getCdmaMdn(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002618 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2619 mApp, subId, "getCdmaMdn");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002620
2621 final long identity = Binder.clearCallingIdentity();
2622 try {
2623 final Phone phone = getPhone(subId);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002624 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002625 return phone.getLine1Number();
2626 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002627 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002628 return null;
2629 }
2630 } finally {
2631 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002632 }
2633 }
2634
2635 /**
2636 * Returns the CDMA MIN.
2637 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002638 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002639 public String getCdmaMin(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002640 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2641 mApp, subId, "getCdmaMin");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002642
2643 final long identity = Binder.clearCallingIdentity();
2644 try {
2645 final Phone phone = getPhone(subId);
2646 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2647 return phone.getCdmaMin();
2648 } else {
2649 return null;
2650 }
2651 } finally {
2652 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002653 }
2654 }
2655
Hall Liud892bec2018-11-30 14:51:45 -08002656 @Override
2657 public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
2658 INumberVerificationCallback callback, String callingPackage) {
2659 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
2660 != PERMISSION_GRANTED) {
2661 throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
2662 }
2663 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2664
2665 String authorizedPackage = NumberVerificationManager.getAuthorizedPackage(mApp);
2666 if (!TextUtils.equals(callingPackage, authorizedPackage)) {
2667 throw new SecurityException("Calling package must be configured in the device config");
2668 }
2669
2670 if (range == null) {
2671 throw new NullPointerException("Range must be non-null");
2672 }
2673
2674 timeoutMillis = Math.min(timeoutMillis,
Hall Liubd069e32019-02-28 18:56:30 -08002675 TelephonyManager.getMaxNumberVerificationTimeoutMillis());
Hall Liud892bec2018-11-30 14:51:45 -08002676
2677 NumberVerificationManager.getInstance().requestVerification(range, callback, timeoutMillis);
2678 }
2679
Junda Liuca05d5d2014-08-14 22:36:34 -07002680 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002681 * Returns true if CDMA provisioning needs to run.
2682 */
2683 public boolean needsOtaServiceProvisioning() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002684 final long identity = Binder.clearCallingIdentity();
2685 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002686 return getDefaultPhone().needsOtaServiceProvisioning();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002687 } finally {
2688 Binder.restoreCallingIdentity(identity);
2689 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002690 }
2691
2692 /**
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002693 * Sets the voice mail number of a given subId.
2694 */
2695 @Override
2696 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002697 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setVoiceMailNumber");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002698
2699 final long identity = Binder.clearCallingIdentity();
2700 try {
2701 Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
2702 new Pair<String, String>(alphaTag, number), new Integer(subId));
2703 return success;
2704 } finally {
2705 Binder.restoreCallingIdentity(identity);
2706 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002707 }
2708
Ta-wei Yen87c49842016-05-13 21:19:52 -07002709 @Override
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002710 public Bundle getVisualVoicemailSettings(String callingPackage, int subId) {
2711 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Tyler Gunn5ddfdc92019-10-31 13:08:23 -07002712 TelecomManager tm = mApp.getSystemService(TelecomManager.class);
2713 String systemDialer = tm.getSystemDialerPackage();
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002714 if (!TextUtils.equals(callingPackage, systemDialer)) {
2715 throw new SecurityException("caller must be system dialer");
2716 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002717
2718 final long identity = Binder.clearCallingIdentity();
2719 try {
2720 PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
2721 if (phoneAccountHandle == null) {
2722 return null;
2723 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002724 return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002725 } finally {
2726 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002727 }
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002728 }
2729
2730 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002731 public String getVisualVoicemailPackageName(String callingPackage, String callingFeatureId,
2732 int subId) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002733 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jeff Davidson7e17e312018-02-13 18:17:36 -08002734 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002735 mApp, subId, callingPackage, callingFeatureId,
2736 "getVisualVoicemailPackageName")) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002737 return null;
2738 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002739
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002740 final long identity = Binder.clearCallingIdentity();
2741 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002742 return RemoteVvmTaskManager.getRemotePackage(mApp, subId).getPackageName();
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002743 } finally {
2744 Binder.restoreCallingIdentity(identity);
2745 }
Ta-wei Yendca928f2017-01-10 16:17:08 -08002746 }
2747
2748 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002749 public void enableVisualVoicemailSmsFilter(String callingPackage, int subId,
2750 VisualVoicemailSmsFilterSettings settings) {
2751 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002752
2753 final long identity = Binder.clearCallingIdentity();
2754 try {
2755 VisualVoicemailSmsFilterConfig.enableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002756 mApp, callingPackage, subId, settings);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002757 } finally {
2758 Binder.restoreCallingIdentity(identity);
2759 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002760 }
2761
2762 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002763 public void disableVisualVoicemailSmsFilter(String callingPackage, int subId) {
2764 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002765
2766 final long identity = Binder.clearCallingIdentity();
2767 try {
2768 VisualVoicemailSmsFilterConfig.disableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002769 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002770 } finally {
2771 Binder.restoreCallingIdentity(identity);
2772 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002773 }
2774
2775 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002776 public VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(
2777 String callingPackage, int subId) {
2778 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002779
2780 final long identity = Binder.clearCallingIdentity();
2781 try {
2782 return VisualVoicemailSmsFilterConfig.getVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002783 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002784 } finally {
2785 Binder.restoreCallingIdentity(identity);
2786 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002787 }
2788
2789 @Override
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002790 public VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002791 enforceReadPrivilegedPermission("getActiveVisualVoicemailSmsFilterSettings");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002792
2793 final long identity = Binder.clearCallingIdentity();
2794 try {
2795 return VisualVoicemailSmsFilterConfig.getActiveVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002796 mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002797 } finally {
2798 Binder.restoreCallingIdentity(identity);
2799 }
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002800 }
2801
2802 @Override
2803 public void sendVisualVoicemailSmsForSubscriber(String callingPackage, int subId,
2804 String number, int port, String text, PendingIntent sentIntent) {
2805 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen527a9c02017-01-06 15:29:25 -08002806 enforceVisualVoicemailPackage(callingPackage, subId);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002807 enforceSendSmsPermission();
Amit Mahajandccb3f12019-05-13 13:48:32 -07002808 SmsController smsController = PhoneFactory.getSmsController();
2809 smsController.sendVisualVoicemailSmsForSubscriber(callingPackage, subId, number, port, text,
2810 sentIntent);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002811 }
Amit Mahajandccb3f12019-05-13 13:48:32 -07002812
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002813 /**
fionaxu0152e512016-11-14 13:36:14 -08002814 * Sets the voice activation state of a given subId.
2815 */
2816 @Override
2817 public void setVoiceActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002818 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2819 mApp, subId, "setVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002820
2821 final long identity = Binder.clearCallingIdentity();
2822 try {
2823 final Phone phone = getPhone(subId);
2824 if (phone != null) {
2825 phone.setVoiceActivationState(activationState);
2826 } else {
2827 loge("setVoiceActivationState fails with invalid subId: " + subId);
2828 }
2829 } finally {
2830 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002831 }
2832 }
2833
2834 /**
2835 * Sets the data activation state of a given subId.
2836 */
2837 @Override
2838 public void setDataActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002839 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2840 mApp, subId, "setDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002841
2842 final long identity = Binder.clearCallingIdentity();
2843 try {
2844 final Phone phone = getPhone(subId);
2845 if (phone != null) {
2846 phone.setDataActivationState(activationState);
2847 } else {
Taesu Leef8fbed92019-10-07 18:47:02 +09002848 loge("setDataActivationState fails with invalid subId: " + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002849 }
2850 } finally {
2851 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002852 }
2853 }
2854
2855 /**
2856 * Returns the voice activation state of a given subId.
2857 */
2858 @Override
2859 public int getVoiceActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002860 enforceReadPrivilegedPermission("getVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002861
fionaxu0152e512016-11-14 13:36:14 -08002862 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002863 final long identity = Binder.clearCallingIdentity();
2864 try {
2865 if (phone != null) {
2866 return phone.getVoiceActivationState();
2867 } else {
2868 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2869 }
2870 } finally {
2871 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002872 }
2873 }
2874
2875 /**
2876 * Returns the data activation state of a given subId.
2877 */
2878 @Override
2879 public int getDataActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002880 enforceReadPrivilegedPermission("getDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002881
fionaxu0152e512016-11-14 13:36:14 -08002882 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002883 final long identity = Binder.clearCallingIdentity();
2884 try {
2885 if (phone != null) {
2886 return phone.getDataActivationState();
2887 } else {
2888 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2889 }
2890 } finally {
2891 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002892 }
2893 }
2894
2895 /**
Wink Saville36469e72014-06-11 15:17:00 -07002896 * Returns the unread count of voicemails for a subId
2897 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002898 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002899 public int getVoiceMessageCountForSubscriber(int subId, String callingPackage,
2900 String callingFeatureId) {
Brad Ebingerf7664ba2018-11-29 12:43:38 -08002901 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07002902 mApp, subId, callingPackage, callingFeatureId,
2903 "getVoiceMessageCountForSubscriber")) {
Brad Ebingerf7664ba2018-11-29 12:43:38 -08002904 return 0;
2905 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002906 final long identity = Binder.clearCallingIdentity();
2907 try {
2908 final Phone phone = getPhone(subId);
2909 if (phone != null) {
2910 return phone.getVoiceMessageCount();
2911 } else {
2912 return 0;
2913 }
2914 } finally {
2915 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002916 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002917 }
2918
2919 /**
pkanwar8a4dcfb2017-01-19 13:43:16 -08002920 * returns true, if the device is in a state where both voice and data
2921 * are supported simultaneously. This can change based on location or network condition.
2922 */
2923 @Override
2924 public boolean isConcurrentVoiceAndDataAllowed(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002925 final long identity = Binder.clearCallingIdentity();
2926 try {
2927 final Phone phone = getPhone(subId);
2928 return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
2929 } finally {
2930 Binder.restoreCallingIdentity(identity);
2931 }
pkanwar8a4dcfb2017-01-19 13:43:16 -08002932 }
2933
2934 /**
fionaxu235cc5e2017-03-06 22:25:57 -08002935 * Send the dialer code if called from the current default dialer or the caller has
2936 * carrier privilege.
2937 * @param inputCode The dialer code to send
2938 */
2939 @Override
2940 public void sendDialerSpecialCode(String callingPackage, String inputCode) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002941 final Phone defaultPhone = getDefaultPhone();
fionaxu235cc5e2017-03-06 22:25:57 -08002942 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Tyler Gunn5ddfdc92019-10-31 13:08:23 -07002943 TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
2944 String defaultDialer = tm.getDefaultDialerPackage();
fionaxu235cc5e2017-03-06 22:25:57 -08002945 if (!TextUtils.equals(callingPackage, defaultDialer)) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002946 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
2947 getDefaultSubscription(), "sendDialerSpecialCode");
fionaxu235cc5e2017-03-06 22:25:57 -08002948 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002949
2950 final long identity = Binder.clearCallingIdentity();
2951 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002952 defaultPhone.sendDialerSpecialCode(inputCode);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002953 } finally {
2954 Binder.restoreCallingIdentity(identity);
2955 }
fionaxu235cc5e2017-03-06 22:25:57 -08002956 }
2957
Pengquan Menga1bb6272018-09-06 09:59:22 -07002958 @Override
2959 public int getNetworkSelectionMode(int subId) {
Pengquan Menge92a50d2018-09-21 15:54:48 -07002960 if (!isActiveSubscription(subId)) {
2961 return TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
2962 }
2963
Pengquan Menga1bb6272018-09-06 09:59:22 -07002964 return (int) sendRequest(CMD_GET_NETWORK_SELECTION_MODE, null /* argument */, subId);
2965 }
2966
Brad Ebinger35c841c2018-10-01 10:40:55 -07002967 @Override
Brad Ebingerb2b65522019-03-15 13:48:47 -07002968 public boolean isInEmergencySmsMode() {
2969 enforceReadPrivilegedPermission("isInEmergencySmsMode");
2970 final long identity = Binder.clearCallingIdentity();
2971 try {
2972 for (Phone phone : PhoneFactory.getPhones()) {
2973 if (phone.isInEmergencySmsMode()) {
2974 return true;
2975 }
2976 }
2977 } finally {
2978 Binder.restoreCallingIdentity(identity);
2979 }
2980 return false;
2981 }
2982
2983 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002984 public void registerImsRegistrationCallback(int subId, IImsRegistrationCallback c)
2985 throws RemoteException {
2986 enforceReadPrivilegedPermission("registerImsRegistrationCallback");
Brad Ebingerbc7dd582019-10-17 17:03:22 -07002987 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
2988 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
2989 "IMS not available on device.");
2990 }
Brad Ebinger35c841c2018-10-01 10:40:55 -07002991 final long token = Binder.clearCallingIdentity();
2992 try {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002993 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002994 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002995 .addRegistrationCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002996 } catch (ImsException e) {
2997 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002998 } finally {
2999 Binder.restoreCallingIdentity(token);
3000 }
3001 }
3002
3003 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003004 public void unregisterImsRegistrationCallback(int subId, IImsRegistrationCallback c) {
3005 enforceReadPrivilegedPermission("unregisterImsRegistrationCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003006 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3007 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3008 }
Meng Wangafbc5852019-09-19 17:37:13 -07003009 final long token = Binder.clearCallingIdentity();
3010 try {
3011 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3012 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
3013 .removeRegistrationCallbackForSubscription(c, subId);
3014 } catch (ImsException e) {
3015 Log.i(LOG_TAG, "unregisterImsRegistrationCallback: " + subId
3016 + "is inactive, ignoring unregister.");
3017 // If the subscription is no longer active, just return, since the callback
3018 // will already have been removed internally.
3019 } finally {
3020 Binder.restoreCallingIdentity(token);
3021 }
Brad Ebinger35c841c2018-10-01 10:40:55 -07003022 }
3023
Brad Ebingera34a6c22019-10-22 17:36:18 -07003024 /**
3025 * Get the IMS service registration state for the MmTelFeature associated with this sub id.
3026 */
3027 @Override
3028 public void getImsMmTelRegistrationState(int subId, IIntegerConsumer consumer) {
3029 enforceReadPrivilegedPermission("getImsMmTelRegistrationState");
3030 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
3031 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
3032 "IMS not available on device.");
3033 }
3034 final long token = Binder.clearCallingIdentity();
3035 try {
3036 Phone phone = getPhone(subId);
3037 if (phone == null) {
3038 Log.w(LOG_TAG, "getImsMmTelRegistrationState: called with an invalid subscription '"
3039 + subId + "'");
3040 throw new ServiceSpecificException(ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
3041 }
3042 phone.getImsRegistrationState(regState -> {
3043 try {
3044 consumer.accept((regState == null)
3045 ? RegistrationManager.REGISTRATION_STATE_NOT_REGISTERED : regState);
3046 } catch (RemoteException e) {
3047 // Ignore if the remote process is no longer available to call back.
3048 Log.w(LOG_TAG, "getImsMmTelRegistrationState: callback not available.");
3049 }
3050 });
3051 } finally {
3052 Binder.restoreCallingIdentity(token);
3053 }
3054 }
3055
3056 /**
3057 * Get the transport type for the IMS service registration state.
3058 */
3059 @Override
3060 public void getImsMmTelRegistrationTransportType(int subId, IIntegerConsumer consumer) {
3061 enforceReadPrivilegedPermission("getImsMmTelRegistrationTransportType");
3062 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
3063 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
3064 "IMS not available on device.");
3065 }
3066 final long token = Binder.clearCallingIdentity();
3067 try {
3068 Phone phone = getPhone(subId);
3069 if (phone == null) {
3070 Log.w(LOG_TAG, "getImsMmTelRegistrationState: called with an invalid subscription '"
3071 + subId + "'");
3072 throw new ServiceSpecificException(ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
3073 }
3074 phone.getImsRegistrationTech(regTech -> {
3075 // Convert registration tech from ImsRegistrationImplBase -> RegistrationManager
3076 int regTechConverted = (regTech == null)
3077 ? ImsRegistrationImplBase.REGISTRATION_TECH_NONE : regTech;
3078 regTechConverted = RegistrationManager.IMS_REG_TO_ACCESS_TYPE_MAP.get(
3079 regTechConverted);
3080 try {
3081 consumer.accept(regTechConverted);
3082 } catch (RemoteException e) {
3083 // Ignore if the remote process is no longer available to call back.
3084 Log.w(LOG_TAG, "getImsMmTelRegistrationState: callback not available.");
3085 }
3086 });
3087 } finally {
3088 Binder.restoreCallingIdentity(token);
3089 }
3090 }
3091
Brad Ebinger35c841c2018-10-01 10:40:55 -07003092 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003093 public void registerMmTelCapabilityCallback(int subId, IImsCapabilityCallback c)
3094 throws RemoteException {
3095 enforceReadPrivilegedPermission("registerMmTelCapabilityCallback");
Brad Ebingerbc7dd582019-10-17 17:03:22 -07003096 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
3097 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
3098 "IMS not available on device.");
3099 }
Brad Ebinger35c841c2018-10-01 10:40:55 -07003100 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3101 final long token = Binder.clearCallingIdentity();
3102 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003103 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07003104 .addCapabilitiesCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003105 } catch (ImsException e) {
3106 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003107 } finally {
3108 Binder.restoreCallingIdentity(token);
3109 }
3110 }
3111
3112 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003113 public void unregisterMmTelCapabilityCallback(int subId, IImsCapabilityCallback c) {
3114 enforceReadPrivilegedPermission("unregisterMmTelCapabilityCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003115 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3116 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3117 }
Meng Wangafbc5852019-09-19 17:37:13 -07003118
3119 final long token = Binder.clearCallingIdentity();
3120 try {
3121 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
3122 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003123 .removeCapabilitiesCallbackForSubscription(c, subId);
Meng Wangafbc5852019-09-19 17:37:13 -07003124 } catch (ImsException e) {
3125 Log.i(LOG_TAG, "unregisterMmTelCapabilityCallback: " + subId
3126 + "is inactive, ignoring unregister.");
3127 // If the subscription is no longer active, just return, since the callback
3128 // will already have been removed internally.
3129 } finally {
3130 Binder.restoreCallingIdentity(token);
3131 }
Brad Ebinger35c841c2018-10-01 10:40:55 -07003132 }
3133
3134 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003135 public boolean isCapable(int subId, int capability, int regTech) {
3136 enforceReadPrivilegedPermission("isCapable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003137 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3138 final long token = Binder.clearCallingIdentity();
3139 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003140 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003141 getSlotIndexOrException(subId)).queryMmTelCapability(capability, regTech);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003142 } catch (com.android.ims.ImsException e) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003143 Log.w(LOG_TAG, "IMS isCapable - service unavailable: " + e.getMessage());
3144 return false;
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003145 } catch (ImsException e) {
Brad Ebinger6b5ac222019-02-04 14:36:52 -08003146 Log.i(LOG_TAG, "isCapable: " + subId + " is inactive, returning false.");
3147 return false;
Brad Ebinger35c841c2018-10-01 10:40:55 -07003148 } finally {
3149 Binder.restoreCallingIdentity(token);
3150 }
3151 }
3152
3153 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003154 public boolean isAvailable(int subId, int capability, int regTech) {
3155 enforceReadPrivilegedPermission("isAvailable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003156 final long token = Binder.clearCallingIdentity();
3157 try {
3158 Phone phone = getPhone(subId);
3159 if (phone == null) return false;
3160 return phone.isImsCapabilityAvailable(capability, regTech);
3161 } finally {
3162 Binder.restoreCallingIdentity(token);
3163 }
3164 }
3165
Brad Ebingerbc7dd582019-10-17 17:03:22 -07003166 /**
3167 * Determines if the MmTel feature capability is supported by the carrier configuration for this
3168 * subscription.
3169 * @param subId The subscription to use to check the configuration.
3170 * @param callback The callback that will be used to send the result.
3171 * @param capability The MmTelFeature capability that will be used to send the result.
3172 * @param transportType The transport type of the MmTelFeature capability.
3173 */
3174 @Override
3175 public void isMmTelCapabilitySupported(int subId, IIntegerConsumer callback, int capability,
3176 int transportType) {
3177 enforceReadPrivilegedPermission("isMmTelCapabilitySupported");
3178 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
3179 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
3180 "IMS not available on device.");
3181 }
3182 final long token = Binder.clearCallingIdentity();
3183 try {
3184 int slotId = getSlotIndex(subId);
3185 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3186 Log.w(LOG_TAG, "isMmTelCapabilitySupported: called with an inactive subscription '"
3187 + subId + "'");
3188 throw new ServiceSpecificException(ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
3189 }
3190 ImsManager.getInstance(mApp, slotId).isSupported(capability,
3191 transportType, aBoolean -> {
3192 try {
3193 callback.accept((aBoolean == null) ? 0 : (aBoolean ? 1 : 0));
3194 } catch (RemoteException e) {
3195 Log.w(LOG_TAG, "isMmTelCapabilitySupported: remote caller is not "
3196 + "running. Ignore");
3197 }
3198 });
3199 } finally {
3200 Binder.restoreCallingIdentity(token);
3201 }
3202 }
3203
Brad Ebinger35c841c2018-10-01 10:40:55 -07003204 @Override
3205 public boolean isAdvancedCallingSettingEnabled(int subId) {
3206 enforceReadPrivilegedPermission("enforceReadPrivilegedPermission");
3207 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3208 final long token = Binder.clearCallingIdentity();
3209 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003210 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003211 getSlotIndexOrException(subId)).isEnhanced4gLteModeSettingEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003212 } catch (ImsException e) {
3213 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003214 } finally {
3215 Binder.restoreCallingIdentity(token);
3216 }
3217 }
3218
3219 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003220 public void setAdvancedCallingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003221 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003222 "setAdvancedCallingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003223 final long identity = Binder.clearCallingIdentity();
3224 try {
3225 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003226 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003227 getSlotIndexOrException(subId)).setEnhanced4gLteModeSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003228 } catch (ImsException e) {
3229 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003230 } finally {
3231 Binder.restoreCallingIdentity(identity);
3232 }
3233 }
3234
3235 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08003236 public boolean isVtSettingEnabled(int subId) {
3237 enforceReadPrivilegedPermission("isVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003238 final long identity = Binder.clearCallingIdentity();
3239 try {
3240 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003241 return ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).isVtEnabledByUser();
3242 } catch (ImsException e) {
3243 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003244 } finally {
3245 Binder.restoreCallingIdentity(identity);
3246 }
3247 }
3248
3249 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003250 public void setVtSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003251 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003252 "setVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003253 final long identity = Binder.clearCallingIdentity();
3254 try {
3255 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003256 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setVtSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003257 } catch (ImsException e) {
3258 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003259 } finally {
3260 Binder.restoreCallingIdentity(identity);
3261 }
3262 }
3263
3264 @Override
3265 public boolean isVoWiFiSettingEnabled(int subId) {
3266 enforceReadPrivilegedPermission("isVoWiFiSettingEnabled");
3267 final long identity = Binder.clearCallingIdentity();
3268 try {
3269 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003270 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003271 getSlotIndexOrException(subId)).isWfcEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003272 } catch (ImsException e) {
3273 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003274 } finally {
3275 Binder.restoreCallingIdentity(identity);
3276 }
3277 }
3278
3279 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003280 public void setVoWiFiSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003281 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003282 "setVoWiFiSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003283 final long identity = Binder.clearCallingIdentity();
3284 try {
3285 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003286 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setWfcSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003287 } catch (ImsException e) {
3288 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003289 } finally {
3290 Binder.restoreCallingIdentity(identity);
3291 }
3292 }
3293
3294 @Override
3295 public boolean isVoWiFiRoamingSettingEnabled(int subId) {
3296 enforceReadPrivilegedPermission("isVoWiFiRoamingSettingEnabled");
3297 final long identity = Binder.clearCallingIdentity();
3298 try {
3299 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003300 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003301 getSlotIndexOrException(subId)).isWfcRoamingEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003302 } catch (ImsException e) {
3303 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003304 } finally {
3305 Binder.restoreCallingIdentity(identity);
3306 }
3307 }
3308
3309 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003310 public void setVoWiFiRoamingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003311 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003312 "setVoWiFiRoamingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003313 final long identity = Binder.clearCallingIdentity();
3314 try {
3315 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003316 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003317 getSlotIndexOrException(subId)).setWfcRoamingSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003318 } catch (ImsException e) {
3319 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003320 } finally {
3321 Binder.restoreCallingIdentity(identity);
3322 }
3323 }
3324
3325 @Override
3326 public void setVoWiFiNonPersistent(int subId, boolean isCapable, int mode) {
3327 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3328 "setVoWiFiNonPersistent");
3329 final long identity = Binder.clearCallingIdentity();
3330 try {
3331 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003332 ImsManager.getInstance(mApp,
Brad Ebinger2d29c012019-05-07 18:33:46 -07003333 getSlotIndexOrException(subId)).setWfcNonPersistent(isCapable, mode);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003334 } catch (ImsException e) {
3335 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003336 } finally {
3337 Binder.restoreCallingIdentity(identity);
3338 }
3339 }
3340
3341 @Override
3342 public int getVoWiFiModeSetting(int subId) {
3343 enforceReadPrivilegedPermission("getVoWiFiModeSetting");
3344 final long identity = Binder.clearCallingIdentity();
3345 try {
3346 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003347 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003348 getSlotIndexOrException(subId)).getWfcMode(false /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003349 } catch (ImsException e) {
3350 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003351 } finally {
3352 Binder.restoreCallingIdentity(identity);
3353 }
3354 }
3355
3356 @Override
3357 public void setVoWiFiModeSetting(int subId, int mode) {
3358 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3359 "setVoWiFiModeSetting");
3360 final long identity = Binder.clearCallingIdentity();
3361 try {
3362 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003363 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003364 getSlotIndexOrException(subId)).setWfcMode(mode, false /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003365 } catch (ImsException e) {
3366 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003367 } finally {
3368 Binder.restoreCallingIdentity(identity);
3369 }
3370 }
3371
3372 @Override
3373 public int getVoWiFiRoamingModeSetting(int subId) {
3374 enforceReadPrivilegedPermission("getVoWiFiRoamingModeSetting");
3375 final long identity = Binder.clearCallingIdentity();
3376 try {
3377 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003378 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003379 getSlotIndexOrException(subId)).getWfcMode(true /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003380 } catch (ImsException e) {
3381 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003382 } finally {
3383 Binder.restoreCallingIdentity(identity);
3384 }
3385 }
3386
3387 @Override
3388 public void setVoWiFiRoamingModeSetting(int subId, int mode) {
3389 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3390 "setVoWiFiRoamingModeSetting");
3391 final long identity = Binder.clearCallingIdentity();
3392 try {
3393 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003394 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003395 getSlotIndexOrException(subId)).setWfcMode(mode, true /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003396 } catch (ImsException e) {
3397 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003398 } finally {
3399 Binder.restoreCallingIdentity(identity);
3400 }
3401 }
3402
3403 @Override
3404 public void setRttCapabilitySetting(int subId, boolean isEnabled) {
3405 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3406 "setRttCapabilityEnabled");
3407 final long identity = Binder.clearCallingIdentity();
3408 try {
3409 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003410 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setRttEnabled(isEnabled);
3411 } catch (ImsException e) {
3412 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003413 } finally {
3414 Binder.restoreCallingIdentity(identity);
3415 }
3416 }
3417
3418 @Override
3419 public boolean isTtyOverVolteEnabled(int subId) {
3420 enforceReadPrivilegedPermission("isTtyOverVolteEnabled");
3421 final long identity = Binder.clearCallingIdentity();
3422 try {
3423 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003424 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003425 getSlotIndexOrException(subId)).isTtyOnVoLteCapable();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003426 } catch (ImsException e) {
3427 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003428 } finally {
3429 Binder.restoreCallingIdentity(identity);
3430 }
3431 }
3432
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003433 @Override
3434 public void registerImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3435 enforceReadPrivilegedPermission("registerImsProvisioningChangedCallback");
3436 final long identity = Binder.clearCallingIdentity();
3437 try {
3438 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003439 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003440 .addProvisioningCallbackForSubscription(callback, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003441 } catch (ImsException e) {
3442 throw new ServiceSpecificException(e.getCode());
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003443 } finally {
3444 Binder.restoreCallingIdentity(identity);
3445 }
3446 }
3447
3448 @Override
3449 public void unregisterImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3450 enforceReadPrivilegedPermission("unregisterImsProvisioningChangedCallback");
3451 final long identity = Binder.clearCallingIdentity();
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003452 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3453 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3454 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003455 try {
3456 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003457 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003458 .removeProvisioningCallbackForSubscription(callback, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003459 } catch (ImsException e) {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003460 Log.i(LOG_TAG, "unregisterImsProvisioningChangedCallback: " + subId
3461 + "is inactive, ignoring unregister.");
3462 // If the subscription is no longer active, just return, since the callback will already
3463 // have been removed internally.
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003464 } finally {
3465 Binder.restoreCallingIdentity(identity);
3466 }
3467 }
3468
3469 @Override
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003470 public void setImsProvisioningStatusForCapability(int subId, int capability, int tech,
3471 boolean isProvisioned) {
3472 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3473 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3474 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3475 }
3476 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3477 "setProvisioningStatusForCapability");
3478 final long identity = Binder.clearCallingIdentity();
3479 try {
3480 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3481 Phone phone = getPhone(subId);
3482 if (phone == null) {
3483 loge("setImsProvisioningStatusForCapability: phone instance null for subid "
3484 + subId);
3485 return;
3486 }
3487 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3488 return;
3489 }
3490
3491 // this capability requires provisioning, route to the correct API.
3492 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3493 switch (capability) {
3494 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3495 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3496 ims.setVolteProvisioned(isProvisioned);
3497 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3498 ims.setWfcProvisioned(isProvisioned);
3499 }
3500 break;
3501 }
3502 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3503 // There is currently no difference in VT provisioning type.
3504 ims.setVtProvisioned(isProvisioned);
3505 break;
3506 }
3507 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3508 // There is no "deprecated" UT provisioning mechanism through ImsConfig, so
3509 // change the capability of the feature instead if needed.
3510 if (isMmTelCapabilityProvisionedInCache(subId, capability, tech)
3511 == isProvisioned) {
3512 // No change in provisioning.
3513 return;
3514 }
3515 cacheMmTelCapabilityProvisioning(subId, capability, tech, isProvisioned);
3516 try {
3517 ims.changeMmTelCapability(capability, tech, isProvisioned);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003518 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003519 loge("setImsProvisioningStatusForCapability: couldn't change UT capability"
3520 + ", Exception" + e.getMessage());
3521 }
3522 break;
3523 }
3524 default: {
3525 throw new IllegalArgumentException("Tried to set provisioning for capability '"
3526 + capability + "', which does not require provisioning.");
3527 }
3528 }
3529
3530 } finally {
3531 Binder.restoreCallingIdentity(identity);
3532 }
3533 }
3534
3535 @Override
3536 public boolean getImsProvisioningStatusForCapability(int subId, int capability, int tech) {
3537 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3538 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3539 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3540 }
3541 enforceReadPrivilegedPermission("getProvisioningStatusForCapability");
3542 final long identity = Binder.clearCallingIdentity();
3543 try {
3544 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3545 Phone phone = getPhone(subId);
3546 if (phone == null) {
3547 loge("getImsProvisioningStatusForCapability: phone instance null for subid "
3548 + subId);
3549 // We will fail with "true" as the provisioning status because this is the default
3550 // if we do not require provisioning.
3551 return true;
3552 }
3553
3554 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3555 return true;
3556 }
3557
3558 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3559 switch (capability) {
3560 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3561 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3562 return ims.isVolteProvisionedOnDevice();
3563 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3564 return ims.isWfcProvisionedOnDevice();
3565 }
3566 // This should never happen, since we are checking tech above to make sure it
3567 // is either LTE or IWLAN.
3568 throw new IllegalArgumentException("Invalid radio technology for voice "
3569 + "capability.");
3570 }
3571 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3572 // There is currently no difference in VT provisioning type.
3573 return ims.isVtProvisionedOnDevice();
3574 }
3575 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3576 // There is no "deprecated" UT provisioning mechanism, so get from shared prefs.
3577 return isMmTelCapabilityProvisionedInCache(subId, capability, tech);
3578 }
3579 default: {
3580 throw new IllegalArgumentException("Tried to get provisioning for capability '"
3581 + capability + "', which does not require provisioning.");
3582 }
3583 }
3584
3585 } finally {
3586 Binder.restoreCallingIdentity(identity);
3587 }
3588 }
3589
3590 @Override
3591 public boolean isMmTelCapabilityProvisionedInCache(int subId, int capability, int tech) {
3592 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3593 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3594 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3595 }
3596 enforceReadPrivilegedPermission("isMmTelCapabilityProvisionedInCache");
3597 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3598 return (provisionedBits & capability) > 0;
3599 }
3600
3601 @Override
3602 public void cacheMmTelCapabilityProvisioning(int subId, int capability, int tech,
3603 boolean isProvisioned) {
3604 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3605 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3606 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3607 }
3608 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3609 "setProvisioningStatusForCapability");
3610 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3611 // If the current provisioning status for capability already matches isProvisioned,
3612 // do nothing.
3613 if (((provisionedBits & capability) > 0) == isProvisioned) {
3614 return;
3615 }
3616 if (isProvisioned) {
3617 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits | capability));
3618 } else {
3619 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits & ~capability));
3620 }
3621 }
3622
3623 /**
3624 * @return the bitfield containing the MmTel provisioning for the provided subscription and
3625 * technology. The bitfield should mirror the bitfield defined by
3626 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}.
3627 */
3628 private int getMmTelCapabilityProvisioningBitfield(int subId, int tech) {
3629 String key = getMmTelProvisioningKey(subId, tech);
3630 // Default is no capabilities are provisioned.
3631 return mTelephonySharedPreferences.getInt(key, 0 /*default*/);
3632 }
3633
3634 /**
3635 * Sets the MmTel capability provisioning bitfield (defined by
3636 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}) for the subscription and
3637 * technology specified.
3638 *
3639 * Note: This is a synchronous command and should not be called on UI thread.
3640 */
3641 private void setMmTelCapabilityProvisioningBitfield(int subId, int tech, int newField) {
3642 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
3643 String key = getMmTelProvisioningKey(subId, tech);
3644 editor.putInt(key, newField);
3645 editor.commit();
3646 }
3647
3648 private static String getMmTelProvisioningKey(int subId, int tech) {
3649 // resulting key is provision_ims_mmtel_{subId}_{tech}
3650 return PREF_PROVISION_IMS_MMTEL_PREFIX + subId + "_" + tech;
3651 }
3652
3653 /**
3654 * Query CarrierConfig to see if the specified capability requires provisioning for the
3655 * carrier associated with the subscription id.
3656 */
3657 private boolean doesImsCapabilityRequireProvisioning(Context context, int subId,
3658 int capability) {
3659 CarrierConfigManager configManager = new CarrierConfigManager(context);
3660 PersistableBundle c = configManager.getConfigForSubId(subId);
3661 boolean requireUtProvisioning = c.getBoolean(
Brad Ebinger076903f2019-05-13 10:00:22 -07003662 CarrierConfigManager.KEY_CARRIER_SUPPORTS_SS_OVER_UT_BOOL, false)
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003663 && c.getBoolean(CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL,
3664 false);
3665 boolean requireVoiceVtProvisioning = c.getBoolean(
3666 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, false);
3667
3668 // First check to make sure that the capability requires provisioning.
3669 switch (capability) {
3670 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE:
3671 // intentional fallthrough
3672 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3673 if (requireVoiceVtProvisioning) {
3674 // Voice and Video requires provisioning
3675 return true;
3676 }
3677 break;
3678 }
3679 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3680 if (requireUtProvisioning) {
3681 // UT requires provisioning
3682 return true;
3683 }
3684 break;
3685 }
3686 }
3687 return false;
3688 }
3689
3690 @Override
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003691 public int getImsProvisioningInt(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003692 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3693 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3694 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003695 enforceReadPrivilegedPermission("getImsProvisioningInt");
3696 final long identity = Binder.clearCallingIdentity();
3697 try {
3698 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003699 int slotId = getSlotIndex(subId);
3700 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3701 Log.w(LOG_TAG, "getImsProvisioningInt: called with an inactive subscription '"
3702 + subId + "' for key:" + key);
3703 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
3704 }
3705 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigInt(key);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003706 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003707 Log.w(LOG_TAG, "getImsProvisioningInt: ImsService is not available for subscription '"
3708 + subId + "' for key:" + key);
3709 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003710 } finally {
3711 Binder.restoreCallingIdentity(identity);
3712 }
3713 }
3714
3715 @Override
3716 public String getImsProvisioningString(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003717 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3718 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3719 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003720 enforceReadPrivilegedPermission("getImsProvisioningString");
3721 final long identity = Binder.clearCallingIdentity();
3722 try {
3723 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003724 int slotId = getSlotIndex(subId);
3725 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3726 Log.w(LOG_TAG, "getImsProvisioningString: called for an inactive subscription id '"
3727 + subId + "' for key:" + key);
3728 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_GENERIC;
3729 }
3730 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigString(key);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003731 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003732 Log.w(LOG_TAG, "getImsProvisioningString: ImsService is not available for sub '"
3733 + subId + "' for key:" + key);
3734 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_NOT_READY;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003735 } finally {
3736 Binder.restoreCallingIdentity(identity);
3737 }
3738 }
3739
3740 @Override
3741 public int setImsProvisioningInt(int subId, int key, int value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003742 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3743 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3744 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003745 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3746 "setImsProvisioningInt");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003747 final long identity = Binder.clearCallingIdentity();
3748 try {
3749 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003750 int slotId = getSlotIndex(subId);
3751 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3752 Log.w(LOG_TAG, "setImsProvisioningInt: called with an inactive subscription id '"
3753 + subId + "' for key:" + key);
3754 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3755 }
3756 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003757 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003758 Log.w(LOG_TAG, "setImsProvisioningInt: ImsService unavailable for sub '" + subId
3759 + "' for key:" + key);
3760 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003761 } finally {
3762 Binder.restoreCallingIdentity(identity);
3763 }
3764 }
3765
3766 @Override
3767 public int setImsProvisioningString(int subId, int key, String value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003768 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3769 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3770 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003771 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3772 "setImsProvisioningString");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003773 final long identity = Binder.clearCallingIdentity();
3774 try {
3775 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003776 int slotId = getSlotIndex(subId);
3777 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3778 Log.w(LOG_TAG, "setImsProvisioningString: called with an inactive subscription id '"
3779 + subId + "' for key:" + key);
3780 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3781 }
3782 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003783 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003784 Log.w(LOG_TAG, "setImsProvisioningString: ImsService unavailable for sub '" + subId
3785 + "' for key:" + key);
3786 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003787 } finally {
3788 Binder.restoreCallingIdentity(identity);
3789 }
3790 }
3791
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003792 private int getSlotIndexOrException(int subId) throws ImsException {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003793 int slotId = SubscriptionManager.getSlotIndex(subId);
3794 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003795 throw new ImsException("Invalid Subscription Id, subId=" + subId,
3796 ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003797 }
3798 return slotId;
3799 }
3800
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003801 private int getSlotIndex(int subId) {
3802 int slotId = SubscriptionManager.getSlotIndex(subId);
3803 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
3804 return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
3805 }
3806 return slotId;
3807 }
3808
Wink Saville36469e72014-06-11 15:17:00 -07003809 /**
Nathan Harold9042f0b2019-05-21 15:51:27 -07003810 * Returns the data network type for a subId; does not throw SecurityException.
Wink Saville36469e72014-06-11 15:17:00 -07003811 */
3812 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003813 public int getNetworkTypeForSubscriber(int subId, String callingPackage,
3814 String callingFeatureId) {
Nathan Haroldef60dba2019-05-22 13:55:14 -07003815 final int targetSdk = getTargetSdk(callingPackage);
3816 if (targetSdk > android.os.Build.VERSION_CODES.Q) {
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003817 return getDataNetworkTypeForSubscriber(subId, callingPackage, callingFeatureId);
Nathan Haroldef60dba2019-05-22 13:55:14 -07003818 } else if (targetSdk == android.os.Build.VERSION_CODES.Q
Nathan Harold9042f0b2019-05-21 15:51:27 -07003819 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003820 mApp, subId, callingPackage, callingFeatureId,
3821 "getNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003822 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3823 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003824
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003825 final long identity = Binder.clearCallingIdentity();
3826 try {
3827 final Phone phone = getPhone(subId);
3828 if (phone != null) {
3829 return phone.getServiceState().getDataNetworkType();
3830 } else {
3831 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3832 }
3833 } finally {
3834 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003835 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003836 }
3837
3838 /**
3839 * Returns the data network type
3840 */
3841 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003842 public int getDataNetworkType(String callingPackage, String callingFeatureId) {
3843 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage,
3844 callingFeatureId);
Wink Saville36469e72014-06-11 15:17:00 -07003845 }
3846
3847 /**
3848 * Returns the data network type for a subId
3849 */
3850 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003851 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage,
3852 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003853 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003854 mApp, subId, callingPackage, callingFeatureId,
3855 "getDataNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003856 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3857 }
3858
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003859 final long identity = Binder.clearCallingIdentity();
3860 try {
3861 final Phone phone = getPhone(subId);
3862 if (phone != null) {
3863 return phone.getServiceState().getDataNetworkType();
3864 } else {
3865 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3866 }
3867 } finally {
3868 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003869 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003870 }
3871
3872 /**
Wink Saville36469e72014-06-11 15:17:00 -07003873 * Returns the Voice network type for a subId
3874 */
3875 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003876 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage,
3877 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003878 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003879 mApp, subId, callingPackage, callingFeatureId,
3880 "getDataNetworkTypeForSubscriber")) {
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003881 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3882 }
3883
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003884 final long identity = Binder.clearCallingIdentity();
3885 try {
3886 final Phone phone = getPhone(subId);
3887 if (phone != null) {
3888 return phone.getServiceState().getVoiceNetworkType();
3889 } else {
3890 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3891 }
3892 } finally {
3893 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003894 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003895 }
3896
3897 /**
3898 * @return true if a ICC card is present
3899 */
3900 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07003901 // FIXME Make changes to pass defaultSimId of type int
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003902 return hasIccCardUsingSlotIndex(mSubscriptionController.getSlotIndex(
3903 getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07003904 }
3905
3906 /**
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003907 * @return true if a ICC card is present for a slotIndex
Wink Saville36469e72014-06-11 15:17:00 -07003908 */
Sanket Padawe356d7632015-06-22 14:03:32 -07003909 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003910 public boolean hasIccCardUsingSlotIndex(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003911 final long identity = Binder.clearCallingIdentity();
3912 try {
3913 final Phone phone = PhoneFactory.getPhone(slotIndex);
3914 if (phone != null) {
3915 return phone.getIccCard().hasIccCard();
3916 } else {
3917 return false;
3918 }
3919 } finally {
3920 Binder.restoreCallingIdentity(identity);
Amit Mahajana6fc2a82015-01-06 11:53:51 -08003921 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003922 }
3923
3924 /**
3925 * Return if the current radio is LTE on CDMA. This
3926 * is a tri-state return value as for a period of time
3927 * the mode may be unknown.
3928 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003929 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003930 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08003931 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003932 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003933 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003934 public int getLteOnCdmaMode(String callingPackage, String callingFeatureId) {
3935 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage,
3936 callingFeatureId);
Wink Saville36469e72014-06-11 15:17:00 -07003937 }
3938
Sanket Padawe356d7632015-06-22 14:03:32 -07003939 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003940 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage,
3941 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003942 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07003943 mApp, subId, callingPackage, callingFeatureId,
3944 "getLteOnCdmaModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003945 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3946 }
3947
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003948 final long identity = Binder.clearCallingIdentity();
3949 try {
3950 final Phone phone = getPhone(subId);
3951 if (phone == null) {
3952 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3953 } else {
3954 return phone.getLteOnCdmaMode();
3955 }
3956 } finally {
3957 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003958 }
Wink Saville36469e72014-06-11 15:17:00 -07003959 }
3960
Wink Saville36469e72014-06-11 15:17:00 -07003961 /**
3962 * {@hide}
3963 * Returns Default subId, 0 in the case of single standby.
3964 */
Wink Savilleb564aae2014-10-23 10:18:09 -07003965 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003966 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07003967 }
3968
Shishir Agrawala9f32182016-04-12 12:00:16 -07003969 private int getSlotForDefaultSubscription() {
3970 return mSubscriptionController.getPhoneId(getDefaultSubscription());
3971 }
3972
Wink Savilleb564aae2014-10-23 10:18:09 -07003973 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003974 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003975 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003976
Pengquan Menge92a50d2018-09-21 15:54:48 -07003977 private boolean isActiveSubscription(int subId) {
3978 return mSubscriptionController.isActiveSubId(subId);
3979 }
3980
Ihab Awadf2177b72013-11-25 13:33:23 -08003981 /**
3982 * @see android.telephony.TelephonyManager.WifiCallingChoices
3983 */
3984 public int getWhenToMakeWifiCalls() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003985 final long identity = Binder.clearCallingIdentity();
3986 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003987 return Settings.System.getInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003988 Settings.System.WHEN_TO_MAKE_WIFI_CALLS,
3989 getWhenToMakeWifiCallsDefaultPreference());
3990 } finally {
3991 Binder.restoreCallingIdentity(identity);
3992 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003993 }
3994
3995 /**
3996 * @see android.telephony.TelephonyManager.WifiCallingChoices
3997 */
3998 public void setWhenToMakeWifiCalls(int preference) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003999 final long identity = Binder.clearCallingIdentity();
4000 try {
4001 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004002 Settings.System.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004003 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
4004 } finally {
4005 Binder.restoreCallingIdentity(identity);
4006 }
Ihab Awadf9e92732013-12-05 18:02:52 -08004007 }
4008
Sailesh Nepald1e68152013-12-12 19:08:02 -08004009 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07004010 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08004011 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08004012 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08004013
Jordan Liu4c733742019-02-28 12:03:40 -08004014 private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
4015 int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
4016 if (phoneId == -1) {
4017 throw new IllegalArgumentException("Given slot index: " + slotIndex
4018 + " does not correspond to an active phone");
4019 }
4020 return PhoneFactory.getPhone(phoneId);
4021 }
4022
Shishir Agrawal566b7612013-10-28 14:41:00 -07004023 @Override
Derek Tan740e1672017-06-27 14:56:27 -07004024 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(
4025 int subId, String callingPackage, String aid, int p2) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004026 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4027 mApp, subId, "iccOpenLogicalChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004028 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08004029 if (DBG) {
4030 log("iccOpenLogicalChannel: subId=" + subId + " aid=" + aid + " p2=" + p2);
4031 }
4032 return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
4033 p2);
4034 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004035
Jordan Liu4c733742019-02-28 12:03:40 -08004036
4037 @Override
4038 public IccOpenLogicalChannelResponse iccOpenLogicalChannelBySlot(
4039 int slotIndex, String callingPackage, String aid, int p2) {
4040 enforceModifyPermission();
4041 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
4042 if (DBG) {
4043 log("iccOpenLogicalChannelBySlot: slot=" + slotIndex + " aid=" + aid + " p2=" + p2);
4044 }
4045 return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
4046 callingPackage, aid, p2);
4047 }
4048
4049 private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
4050 String callingPackage, String aid, int p2) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004051 final long identity = Binder.clearCallingIdentity();
4052 try {
4053 if (TextUtils.equals(ISDR_AID, aid)) {
4054 // Only allows LPA to open logical channel to ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004055 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
4056 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004057 if (bestComponent == null
4058 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
4059 loge("The calling package is not allowed to access ISD-R.");
4060 throw new SecurityException(
4061 "The calling package is not allowed to access ISD-R.");
4062 }
Derek Tan740e1672017-06-27 14:56:27 -07004063 }
Derek Tan740e1672017-06-27 14:56:27 -07004064
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004065 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse) sendRequest(
Jordan Liu4c733742019-02-28 12:03:40 -08004066 CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
4067 null /* workSource */);
4068 if (DBG) log("iccOpenLogicalChannelWithPermission: " + response);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004069 return response;
4070 } finally {
4071 Binder.restoreCallingIdentity(identity);
4072 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004073 }
4074
4075 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004076 public boolean iccCloseLogicalChannel(int subId, int channel) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004077 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4078 mApp, subId, "iccCloseLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08004079 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
4080 return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
4081 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004082
Jordan Liu4c733742019-02-28 12:03:40 -08004083 @Override
4084 public boolean iccCloseLogicalChannelBySlot(int slotIndex, int channel) {
4085 enforceModifyPermission();
4086 if (DBG) log("iccCloseLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel);
4087 return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
4088 channel);
4089 }
4090
4091 private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004092 final long identity = Binder.clearCallingIdentity();
4093 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004094 if (channel < 0) {
4095 return false;
4096 }
Jordan Liu4c733742019-02-28 12:03:40 -08004097 Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
4098 null /* workSource */);
4099 if (DBG) log("iccCloseLogicalChannelWithPermission: " + success);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004100 return success;
4101 } finally {
4102 Binder.restoreCallingIdentity(identity);
Shishir Agrawal566b7612013-10-28 14:41:00 -07004103 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004104 }
4105
4106 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004107 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07004108 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004109 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4110 mApp, subId, "iccTransmitApduLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08004111 if (DBG) {
4112 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel
4113 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
4114 + p3 + " data=" + data);
4115 }
4116 return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
4117 command, p1, p2, p3, data);
4118 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004119
Jordan Liu4c733742019-02-28 12:03:40 -08004120 @Override
4121 public String iccTransmitApduLogicalChannelBySlot(int slotIndex, int channel, int cla,
4122 int command, int p1, int p2, int p3, String data) {
4123 enforceModifyPermission();
4124 if (DBG) {
4125 log("iccTransmitApduLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel
4126 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
4127 + p3 + " data=" + data);
4128 }
4129 return iccTransmitApduLogicalChannelWithPermission(
4130 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
4131 data);
4132 }
4133
4134 private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
4135 int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004136 final long identity = Binder.clearCallingIdentity();
4137 try {
Hall Liu4fd771b2019-05-02 09:16:29 -07004138 if (channel <= 0) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004139 return "";
4140 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004141
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004142 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08004143 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
4144 null /* workSource */);
4145 if (DBG) log("iccTransmitApduLogicalChannelWithPermission: " + response);
Shishir Agrawal566b7612013-10-28 14:41:00 -07004146
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004147 // Append the returned status code to the end of the response payload.
4148 String s = Integer.toHexString(
4149 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4150 if (response.payload != null) {
4151 s = IccUtils.bytesToHexString(response.payload) + s;
4152 }
4153 return s;
4154 } finally {
4155 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07004156 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07004157 }
Jake Hambye994d462014-02-03 13:10:13 -08004158
Evan Charltonc66da362014-05-16 14:06:40 -07004159 @Override
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08004160 public String iccTransmitApduBasicChannel(int subId, String callingPackage, int cla,
4161 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004162 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4163 mApp, subId, "iccTransmitApduBasicChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004164 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08004165 if (DBG) {
4166 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd="
4167 + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
4168 }
4169 return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
4170 cla, command, p1, p2, p3, data);
4171 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004172
Jordan Liu4c733742019-02-28 12:03:40 -08004173 @Override
4174 public String iccTransmitApduBasicChannelBySlot(int slotIndex, String callingPackage, int cla,
4175 int command, int p1, int p2, int p3, String data) {
4176 enforceModifyPermission();
4177 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
4178 if (DBG) {
4179 log("iccTransmitApduBasicChannelBySlot: slotIndex=" + slotIndex + " cla=" + cla
4180 + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3
4181 + " data=" + data);
4182 }
4183
4184 return iccTransmitApduBasicChannelWithPermission(
4185 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
4186 p2, p3, data);
4187 }
4188
4189 // open APDU basic channel assuming the caller has sufficient permissions
4190 private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
4191 int cla, int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004192 final long identity = Binder.clearCallingIdentity();
4193 try {
4194 if (command == SELECT_COMMAND && p1 == SELECT_P1 && p2 == SELECT_P2 && p3 == SELECT_P3
4195 && TextUtils.equals(ISDR_AID, data)) {
4196 // Only allows LPA to select ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004197 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
4198 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004199 if (bestComponent == null
4200 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
4201 loge("The calling package is not allowed to select ISD-R.");
4202 throw new SecurityException(
4203 "The calling package is not allowed to select ISD-R.");
4204 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08004205 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08004206
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004207 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08004208 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
4209 null /* workSource */);
4210 if (DBG) log("iccTransmitApduBasicChannelWithPermission: " + response);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004211
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004212 // Append the returned status code to the end of the response payload.
4213 String s = Integer.toHexString(
4214 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4215 if (response.payload != null) {
4216 s = IccUtils.bytesToHexString(response.payload) + s;
4217 }
4218 return s;
4219 } finally {
4220 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07004221 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004222 }
4223
4224 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004225 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004226 String filePath) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004227 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4228 mApp, subId, "iccExchangeSimIO");
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004229
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004230 final long identity = Binder.clearCallingIdentity();
4231 try {
4232 if (DBG) {
4233 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " "
4234 + p1 + " " + p2 + " " + p3 + ":" + filePath);
4235 }
4236
4237 IccIoResult response =
4238 (IccIoResult) sendRequest(CMD_EXCHANGE_SIM_IO,
4239 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
4240 subId);
4241
4242 if (DBG) {
4243 log("Exchange SIM_IO [R]" + response);
4244 }
4245
4246 byte[] result = null;
4247 int length = 2;
4248 if (response.payload != null) {
4249 length = 2 + response.payload.length;
4250 result = new byte[length];
4251 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
4252 } else {
4253 result = new byte[length];
4254 }
4255
4256 result[length - 1] = (byte) response.sw2;
4257 result[length - 2] = (byte) response.sw1;
4258 return result;
4259 } finally {
4260 Binder.restoreCallingIdentity(identity);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004261 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004262 }
4263
Nathan Haroldb3014052017-01-25 15:57:32 -08004264 /**
4265 * Get the forbidden PLMN List from the given app type (ex APPTYPE_USIM)
4266 * on a particular subscription
4267 */
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004268 public String[] getForbiddenPlmns(int subId, int appType, String callingPackage,
4269 String callingFeatureId) {
sqianb6e41952018-03-12 14:54:01 -07004270 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004271 mApp, subId, callingPackage, callingFeatureId, "getForbiddenPlmns")) {
sqianb6e41952018-03-12 14:54:01 -07004272 return null;
4273 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004274
4275 final long identity = Binder.clearCallingIdentity();
4276 try {
4277 if (appType != TelephonyManager.APPTYPE_USIM
4278 && appType != TelephonyManager.APPTYPE_SIM) {
4279 loge("getForbiddenPlmnList(): App Type must be USIM or SIM");
4280 return null;
4281 }
4282 Object response = sendRequest(
4283 CMD_GET_FORBIDDEN_PLMNS, new Integer(appType), subId);
4284 if (response instanceof String[]) {
4285 return (String[]) response;
4286 }
yincheng zhao2737e882019-09-06 17:06:54 -07004287 // Response is an Exception of some kind
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004288 // which is signalled to the user as a NULL retval
Nathan Haroldb3014052017-01-25 15:57:32 -08004289 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004290 } finally {
4291 Binder.restoreCallingIdentity(identity);
Nathan Haroldb3014052017-01-25 15:57:32 -08004292 }
Nathan Haroldb3014052017-01-25 15:57:32 -08004293 }
4294
yincheng zhao2737e882019-09-06 17:06:54 -07004295 /**
4296 * Set the forbidden PLMN list from the given app type (ex APPTYPE_USIM) on a particular
4297 * subscription.
4298 *
4299 * @param subId the id of the subscription.
4300 * @param appType the uicc app type, must be USIM or SIM.
4301 * @param fplmns the Forbiden plmns list that needed to be written to the SIM.
4302 * @param callingPackage the op Package name.
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004303 * @param callingFeatureId the feature in the package.
yincheng zhao2737e882019-09-06 17:06:54 -07004304 * @return number of fplmns that is successfully written to the SIM.
4305 */
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004306 public int setForbiddenPlmns(int subId, int appType, List<String> fplmns, String callingPackage,
4307 String callingFeatureId) {
4308 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, subId, callingPackage,
4309 callingFeatureId, "setForbiddenPlmns")) {
yincheng zhao2737e882019-09-06 17:06:54 -07004310 if (DBG) logv("no permissions for setForbiddenplmns");
4311 throw new IllegalStateException("No Permissions for setForbiddenPlmns");
4312 }
4313 if (appType != TelephonyManager.APPTYPE_USIM && appType != TelephonyManager.APPTYPE_SIM) {
4314 loge("setForbiddenPlmnList(): App Type must be USIM or SIM");
4315 throw new IllegalArgumentException("Invalid appType: App Type must be USIM or SIM");
4316 }
4317 if (fplmns == null) {
4318 throw new IllegalArgumentException("Fplmn List provided is null");
4319 }
4320 for (String fplmn : fplmns) {
4321 if (!CellIdentity.isValidPlmn(fplmn)) {
4322 throw new IllegalArgumentException("Invalid fplmn provided: " + fplmn);
4323 }
4324 }
4325 final long identity = Binder.clearCallingIdentity();
4326 try {
4327 Object response = sendRequest(
4328 CMD_SET_FORBIDDEN_PLMNS,
4329 new Pair<Integer, List<String>>(new Integer(appType), fplmns),
4330 subId);
4331 return (int) response;
4332 } finally {
4333 Binder.restoreCallingIdentity(identity);
4334 }
4335 }
4336
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004337 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004338 public String sendEnvelopeWithStatus(int subId, String content) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004339 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4340 mApp, subId, "sendEnvelopeWithStatus");
Evan Charltonc66da362014-05-16 14:06:40 -07004341
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004342 final long identity = Binder.clearCallingIdentity();
4343 try {
4344 IccIoResult response = (IccIoResult) sendRequest(CMD_SEND_ENVELOPE, content, subId);
4345 if (response.payload == null) {
4346 return "";
4347 }
Evan Charltonc66da362014-05-16 14:06:40 -07004348
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004349 // Append the returned status code to the end of the response payload.
4350 String s = Integer.toHexString(
4351 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4352 s = IccUtils.bytesToHexString(response.payload) + s;
4353 return s;
4354 } finally {
4355 Binder.restoreCallingIdentity(identity);
4356 }
Evan Charltonc66da362014-05-16 14:06:40 -07004357 }
4358
Jake Hambye994d462014-02-03 13:10:13 -08004359 /**
4360 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4361 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4362 *
4363 * @param itemID the ID of the item to read
4364 * @return the NV item as a String, or null on error.
4365 */
4366 @Override
4367 public String nvReadItem(int itemID) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004368 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004369 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4370 mApp, getDefaultSubscription(), "nvReadItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004371
4372 final long identity = Binder.clearCallingIdentity();
4373 try {
4374 if (DBG) log("nvReadItem: item " + itemID);
vagdeviaf9a5b92018-08-15 16:01:53 -07004375 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004376 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
4377 return value;
4378 } finally {
4379 Binder.restoreCallingIdentity(identity);
4380 }
Jake Hambye994d462014-02-03 13:10:13 -08004381 }
4382
4383 /**
4384 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4385 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4386 *
4387 * @param itemID the ID of the item to read
4388 * @param itemValue the value to write, as a String
4389 * @return true on success; false on any failure
4390 */
4391 @Override
4392 public boolean nvWriteItem(int itemID, String itemValue) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004393 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004394 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4395 mApp, getDefaultSubscription(), "nvWriteItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004396
4397 final long identity = Binder.clearCallingIdentity();
4398 try {
4399 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
4400 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
vagdeviaf9a5b92018-08-15 16:01:53 -07004401 new Pair<Integer, String>(itemID, itemValue), workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004402 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
4403 return success;
4404 } finally {
4405 Binder.restoreCallingIdentity(identity);
4406 }
Jake Hambye994d462014-02-03 13:10:13 -08004407 }
4408
4409 /**
4410 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
4411 * Used for device configuration by some CDMA operators.
4412 *
4413 * @param preferredRoamingList byte array containing the new PRL
4414 * @return true on success; false on any failure
4415 */
4416 @Override
4417 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004418 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4419 mApp, getDefaultSubscription(), "nvWriteCdmaPrl");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004420
4421 final long identity = Binder.clearCallingIdentity();
4422 try {
4423 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
4424 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
4425 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
4426 return success;
4427 } finally {
4428 Binder.restoreCallingIdentity(identity);
4429 }
Jake Hambye994d462014-02-03 13:10:13 -08004430 }
4431
4432 /**
chen xu6dac5ab2018-10-26 17:39:23 -07004433 * Rollback modem configurations to factory default except some config which are in whitelist.
Jake Hambye994d462014-02-03 13:10:13 -08004434 * Used for device configuration by some CDMA operators.
4435 *
chen xu6dac5ab2018-10-26 17:39:23 -07004436 * @param slotIndex - device slot.
4437 *
Jake Hambye994d462014-02-03 13:10:13 -08004438 * @return true on success; false on any failure
4439 */
4440 @Override
chen xu6dac5ab2018-10-26 17:39:23 -07004441 public boolean resetModemConfig(int slotIndex) {
4442 Phone phone = PhoneFactory.getPhone(slotIndex);
4443 if (phone != null) {
4444 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4445 mApp, phone.getSubId(), "resetModemConfig");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004446
chen xu6dac5ab2018-10-26 17:39:23 -07004447 final long identity = Binder.clearCallingIdentity();
4448 try {
4449 Boolean success = (Boolean) sendRequest(CMD_RESET_MODEM_CONFIG, null);
4450 if (DBG) log("resetModemConfig:" + ' ' + (success ? "ok" : "fail"));
4451 return success;
4452 } finally {
4453 Binder.restoreCallingIdentity(identity);
4454 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004455 }
chen xu6dac5ab2018-10-26 17:39:23 -07004456 return false;
4457 }
4458
4459 /**
4460 * Generate a radio modem reset. Used for device configuration by some CDMA operators.
4461 *
4462 * @param slotIndex - device slot.
4463 *
4464 * @return true on success; false on any failure
4465 */
4466 @Override
4467 public boolean rebootModem(int slotIndex) {
4468 Phone phone = PhoneFactory.getPhone(slotIndex);
4469 if (phone != null) {
4470 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4471 mApp, phone.getSubId(), "rebootModem");
4472
4473 final long identity = Binder.clearCallingIdentity();
4474 try {
4475 Boolean success = (Boolean) sendRequest(CMD_MODEM_REBOOT, null);
4476 if (DBG) log("rebootModem:" + ' ' + (success ? "ok" : "fail"));
4477 return success;
4478 } finally {
4479 Binder.restoreCallingIdentity(identity);
4480 }
4481 }
4482 return false;
Jake Hambye994d462014-02-03 13:10:13 -08004483 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004484
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004485 public String[] getPcscfAddress(String apnType, String callingPackage,
4486 String callingFeatureId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004487 final Phone defaultPhone = getDefaultPhone();
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004488 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
4489 callingPackage, callingFeatureId, "getPcscfAddress")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004490 return new String[0];
4491 }
4492
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004493 final long identity = Binder.clearCallingIdentity();
4494 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004495 return defaultPhone.getPcscfAddress(apnType);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004496 } finally {
4497 Binder.restoreCallingIdentity(identity);
4498 }
Wink Saville36469e72014-06-11 15:17:00 -07004499 }
4500
Brad Ebinger51f743a2017-01-23 13:50:20 -08004501 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004502 * Enables IMS for the framework. This will trigger IMS registration and ImsFeature capability
4503 * status updates, if not already enabled.
Brad Ebinger51f743a2017-01-23 13:50:20 -08004504 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004505 public void enableIms(int slotId) {
Brad Ebinger51f743a2017-01-23 13:50:20 -08004506 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004507
4508 final long identity = Binder.clearCallingIdentity();
4509 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004510 ImsResolver resolver = PhoneFactory.getImsResolver();
4511 if (resolver == null) {
4512 // may happen if the device does not support IMS.
4513 return;
4514 }
4515 resolver.enableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004516 } finally {
4517 Binder.restoreCallingIdentity(identity);
4518 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004519 }
4520
4521 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004522 * Disables IMS for the framework. This will trigger IMS de-registration and trigger ImsFeature
4523 * status updates to disabled.
Brad Ebinger34bef922017-11-09 10:27:08 -08004524 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004525 public void disableIms(int slotId) {
4526 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004527
4528 final long identity = Binder.clearCallingIdentity();
4529 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004530 ImsResolver resolver = PhoneFactory.getImsResolver();
4531 if (resolver == null) {
4532 // may happen if the device does not support IMS.
4533 return;
4534 }
4535 resolver.disableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004536 } finally {
4537 Binder.restoreCallingIdentity(identity);
4538 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004539 }
4540
4541 /**
4542 * Returns the {@link IImsMmTelFeature} that corresponds to the given slot Id for the MMTel
4543 * feature or {@link null} if the service is not available. If the feature is available, the
4544 * {@link IImsServiceFeatureCallback} callback is registered as a listener for feature updates.
4545 */
4546 public IImsMmTelFeature getMmTelFeatureAndListen(int slotId,
Brad Ebinger34bef922017-11-09 10:27:08 -08004547 IImsServiceFeatureCallback callback) {
4548 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004549
4550 final long identity = Binder.clearCallingIdentity();
4551 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004552 ImsResolver resolver = PhoneFactory.getImsResolver();
4553 if (resolver == null) {
4554 // may happen if the device does not support IMS.
4555 return null;
4556 }
4557 return resolver.getMmTelFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004558 } finally {
4559 Binder.restoreCallingIdentity(identity);
4560 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004561 }
4562
4563 /**
4564 * Returns the {@link IImsRcsFeature} that corresponds to the given slot Id for the RCS
4565 * feature during emergency calling or {@link null} if the service is not available. If the
4566 * feature is available, the {@link IImsServiceFeatureCallback} callback is registered as a
4567 * listener for feature updates.
4568 */
4569 public IImsRcsFeature getRcsFeatureAndListen(int slotId, IImsServiceFeatureCallback callback) {
4570 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004571
4572 final long identity = Binder.clearCallingIdentity();
4573 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004574 ImsResolver resolver = PhoneFactory.getImsResolver();
4575 if (resolver == null) {
4576 // may happen if the device does not support IMS.
4577 return null;
4578 }
4579 return resolver.getRcsFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004580 } finally {
4581 Binder.restoreCallingIdentity(identity);
4582 }
Brad Ebinger51f743a2017-01-23 13:50:20 -08004583 }
4584
Brad Ebinger5f64b052017-12-14 14:26:15 -08004585 /**
4586 * Returns the {@link IImsRegistration} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004587 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger5f64b052017-12-14 14:26:15 -08004588 */
4589 public IImsRegistration getImsRegistration(int slotId, int feature) throws RemoteException {
4590 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004591
4592 final long identity = Binder.clearCallingIdentity();
4593 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004594 ImsResolver resolver = PhoneFactory.getImsResolver();
4595 if (resolver == null) {
4596 // may happen if the device does not support IMS.
4597 return null;
4598 }
4599 return resolver.getImsRegistration(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004600 } finally {
4601 Binder.restoreCallingIdentity(identity);
4602 }
Brad Ebinger5f64b052017-12-14 14:26:15 -08004603 }
4604
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004605 /**
4606 * Returns the {@link IImsConfig} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004607 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004608 */
4609 public IImsConfig getImsConfig(int slotId, int feature) throws RemoteException {
4610 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004611
4612 final long identity = Binder.clearCallingIdentity();
4613 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004614 ImsResolver resolver = PhoneFactory.getImsResolver();
4615 if (resolver == null) {
4616 // may happen if the device does not support IMS.
4617 return null;
4618 }
4619 return resolver.getImsConfig(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004620 } finally {
4621 Binder.restoreCallingIdentity(identity);
4622 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004623 }
4624
Brad Ebinger884c07b2018-02-15 16:17:40 -08004625 /**
Brad Ebingerdac2f002018-04-03 15:17:52 -07004626 * Sets the ImsService Package Name that Telephony will bind to.
4627 *
4628 * @param slotId the slot ID that the ImsService should bind for.
4629 * @param isCarrierImsService true if the ImsService is the carrier override, false if the
4630 * ImsService is the device default ImsService.
4631 * @param packageName The package name of the application that contains the ImsService to bind
4632 * to.
4633 * @return true if setting the ImsService to bind to succeeded, false if it did not.
4634 * @hide
4635 */
4636 public boolean setImsService(int slotId, boolean isCarrierImsService, String packageName) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004637 int[] subIds = SubscriptionManager.getSubId(slotId);
4638 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4639 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4640 "setImsService");
4641
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004642 final long identity = Binder.clearCallingIdentity();
4643 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004644 ImsResolver resolver = PhoneFactory.getImsResolver();
4645 if (resolver == null) {
4646 // may happen if the device does not support IMS.
4647 return false;
4648 }
4649 return resolver.overrideImsServiceConfiguration(slotId, isCarrierImsService,
4650 packageName);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004651 } finally {
4652 Binder.restoreCallingIdentity(identity);
4653 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004654 }
4655
4656 /**
4657 * Return the ImsService configuration.
4658 *
4659 * @param slotId The slot that the ImsService is associated with.
4660 * @param isCarrierImsService true, if the ImsService is a carrier override, false if it is
4661 * the device default.
4662 * @return the package name of the ImsService configuration.
4663 */
4664 public String getImsService(int slotId, boolean isCarrierImsService) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004665 int[] subIds = SubscriptionManager.getSubId(slotId);
4666 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4667 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4668 "getImsService");
4669
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004670 final long identity = Binder.clearCallingIdentity();
4671 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004672 ImsResolver resolver = PhoneFactory.getImsResolver();
4673 if (resolver == null) {
4674 // may happen if the device does not support IMS.
4675 return "";
4676 }
4677 return resolver.getImsServiceConfiguration(slotId, isCarrierImsService);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004678 } finally {
4679 Binder.restoreCallingIdentity(identity);
4680 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004681 }
4682
Brad Ebingerbc7dd582019-10-17 17:03:22 -07004683 /**
4684 * Get the MmTelFeature state associated with the requested subscription id.
4685 * @param subId The subscription that the MmTelFeature is associated with.
4686 * @param callback A callback with an integer containing the
4687 * {@link android.telephony.ims.feature.ImsFeature.ImsState} associated with the MmTelFeature.
4688 */
4689 @Override
4690 public void getImsMmTelFeatureState(int subId, IIntegerConsumer callback) {
4691 enforceReadPrivilegedPermission("getImsMmTelFeatureState");
4692 if (!ImsManager.isImsSupportedOnDevice(mApp)) {
4693 throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
4694 "IMS not available on device.");
4695 }
4696 final long token = Binder.clearCallingIdentity();
4697 try {
4698 int slotId = getSlotIndex(subId);
4699 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
4700 Log.w(LOG_TAG, "getImsMmTelFeatureState: called with an inactive subscription '"
4701 + subId + "'");
4702 throw new ServiceSpecificException(ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
4703 }
4704 ImsManager.getInstance(mApp, slotId).getImsServiceState(anInteger -> {
4705 try {
4706 callback.accept(anInteger == null ? ImsFeature.STATE_UNAVAILABLE : anInteger);
4707 } catch (RemoteException e) {
4708 Log.w(LOG_TAG, "getImsMmTelFeatureState: remote caller is no longer running. "
4709 + "Ignore");
4710 }
4711 });
4712 } finally {
4713 Binder.restoreCallingIdentity(token);
4714 }
4715 }
4716
Wink Saville36469e72014-06-11 15:17:00 -07004717 public void setImsRegistrationState(boolean registered) {
4718 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004719
4720 final long identity = Binder.clearCallingIdentity();
4721 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004722 getDefaultPhone().setImsRegistrationState(registered);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004723 } finally {
4724 Binder.restoreCallingIdentity(identity);
4725 }
Wink Saville36469e72014-06-11 15:17:00 -07004726 }
4727
4728 /**
Stuart Scott54788802015-03-30 13:18:01 -07004729 * Set the network selection mode to automatic.
4730 *
4731 */
4732 @Override
4733 public void setNetworkSelectionModeAutomatic(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004734 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4735 mApp, subId, "setNetworkSelectionModeAutomatic");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004736
Pengquan Menge92a50d2018-09-21 15:54:48 -07004737 if (!isActiveSubscription(subId)) {
4738 return;
4739 }
4740
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004741 final long identity = Binder.clearCallingIdentity();
4742 try {
4743 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
4744 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
4745 } finally {
4746 Binder.restoreCallingIdentity(identity);
4747 }
Stuart Scott54788802015-03-30 13:18:01 -07004748 }
4749
Pengquan Mengea84e042018-09-20 14:57:26 -07004750 /**
4751 * Ask the radio to connect to the input network and change selection mode to manual.
4752 *
4753 * @param subId the id of the subscription.
4754 * @param operatorInfo the operator information, included the PLMN, long name and short name of
4755 * the operator to attach to.
4756 * @param persistSelection whether the selection will persist until reboot. If true, only allows
4757 * attaching to the selected PLMN until reboot; otherwise, attach to the chosen PLMN and resume
4758 * normal network selection next time.
4759 * @return {@code true} on success; {@code true} on any failure.
Shishir Agrawal302c8692015-06-19 13:49:39 -07004760 */
4761 @Override
Pengquan Mengea84e042018-09-20 14:57:26 -07004762 public boolean setNetworkSelectionModeManual(
4763 int subId, OperatorInfo operatorInfo, boolean persistSelection) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004764 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4765 mApp, subId, "setNetworkSelectionModeManual");
Pengquan Menge92a50d2018-09-21 15:54:48 -07004766
4767 if (!isActiveSubscription(subId)) {
4768 return false;
4769 }
4770
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004771 final long identity = Binder.clearCallingIdentity();
4772 try {
Pengquan Mengea84e042018-09-20 14:57:26 -07004773 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operatorInfo,
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004774 persistSelection);
Pengquan Mengea84e042018-09-20 14:57:26 -07004775 if (DBG) {
4776 log("setNetworkSelectionModeManual: subId: " + subId
4777 + " operator: " + operatorInfo);
4778 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004779 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
4780 } finally {
4781 Binder.restoreCallingIdentity(identity);
4782 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004783 }
4784
4785 /**
4786 * Scans for available networks.
4787 */
4788 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07004789 public CellNetworkScanResult getCellNetworkScanResults(int subId, String callingPackage,
4790 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004791 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4792 mApp, subId, "getCellNetworkScanResults");
Hall Liuf19c44f2018-11-27 14:38:17 -08004793 LocationAccessPolicy.LocationPermissionResult locationResult =
4794 LocationAccessPolicy.checkLocationPermission(mApp,
4795 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4796 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07004797 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08004798 .setCallingPid(Binder.getCallingPid())
4799 .setCallingUid(Binder.getCallingUid())
4800 .setMethod("getCellNetworkScanResults")
4801 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4802 .build());
4803 switch (locationResult) {
4804 case DENIED_HARD:
4805 throw new SecurityException("Not allowed to access scan results -- location");
4806 case DENIED_SOFT:
4807 return null;
4808 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004809
Pengquan Menga1bb6272018-09-06 09:59:22 -07004810 long identity = Binder.clearCallingIdentity();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004811 try {
4812 if (DBG) log("getCellNetworkScanResults: subId " + subId);
Pengquan Menga1bb6272018-09-06 09:59:22 -07004813 return (CellNetworkScanResult) sendRequest(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004814 CMD_PERFORM_NETWORK_SCAN, null, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004815 } finally {
4816 Binder.restoreCallingIdentity(identity);
4817 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004818 }
4819
4820 /**
yinxub1bed742017-04-17 11:45:04 -07004821 * Starts a new network scan and returns the id of this scan.
yinxu504e1392017-04-12 16:03:22 -07004822 *
yinxub1bed742017-04-17 11:45:04 -07004823 * @param subId id of the subscription
4824 * @param request contains the radio access networks with bands/channels to scan
4825 * @param messenger callback messenger for scan results or errors
4826 * @param binder for the purpose of auto clean when the user thread crashes
yinxu504e1392017-04-12 16:03:22 -07004827 * @return the id of the requested scan which can be used to stop the scan.
4828 */
4829 @Override
4830 public int requestNetworkScan(int subId, NetworkScanRequest request, Messenger messenger,
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07004831 IBinder binder, String callingPackage, String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004832 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4833 mApp, subId, "requestNetworkScan");
Hall Liuf19c44f2018-11-27 14:38:17 -08004834 LocationAccessPolicy.LocationPermissionResult locationResult =
4835 LocationAccessPolicy.checkLocationPermission(mApp,
4836 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4837 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07004838 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08004839 .setCallingPid(Binder.getCallingPid())
4840 .setCallingUid(Binder.getCallingUid())
4841 .setMethod("requestNetworkScan")
4842 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4843 .build());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004844 if (locationResult != LocationAccessPolicy.LocationPermissionResult.ALLOWED) {
Hall Liu558027f2019-05-15 19:14:05 -07004845 SecurityException e = checkNetworkRequestForSanitizedLocationAccess(request, subId);
Hall Liub2ac8ef2019-02-28 15:56:23 -08004846 if (e != null) {
4847 if (locationResult == LocationAccessPolicy.LocationPermissionResult.DENIED_HARD) {
4848 throw e;
4849 } else {
Hall Liu0e5abaf2019-04-04 01:25:30 -07004850 loge(e.getMessage());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004851 return TelephonyScanManager.INVALID_SCAN_ID;
4852 }
4853 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004854 }
Hall Liu912dfd32019-04-25 14:02:26 -07004855 int callingUid = Binder.getCallingUid();
4856 int callingPid = Binder.getCallingPid();
Ying Xu94a46582019-04-18 17:14:56 -07004857 final long identity = Binder.clearCallingIdentity();
4858 try {
4859 return mNetworkScanRequestTracker.startNetworkScan(
4860 request, messenger, binder, getPhone(subId),
Hall Liu912dfd32019-04-25 14:02:26 -07004861 callingUid, callingPid, callingPackage);
Ying Xu94a46582019-04-18 17:14:56 -07004862 } finally {
4863 Binder.restoreCallingIdentity(identity);
4864 }
yinxu504e1392017-04-12 16:03:22 -07004865 }
4866
Hall Liub2ac8ef2019-02-28 15:56:23 -08004867 private SecurityException checkNetworkRequestForSanitizedLocationAccess(
Hall Liu558027f2019-05-15 19:14:05 -07004868 NetworkScanRequest request, int subId) {
4869 boolean hasCarrierPriv = getCarrierPrivilegeStatusForUid(subId, Binder.getCallingUid())
4870 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
4871 boolean hasNetworkScanPermission =
4872 mApp.checkCallingOrSelfPermission(android.Manifest.permission.NETWORK_SCAN)
4873 == PERMISSION_GRANTED;
4874
4875 if (!hasCarrierPriv && !hasNetworkScanPermission) {
4876 return new SecurityException("permission.NETWORK_SCAN or carrier privileges is needed"
4877 + " for network scans without location access.");
Hall Liub2ac8ef2019-02-28 15:56:23 -08004878 }
4879
4880 if (request.getSpecifiers() != null && request.getSpecifiers().length > 0) {
4881 for (RadioAccessSpecifier ras : request.getSpecifiers()) {
Hall Liub2ac8ef2019-02-28 15:56:23 -08004882 if (ras.getChannels() != null && ras.getChannels().length > 0) {
4883 return new SecurityException("Specific channels must not be"
4884 + " scanned without location access.");
4885 }
4886 }
4887 }
4888
Hall Liub2ac8ef2019-02-28 15:56:23 -08004889 return null;
4890 }
4891
yinxu504e1392017-04-12 16:03:22 -07004892 /**
4893 * Stops an existing network scan with the given scanId.
yinxub1bed742017-04-17 11:45:04 -07004894 *
4895 * @param subId id of the subscription
4896 * @param scanId id of the scan that needs to be stopped
yinxu504e1392017-04-12 16:03:22 -07004897 */
4898 @Override
4899 public void stopNetworkScan(int subId, int scanId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004900 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4901 mApp, subId, "stopNetworkScan");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004902
Hall Liu912dfd32019-04-25 14:02:26 -07004903 int callingUid = Binder.getCallingUid();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004904 final long identity = Binder.clearCallingIdentity();
4905 try {
Hall Liu912dfd32019-04-25 14:02:26 -07004906 mNetworkScanRequestTracker.stopNetworkScan(scanId, callingUid);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004907 } finally {
4908 Binder.restoreCallingIdentity(identity);
4909 }
yinxu504e1392017-04-12 16:03:22 -07004910 }
4911
4912 /**
Junda Liu84d15a22014-07-02 11:21:04 -07004913 * Get the calculated preferred network type.
4914 * Used for debugging incorrect network type.
4915 *
4916 * @return the preferred network type, defined in RILConstants.java.
4917 */
4918 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004919 public int getCalculatedPreferredNetworkType(String callingPackage, String callingFeatureId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004920 final Phone defaultPhone = getDefaultPhone();
4921 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
Philip P. Moltmann700a9592019-10-03 11:53:50 -07004922 callingPackage, callingFeatureId, "getCalculatedPreferredNetworkType")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004923 return RILConstants.PREFERRED_NETWORK_MODE;
4924 }
4925
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004926 final long identity = Binder.clearCallingIdentity();
4927 try {
4928 // FIXME: need to get SubId from somewhere.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004929 return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004930 } finally {
4931 Binder.restoreCallingIdentity(identity);
4932 }
Junda Liu84d15a22014-07-02 11:21:04 -07004933 }
4934
4935 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08004936 * Get the preferred network type.
4937 * Used for device configuration by some CDMA operators.
4938 *
4939 * @return the preferred network type, defined in RILConstants.java.
4940 */
4941 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004942 public int getPreferredNetworkType(int subId) {
Pengquan Menga4009cb2018-12-20 11:00:24 -08004943 TelephonyPermissions
4944 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
4945 mApp, subId, "getPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004946
4947 final long identity = Binder.clearCallingIdentity();
4948 try {
4949 if (DBG) log("getPreferredNetworkType");
4950 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
4951 int networkType = (result != null ? result[0] : -1);
4952 if (DBG) log("getPreferredNetworkType: " + networkType);
4953 return networkType;
4954 } finally {
4955 Binder.restoreCallingIdentity(identity);
4956 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004957 }
4958
4959 /**
4960 * Set the preferred network type.
4961 * Used for device configuration by some CDMA operators.
4962 *
4963 * @param networkType the preferred network type, defined in RILConstants.java.
4964 * @return true on success; false on any failure.
4965 */
4966 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004967 public boolean setPreferredNetworkType(int subId, int networkType) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004968 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4969 mApp, subId, "setPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004970
4971 final long identity = Binder.clearCallingIdentity();
4972 try {
4973 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
4974 Boolean success = (Boolean) sendRequest(
4975 CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
4976 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
4977 if (success) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004978 Settings.Global.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004979 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
4980 }
4981 return success;
4982 } finally {
4983 Binder.restoreCallingIdentity(identity);
Junda Liu80bc0d12014-07-14 16:36:44 -07004984 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004985 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004986
4987 /**
Miaoa84611c2019-03-15 09:21:10 +08004988 * Check whether DUN APN is required for tethering with subId.
Junda Liu475951f2014-11-07 16:45:03 -08004989 *
Miaoa84611c2019-03-15 09:21:10 +08004990 * @param subId the id of the subscription to require tethering.
Amit Mahajanfe58cdf2017-07-11 12:01:53 -07004991 * @return {@code true} if DUN APN is required for tethering.
Junda Liu475951f2014-11-07 16:45:03 -08004992 * @hide
4993 */
4994 @Override
SongFerngWangf08d8122019-11-15 14:58:44 +08004995 public boolean isTetheringApnRequiredForSubscriber(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004996 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004997 final long identity = Binder.clearCallingIdentity();
Miaoa84611c2019-03-15 09:21:10 +08004998 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004999 try {
Miaoa84611c2019-03-15 09:21:10 +08005000 if (phone != null) {
5001 return phone.hasMatchedTetherApnSetting();
5002 } else {
5003 return false;
5004 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005005 } finally {
5006 Binder.restoreCallingIdentity(identity);
Junda Liu475951f2014-11-07 16:45:03 -08005007 }
Junda Liu475951f2014-11-07 16:45:03 -08005008 }
5009
5010 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07005011 * Set mobile data enabled
5012 * Used by the user through settings etc to turn on/off mobile data
5013 *
5014 * @param enable {@code true} turn turn data on, else {@code false}
5015 */
5016 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08005017 public void setUserDataEnabled(int subId, boolean enable) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005018 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5019 mApp, subId, "setUserDataEnabled");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005020
5021 final long identity = Binder.clearCallingIdentity();
5022 try {
5023 int phoneId = mSubscriptionController.getPhoneId(subId);
5024 if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5025 Phone phone = PhoneFactory.getPhone(phoneId);
5026 if (phone != null) {
5027 if (DBG) log("setUserDataEnabled: subId=" + subId + " enable=" + enable);
Jack Yud79fba22018-12-13 11:51:28 -08005028 phone.getDataEnabledSettings().setUserDataEnabled(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005029 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005030 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005031 }
5032 } finally {
5033 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08005034 }
Robert Greenwalted86e582014-05-21 20:03:20 -07005035 }
5036
5037 /**
Malcolm Chen964682d2017-11-28 16:20:07 -08005038 * Get the user enabled state of Mobile Data.
5039 *
5040 * TODO: remove and use isUserDataEnabled.
5041 * This can't be removed now because some vendor codes
5042 * calls through ITelephony directly while they should
5043 * use TelephonyManager.
5044 *
5045 * @return true on enabled
5046 */
5047 @Override
5048 public boolean getDataEnabled(int subId) {
5049 return isUserDataEnabled(subId);
5050 }
5051
5052 /**
5053 * Get whether mobile data is enabled per user setting.
5054 *
5055 * There are other factors deciding whether mobile data is actually enabled, but they are
5056 * not considered here. See {@link #isDataEnabled(int)} for more details.
Robert Greenwalt646120a2014-05-23 11:54:03 -07005057 *
Jeff Davidsona1920712016-11-18 17:05:56 -08005058 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
Robert Greenwalted86e582014-05-21 20:03:20 -07005059 *
5060 * @return {@code true} if data is enabled else {@code false}
5061 */
5062 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08005063 public boolean isUserDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07005064 try {
5065 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
5066 null);
5067 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005068 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5069 mApp, subId, "isUserDataEnabled");
Robert Greenwalt646120a2014-05-23 11:54:03 -07005070 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005071
5072 final long identity = Binder.clearCallingIdentity();
5073 try {
5074 int phoneId = mSubscriptionController.getPhoneId(subId);
5075 if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5076 Phone phone = PhoneFactory.getPhone(phoneId);
5077 if (phone != null) {
5078 boolean retVal = phone.isUserDataEnabled();
5079 if (DBG) log("isUserDataEnabled: subId=" + subId + " retVal=" + retVal);
5080 return retVal;
5081 } else {
5082 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
5083 return false;
5084 }
5085 } finally {
5086 Binder.restoreCallingIdentity(identity);
Malcolm Chen964682d2017-11-28 16:20:07 -08005087 }
5088 }
5089
5090 /**
5091 * Get whether mobile data is enabled.
5092 *
5093 * Comparable to {@link #isUserDataEnabled(int)}, this considers all factors deciding
5094 * whether mobile data is actually enabled.
5095 *
5096 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
5097 *
5098 * @return {@code true} if data is enabled else {@code false}
5099 */
5100 @Override
5101 public boolean isDataEnabled(int subId) {
5102 try {
5103 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
5104 null);
5105 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005106 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5107 mApp, subId, "isDataEnabled");
Malcolm Chen964682d2017-11-28 16:20:07 -08005108 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005109
5110 final long identity = Binder.clearCallingIdentity();
5111 try {
5112 int phoneId = mSubscriptionController.getPhoneId(subId);
5113 if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
5114 Phone phone = PhoneFactory.getPhone(phoneId);
5115 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08005116 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005117 if (DBG) log("isDataEnabled: subId=" + subId + " retVal=" + retVal);
5118 return retVal;
5119 } else {
5120 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
5121 return false;
5122 }
5123 } finally {
5124 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08005125 }
Robert Greenwalted86e582014-05-21 20:03:20 -07005126 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07005127
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005128 private int getCarrierPrivilegeStatusFromCarrierConfigRules(int privilegeFromSim,
5129 Phone phone) {
5130 //load access rules from carrier configs, and check those as well: b/139133814
5131 SubscriptionController subController = SubscriptionController.getInstance();
5132 if (privilegeFromSim == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS
5133 || subController == null) return privilegeFromSim;
5134
5135 int uid = Binder.getCallingUid();
5136 PackageManager pkgMgr = phone.getContext().getPackageManager();
5137 String[] packages = pkgMgr.getPackagesForUid(uid);
5138
5139 final long identity = Binder.clearCallingIdentity();
5140 try {
5141 SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());
5142 SubscriptionManager subManager = (SubscriptionManager)
5143 phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
5144 for (String pkg : packages) {
5145 if (subManager.canManageSubscription(subInfo, pkg)) {
5146 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
5147 }
5148 }
5149 return privilegeFromSim;
5150 } finally {
5151 Binder.restoreCallingIdentity(identity);
5152 }
5153 }
5154
5155 private int getCarrierPrivilegeStatusFromCarrierConfigRules(int privilegeFromSim, Phone phone,
5156 String pkgName) {
5157 //load access rules from carrier configs, and check those as well: b/139133814
5158 SubscriptionController subController = SubscriptionController.getInstance();
5159 if (privilegeFromSim == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS
5160 || subController == null) return privilegeFromSim;
5161
5162 final long identity = Binder.clearCallingIdentity();
5163 try {
5164 SubscriptionInfo subInfo = subController.getSubscriptionInfo(phone.getSubId());
5165 SubscriptionManager subManager = (SubscriptionManager)
5166 phone.getContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
5167 return subManager.canManageSubscription(subInfo, pkgName)
5168 ? TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS : privilegeFromSim;
5169 } finally {
5170 Binder.restoreCallingIdentity(identity);
5171 }
5172 }
5173
Shishir Agrawal60f9c952014-06-23 12:00:43 -07005174 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005175 public int getCarrierPrivilegeStatus(int subId) {
5176 final Phone phone = getPhone(subId);
5177 if (phone == null) {
5178 loge("getCarrierPrivilegeStatus: Invalid subId");
5179 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
5180 }
5181 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07005182 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08005183 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07005184 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
5185 }
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005186
5187 return getCarrierPrivilegeStatusFromCarrierConfigRules(
5188 card.getCarrierPrivilegeStatusForCurrentTransaction(
5189 phone.getContext().getPackageManager()), phone);
Shishir Agrawal60f9c952014-06-23 12:00:43 -07005190 }
Junda Liu29340342014-07-10 15:23:27 -07005191
5192 @Override
Jeff Davidson7e17e312018-02-13 18:17:36 -08005193 public int getCarrierPrivilegeStatusForUid(int subId, int uid) {
5194 final Phone phone = getPhone(subId);
5195 if (phone == null) {
Taesu Leef8fbed92019-10-07 18:47:02 +09005196 loge("getCarrierPrivilegeStatusForUid: Invalid subId");
Jeff Davidson7e17e312018-02-13 18:17:36 -08005197 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
5198 }
5199 UiccProfile profile =
5200 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
5201 if (profile == null) {
Taesu Leef8fbed92019-10-07 18:47:02 +09005202 loge("getCarrierPrivilegeStatusForUid: No UICC");
Jeff Davidson7e17e312018-02-13 18:17:36 -08005203 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
5204 }
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005205 return getCarrierPrivilegeStatusFromCarrierConfigRules(
5206 profile.getCarrierPrivilegeStatusForUid(
5207 phone.getContext().getPackageManager(), uid), phone);
Jeff Davidson7e17e312018-02-13 18:17:36 -08005208 }
5209
5210 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07005211 public int checkCarrierPrivilegesForPackage(int subId, String pkgName) {
5212 if (TextUtils.isEmpty(pkgName)) {
Junda Liu317d70b2016-03-08 09:33:53 -08005213 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
chen xuf7e9fe82019-05-09 19:31:02 -07005214 }
5215
5216 int phoneId = SubscriptionManager.getPhoneId(subId);
5217 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07005218 if (card == null) {
chen xuf7e9fe82019-05-09 19:31:02 -07005219 loge("checkCarrierPrivilegesForPackage: No UICC on subId " + subId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07005220 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
5221 }
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005222 return getCarrierPrivilegeStatusFromCarrierConfigRules(
5223 card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName),
5224 getPhone(phoneId), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07005225 }
5226
5227 @Override
5228 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08005229 if (TextUtils.isEmpty(pkgName))
5230 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07005231 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
5232 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
5233 UiccCard card = UiccController.getInstance().getUiccCard(i);
5234 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07005235 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07005236 continue;
5237 }
5238
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005239 result = getCarrierPrivilegeStatusFromCarrierConfigRules(
5240 card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName),
5241 getPhone(i), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07005242 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
5243 break;
5244 }
5245 }
5246
5247 return result;
Junda Liu29340342014-07-10 15:23:27 -07005248 }
Derek Tan89e89d42014-07-08 17:00:10 -07005249
5250 @Override
Junda Liue64de782015-04-16 17:19:16 -07005251 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
5252 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
5253 loge("phoneId " + phoneId + " is not valid.");
5254 return null;
5255 }
5256 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07005257 if (card == null) {
Taesu Leef8fbed92019-10-07 18:47:02 +09005258 loge("getCarrierPackageNamesForIntentAndPhone: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07005259 return null ;
5260 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005261 return card.getCarrierPackageNamesForIntent(mApp.getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07005262 }
5263
Amith Yamasani6e118872016-02-19 12:53:51 -08005264 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07005265 public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005266 PackageManager pm = mApp.getPackageManager();
Amith Yamasani6e118872016-02-19 12:53:51 -08005267 List<String> privilegedPackages = new ArrayList<>();
5268 List<PackageInfo> packages = null;
chen xuf7e9fe82019-05-09 19:31:02 -07005269 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
5270 // has UICC in that slot.
5271 if (card != null) {
Amith Yamasani6e118872016-02-19 12:53:51 -08005272 if (card.hasCarrierPrivilegeRules()) {
5273 if (packages == null) {
5274 // Only check packages in user 0 for now
5275 packages = pm.getInstalledPackagesAsUser(
Nazanin Bakhshi5d0636e2019-08-19 16:29:37 -07005276 PackageManager.MATCH_DISABLED_COMPONENTS
5277 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
Cheonho Park17089c62019-08-01 15:23:12 +09005278 | PackageManager.GET_SIGNING_CERTIFICATES,
5279 UserHandle.USER_SYSTEM);
Amith Yamasani6e118872016-02-19 12:53:51 -08005280 }
5281 for (int p = packages.size() - 1; p >= 0; p--) {
5282 PackageInfo pkgInfo = packages.get(p);
5283 if (pkgInfo != null && pkgInfo.packageName != null
5284 && card.getCarrierPrivilegeStatus(pkgInfo)
chen xuf7e9fe82019-05-09 19:31:02 -07005285 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Amith Yamasani6e118872016-02-19 12:53:51 -08005286 privilegedPackages.add(pkgInfo.packageName);
5287 }
5288 }
5289 }
5290 }
5291 return privilegedPackages;
5292 }
5293
chen xuf7e9fe82019-05-09 19:31:02 -07005294 @Override
5295 public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
Shuo Qian067a06d2019-12-03 23:40:18 +00005296 enforceReadPrivilegedPermission("getPackagesWithCarrierPrivilegesForAllPhones");
5297
5298 final long identity = Binder.clearCallingIdentity();
5299
chen xuf7e9fe82019-05-09 19:31:02 -07005300 List<String> privilegedPackages = new ArrayList<>();
Shuo Qian067a06d2019-12-03 23:40:18 +00005301 try {
5302 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
5303 privilegedPackages.addAll(getPackagesWithCarrierPrivileges(i));
5304 }
5305 } finally {
5306 Binder.restoreCallingIdentity(identity);
chen xuf7e9fe82019-05-09 19:31:02 -07005307 }
5308 return privilegedPackages;
5309 }
5310
Wink Savilleb564aae2014-10-23 10:18:09 -07005311 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07005312 final Phone phone = getPhone(subId);
5313 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07005314 if (card == null) {
5315 loge("getIccId: No UICC");
5316 return null;
5317 }
5318 String iccId = card.getIccId();
5319 if (TextUtils.isEmpty(iccId)) {
5320 loge("getIccId: ICC ID is null or empty.");
5321 return null;
5322 }
5323 return iccId;
5324 }
5325
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07005326 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08005327 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
5328 String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005329 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
5330 subId, "setLine1NumberForDisplayForSubscriber");
Derek Tan97ebb422014-09-05 16:55:38 -07005331
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005332 final long identity = Binder.clearCallingIdentity();
5333 try {
5334 final String iccId = getIccId(subId);
5335 final Phone phone = getPhone(subId);
5336 if (phone == null) {
5337 return false;
5338 }
5339 final String subscriberId = phone.getSubscriberId();
5340
5341 if (DBG_MERGE) {
5342 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
5343 + subscriberId + " to " + number);
5344 }
5345
5346 if (TextUtils.isEmpty(iccId)) {
5347 return false;
5348 }
5349
5350 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
5351
5352 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
5353 if (alphaTag == null) {
5354 editor.remove(alphaTagPrefKey);
5355 } else {
5356 editor.putString(alphaTagPrefKey, alphaTag);
5357 }
5358
5359 // Record both the line number and IMSI for this ICCID, since we need to
5360 // track all merged IMSIs based on line number
5361 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5362 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
5363 if (number == null) {
5364 editor.remove(numberPrefKey);
5365 editor.remove(subscriberPrefKey);
5366 } else {
5367 editor.putString(numberPrefKey, number);
5368 editor.putString(subscriberPrefKey, subscriberId);
5369 }
5370
5371 editor.commit();
5372 return true;
5373 } finally {
5374 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07005375 }
Derek Tan7226c842014-07-02 17:42:23 -07005376 }
5377
5378 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005379 public String getLine1NumberForDisplay(int subId, String callingPackage,
5380 String callingFeatureId) {
Makoto Onukifee69342015-06-29 14:44:50 -07005381 // This is open to apps with WRITE_SMS.
Jeff Davidson7e17e312018-02-13 18:17:36 -08005382 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005383 mApp, subId, callingPackage, callingFeatureId, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08005384 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07005385 return null;
5386 }
Derek Tan97ebb422014-09-05 16:55:38 -07005387
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005388 final long identity = Binder.clearCallingIdentity();
5389 try {
5390 String iccId = getIccId(subId);
5391 if (iccId != null) {
5392 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5393 if (DBG_MERGE) {
5394 log("getLine1NumberForDisplay returning "
5395 + mTelephonySharedPreferences.getString(numberPrefKey, null));
5396 }
5397 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Amit Mahajan9cf11512015-11-09 11:40:48 -08005398 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005399 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
5400 return null;
5401 } finally {
5402 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07005403 }
Derek Tan7226c842014-07-02 17:42:23 -07005404 }
5405
5406 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005407 public String getLine1AlphaTagForDisplay(int subId, String callingPackage,
5408 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005409 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005410 mApp, subId, callingPackage, callingFeatureId, "getLine1AlphaTagForDisplay")) {
Svet Ganovb320e182015-04-16 12:30:10 -07005411 return null;
5412 }
Derek Tan97ebb422014-09-05 16:55:38 -07005413
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005414 final long identity = Binder.clearCallingIdentity();
5415 try {
5416 String iccId = getIccId(subId);
5417 if (iccId != null) {
5418 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
5419 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
5420 }
5421 return null;
5422 } finally {
5423 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07005424 }
Derek Tan7226c842014-07-02 17:42:23 -07005425 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005426
5427 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005428 public String[] getMergedSubscriberIds(int subId, String callingPackage,
5429 String callingFeatureId) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005430 // This API isn't public, so no need to provide a valid subscription ID - we're not worried
5431 // about carrier-privileged callers not having access.
Jeff Davidson7e17e312018-02-13 18:17:36 -08005432 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005433 mApp, SubscriptionManager.INVALID_SUBSCRIPTION_ID, callingPackage,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005434 callingFeatureId, "getMergedSubscriberIds")) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005435 return null;
5436 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005437
Jordan Liub49b04b2019-05-06 14:45:15 -07005438 // Clear calling identity, when calling TelephonyManager, because callerUid must be
5439 // the process, where TelephonyManager was instantiated.
5440 // Otherwise AppOps check will fail.
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005441 final long identity = Binder.clearCallingIdentity();
5442 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005443 final Context context = mApp;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005444 final TelephonyManager tele = TelephonyManager.from(context);
5445 final SubscriptionManager sub = SubscriptionManager.from(context);
5446
5447 // Figure out what subscribers are currently active
5448 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005449
Jordan Liub49b04b2019-05-06 14:45:15 -07005450 // Only consider subs which match the current subId
5451 // This logic can be simplified. See b/131189269 for progress.
5452 if (isActiveSubscription(subId)) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005453 activeSubscriberIds.add(tele.getSubscriberId(subId));
5454 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005455
5456 // First pass, find a number override for an active subscriber
5457 String mergeNumber = null;
5458 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
5459 for (String key : prefs.keySet()) {
5460 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
5461 final String subscriberId = (String) prefs.get(key);
5462 if (activeSubscriberIds.contains(subscriberId)) {
5463 final String iccId = key.substring(
5464 PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
5465 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5466 mergeNumber = (String) prefs.get(numberKey);
5467 if (DBG_MERGE) {
5468 Slog.d(LOG_TAG, "Found line number " + mergeNumber
5469 + " for active subscriber " + subscriberId);
5470 }
5471 if (!TextUtils.isEmpty(mergeNumber)) {
5472 break;
5473 }
5474 }
5475 }
5476 }
5477
5478 // Shortcut when no active merged subscribers
5479 if (TextUtils.isEmpty(mergeNumber)) {
5480 return null;
5481 }
5482
5483 // Second pass, find all subscribers under that line override
5484 final ArraySet<String> result = new ArraySet<>();
5485 for (String key : prefs.keySet()) {
5486 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
5487 final String number = (String) prefs.get(key);
5488 if (mergeNumber.equals(number)) {
5489 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
5490 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
5491 final String subscriberId = (String) prefs.get(subscriberKey);
5492 if (!TextUtils.isEmpty(subscriberId)) {
5493 result.add(subscriberId);
5494 }
5495 }
5496 }
5497 }
5498
5499 final String[] resultArray = result.toArray(new String[result.size()]);
5500 Arrays.sort(resultArray);
5501 if (DBG_MERGE) {
5502 Slog.d(LOG_TAG,
5503 "Found subscribers " + Arrays.toString(resultArray) + " after merge");
5504 }
5505 return resultArray;
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005506 } finally {
5507 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08005508 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005509 }
5510
5511 @Override
Malcolm Chen6ca97372019-07-01 16:28:21 -07005512 public String[] getMergedSubscriberIdsFromGroup(int subId, String callingPackage) {
5513 enforceReadPrivilegedPermission("getMergedSubscriberIdsFromGroup");
5514
5515 final long identity = Binder.clearCallingIdentity();
5516 try {
5517 final TelephonyManager telephonyManager = mApp.getSystemService(
5518 TelephonyManager.class);
5519 String subscriberId = telephonyManager.getSubscriberId(subId);
5520 if (subscriberId == null) {
5521 if (DBG) {
5522 log("getMergedSubscriberIdsFromGroup can't find subscriberId for subId "
5523 + subId);
5524 }
5525 return null;
5526 }
5527
5528 final SubscriptionInfo info = SubscriptionController.getInstance()
5529 .getSubscriptionInfo(subId);
5530 final ParcelUuid groupUuid = info.getGroupUuid();
5531 // If it doesn't belong to any group, return just subscriberId of itself.
5532 if (groupUuid == null) {
5533 return new String[]{subscriberId};
5534 }
5535
5536 // Get all subscriberIds from the group.
5537 final List<String> mergedSubscriberIds = new ArrayList<>();
5538 final List<SubscriptionInfo> groupInfos = SubscriptionController.getInstance()
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005539 .getSubscriptionsInGroup(groupUuid, mApp.getOpPackageName(),
5540 mApp.getFeatureId());
Malcolm Chen6ca97372019-07-01 16:28:21 -07005541 for (SubscriptionInfo subInfo : groupInfos) {
5542 subscriberId = telephonyManager.getSubscriberId(subInfo.getSubscriptionId());
5543 if (subscriberId != null) {
5544 mergedSubscriberIds.add(subscriberId);
5545 }
5546 }
5547
5548 return mergedSubscriberIds.toArray(new String[mergedSubscriberIds.size()]);
5549 } finally {
5550 Binder.restoreCallingIdentity(identity);
5551
5552 }
5553 }
5554
5555 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005556 public boolean setOperatorBrandOverride(int subId, String brand) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005557 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
5558 subId, "setOperatorBrandOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005559
5560 final long identity = Binder.clearCallingIdentity();
5561 try {
5562 final Phone phone = getPhone(subId);
5563 return phone == null ? false : phone.setOperatorBrandOverride(brand);
5564 } finally {
5565 Binder.restoreCallingIdentity(identity);
5566 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005567 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05005568
5569 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005570 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005571 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
5572 List<String> cdmaNonRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005573 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setRoamingOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005574
5575 final long identity = Binder.clearCallingIdentity();
5576 try {
5577 final Phone phone = getPhone(subId);
5578 if (phone == null) {
5579 return false;
5580 }
5581 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
5582 cdmaNonRoamingList);
5583 } finally {
5584 Binder.restoreCallingIdentity(identity);
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005585 }
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005586 }
5587
5588 @Override
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005589 @Deprecated
5590 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
5591 enforceModifyPermission();
5592
5593 int returnValue = 0;
5594 try {
vagdeviaf9a5b92018-08-15 16:01:53 -07005595 AsyncResult result = (AsyncResult) sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005596 if(result.exception == null) {
5597 if (result.result != null) {
5598 byte[] responseData = (byte[])(result.result);
5599 if(responseData.length > oemResp.length) {
5600 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
5601 responseData.length + "bytes. Buffer Size is " +
5602 oemResp.length + "bytes.");
5603 }
5604 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
5605 returnValue = responseData.length;
5606 }
5607 } else {
5608 CommandException ex = (CommandException) result.exception;
5609 returnValue = ex.getCommandError().ordinal();
5610 if(returnValue > 0) returnValue *= -1;
5611 }
5612 } catch (RuntimeException e) {
5613 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
5614 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
5615 if(returnValue > 0) returnValue *= -1;
5616 }
5617
5618 return returnValue;
5619 }
5620
5621 @Override
Wink Saville5d475dd2014-10-17 15:00:58 -07005622 public void setRadioCapability(RadioAccessFamily[] rafs) {
5623 try {
5624 ProxyController.getInstance().setRadioCapability(rafs);
5625 } catch (RuntimeException e) {
5626 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
5627 }
5628 }
5629
5630 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07005631 public int getRadioAccessFamily(int phoneId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005632 Phone phone = PhoneFactory.getPhone(phoneId);
chen xub97461a2018-10-26 14:17:57 -07005633 int raf = RadioAccessFamily.RAF_UNKNOWN;
Jeff Davidson913390f2018-02-23 17:11:49 -08005634 if (phone == null) {
chen xub97461a2018-10-26 14:17:57 -07005635 return raf;
Jeff Davidson913390f2018-02-23 17:11:49 -08005636 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005637 final long identity = Binder.clearCallingIdentity();
5638 try {
chen xub97461a2018-10-26 14:17:57 -07005639 TelephonyPermissions
5640 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5641 mApp, phone.getSubId(), "getRadioAccessFamily");
5642 raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005643 } finally {
5644 Binder.restoreCallingIdentity(identity);
5645 }
chen xub97461a2018-10-26 14:17:57 -07005646 return raf;
Wink Saville5d475dd2014-10-17 15:00:58 -07005647 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005648
5649 @Override
5650 public void enableVideoCalling(boolean enable) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005651 final Phone defaultPhone = getDefaultPhone();
Andrew Leedf14ead2014-10-17 14:22:52 -07005652 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005653
5654 final long identity = Binder.clearCallingIdentity();
5655 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005656 ImsManager.getInstance(defaultPhone.getContext(),
5657 defaultPhone.getPhoneId()).setVtSetting(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005658 } finally {
5659 Binder.restoreCallingIdentity(identity);
5660 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005661 }
5662
5663 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005664 public boolean isVideoCallingEnabled(String callingPackage, String callingFeatureId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005665 final Phone defaultPhone = getDefaultPhone();
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005666 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
5667 callingPackage, callingFeatureId, "isVideoCallingEnabled")) {
Amit Mahajan578e53d2018-03-20 16:18:38 +00005668 return false;
5669 }
Svet Ganovb320e182015-04-16 12:30:10 -07005670
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005671 final long identity = Binder.clearCallingIdentity();
5672 try {
5673 // Check the user preference and the system-level IMS setting. Even if the user has
5674 // enabled video calling, if IMS is disabled we aren't able to support video calling.
5675 // In the long run, we may instead need to check if there exists a connection service
5676 // which can support video calling.
5677 ImsManager imsManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005678 ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005679 return imsManager.isVtEnabledByPlatform()
5680 && imsManager.isEnhanced4gLteModeSettingEnabledByUser()
5681 && imsManager.isVtEnabledByUser();
5682 } finally {
5683 Binder.restoreCallingIdentity(identity);
5684 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005685 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06005686
Andrew Leea1239f22015-03-02 17:44:07 -08005687 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005688 public boolean canChangeDtmfToneLength(int subId, String callingPackage,
5689 String callingFeatureId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005690 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005691 mApp, subId, callingPackage, callingFeatureId,
5692 "isVideoCallingEnabled")) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005693 return false;
5694 }
5695
5696 final long identity = Binder.clearCallingIdentity();
5697 try {
5698 CarrierConfigManager configManager =
5699 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005700 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005701 .getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
5702 } finally {
5703 Binder.restoreCallingIdentity(identity);
5704 }
Andrew Leea1239f22015-03-02 17:44:07 -08005705 }
5706
5707 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005708 public boolean isWorldPhone(int subId, String callingPackage, String callingFeatureId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005709 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005710 mApp, subId, callingPackage, callingFeatureId, "isVideoCallingEnabled")) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005711 return false;
5712 }
5713
5714 final long identity = Binder.clearCallingIdentity();
5715 try {
5716 CarrierConfigManager configManager =
5717 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005718 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005719 .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
5720 } finally {
5721 Binder.restoreCallingIdentity(identity);
5722 }
Andrew Leea1239f22015-03-02 17:44:07 -08005723 }
5724
Andrew Lee9431b832015-03-09 18:46:45 -07005725 @Override
5726 public boolean isTtyModeSupported() {
Tyler Gunn5ddfdc92019-10-31 13:08:23 -07005727 TelecomManager telecomManager = mApp.getSystemService(TelecomManager.class);
Wooki Wu1f82f7a2016-02-15 15:59:58 +08005728 return telecomManager.isTtySupported();
Andrew Lee9431b832015-03-09 18:46:45 -07005729 }
5730
5731 @Override
5732 public boolean isHearingAidCompatibilitySupported() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005733 final long identity = Binder.clearCallingIdentity();
5734 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005735 return mApp.getResources().getBoolean(R.bool.hac_enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005736 } finally {
5737 Binder.restoreCallingIdentity(identity);
5738 }
Andrew Lee9431b832015-03-09 18:46:45 -07005739 }
5740
Hall Liuf6668912018-10-31 17:05:23 -07005741 /**
5742 * Determines whether the device currently supports RTT (Real-time text). Based both on carrier
5743 * support for the feature and device firmware support.
5744 *
5745 * @return {@code true} if the device and carrier both support RTT, {@code false} otherwise.
5746 */
5747 @Override
5748 public boolean isRttSupported(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005749 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005750 final Phone phone = getPhone(subscriptionId);
5751 if (phone == null) {
5752 loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
5753 return false;
5754 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005755 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005756 boolean isCarrierSupported = mApp.getCarrierConfigForSubId(subscriptionId).getBoolean(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005757 CarrierConfigManager.KEY_RTT_SUPPORTED_BOOL);
5758 boolean isDeviceSupported =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005759 phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005760 return isCarrierSupported && isDeviceSupported;
5761 } finally {
5762 Binder.restoreCallingIdentity(identity);
5763 }
Hall Liu98187582018-01-22 19:15:32 -08005764 }
5765
Hall Liuf6668912018-10-31 17:05:23 -07005766 /**
Hall Liuf2daa022019-07-23 18:39:00 -07005767 * Determines whether the user has turned on RTT. If the carrier wants to ignore the user-set
5768 * RTT setting, will return true if the device and carrier both support RTT.
5769 * Otherwise. only returns true if the device and carrier both also support RTT.
Hall Liuf6668912018-10-31 17:05:23 -07005770 */
5771 public boolean isRttEnabled(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005772 final long identity = Binder.clearCallingIdentity();
5773 try {
Hall Liuf2daa022019-07-23 18:39:00 -07005774 boolean isRttSupported = isRttSupported(subscriptionId);
5775 boolean isUserRttSettingOn = Settings.Secure.getInt(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005776 mApp.getContentResolver(), Settings.Secure.RTT_CALLING_MODE, 0) != 0;
Hall Liuf2daa022019-07-23 18:39:00 -07005777 boolean shouldIgnoreUserRttSetting = mApp.getCarrierConfigForSubId(subscriptionId)
5778 .getBoolean(CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL);
5779 return isRttSupported && (isUserRttSettingOn || shouldIgnoreUserRttSetting);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005780 } finally {
5781 Binder.restoreCallingIdentity(identity);
5782 }
Hall Liu3ad5f012018-04-06 16:23:39 -07005783 }
5784
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005785 @Deprecated
5786 @Override
5787 public String getDeviceId(String callingPackage) {
5788 return getDeviceIdWithFeature(callingPackage, null);
5789 }
5790
Sanket Padawe7310cc72015-01-14 09:53:20 -08005791 /**
5792 * Returns the unique device ID of phone, for example, the IMEI for
5793 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
5794 *
5795 * <p>Requires Permission:
5796 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
5797 */
5798 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005799 public String getDeviceIdWithFeature(String callingPackage, String callingFeatureId) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005800 final Phone phone = PhoneFactory.getPhone(0);
Jeff Davidson913390f2018-02-23 17:11:49 -08005801 if (phone == null) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005802 return null;
5803 }
Jeff Davidson913390f2018-02-23 17:11:49 -08005804 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07005805 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005806 callingPackage, callingFeatureId, "getDeviceId")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005807 return null;
5808 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005809
5810 final long identity = Binder.clearCallingIdentity();
5811 try {
5812 return phone.getDeviceId();
5813 } finally {
5814 Binder.restoreCallingIdentity(identity);
5815 }
Sanket Padawe7310cc72015-01-14 09:53:20 -08005816 }
5817
Ping Sunc67b7c22016-03-02 19:16:45 +08005818 /**
5819 * {@hide}
5820 * Returns the IMS Registration Status on a particular subid
5821 *
5822 * @param subId
5823 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005824 public boolean isImsRegistered(int subId) {
Ping Sunc67b7c22016-03-02 19:16:45 +08005825 Phone phone = getPhone(subId);
5826 if (phone != null) {
5827 return phone.isImsRegistered();
5828 } else {
5829 return false;
5830 }
5831 }
5832
Santos Cordon7a1885b2015-02-03 11:15:19 -08005833 @Override
5834 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005835 final long identity = Binder.clearCallingIdentity();
5836 try {
5837 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
5838 } finally {
5839 Binder.restoreCallingIdentity(identity);
5840 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08005841 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07005842
Tyler Gunnf70ed162019-04-03 15:28:53 -07005843 @Override
Shuo Qian6e6137d2019-10-30 16:33:31 -07005844 public int getSubIdForPhoneAccountHandle(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005845 PhoneAccountHandle phoneAccountHandle, String callingPackage, String callingFeatureId) {
Shuo Qian6e6137d2019-10-30 16:33:31 -07005846 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, getDefaultSubscription(),
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005847 callingPackage, callingFeatureId, "getSubIdForPhoneAccountHandle")) {
Shuo Qian6e6137d2019-10-30 16:33:31 -07005848 throw new SecurityException("Requires READ_PHONE_STATE permission.");
5849 }
5850 final long identity = Binder.clearCallingIdentity();
5851 try {
5852 return PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle);
5853 } finally {
5854 Binder.restoreCallingIdentity(identity);
5855 }
5856 }
5857
5858 @Override
Tyler Gunnf70ed162019-04-03 15:28:53 -07005859 public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
5860 final long identity = Binder.clearCallingIdentity();
5861 try {
5862 Phone phone = getPhone(subscriptionId);
5863 if (phone == null) {
5864 return null;
5865 }
5866 return PhoneUtils.makePstnPhoneAccountHandle(phone);
5867 } finally {
5868 Binder.restoreCallingIdentity(identity);
5869 }
5870 }
5871
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005872 /**
5873 * @return the VoWiFi calling availability.
Nathan Haroldc55097a2015-03-11 18:14:50 -07005874 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005875 public boolean isWifiCallingAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005876 final long identity = Binder.clearCallingIdentity();
5877 try {
5878 Phone phone = getPhone(subId);
5879 if (phone != null) {
5880 return phone.isWifiCallingEnabled();
5881 } else {
5882 return false;
5883 }
5884 } finally {
5885 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005886 }
Nathan Haroldc55097a2015-03-11 18:14:50 -07005887 }
5888
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005889 /**
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005890 * @return the VT calling availability.
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005891 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005892 public boolean isVideoTelephonyAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005893 final long identity = Binder.clearCallingIdentity();
5894 try {
5895 Phone phone = getPhone(subId);
5896 if (phone != null) {
5897 return phone.isVideoEnabled();
5898 } else {
5899 return false;
5900 }
5901 } finally {
5902 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005903 }
5904 }
5905
5906 /**
5907 * @return the IMS registration technology for the MMTEL feature. Valid return values are
5908 * defined in {@link ImsRegistrationImplBase}.
5909 */
5910 public @ImsRegistrationImplBase.ImsRegistrationTech int getImsRegTechnologyForMmTel(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005911 final long identity = Binder.clearCallingIdentity();
5912 try {
5913 Phone phone = getPhone(subId);
5914 if (phone != null) {
5915 return phone.getImsRegistrationTech();
5916 } else {
5917 return ImsRegistrationImplBase.REGISTRATION_TECH_NONE;
5918 }
5919 } finally {
5920 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005921 }
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005922 }
5923
Stuart Scott8eef64f2015-04-08 15:13:54 -07005924 @Override
5925 public void factoryReset(int subId) {
5926 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07005927 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
5928 return;
5929 }
5930
Svet Ganovcc087f82015-05-12 20:35:54 -07005931 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005932
Svet Ganovcc087f82015-05-12 20:35:54 -07005933 try {
Stuart Scott981d8582015-04-21 14:09:50 -07005934 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
5935 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Pengquan Meng85728fb2018-03-12 16:31:21 -07005936 setUserDataEnabled(subId, getDefaultDataEnabled());
Svet Ganovcc087f82015-05-12 20:35:54 -07005937 setNetworkSelectionModeAutomatic(subId);
Pengquan Meng85728fb2018-03-12 16:31:21 -07005938 setPreferredNetworkType(subId, getDefaultNetworkType(subId));
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005939 setDataRoamingEnabled(subId, getDefaultDataRoamingEnabled(subId));
5940 CarrierInfoManager.deleteAllCarrierKeysForImsiEncryption(mApp);
Svet Ganovcc087f82015-05-12 20:35:54 -07005941 }
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005942 // There has been issues when Sms raw table somehow stores orphan
5943 // fragments. They lead to garbled message when new fragments come
5944 // in and combined with those stale ones. In case this happens again,
5945 // user can reset all network settings which will clean up this table.
5946 cleanUpSmsRawTable(getDefaultPhone().getContext());
Brad Ebingerbc7dd582019-10-17 17:03:22 -07005947 // Clean up IMS settings as well here.
5948 int slotId = getSlotIndex(subId);
5949 if (slotId > SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
5950 ImsManager.getInstance(mApp, slotId).factoryReset();
5951 }
Naina Nallurid63128d2019-09-17 14:10:30 -07005952
5953 // Erase modem config if erase modem on network setting is enabled.
5954 String configValue = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_TELEPHONY,
5955 RESET_NETWORK_ERASE_MODEM_CONFIG_ENABLED);
5956 if (configValue != null && Boolean.parseBoolean(configValue)) {
5957 sendEraseModemConfig(getDefaultPhone());
5958 }
Svet Ganovcc087f82015-05-12 20:35:54 -07005959 } finally {
5960 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07005961 }
5962 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005963
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005964 private void cleanUpSmsRawTable(Context context) {
5965 ContentResolver resolver = context.getContentResolver();
5966 Uri uri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw/permanentDelete");
5967 resolver.delete(uri, null, null);
5968 }
5969
Narayan Kamath1c496c22015-04-16 14:40:19 +01005970 @Override
chen xu5d3637b2019-01-21 23:31:38 -08005971 public String getSimLocaleForSubscriber(int subId) {
5972 enforceReadPrivilegedPermission("getSimLocaleForSubscriber, subId: " + subId);
5973 final Phone phone = getPhone(subId);
5974 if (phone == null) {
5975 log("getSimLocaleForSubscriber, invalid subId");
chen xu2bb91e42019-01-24 14:35:54 -08005976 return null;
chen xu5d3637b2019-01-21 23:31:38 -08005977 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005978 final long identity = Binder.clearCallingIdentity();
5979 try {
chen xu5d3637b2019-01-21 23:31:38 -08005980 final SubscriptionInfo info = mSubscriptionController.getActiveSubscriptionInfo(subId,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07005981 phone.getContext().getOpPackageName(), phone.getContext().getFeatureId());
chen xu6291c472019-02-04 12:55:53 -08005982 if (info == null) {
5983 log("getSimLocaleForSubscriber, inactive subId: " + subId);
5984 return null;
5985 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005986 // Try and fetch the locale from the carrier properties or from the SIM language
5987 // preferences (EF-PL and EF-LI)...
5988 final int mcc = info.getMcc();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005989 String simLanguage = null;
chen xu5d3637b2019-01-21 23:31:38 -08005990 final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
5991 if (localeFromDefaultSim != null) {
5992 if (!localeFromDefaultSim.getCountry().isEmpty()) {
5993 if (DBG) log("Using locale from subId: " + subId + " locale: "
5994 + localeFromDefaultSim);
5995 return localeFromDefaultSim.toLanguageTag();
5996 } else {
5997 simLanguage = localeFromDefaultSim.getLanguage();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005998 }
5999 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01006000
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006001 // The SIM language preferences only store a language (e.g. fr = French), not an
6002 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
6003 // the SIM and carrier preferences does not include a country we add the country
6004 // determined from the SIM MCC to provide an exact locale.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006005 final Locale mccLocale = MccTable.getLocaleFromMcc(mApp, mcc, simLanguage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006006 if (mccLocale != null) {
chen xu5d3637b2019-01-21 23:31:38 -08006007 if (DBG) log("No locale from SIM, using mcc locale:" + mccLocale);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006008 return mccLocale.toLanguageTag();
6009 }
6010
6011 if (DBG) log("No locale found - returning null");
6012 return null;
6013 } finally {
6014 Binder.restoreCallingIdentity(identity);
6015 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01006016 }
6017
6018 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006019 return mSubscriptionController.getAllSubInfoList(mApp.getOpPackageName(),
6020 mApp.getFeatureId());
Narayan Kamath1c496c22015-04-16 14:40:19 +01006021 }
6022
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006023 /**
6024 * NOTE: this method assumes permission checks are done and caller identity has been cleared.
6025 */
6026 private List<SubscriptionInfo> getActiveSubscriptionInfoListPrivileged() {
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006027 return mSubscriptionController.getActiveSubscriptionInfoList(mApp.getOpPackageName(),
6028 mApp.getFeatureId());
Narayan Kamath1c496c22015-04-16 14:40:19 +01006029 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07006030
Chenjie Yu1ba97252018-01-11 18:16:20 -08006031 private final ModemActivityInfo mLastModemActivityInfo =
Chen Xud78231e2019-09-10 18:49:52 -07006032 new ModemActivityInfo(0, 0, 0, new int[0], 0);
Chenjie Yu1ba97252018-01-11 18:16:20 -08006033
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07006034 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07006035 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
6036 * representing the state of the modem.
6037 *
Chenjie Yu1ba97252018-01-11 18:16:20 -08006038 * NOTE: The underlying implementation clears the modem state, so there should only ever be one
6039 * caller to it. Everyone should call this class to get cumulative data.
Adam Lesinski903a54c2016-04-11 14:49:52 -07006040 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07006041 */
6042 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07006043 public void requestModemActivityInfo(ResultReceiver result) {
6044 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07006045 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006046
6047 final long identity = Binder.clearCallingIdentity();
6048 try {
6049 ModemActivityInfo ret = null;
6050 synchronized (mLastModemActivityInfo) {
6051 ModemActivityInfo info = (ModemActivityInfo) sendRequest(
6052 CMD_GET_MODEM_ACTIVITY_INFO,
vagdeviaf9a5b92018-08-15 16:01:53 -07006053 null, workSource);
Siddharth Rayb8114062018-06-17 15:02:38 -07006054 if (isModemActivityInfoValid(info)) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006055 int[] mergedTxTimeMs = new int[ModemActivityInfo.TX_POWER_LEVELS];
Chen Xud78231e2019-09-10 18:49:52 -07006056 int[] txTimeMs = info.getTransmitTimeMillis();
6057 int[] lastModemTxTimeMs = mLastModemActivityInfo.getTransmitTimeMillis();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006058 for (int i = 0; i < mergedTxTimeMs.length; i++) {
Chen Xud78231e2019-09-10 18:49:52 -07006059 mergedTxTimeMs[i] = txTimeMs[i] + lastModemTxTimeMs[i];
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006060 }
6061 mLastModemActivityInfo.setTimestamp(info.getTimestamp());
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006062 mLastModemActivityInfo.setSleepTimeMillis(info.getSleepTimeMillis()
6063 + mLastModemActivityInfo.getSleepTimeMillis());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006064 mLastModemActivityInfo.setIdleTimeMillis(
6065 info.getIdleTimeMillis() + mLastModemActivityInfo.getIdleTimeMillis());
Chen Xud78231e2019-09-10 18:49:52 -07006066 mLastModemActivityInfo.setTransmitTimeMillis(mergedTxTimeMs);
6067 mLastModemActivityInfo.setReceiveTimeMillis(
6068 info.getReceiveTimeMillis() + mLastModemActivityInfo
6069 .getReceiveTimeMillis());
Chenjie Yu1ba97252018-01-11 18:16:20 -08006070 }
Chen Xud78231e2019-09-10 18:49:52 -07006071
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006072 ret = new ModemActivityInfo(mLastModemActivityInfo.getTimestamp(),
6073 mLastModemActivityInfo.getSleepTimeMillis(),
6074 mLastModemActivityInfo.getIdleTimeMillis(),
Chen Xud78231e2019-09-10 18:49:52 -07006075 mLastModemActivityInfo.getTransmitTimeMillis(),
6076 mLastModemActivityInfo.getReceiveTimeMillis());
Chenjie Yu1ba97252018-01-11 18:16:20 -08006077 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006078 Bundle bundle = new Bundle();
6079 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, ret);
6080 result.send(0, bundle);
6081 } finally {
6082 Binder.restoreCallingIdentity(identity);
Chenjie Yu1ba97252018-01-11 18:16:20 -08006083 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07006084 }
Jack Yu85bd38a2015-11-09 11:34:32 -08006085
Siddharth Rayb8114062018-06-17 15:02:38 -07006086 // Checks that ModemActivityInfo is valid. Sleep time, Idle time, Rx time and Tx time should be
6087 // less than total activity duration.
6088 private boolean isModemActivityInfoValid(ModemActivityInfo info) {
6089 if (info == null) {
6090 return false;
6091 }
6092 int activityDurationMs =
6093 (int) (info.getTimestamp() - mLastModemActivityInfo.getTimestamp());
6094 int totalTxTimeMs = 0;
Chen Xud78231e2019-09-10 18:49:52 -07006095 int[] txTimeMs = info.getTransmitTimeMillis();
6096 for (int i = 0; i < info.getTransmitPowerInfo().size(); i++) {
6097 totalTxTimeMs += txTimeMs[i];
Siddharth Rayb8114062018-06-17 15:02:38 -07006098 }
6099 return (info.isValid()
6100 && (info.getSleepTimeMillis() <= activityDurationMs)
6101 && (info.getIdleTimeMillis() <= activityDurationMs)
Chen Xud78231e2019-09-10 18:49:52 -07006102 && (info.getReceiveTimeMillis() <= activityDurationMs)
Siddharth Rayb8114062018-06-17 15:02:38 -07006103 && (totalTxTimeMs <= activityDurationMs));
6104 }
6105
Jack Yu85bd38a2015-11-09 11:34:32 -08006106 /**
6107 * {@hide}
6108 * Returns the service state information on specified subscription.
6109 */
6110 @Override
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07006111 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage,
6112 String callingFeatureId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006113 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006114 mApp, subId, callingPackage, callingFeatureId, "getServiceStateForSubscriber")) {
Jack Yu85bd38a2015-11-09 11:34:32 -08006115 return null;
6116 }
6117
Hall Liuf19c44f2018-11-27 14:38:17 -08006118 LocationAccessPolicy.LocationPermissionResult fineLocationResult =
6119 LocationAccessPolicy.checkLocationPermission(mApp,
6120 new LocationAccessPolicy.LocationPermissionQuery.Builder()
6121 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07006122 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08006123 .setCallingPid(Binder.getCallingPid())
6124 .setCallingUid(Binder.getCallingUid())
6125 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07006126 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08006127 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
6128 .build());
6129
6130 LocationAccessPolicy.LocationPermissionResult coarseLocationResult =
6131 LocationAccessPolicy.checkLocationPermission(mApp,
6132 new LocationAccessPolicy.LocationPermissionQuery.Builder()
6133 .setCallingPackage(callingPackage)
Philip P. Moltmann3a2772a2019-10-04 08:15:00 -07006134 .setCallingFeatureId(callingFeatureId)
Hall Liuf19c44f2018-11-27 14:38:17 -08006135 .setCallingPid(Binder.getCallingPid())
6136 .setCallingUid(Binder.getCallingUid())
6137 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07006138 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08006139 .setMinSdkVersionForCoarse(Build.VERSION_CODES.Q)
6140 .build());
6141 // We don't care about hard or soft here -- all we need to know is how much info to scrub.
6142 boolean hasFinePermission =
6143 fineLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
6144 boolean hasCoarsePermission =
6145 coarseLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
6146
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006147 final long identity = Binder.clearCallingIdentity();
6148 try {
6149 final Phone phone = getPhone(subId);
6150 if (phone == null) {
6151 return null;
6152 }
Jack Yu85bd38a2015-11-09 11:34:32 -08006153
Hall Liuf19c44f2018-11-27 14:38:17 -08006154 ServiceState ss = phone.getServiceState();
6155
6156 // Scrub out the location info in ServiceState depending on what level of access
6157 // the caller has.
6158 if (hasFinePermission) return ss;
6159 if (hasCoarsePermission) return ss.sanitizeLocationInfo(false);
6160 return ss.sanitizeLocationInfo(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006161 } finally {
6162 Binder.restoreCallingIdentity(identity);
6163 }
Jack Yu85bd38a2015-11-09 11:34:32 -08006164 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08006165
6166 /**
6167 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
6168 *
6169 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
6170 * voicemail ringtone.
6171 * @return The URI for the ringtone to play when receiving a voicemail from a specific
6172 * PhoneAccount.
6173 */
6174 @Override
6175 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006176 final long identity = Binder.clearCallingIdentity();
6177 try {
6178 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
6179 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006180 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006181 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08006182
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006183 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
6184 } finally {
6185 Binder.restoreCallingIdentity(identity);
6186 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08006187 }
6188
6189 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006190 * Sets the per-account voicemail ringtone.
6191 *
6192 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
6193 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6194 *
6195 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
6196 * voicemail ringtone.
6197 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific
6198 * PhoneAccount.
6199 */
6200 @Override
6201 public void setVoicemailRingtoneUri(String callingPackage,
6202 PhoneAccountHandle phoneAccountHandle, Uri uri) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006203 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006204 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Tyler Gunn5ddfdc92019-10-31 13:08:23 -07006205 TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
6206 if (!TextUtils.equals(callingPackage, tm.getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006207 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6208 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
6209 "setVoicemailRingtoneUri");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006210 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006211
6212 final long identity = Binder.clearCallingIdentity();
6213 try {
6214 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
6215 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006216 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006217 }
6218 VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
6219 } finally {
6220 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006221 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006222 }
6223
6224 /**
Nancy Chen31f9ba12016-01-06 11:42:12 -08006225 * Returns whether vibration is set for voicemail notification in Phone settings.
6226 *
6227 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
6228 * voicemail vibration setting.
6229 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
6230 */
6231 @Override
6232 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006233 final long identity = Binder.clearCallingIdentity();
6234 try {
6235 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
6236 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006237 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006238 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08006239
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006240 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
6241 } finally {
6242 Binder.restoreCallingIdentity(identity);
6243 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08006244 }
6245
Youhan Wange64578a2016-05-02 15:32:42 -07006246 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006247 * Sets the per-account voicemail vibration.
6248 *
6249 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
6250 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6251 *
6252 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
6253 * voicemail vibration setting.
6254 * @param enabled Whether to enable or disable vibration for voicemail notifications from a
6255 * specific PhoneAccount.
6256 */
6257 @Override
6258 public void setVoicemailVibrationEnabled(String callingPackage,
6259 PhoneAccountHandle phoneAccountHandle, boolean enabled) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006260 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006261 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Tyler Gunn5ddfdc92019-10-31 13:08:23 -07006262 TelecomManager tm = defaultPhone.getContext().getSystemService(TelecomManager.class);
6263 if (!TextUtils.equals(callingPackage, tm.getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006264 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6265 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
6266 "setVoicemailVibrationEnabled");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006267 }
6268
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006269 final long identity = Binder.clearCallingIdentity();
6270 try {
6271 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
6272 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006273 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006274 }
6275 VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
6276 } finally {
6277 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006278 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08006279 }
6280
6281 /**
Youhan Wange64578a2016-05-02 15:32:42 -07006282 * Make sure either called from same process as self (phone) or IPC caller has read privilege.
6283 *
6284 * @throws SecurityException if the caller does not have the required permission
6285 */
Brad Ebinger35c841c2018-10-01 10:40:55 -07006286 private void enforceReadPrivilegedPermission(String message) {
Youhan Wange64578a2016-05-02 15:32:42 -07006287 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
Brad Ebinger35c841c2018-10-01 10:40:55 -07006288 message);
Youhan Wange64578a2016-05-02 15:32:42 -07006289 }
6290
6291 /**
Ta-wei Yen30a69c82016-12-27 14:52:32 -08006292 * Make sure either called from same process as self (phone) or IPC caller has send SMS
6293 * permission.
6294 *
6295 * @throws SecurityException if the caller does not have the required permission
6296 */
6297 private void enforceSendSmsPermission() {
6298 mApp.enforceCallingOrSelfPermission(permission.SEND_SMS, null);
6299 }
6300
6301 /**
Ta-wei Yen527a9c02017-01-06 15:29:25 -08006302 * Make sure called from the package in charge of visual voicemail.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08006303 *
Ta-wei Yen527a9c02017-01-06 15:29:25 -08006304 * @throws SecurityException if the caller is not the visual voicemail package.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08006305 */
Ta-wei Yen527a9c02017-01-06 15:29:25 -08006306 private void enforceVisualVoicemailPackage(String callingPackage, int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006307 final long identity = Binder.clearCallingIdentity();
6308 try {
6309 ComponentName componentName =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006310 RemoteVvmTaskManager.getRemotePackage(mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006311 if (componentName == null) {
6312 throw new SecurityException(
6313 "Caller not current active visual voicemail package[null]");
6314 }
6315 String vvmPackage = componentName.getPackageName();
6316 if (!callingPackage.equals(vvmPackage)) {
6317 throw new SecurityException("Caller not current active visual voicemail package["
6318 + vvmPackage + "]");
6319 }
6320 } finally {
6321 Binder.restoreCallingIdentity(identity);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08006322 }
6323 }
6324
6325 /**
Youhan Wange64578a2016-05-02 15:32:42 -07006326 * Return the application ID for the app type.
6327 *
6328 * @param subId the subscription ID that this request applies to.
6329 * @param appType the uicc app type.
6330 * @return Application ID for specificied app type, or null if no uicc.
6331 */
6332 @Override
6333 public String getAidForAppType(int subId, int appType) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006334 enforceReadPrivilegedPermission("getAidForAppType");
Youhan Wange64578a2016-05-02 15:32:42 -07006335 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006336
6337 final long identity = Binder.clearCallingIdentity();
Youhan Wange64578a2016-05-02 15:32:42 -07006338 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006339 if (phone == null) {
6340 return null;
6341 }
6342 String aid = null;
6343 try {
6344 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
6345 .getApplicationByType(appType).getAid();
6346 } catch (Exception e) {
6347 Log.e(LOG_TAG, "Not getting aid. Exception ex=" + e);
6348 }
6349 return aid;
6350 } finally {
6351 Binder.restoreCallingIdentity(identity);
Youhan Wange64578a2016-05-02 15:32:42 -07006352 }
Youhan Wange64578a2016-05-02 15:32:42 -07006353 }
6354
Youhan Wang4001d252016-05-11 10:29:41 -07006355 /**
6356 * Return the Electronic Serial Number.
6357 *
6358 * @param subId the subscription ID that this request applies to.
6359 * @return ESN or null if error.
6360 */
6361 @Override
6362 public String getEsn(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006363 enforceReadPrivilegedPermission("getEsn");
Youhan Wang4001d252016-05-11 10:29:41 -07006364 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006365
6366 final long identity = Binder.clearCallingIdentity();
Youhan Wang4001d252016-05-11 10:29:41 -07006367 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006368 if (phone == null) {
6369 return null;
6370 }
6371 String esn = null;
6372 try {
6373 esn = phone.getEsn();
6374 } catch (Exception e) {
6375 Log.e(LOG_TAG, "Not getting ESN. Exception ex=" + e);
6376 }
6377 return esn;
6378 } finally {
6379 Binder.restoreCallingIdentity(identity);
Youhan Wang4001d252016-05-11 10:29:41 -07006380 }
Youhan Wang4001d252016-05-11 10:29:41 -07006381 }
6382
Sanket Padawe99ef1e32016-05-18 16:12:33 -07006383 /**
Youhan Wang66ad5d72016-07-18 17:56:58 -07006384 * Return the Preferred Roaming List Version.
6385 *
6386 * @param subId the subscription ID that this request applies to.
6387 * @return PRLVersion or null if error.
6388 */
6389 @Override
6390 public String getCdmaPrlVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006391 enforceReadPrivilegedPermission("getCdmaPrlVersion");
Youhan Wang66ad5d72016-07-18 17:56:58 -07006392 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006393
6394 final long identity = Binder.clearCallingIdentity();
Youhan Wang66ad5d72016-07-18 17:56:58 -07006395 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006396 if (phone == null) {
6397 return null;
6398 }
6399 String cdmaPrlVersion = null;
6400 try {
6401 cdmaPrlVersion = phone.getCdmaPrlVersion();
6402 } catch (Exception e) {
6403 Log.e(LOG_TAG, "Not getting PRLVersion", e);
6404 }
6405 return cdmaPrlVersion;
6406 } finally {
6407 Binder.restoreCallingIdentity(identity);
Youhan Wang66ad5d72016-07-18 17:56:58 -07006408 }
Youhan Wang66ad5d72016-07-18 17:56:58 -07006409 }
6410
6411 /**
Sanket Padawe99ef1e32016-05-18 16:12:33 -07006412 * Get snapshot of Telephony histograms
6413 * @return List of Telephony histograms
6414 * @hide
6415 */
6416 @Override
6417 public List<TelephonyHistogram> getTelephonyHistograms() {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006418 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6419 mApp, getDefaultSubscription(), "getTelephonyHistograms");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006420
6421 final long identity = Binder.clearCallingIdentity();
6422 try {
6423 return RIL.getTelephonyRILTimingHistograms();
6424 } finally {
6425 Binder.restoreCallingIdentity(identity);
6426 }
Sanket Padawe99ef1e32016-05-18 16:12:33 -07006427 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07006428
6429 /**
6430 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08006431 * Set the allowed carrier list and the excluded carrier list, indicating the priority between
6432 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07006433 * Require system privileges. In the future we may add this to carrier APIs.
6434 *
Michele Berionne482f8202018-11-27 18:57:59 -08006435 * @return Integer with the result of the operation, as defined in {@link TelephonyManager}.
Meng Wang1a7c35a2016-05-05 20:56:15 -07006436 */
6437 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08006438 @TelephonyManager.SetCarrierRestrictionResult
6439 public int setAllowedCarriers(CarrierRestrictionRules carrierRestrictionRules) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07006440 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07006441 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006442
Michele Berionne482f8202018-11-27 18:57:59 -08006443 if (carrierRestrictionRules == null) {
6444 throw new NullPointerException("carrier restriction cannot be null");
Meng Wang9b7c4e92017-02-17 11:41:27 -08006445 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006446
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006447 final long identity = Binder.clearCallingIdentity();
6448 try {
Michele Berionne482f8202018-11-27 18:57:59 -08006449 return (int) sendRequest(CMD_SET_ALLOWED_CARRIERS, carrierRestrictionRules,
vagdeviaf9a5b92018-08-15 16:01:53 -07006450 workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006451 } finally {
6452 Binder.restoreCallingIdentity(identity);
6453 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07006454 }
6455
6456 /**
6457 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08006458 * Get the allowed carrier list and the excluded carrier list, including the priority between
6459 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07006460 * Require system privileges. In the future we may add this to carrier APIs.
6461 *
Michele Berionne482f8202018-11-27 18:57:59 -08006462 * @return {@link android.telephony.CarrierRestrictionRules}
Meng Wang1a7c35a2016-05-05 20:56:15 -07006463 */
6464 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08006465 public CarrierRestrictionRules getAllowedCarriers() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006466 enforceReadPrivilegedPermission("getAllowedCarriers");
vagdeviaf9a5b92018-08-15 16:01:53 -07006467 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006468
6469 final long identity = Binder.clearCallingIdentity();
6470 try {
Michele Berionne482f8202018-11-27 18:57:59 -08006471 Object response = sendRequest(CMD_GET_ALLOWED_CARRIERS, null, workSource);
6472 if (response instanceof CarrierRestrictionRules) {
6473 return (CarrierRestrictionRules) response;
6474 }
6475 // Response is an Exception of some kind,
6476 // which is signalled to the user as a NULL retval
6477 return null;
6478 } catch (Exception e) {
6479 Log.e(LOG_TAG, "getAllowedCarriers. Exception ex=" + e);
6480 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006481 } finally {
6482 Binder.restoreCallingIdentity(identity);
6483 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07006484 }
6485
fionaxu59545b42016-05-25 15:53:37 -07006486 /**
6487 * Action set from carrier signalling broadcast receivers to enable/disable metered apns
6488 * @param subId the subscription ID that this action applies to.
6489 * @param enabled control enable or disable metered apns.
6490 * {@hide}
6491 */
6492 @Override
6493 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) {
6494 enforceModifyPermission();
6495 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006496
6497 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07006498 if (phone == null) {
6499 loge("carrierAction: SetMeteredApnsEnabled fails with invalid subId: " + subId);
6500 return;
6501 }
6502 try {
6503 phone.carrierActionSetMeteredApnsEnabled(enabled);
6504 } catch (Exception e) {
6505 Log.e(LOG_TAG, "carrierAction: SetMeteredApnsEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006506 } finally {
6507 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006508 }
6509 }
6510
6511 /**
6512 * Action set from carrier signalling broadcast receivers to enable/disable radio
6513 * @param subId the subscription ID that this action applies to.
6514 * @param enabled control enable or disable radio.
6515 * {@hide}
6516 */
6517 @Override
6518 public void carrierActionSetRadioEnabled(int subId, boolean enabled) {
6519 enforceModifyPermission();
6520 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006521
6522 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07006523 if (phone == null) {
6524 loge("carrierAction: SetRadioEnabled fails with invalid sibId: " + subId);
6525 return;
6526 }
6527 try {
6528 phone.carrierActionSetRadioEnabled(enabled);
6529 } catch (Exception e) {
6530 Log.e(LOG_TAG, "carrierAction: SetRadioEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006531 } finally {
6532 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006533 }
6534 }
6535
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006536 /**
fionaxu8da9cb12017-05-23 15:02:46 -07006537 * Action set from carrier signalling broadcast receivers to start/stop reporting the default
6538 * network status based on which carrier apps could apply actions accordingly,
6539 * enable/disable default url handler for example.
6540 *
6541 * @param subId the subscription ID that this action applies to.
6542 * @param report control start/stop reporting the default network status.
6543 * {@hide}
6544 */
6545 @Override
6546 public void carrierActionReportDefaultNetworkStatus(int subId, boolean report) {
6547 enforceModifyPermission();
6548 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006549
6550 final long identity = Binder.clearCallingIdentity();
fionaxu8da9cb12017-05-23 15:02:46 -07006551 if (phone == null) {
6552 loge("carrierAction: ReportDefaultNetworkStatus fails with invalid sibId: " + subId);
6553 return;
6554 }
6555 try {
6556 phone.carrierActionReportDefaultNetworkStatus(report);
6557 } catch (Exception e) {
6558 Log.e(LOG_TAG, "carrierAction: ReportDefaultNetworkStatus fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006559 } finally {
6560 Binder.restoreCallingIdentity(identity);
fionaxu8da9cb12017-05-23 15:02:46 -07006561 }
6562 }
6563
6564 /**
fionaxud9622282017-07-17 17:51:30 -07006565 * Action set from carrier signalling broadcast receivers to reset all carrier actions
6566 * @param subId the subscription ID that this action applies to.
6567 * {@hide}
6568 */
6569 @Override
6570 public void carrierActionResetAll(int subId) {
6571 enforceModifyPermission();
6572 final Phone phone = getPhone(subId);
6573 if (phone == null) {
6574 loge("carrierAction: ResetAll fails with invalid sibId: " + subId);
6575 return;
6576 }
6577 try {
6578 phone.carrierActionResetAll();
6579 } catch (Exception e) {
6580 Log.e(LOG_TAG, "carrierAction: ResetAll fails. Exception ex=" + e);
6581 }
6582 }
6583
6584 /**
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006585 * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
6586 * bug report is being generated.
6587 */
6588 @Override
Ta-wei Yen99282e02016-06-21 18:19:35 -07006589 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006590 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
6591 != PackageManager.PERMISSION_GRANTED) {
dcashman22b950d2016-06-27 11:39:02 -07006592 writer.println("Permission Denial: can't dump Phone from pid="
6593 + Binder.getCallingPid()
6594 + ", uid=" + Binder.getCallingUid()
6595 + "without permission "
6596 + android.Manifest.permission.DUMP);
6597 return;
6598 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006599 DumpsysHandler.dump(mApp, fd, writer, args);
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006600 }
Jack Yueb89b242016-06-22 13:27:47 -07006601
Brad Ebingerdac2f002018-04-03 15:17:52 -07006602 @Override
6603 public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
6604 String[] args, ShellCallback callback, ResultReceiver resultReceiver)
6605 throws RemoteException {
Torbjorn Eklund1050cb02018-11-16 14:05:38 +01006606 (new TelephonyShellCommand(this, getDefaultPhone().getContext()))
6607 .exec(this, in, out, err, args, callback, resultReceiver);
Brad Ebingerdac2f002018-04-03 15:17:52 -07006608 }
6609
Jack Yueb89b242016-06-22 13:27:47 -07006610 /**
Jack Yu84291ec2017-05-26 16:07:50 -07006611 * Get aggregated video call data usage since boot.
6612 *
6613 * @param perUidStats True if requesting data usage per uid, otherwise overall usage.
6614 * @return Snapshot of video call data usage
Jack Yueb89b242016-06-22 13:27:47 -07006615 * {@hide}
6616 */
6617 @Override
Jack Yu84291ec2017-05-26 16:07:50 -07006618 public NetworkStats getVtDataUsage(int subId, boolean perUidStats) {
Jack Yueb89b242016-06-22 13:27:47 -07006619 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_NETWORK_USAGE_HISTORY,
6620 null);
6621
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006622 final long identity = Binder.clearCallingIdentity();
6623 try {
6624 // NetworkStatsService keeps tracking the active network interface and identity. It
6625 // records the delta with the corresponding network identity.
6626 // We just return the total video call data usage snapshot since boot.
6627 Phone phone = getPhone(subId);
6628 if (phone != null) {
6629 return phone.getVtDataUsage(perUidStats);
6630 }
6631 return null;
6632 } finally {
6633 Binder.restoreCallingIdentity(identity);
Jack Yueb89b242016-06-22 13:27:47 -07006634 }
Jack Yueb89b242016-06-22 13:27:47 -07006635 }
Jack Yu75ab2952016-07-08 14:29:33 -07006636
6637 /**
6638 * Policy control of data connection. Usually used when data limit is passed.
6639 * @param enabled True if enabling the data, otherwise disabling.
6640 * @param subId Subscription index
6641 * {@hide}
6642 */
6643 @Override
6644 public void setPolicyDataEnabled(boolean enabled, int subId) {
6645 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006646
6647 final long identity = Binder.clearCallingIdentity();
6648 try {
6649 Phone phone = getPhone(subId);
6650 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08006651 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006652 }
6653 } finally {
6654 Binder.restoreCallingIdentity(identity);
Jack Yu75ab2952016-07-08 14:29:33 -07006655 }
6656 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006657
6658 /**
6659 * Get Client request stats
6660 * @return List of Client Request Stats
6661 * @hide
6662 */
6663 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006664 public List<ClientRequestStats> getClientRequestStats(String callingPackage,
6665 String callingFeatureId, int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006666 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006667 mApp, subId, callingPackage, callingFeatureId, "getClientRequestStats")) {
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006668 return null;
6669 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006670 Phone phone = getPhone(subId);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006671
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006672 final long identity = Binder.clearCallingIdentity();
6673 try {
6674 if (phone != null) {
6675 return phone.getClientRequestStats();
6676 }
6677
6678 return null;
6679 } finally {
6680 Binder.restoreCallingIdentity(identity);
6681 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006682 }
6683
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006684 private WorkSource getWorkSource(int uid) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006685 String packageName = mApp.getPackageManager().getNameForUid(uid);
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006686 return new WorkSource(uid, packageName);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006687 }
Jack Yueb4124c2017-02-16 15:32:43 -08006688
6689 /**
Grace Chen70990072017-03-24 17:21:30 -07006690 * Set SIM card power state.
Jack Yueb4124c2017-02-16 15:32:43 -08006691 *
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006692 * @param slotIndex SIM slot id.
Grace Chen70990072017-03-24 17:21:30 -07006693 * @param state State of SIM (power down, power up, pass through)
6694 * - {@link android.telephony.TelephonyManager#CARD_POWER_DOWN}
6695 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP}
6696 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP_PASS_THROUGH}
Jack Yueb4124c2017-02-16 15:32:43 -08006697 *
6698 **/
6699 @Override
Grace Chen70990072017-03-24 17:21:30 -07006700 public void setSimPowerStateForSlot(int slotIndex, int state) {
Jack Yueb4124c2017-02-16 15:32:43 -08006701 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006702 Phone phone = PhoneFactory.getPhone(slotIndex);
6703
vagdeviaf9a5b92018-08-15 16:01:53 -07006704 WorkSource workSource = getWorkSource(Binder.getCallingUid());
6705
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006706 final long identity = Binder.clearCallingIdentity();
6707 try {
6708 if (phone != null) {
vagdeviaf9a5b92018-08-15 16:01:53 -07006709 phone.setSimPowerState(state, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006710 }
6711 } finally {
6712 Binder.restoreCallingIdentity(identity);
Jack Yueb4124c2017-02-16 15:32:43 -08006713 }
6714 }
Shuo Qiandd210312017-04-12 22:11:33 +00006715
Tyler Gunn65d45c22017-06-05 11:22:26 -07006716 private boolean isUssdApiAllowed(int subId) {
6717 CarrierConfigManager configManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006718 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Tyler Gunn65d45c22017-06-05 11:22:26 -07006719 if (configManager == null) {
6720 return false;
6721 }
6722 PersistableBundle pb = configManager.getConfigForSubId(subId);
6723 if (pb == null) {
6724 return false;
6725 }
6726 return pb.getBoolean(
6727 CarrierConfigManager.KEY_ALLOW_USSD_REQUESTS_VIA_TELEPHONY_MANAGER_BOOL);
6728 }
6729
Shuo Qiandd210312017-04-12 22:11:33 +00006730 /**
6731 * Check if phone is in emergency callback mode
6732 * @return true if phone is in emergency callback mode
6733 * @param subId sub id
6734 */
goneil9c5f4872017-12-05 14:07:56 -08006735 @Override
Shuo Qiandd210312017-04-12 22:11:33 +00006736 public boolean getEmergencyCallbackMode(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006737 enforceReadPrivilegedPermission("getEmergencyCallbackMode");
Shuo Qiandd210312017-04-12 22:11:33 +00006738 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006739
6740 final long identity = Binder.clearCallingIdentity();
6741 try {
6742 if (phone != null) {
6743 return phone.isInEcm();
6744 } else {
6745 return false;
6746 }
6747 } finally {
6748 Binder.restoreCallingIdentity(identity);
Shuo Qiandd210312017-04-12 22:11:33 +00006749 }
6750 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006751
6752 /**
6753 * Get the current signal strength information for the given subscription.
6754 * Because this information is not updated when the device is in a low power state
6755 * it should not be relied-upon to be current.
6756 * @param subId Subscription index
6757 * @return the most recent cached signal strength info from the modem
6758 */
6759 @Override
6760 public SignalStrength getSignalStrength(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006761 final long identity = Binder.clearCallingIdentity();
6762 try {
6763 Phone p = getPhone(subId);
6764 if (p == null) {
6765 return null;
6766 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006767
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006768 return p.getSignalStrength();
6769 } finally {
6770 Binder.restoreCallingIdentity(identity);
6771 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006772 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006773
Pengquan Meng77b7f132018-08-22 14:49:57 -07006774 /**
Chen Xuf792fd62018-10-17 17:54:36 +00006775 * Get the current modem radio state for the given slot.
6776 * @param slotIndex slot index.
6777 * @param callingPackage the name of the package making the call.
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006778 * @param callingFeatureId The feature in the package.
Chen Xuf792fd62018-10-17 17:54:36 +00006779 * @return the current radio power state from the modem
6780 */
6781 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006782 public int getRadioPowerState(int slotIndex, String callingPackage, String callingFeatureId) {
Chen Xuf792fd62018-10-17 17:54:36 +00006783 Phone phone = PhoneFactory.getPhone(slotIndex);
6784 if (phone != null) {
Philip P. Moltmann700a9592019-10-03 11:53:50 -07006785 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, phone.getSubId(),
6786 callingPackage, callingFeatureId, "getRadioPowerState")) {
Chen Xuf792fd62018-10-17 17:54:36 +00006787 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6788 }
6789
6790 final long identity = Binder.clearCallingIdentity();
6791 try {
6792 return phone.getRadioPowerState();
6793 } finally {
6794 Binder.restoreCallingIdentity(identity);
6795 }
6796 }
6797 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6798 }
6799
6800 /**
Pengquan Meng77b7f132018-08-22 14:49:57 -07006801 * Checks if data roaming is enabled on the subscription with id {@code subId}.
6802 *
6803 * <p>Requires one of the following permissions:
6804 * {@link android.Manifest.permission#ACCESS_NETWORK_STATE},
6805 * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
6806 * privileges.
6807 *
6808 * @param subId subscription id
6809 * @return {@code true} if data roaming is enabled on this subscription, otherwise return
6810 * {@code false}.
6811 */
6812 @Override
6813 public boolean isDataRoamingEnabled(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006814 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
6815 null /* message */);
6816
Pengquan Menga1bb6272018-09-06 09:59:22 -07006817 boolean isEnabled = false;
6818 final long identity = Binder.clearCallingIdentity();
Pengquan Meng77b7f132018-08-22 14:49:57 -07006819 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006820 Phone phone = getPhone(subId);
6821 isEnabled = phone != null ? phone.getDataRoamingEnabled() : false;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006822 } catch (Exception e) {
6823 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6824 mApp, subId, "isDataRoamingEnabled");
Pengquan Menga1bb6272018-09-06 09:59:22 -07006825 } finally {
6826 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006827 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006828 return isEnabled;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006829 }
6830
6831
6832 /**
6833 * Enables/Disables the data roaming on the subscription with id {@code subId}.
6834 *
6835 * <p> Requires permission:
6836 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
6837 * privileges.
6838 *
6839 * @param subId subscription id
6840 * @param isEnabled {@code true} means enable, {@code false} means disable.
6841 */
6842 @Override
6843 public void setDataRoamingEnabled(int subId, boolean isEnabled) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006844 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6845 mApp, subId, "setDataRoamingEnabled");
6846
Pengquan Menga1bb6272018-09-06 09:59:22 -07006847 final long identity = Binder.clearCallingIdentity();
6848 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006849 Phone phone = getPhone(subId);
6850 if (phone != null) {
6851 phone.setDataRoamingEnabled(isEnabled);
6852 }
6853 } finally {
6854 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006855 }
6856 }
6857
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006858 @Override
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006859 public boolean isManualNetworkSelectionAllowed(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006860 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6861 mApp, subId, "isManualNetworkSelectionAllowed");
6862
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006863 boolean isAllowed = true;
6864 final long identity = Binder.clearCallingIdentity();
6865 try {
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006866 Phone phone = getPhone(subId);
6867 if (phone != null) {
6868 isAllowed = phone.isCspPlmnEnabled();
6869 }
6870 } finally {
6871 Binder.restoreCallingIdentity(identity);
6872 }
6873 return isAllowed;
6874 }
6875
6876 @Override
Jordan Liu75f43ea2019-01-17 16:56:37 -08006877 public List<UiccCardInfo> getUiccCardsInfo(String callingPackage) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006878 boolean hasReadPermission = false;
Jordan Liuc65bc952019-02-12 17:54:02 -08006879 try {
6880 enforceReadPrivilegedPermission("getUiccCardsInfo");
Jordan Liu1e142fc2019-04-22 15:10:43 -07006881 hasReadPermission = true;
Jordan Liuc65bc952019-02-12 17:54:02 -08006882 } catch (SecurityException e) {
6883 // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
6884 // has carrier privileges on an active UICC
6885 if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
6886 != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006887 throw new SecurityException("Caller does not have permission.");
Jordan Liuc65bc952019-02-12 17:54:02 -08006888 }
Jordan Liu75f43ea2019-01-17 16:56:37 -08006889 }
Jordan Liu5aa07002018-12-18 15:44:48 -08006890
6891 final long identity = Binder.clearCallingIdentity();
6892 try {
Jordan Liu75f43ea2019-01-17 16:56:37 -08006893 UiccController uiccController = UiccController.getInstance();
6894 ArrayList<UiccCardInfo> cardInfos = uiccController.getAllUiccCardInfos();
Jordan Liu1e142fc2019-04-22 15:10:43 -07006895 if (hasReadPermission) {
6896 return cardInfos;
Jordan Liu75f43ea2019-01-17 16:56:37 -08006897 }
Jordan Liu1e142fc2019-04-22 15:10:43 -07006898
6899 // Remove private info if the caller doesn't have access
6900 ArrayList<UiccCardInfo> filteredInfos = new ArrayList<>();
6901 for (UiccCardInfo cardInfo : cardInfos) {
6902 // For an inactive eUICC, the UiccCard will be null even though the UiccCardInfo
6903 // is available
6904 UiccCard card = uiccController.getUiccCardForSlot(cardInfo.getSlotIndex());
6905 if (card == null || card.getUiccProfile() == null) {
6906 // assume no access if the card or profile is unavailable
6907 filteredInfos.add(cardInfo.getUnprivileged());
6908 continue;
6909 }
6910 UiccProfile profile = card.getUiccProfile();
6911 if (profile.getCarrierPrivilegeStatus(mApp.getPackageManager(), callingPackage)
6912 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
6913 filteredInfos.add(cardInfo);
6914 } else {
6915 filteredInfos.add(cardInfo.getUnprivileged());
6916 }
6917 }
6918 return filteredInfos;
Jordan Liu5aa07002018-12-18 15:44:48 -08006919 } finally {
6920 Binder.restoreCallingIdentity(identity);
6921 }
6922 }
6923
6924 @Override
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006925 public UiccSlotInfo[] getUiccSlotsInfo() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006926 enforceReadPrivilegedPermission("getUiccSlotsInfo");
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006927
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006928 final long identity = Binder.clearCallingIdentity();
6929 try {
6930 UiccSlot[] slots = UiccController.getInstance().getUiccSlots();
6931 if (slots == null) {
6932 Rlog.i(LOG_TAG, "slots is null.");
6933 return null;
6934 }
6935
6936 UiccSlotInfo[] infos = new UiccSlotInfo[slots.length];
6937 for (int i = 0; i < slots.length; i++) {
6938 UiccSlot slot = slots[i];
6939 if (slot == null) {
6940 continue;
6941 }
6942
Jordan Liu7be7e652019-05-06 18:55:02 +00006943 String cardId;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006944 UiccCard card = slot.getUiccCard();
6945 if (card != null) {
6946 cardId = card.getCardId();
Jordan Liu7be7e652019-05-06 18:55:02 +00006947 } else {
Jordan Liu01bd00d2019-09-12 16:19:43 -07006948 cardId = slot.getEid();
6949 if (TextUtils.isEmpty(cardId)) {
6950 cardId = slot.getIccId();
6951 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006952 }
6953
Jordan Liu857451f2019-05-09 16:35:35 -07006954 if (cardId != null) {
6955 // if cardId is an ICCID, strip off trailing Fs before exposing to user
6956 // if cardId is an EID, it's all digits so this is fine
6957 cardId = IccUtils.stripTrailingFs(cardId);
6958 }
6959
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006960 int cardState = 0;
6961 switch (slot.getCardState()) {
6962 case CARDSTATE_ABSENT:
6963 cardState = UiccSlotInfo.CARD_STATE_INFO_ABSENT;
6964 break;
6965 case CARDSTATE_PRESENT:
6966 cardState = UiccSlotInfo.CARD_STATE_INFO_PRESENT;
6967 break;
6968 case CARDSTATE_ERROR:
6969 cardState = UiccSlotInfo.CARD_STATE_INFO_ERROR;
6970 break;
6971 case CARDSTATE_RESTRICTED:
6972 cardState = UiccSlotInfo.CARD_STATE_INFO_RESTRICTED;
6973 break;
6974 default:
6975 break;
6976
6977 }
6978
6979 infos[i] = new UiccSlotInfo(
6980 slot.isActive(),
6981 slot.isEuicc(),
6982 cardId,
6983 cardState,
6984 slot.getPhoneId(),
Jordan Liua2619582019-02-14 12:56:40 -08006985 slot.isExtendedApduSupported(),
6986 slot.isRemovable());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006987 }
6988 return infos;
6989 } finally {
6990 Binder.restoreCallingIdentity(identity);
Holly Jiuyu Sun1d957c52018-04-04 13:52:42 -07006991 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006992 }
6993
6994 @Override
6995 public boolean switchSlots(int[] physicalSlots) {
6996 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006997
6998 final long identity = Binder.clearCallingIdentity();
6999 try {
7000 return (Boolean) sendRequest(CMD_SWITCH_SLOTS, physicalSlots);
7001 } finally {
7002 Binder.restoreCallingIdentity(identity);
7003 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00007004 }
Jack Yu4c988042018-02-27 15:30:01 -08007005
7006 @Override
Jordan Liu7de49fa2018-12-06 14:48:49 -08007007 public int getCardIdForDefaultEuicc(int subId, String callingPackage) {
Jordan Liu7de49fa2018-12-06 14:48:49 -08007008 final long identity = Binder.clearCallingIdentity();
7009 try {
7010 return UiccController.getInstance().getCardIdForDefaultEuicc();
7011 } finally {
7012 Binder.restoreCallingIdentity(identity);
7013 }
7014 }
7015
7016 @Override
Jack Yu4c988042018-02-27 15:30:01 -08007017 public void setRadioIndicationUpdateMode(int subId, int filters, int mode) {
7018 enforceModifyPermission();
7019 final Phone phone = getPhone(subId);
7020 if (phone == null) {
7021 loge("setRadioIndicationUpdateMode fails with invalid subId: " + subId);
7022 return;
7023 }
7024
Malcolm Chenaa4a8532018-02-28 15:00:40 -08007025 final long identity = Binder.clearCallingIdentity();
7026 try {
7027 phone.setRadioIndicationUpdateMode(filters, mode);
7028 } finally {
7029 Binder.restoreCallingIdentity(identity);
7030 }
Jack Yu4c988042018-02-27 15:30:01 -08007031 }
Pengquan Meng85728fb2018-03-12 16:31:21 -07007032
7033 /**
goneil47ffb6e2018-04-06 15:40:58 -07007034 * A test API to reload the UICC profile.
7035 *
7036 * <p>Requires that the calling app has permission
7037 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
7038 * @hide
7039 */
7040 @Override
7041 public void refreshUiccProfile(int subId) {
7042 enforceModifyPermission();
7043
7044 final long identity = Binder.clearCallingIdentity();
7045 try {
7046 Phone phone = getPhone(subId);
7047 if (phone == null) {
7048 return;
7049 }
7050 UiccCard uiccCard = phone.getUiccCard();
7051 if (uiccCard == null) {
7052 return;
7053 }
7054 UiccProfile uiccProfile = uiccCard.getUiccProfile();
7055 if (uiccProfile == null) {
7056 return;
7057 }
7058 uiccProfile.refresh();
7059 } finally {
7060 Binder.restoreCallingIdentity(identity);
7061 }
7062 }
7063
7064 /**
Pengquan Meng85728fb2018-03-12 16:31:21 -07007065 * Returns false if the mobile data is disabled by default, otherwise return true.
7066 */
7067 private boolean getDefaultDataEnabled() {
Inseob Kim14bb3d02018-12-13 17:11:34 +09007068 return TelephonyProperties.mobile_data().orElse(true);
Pengquan Meng85728fb2018-03-12 16:31:21 -07007069 }
7070
7071 /**
7072 * Returns true if the data roaming is enabled by default, i.e the system property
7073 * of {@link #DEFAULT_DATA_ROAMING_PROPERTY_NAME} is true or the config of
7074 * {@link CarrierConfigManager#KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL} is true.
7075 */
7076 private boolean getDefaultDataRoamingEnabled(int subId) {
7077 final CarrierConfigManager configMgr = (CarrierConfigManager)
Nazanin Bakhshif782e562018-12-11 15:15:39 -08007078 mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Inseob Kim14bb3d02018-12-13 17:11:34 +09007079 boolean isDataRoamingEnabled = TelephonyProperties.data_roaming().orElse(true);
Pengquan Meng85728fb2018-03-12 16:31:21 -07007080 isDataRoamingEnabled |= configMgr.getConfigForSubId(subId).getBoolean(
7081 CarrierConfigManager.KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL);
7082 return isDataRoamingEnabled;
7083 }
7084
7085 /**
7086 * Returns the default network type for the given {@code subId}, if the default network type is
7087 * not set, return {@link Phone#PREFERRED_NT_MODE}.
7088 */
7089 private int getDefaultNetworkType(int subId) {
Inseob Kim14bb3d02018-12-13 17:11:34 +09007090 List<Integer> list = TelephonyProperties.default_network();
7091 int phoneId = mSubscriptionController.getPhoneId(subId);
7092 if (phoneId >= 0 && phoneId < list.size() && list.get(phoneId) != null) {
7093 return list.get(phoneId);
7094 }
7095 return Phone.PREFERRED_NT_MODE;
Pengquan Meng85728fb2018-03-12 16:31:21 -07007096 }
fionaxua13278b2018-03-21 00:08:13 -07007097
7098 @Override
7099 public void setCarrierTestOverride(int subId, String mccmnc, String imsi, String iccid, String
chen xueaba88a2019-03-15 13:15:10 -07007100 gid1, String gid2, String plmn, String spn, String carrierPrivilegeRules, String apn) {
fionaxua13278b2018-03-21 00:08:13 -07007101 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08007102
7103 final long identity = Binder.clearCallingIdentity();
7104 try {
7105 final Phone phone = getPhone(subId);
7106 if (phone == null) {
7107 loge("setCarrierTestOverride fails with invalid subId: " + subId);
7108 return;
7109 }
chen xueaba88a2019-03-15 13:15:10 -07007110 phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
7111 carrierPrivilegeRules, apn);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08007112 } finally {
7113 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07007114 }
fionaxua13278b2018-03-21 00:08:13 -07007115 }
7116
7117 @Override
7118 public int getCarrierIdListVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07007119 enforceReadPrivilegedPermission("getCarrierIdListVersion");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08007120
7121 final long identity = Binder.clearCallingIdentity();
7122 try {
7123 final Phone phone = getPhone(subId);
7124 if (phone == null) {
7125 loge("getCarrierIdListVersion fails with invalid subId: " + subId);
7126 return TelephonyManager.UNKNOWN_CARRIER_ID_LIST_VERSION;
7127 }
7128 return phone.getCarrierIdListVersion();
7129 } finally {
7130 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07007131 }
fionaxua13278b2018-03-21 00:08:13 -07007132 }
Malcolm Chen2c63d402018-08-14 16:00:53 -07007133
7134 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007135 public int getNumberOfModemsWithSimultaneousDataConnections(int subId, String callingPackage,
7136 String callingFeatureId) {
Malcolm Chen2c63d402018-08-14 16:00:53 -07007137 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007138 mApp, subId, callingPackage, callingFeatureId,
7139 "getNumberOfModemsWithSimultaneousDataConnections")) {
Malcolm Chen2c63d402018-08-14 16:00:53 -07007140 return -1;
7141 }
7142
7143 final long identity = Binder.clearCallingIdentity();
7144 try {
7145 return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
7146 } finally {
7147 Binder.restoreCallingIdentity(identity);
7148 }
7149 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07007150
7151 @Override
7152 public int getCdmaRoamingMode(int subId) {
7153 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
7154 mApp, subId, "getCdmaRoamingMode");
7155
7156 final long identity = Binder.clearCallingIdentity();
7157 try {
7158 return (int) sendRequest(CMD_GET_CDMA_ROAMING_MODE, null /* argument */, subId);
7159 } finally {
7160 Binder.restoreCallingIdentity(identity);
7161 }
7162 }
7163
7164 @Override
7165 public boolean setCdmaRoamingMode(int subId, int mode) {
7166 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
7167 mApp, subId, "setCdmaRoamingMode");
7168
7169 final long identity = Binder.clearCallingIdentity();
7170 try {
7171 return (boolean) sendRequest(CMD_SET_CDMA_ROAMING_MODE, mode, subId);
7172 } finally {
7173 Binder.restoreCallingIdentity(identity);
7174 }
7175 }
7176
7177 @Override
7178 public boolean setCdmaSubscriptionMode(int subId, int mode) {
7179 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
7180 mApp, subId, "setCdmaSubscriptionMode");
7181
7182 final long identity = Binder.clearCallingIdentity();
7183 try {
7184 return (boolean) sendRequest(CMD_SET_CDMA_SUBSCRIPTION_MODE, mode, subId);
7185 } finally {
7186 Binder.restoreCallingIdentity(identity);
7187 }
7188 }
Makoto Onukida3bf792018-09-18 16:06:29 -07007189
sqianc5eccab2018-10-19 18:46:41 -07007190 @Override
sqian8c685422019-02-22 15:55:18 -08007191 public Map<Integer, List<EmergencyNumber>> getEmergencyNumberList(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007192 String callingPackage, String callingFeatureId) {
sqian11b7a0e2018-12-05 18:48:28 -08007193 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007194 mApp, getDefaultSubscription(), callingPackage, callingFeatureId,
7195 "getEmergencyNumberList")) {
sqian11b7a0e2018-12-05 18:48:28 -08007196 throw new SecurityException("Requires READ_PHONE_STATE permission.");
7197 }
7198 final long identity = Binder.clearCallingIdentity();
7199 try {
sqian854d44b2018-12-12 16:48:18 -08007200 Map<Integer, List<EmergencyNumber>> emergencyNumberListInternal = new HashMap<>();
7201 for (Phone phone: PhoneFactory.getPhones()) {
7202 if (phone.getEmergencyNumberTracker() != null
7203 && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
7204 emergencyNumberListInternal.put(
7205 phone.getSubId(),
7206 phone.getEmergencyNumberTracker().getEmergencyNumberList());
7207 }
sqian11b7a0e2018-12-05 18:48:28 -08007208 }
sqian854d44b2018-12-12 16:48:18 -08007209 return emergencyNumberListInternal;
sqian11b7a0e2018-12-05 18:48:28 -08007210 } finally {
7211 Binder.restoreCallingIdentity(identity);
7212 }
sqianc5eccab2018-10-19 18:46:41 -07007213 }
7214
7215 @Override
sqian8c685422019-02-22 15:55:18 -08007216 public boolean isEmergencyNumber(String number, boolean exactMatch) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08007217 final Phone defaultPhone = getDefaultPhone();
sqian11b7a0e2018-12-05 18:48:28 -08007218 if (!exactMatch) {
7219 TelephonyPermissions
7220 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
sqian8c685422019-02-22 15:55:18 -08007221 mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
sqian11b7a0e2018-12-05 18:48:28 -08007222 }
7223 final long identity = Binder.clearCallingIdentity();
7224 try {
sqian854d44b2018-12-12 16:48:18 -08007225 for (Phone phone: PhoneFactory.getPhones()) {
7226 if (phone.getEmergencyNumberTracker() != null
7227 && phone.getEmergencyNumberTracker() != null) {
7228 if (phone.getEmergencyNumberTracker().isEmergencyNumber(
7229 number, exactMatch)) {
7230 return true;
sqian11b7a0e2018-12-05 18:48:28 -08007231 }
7232 }
sqian11b7a0e2018-12-05 18:48:28 -08007233 }
7234 return false;
7235 } finally {
7236 Binder.restoreCallingIdentity(identity);
7237 }
7238 }
7239
sqianf4ca7ed2019-01-15 18:32:07 -08007240 /**
7241 * Update emergency number list for test mode.
7242 */
7243 @Override
7244 public void updateEmergencyNumberListTestMode(int action, EmergencyNumber num) {
7245 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
7246 "updateEmergencyNumberListTestMode");
7247
7248 final long identity = Binder.clearCallingIdentity();
7249 try {
7250 for (Phone phone: PhoneFactory.getPhones()) {
7251 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7252 if (tracker != null) {
7253 tracker.executeEmergencyNumberTestModeCommand(action, num);
7254 }
7255 }
7256 } finally {
7257 Binder.restoreCallingIdentity(identity);
7258 }
7259 }
7260
7261 /**
7262 * Get the full emergency number list for test mode.
7263 */
7264 @Override
7265 public List<String> getEmergencyNumberListTestMode() {
7266 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
7267 "getEmergencyNumberListTestMode");
7268
7269 final long identity = Binder.clearCallingIdentity();
7270 try {
7271 Set<String> emergencyNumbers = new HashSet<>();
7272 for (Phone phone: PhoneFactory.getPhones()) {
7273 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7274 if (tracker != null) {
7275 for (EmergencyNumber num : tracker.getEmergencyNumberList()) {
7276 emergencyNumbers.add(num.getNumber());
7277 }
7278 }
7279 }
7280 return new ArrayList<>(emergencyNumbers);
7281 } finally {
7282 Binder.restoreCallingIdentity(identity);
7283 }
7284 }
7285
chen xud6b45bd2018-10-30 22:27:10 -07007286 @Override
Shuo Qian3b6ee772019-11-13 17:43:31 -08007287 public int getEmergencyNumberDbVersion(int subId) {
7288 enforceReadPrivilegedPermission("getEmergencyNumberDbVersion");
7289
7290 final long identity = Binder.clearCallingIdentity();
7291 try {
7292 final Phone phone = getPhone(subId);
7293 if (phone == null) {
7294 loge("getEmergencyNumberDbVersion fails with invalid subId: " + subId);
7295 return TelephonyManager.INVALID_EMERGENCY_NUMBER_DB_VERSION;
7296 }
7297 return phone.getEmergencyNumberDbVersion();
7298 } finally {
7299 Binder.restoreCallingIdentity(identity);
7300 }
7301 }
7302
7303 @Override
7304 public void notifyOtaEmergencyNumberDbInstalled() {
7305 enforceModifyPermission();
7306
7307 final long identity = Binder.clearCallingIdentity();
7308 try {
7309 for (Phone phone: PhoneFactory.getPhones()) {
7310 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7311 if (tracker != null) {
7312 tracker.updateOtaEmergencyNumberDatabase();
7313 }
7314 }
7315 } finally {
7316 Binder.restoreCallingIdentity(identity);
7317 }
7318 }
7319
7320 @Override
7321 public void updateTestOtaEmergencyNumberDbFilePath(String otaFilePath) {
7322 enforceActiveEmergencySessionPermission();
7323
7324 final long identity = Binder.clearCallingIdentity();
7325 try {
7326 for (Phone phone: PhoneFactory.getPhones()) {
7327 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
7328 if (tracker != null) {
7329 tracker.updateTestOtaEmergencyNumberDbFilePath(otaFilePath);
7330 }
7331 }
7332 } finally {
7333 Binder.restoreCallingIdentity(identity);
7334 }
7335 }
7336
7337 @Override
chen xud6b45bd2018-10-30 22:27:10 -07007338 public List<String> getCertsFromCarrierPrivilegeAccessRules(int subId) {
7339 enforceReadPrivilegedPermission("getCertsFromCarrierPrivilegeAccessRules");
7340 Phone phone = getPhone(subId);
7341 if (phone == null) {
7342 return null;
7343 }
7344 final long identity = Binder.clearCallingIdentity();
7345 try {
7346 UiccProfile profile = UiccController.getInstance()
7347 .getUiccProfileForPhone(phone.getPhoneId());
7348 if (profile != null) {
7349 return profile.getCertsFromCarrierPrivilegeAccessRules();
7350 }
7351 } finally {
7352 Binder.restoreCallingIdentity(identity);
7353 }
7354 return null;
7355 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08007356
7357 /**
7358 * Enable or disable a modem stack.
7359 */
7360 @Override
7361 public boolean enableModemForSlot(int slotIndex, boolean enable) {
7362 enforceModifyPermission();
7363
7364 final long identity = Binder.clearCallingIdentity();
7365 try {
7366 Phone phone = PhoneFactory.getPhone(slotIndex);
7367 if (phone == null) {
7368 return false;
7369 } else {
7370 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
7371 }
7372 } finally {
7373 Binder.restoreCallingIdentity(identity);
7374 }
7375 }
Michelecea4cf22018-12-21 15:00:11 -08007376
Malcolm Chen4bcd9822019-03-27 18:34:05 -07007377 /**
7378 * Whether a modem stack is enabled or not.
7379 */
7380 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007381 public boolean isModemEnabledForSlot(int slotIndex, String callingPackage,
7382 String callingFeatureId) {
Malcolm Chen4bcd9822019-03-27 18:34:05 -07007383 Phone phone = PhoneFactory.getPhone(slotIndex);
7384 if (phone == null) return false;
7385
7386 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007387 mApp, phone.getSubId(), callingPackage, callingFeatureId,
7388 "isModemEnabledForSlot")) {
Malcolm Chen4bcd9822019-03-27 18:34:05 -07007389 throw new SecurityException("Requires READ_PHONE_STATE permission.");
7390 }
7391
7392 final long identity = Binder.clearCallingIdentity();
7393 try {
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07007394 try {
7395 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
7396 } catch (NoSuchElementException ex) {
7397 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
7398 }
Malcolm Chen4bcd9822019-03-27 18:34:05 -07007399 } finally {
7400 Binder.restoreCallingIdentity(identity);
7401 }
7402 }
7403
Michelecea4cf22018-12-21 15:00:11 -08007404 @Override
Michele0ea7d782019-03-19 14:58:42 -07007405 public void setMultiSimCarrierRestriction(boolean isMultiSimCarrierRestricted) {
Michelecea4cf22018-12-21 15:00:11 -08007406 enforceModifyPermission();
7407
7408 final long identity = Binder.clearCallingIdentity();
7409 try {
7410 mTelephonySharedPreferences.edit()
Michele0ea7d782019-03-19 14:58:42 -07007411 .putBoolean(PREF_MULTI_SIM_RESTRICTED, isMultiSimCarrierRestricted)
Michelecea4cf22018-12-21 15:00:11 -08007412 .commit();
7413 } finally {
7414 Binder.restoreCallingIdentity(identity);
7415 }
7416 }
7417
7418 @Override
Michele0ea7d782019-03-19 14:58:42 -07007419 @TelephonyManager.IsMultiSimSupportedResult
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007420 public int isMultiSimSupported(String callingPackage, String callingFeatureId) {
Michele4245e952019-02-04 11:36:23 -08007421 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007422 getDefaultPhone().getSubId(), callingPackage, callingFeatureId,
7423 "isMultiSimSupported")) {
Michele0ea7d782019-03-19 14:58:42 -07007424 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele4245e952019-02-04 11:36:23 -08007425 }
Michelecea4cf22018-12-21 15:00:11 -08007426
7427 final long identity = Binder.clearCallingIdentity();
7428 try {
Michele0ea7d782019-03-19 14:58:42 -07007429 return isMultiSimSupportedInternal();
Michelecea4cf22018-12-21 15:00:11 -08007430 } finally {
7431 Binder.restoreCallingIdentity(identity);
7432 }
7433 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007434
Michele0ea7d782019-03-19 14:58:42 -07007435 @TelephonyManager.IsMultiSimSupportedResult
7436 private int isMultiSimSupportedInternal() {
Michele30b57b22019-03-01 12:01:14 -08007437 // If the device has less than 2 SIM cards, indicate that multisim is restricted.
7438 int numPhysicalSlots = UiccController.getInstance().getUiccSlots().length;
7439 if (numPhysicalSlots < 2) {
Michele0ea7d782019-03-19 14:58:42 -07007440 loge("isMultiSimSupportedInternal: requires at least 2 cards");
7441 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08007442 }
7443 // Check if the hardware supports multisim functionality. If usage of multisim is not
7444 // supported by the modem, indicate that it is restricted.
7445 PhoneCapability staticCapability =
7446 mPhoneConfigurationManager.getStaticPhoneCapability();
7447 if (staticCapability == null) {
Michele0ea7d782019-03-19 14:58:42 -07007448 loge("isMultiSimSupportedInternal: no static configuration available");
7449 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08007450 }
7451 if (staticCapability.logicalModemList.size() < 2) {
Michele0ea7d782019-03-19 14:58:42 -07007452 loge("isMultiSimSupportedInternal: maximum number of modem is < 2");
7453 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08007454 }
7455 // Check if support of multiple SIMs is restricted by carrier
7456 if (mTelephonySharedPreferences.getBoolean(PREF_MULTI_SIM_RESTRICTED, false)) {
Michele0ea7d782019-03-19 14:58:42 -07007457 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_CARRIER;
Michele30b57b22019-03-01 12:01:14 -08007458 }
7459
Michele0ea7d782019-03-19 14:58:42 -07007460 return TelephonyManager.MULTISIM_ALLOWED;
Michele30b57b22019-03-01 12:01:14 -08007461 }
7462
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007463 /**
7464 * Switch configs to enable multi-sim or switch back to single-sim
Nazanin Bakhshi17318782019-03-01 11:56:08 -08007465 * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
7466 * permission, but the other way around is possible with either MODIFY_PHONE_STATE
7467 * or carrier privileges
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007468 * @param numOfSims number of active sims we want to switch to
7469 */
7470 @Override
7471 public void switchMultiSimConfig(int numOfSims) {
Nazanin Bakhshi17318782019-03-01 11:56:08 -08007472 if (numOfSims == 1) {
7473 enforceModifyPermission();
7474 } else {
7475 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
7476 mApp, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "switchMultiSimConfig");
7477 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007478 final long identity = Binder.clearCallingIdentity();
Michele30b57b22019-03-01 12:01:14 -08007479
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007480 try {
Michele30b57b22019-03-01 12:01:14 -08007481 //only proceed if multi-sim is not restricted
Michele0ea7d782019-03-19 14:58:42 -07007482 if (isMultiSimSupportedInternal() != TelephonyManager.MULTISIM_ALLOWED) {
Michele30b57b22019-03-01 12:01:14 -08007483 loge("switchMultiSimConfig not possible. It is restricted or not supported.");
7484 return;
7485 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007486 mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
7487 } finally {
7488 Binder.restoreCallingIdentity(identity);
7489 }
7490 }
7491
Hyungjun Parkbb07fde2019-01-10 15:28:51 +09007492 @Override
7493 public boolean isApplicationOnUicc(int subId, int appType) {
7494 enforceReadPrivilegedPermission("isApplicationOnUicc");
7495 Phone phone = getPhone(subId);
7496 if (phone == null) {
7497 return false;
7498 }
7499 final long identity = Binder.clearCallingIdentity();
7500 try {
7501 UiccCard uiccCard = phone.getUiccCard();
7502 if (uiccCard == null) {
7503 return false;
7504 }
7505 UiccProfile uiccProfile = uiccCard.getUiccProfile();
7506 if (uiccProfile == null) {
7507 return false;
7508 }
7509 if (TelephonyManager.APPTYPE_SIM <= appType
7510 && appType <= TelephonyManager.APPTYPE_ISIM) {
7511 return uiccProfile.isApplicationOnIcc(AppType.values()[appType]);
7512 }
7513 return false;
7514 } finally {
7515 Binder.restoreCallingIdentity(identity);
7516 }
7517 }
7518
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007519 /**
chen xub4baa772019-04-03 10:23:41 -07007520 * Get whether making changes to modem configurations will trigger reboot.
7521 * Return value defaults to true.
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08007522 */
7523 @Override
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007524 public boolean doesSwitchMultiSimConfigTriggerReboot(int subId, String callingPackage,
7525 String callingFeatureId) {
chen xub4baa772019-04-03 10:23:41 -07007526 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Philip P. Moltmann700a9592019-10-03 11:53:50 -07007527 mApp, subId, callingPackage, callingFeatureId,
7528 "doesSwitchMultiSimConfigTriggerReboot")) {
chen xub4baa772019-04-03 10:23:41 -07007529 return false;
7530 }
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08007531 final long identity = Binder.clearCallingIdentity();
7532 try {
7533 return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
7534 } finally {
7535 Binder.restoreCallingIdentity(identity);
7536 }
7537 }
7538
Nathan Harold29f5f052019-02-15 13:41:57 -08007539 private void updateModemStateMetrics() {
7540 TelephonyMetrics metrics = TelephonyMetrics.getInstance();
7541 // TODO: check the state for each modem if the api is ready.
7542 metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
7543 }
7544
Pengquan Meng3889a572019-01-23 11:16:29 -08007545 @Override
7546 public int[] getSlotsMapping() {
7547 enforceReadPrivilegedPermission("getSlotsMapping");
7548
7549 final long identity = Binder.clearCallingIdentity();
7550 try {
7551 int phoneCount = TelephonyManager.getDefault().getPhoneCount();
7552 // All logical slots should have a mapping to a physical slot.
7553 int[] logicalSlotsMapping = new int[phoneCount];
7554 UiccSlotInfo[] slotInfos = getUiccSlotsInfo();
7555 for (int i = 0; i < slotInfos.length; i++) {
7556 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
7557 logicalSlotsMapping[slotInfos[i].getLogicalSlotIdx()] = i;
7558 }
7559 }
7560 return logicalSlotsMapping;
7561 } finally {
7562 Binder.restoreCallingIdentity(identity);
7563 }
7564 }
Nathan Harold48d6fd52019-02-06 19:01:40 -08007565
7566 /**
7567 * Get the IRadio HAL Version
7568 */
7569 @Override
7570 public int getRadioHalVersion() {
7571 Phone phone = getDefaultPhone();
7572 if (phone == null) return -1;
7573 HalVersion hv = phone.getHalVersion();
7574 if (hv.equals(HalVersion.UNKNOWN)) return -1;
7575 return hv.major * 100 + hv.minor;
7576 }
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007577
7578 /**
Malcolm Chene5ad5792019-04-18 13:51:02 -07007579 * Return whether data is enabled for certain APN type. This will tell if framework will accept
7580 * corresponding network requests on a subId.
7581 *
7582 * Data is enabled if:
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007583 * 1) user data is turned on, or
Malcolm Chene5ad5792019-04-18 13:51:02 -07007584 * 2) APN is un-metered for this subscription, or
7585 * 3) APN type is whitelisted. E.g. MMS is whitelisted if
7586 * {@link SubscriptionManager#setAlwaysAllowMmsData} is turned on.
7587 *
7588 * @return whether data is allowed for a apn type.
7589 *
7590 * @hide
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007591 */
7592 @Override
Malcolm Chene5ad5792019-04-18 13:51:02 -07007593 public boolean isDataEnabledForApn(int apnType, int subId, String callingPackage) {
Amit Mahajan5d4e1922019-10-07 16:20:43 -07007594 enforceReadPrivilegedPermission("Needs READ_PRIVILEGED_PHONE_STATE for "
7595 + "isDataEnabledForApn");
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007596
7597 // Now that all security checks passes, perform the operation as ourselves.
7598 final long identity = Binder.clearCallingIdentity();
7599 try {
7600 Phone phone = getPhone(subId);
7601 if (phone == null) return false;
7602
Jack Yu41407ee2019-05-13 16:54:09 -07007603 boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chene5ad5792019-04-18 13:51:02 -07007604 return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
7605 } finally {
7606 Binder.restoreCallingIdentity(identity);
7607 }
7608 }
7609
7610 @Override
Jack Yu41407ee2019-05-13 16:54:09 -07007611 public boolean isApnMetered(@ApnType int apnType, int subId) {
Malcolm Chene5ad5792019-04-18 13:51:02 -07007612 enforceReadPrivilegedPermission("isApnMetered");
7613
7614 // Now that all security checks passes, perform the operation as ourselves.
7615 final long identity = Binder.clearCallingIdentity();
7616 try {
7617 Phone phone = getPhone(subId);
7618 if (phone == null) return true; // By default return true.
7619
Jack Yu41407ee2019-05-13 16:54:09 -07007620 return ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007621 } finally {
7622 Binder.restoreCallingIdentity(identity);
7623 }
7624 }
Brad Ebingera63db5f2019-04-23 16:31:13 -07007625
7626 @Override
7627 public void enqueueSmsPickResult(String callingPackage, IIntegerConsumer pendingSubIdResult) {
7628 SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
7629 (AppOpsManager) mApp.getSystemService(Context.APP_OPS_SERVICE));
7630 if (!permissions.checkCallingCanSendSms(callingPackage, "Sending message")) {
7631 throw new SecurityException("Requires SEND_SMS permission to perform this operation");
7632 }
7633 PickSmsSubscriptionActivity.addPendingResult(pendingSubIdResult);
7634 Intent intent = new Intent();
7635 intent.setClass(mApp, PickSmsSubscriptionActivity.class);
7636 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
7637 // Bring up choose default SMS subscription dialog right now
7638 intent.putExtra(PickSmsSubscriptionActivity.DIALOG_TYPE_KEY,
7639 PickSmsSubscriptionActivity.SMS_PICK_FOR_MESSAGE);
7640 mApp.startActivity(intent);
7641 }
chen xud5ca2d52019-05-28 15:20:57 -07007642
7643 @Override
7644 public String getMmsUAProfUrl(int subId) {
7645 //TODO investigate if this API should require proper permission check in R b/133791609
7646 final long identity = Binder.clearCallingIdentity();
7647 try {
7648 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7649 .getString(com.android.internal.R.string.config_mms_user_agent_profile_url);
7650 } finally {
7651 Binder.restoreCallingIdentity(identity);
7652 }
7653 }
7654
7655 @Override
7656 public String getMmsUserAgent(int subId) {
7657 //TODO investigate if this API should require proper permission check in R b/133791609
7658 final long identity = Binder.clearCallingIdentity();
7659 try {
7660 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7661 .getString(com.android.internal.R.string.config_mms_user_agent);
7662 } finally {
7663 Binder.restoreCallingIdentity(identity);
7664 }
7665 }
Jack Yub07d4972019-05-28 16:12:25 -07007666
7667 @Override
7668 public boolean setDataAllowedDuringVoiceCall(int subId, boolean allow) {
7669 enforceModifyPermission();
7670
7671 // Now that all security checks passes, perform the operation as ourselves.
7672 final long identity = Binder.clearCallingIdentity();
7673 try {
7674 Phone phone = getPhone(subId);
7675 if (phone == null) return false;
7676
7677 return phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(allow);
7678 } finally {
7679 Binder.restoreCallingIdentity(identity);
7680 }
7681 }
7682
7683 @Override
7684 public boolean isDataAllowedInVoiceCall(int subId) {
7685 enforceReadPrivilegedPermission("isDataAllowedInVoiceCall");
7686
7687 // Now that all security checks passes, perform the operation as ourselves.
7688 final long identity = Binder.clearCallingIdentity();
7689 try {
7690 Phone phone = getPhone(subId);
7691 if (phone == null) return false;
7692
7693 return phone.getDataEnabledSettings().isDataAllowedInVoiceCall();
7694 } finally {
7695 Binder.restoreCallingIdentity(identity);
7696 }
7697 }
Tyler Gunn7bcdc742019-10-04 15:56:59 -07007698
7699 /**
7700 * Updates whether conference event pacakge handling is enabled.
7701 * @param isCepEnabled {@code true} if CEP handling is enabled (default), or {@code false}
7702 * otherwise.
7703 */
7704 @Override
7705 public void setCepEnabled(boolean isCepEnabled) {
7706 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "setCepEnabled");
7707
7708 final long identity = Binder.clearCallingIdentity();
7709 try {
7710 Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled);
7711 for (Phone phone : PhoneFactory.getPhones()) {
7712 Phone defaultPhone = phone.getImsPhone();
7713 if (defaultPhone != null && defaultPhone.getPhoneType() == PHONE_TYPE_IMS) {
7714 ImsPhone imsPhone = (ImsPhone) defaultPhone;
7715 ImsPhoneCallTracker imsPhoneCallTracker =
7716 (ImsPhoneCallTracker) imsPhone.getCallTracker();
7717 imsPhoneCallTracker.setConferenceEventPackageEnabled(isCepEnabled);
7718 Rlog.i(LOG_TAG, "setCepEnabled isCepEnabled=" + isCepEnabled + ", for imsPhone "
7719 + imsPhone.getMsisdn());
7720 }
7721 }
7722 } finally {
7723 Binder.restoreCallingIdentity(identity);
7724 }
7725 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07007726}