blob: 6a98764dcab821b782e5a419418ba22a538193e0 [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
Ta-wei Yen87c49842016-05-13 21:19:52 -070021import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
22
Ta-wei Yen30a69c82016-12-27 14:52:32 -080023import android.Manifest.permission;
Tyler Gunnf70ed162019-04-03 15:28:53 -070024import android.annotation.Nullable;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070025import android.app.AppOpsManager;
Ta-wei Yen30a69c82016-12-27 14:52:32 -080026import android.app.PendingIntent;
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -070027import android.content.ComponentName;
Amit Mahajan7dbbd822019-03-13 17:33:47 -070028import android.content.ContentResolver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070029import android.content.Context;
30import android.content.Intent;
Derek Tan97ebb422014-09-05 16:55:38 -070031import android.content.SharedPreferences;
Nathan Harold31d7ff32018-10-15 20:20:30 -070032import android.content.pm.ApplicationInfo;
Derek Tan740e1672017-06-27 14:56:27 -070033import android.content.pm.ComponentInfo;
Amith Yamasani6e118872016-02-19 12:53:51 -080034import android.content.pm.PackageInfo;
Shishir Agrawal60f9c952014-06-23 12:00:43 -070035import android.content.pm.PackageManager;
Jack Yu84291ec2017-05-26 16:07:50 -070036import android.net.NetworkStats;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070037import android.net.Uri;
38import android.os.AsyncResult;
39import android.os.Binder;
Hall Liuf19c44f2018-11-27 14:38:17 -080040import android.os.Build;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070041import android.os.Bundle;
42import android.os.Handler;
yinxu504e1392017-04-12 16:03:22 -070043import android.os.IBinder;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070044import android.os.Looper;
45import android.os.Message;
yinxu504e1392017-04-12 16:03:22 -070046import android.os.Messenger;
Tyler Gunn65d45c22017-06-05 11:22:26 -070047import android.os.PersistableBundle;
Brad Ebinger5f64b052017-12-14 14:26:15 -080048import android.os.RemoteException;
Adam Lesinski903a54c2016-04-11 14:49:52 -070049import android.os.ResultReceiver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070050import android.os.ServiceManager;
Brad Ebinger1ce9c432019-07-16 13:19:44 -070051import android.os.ServiceSpecificException;
Brad Ebingerdac2f002018-04-03 15:17:52 -070052import android.os.ShellCallback;
Pengquan Meng85728fb2018-03-12 16:31:21 -070053import android.os.SystemProperties;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070054import android.os.UserHandle;
Stuart Scott981d8582015-04-21 14:09:50 -070055import android.os.UserManager;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070056import android.os.WorkSource;
Derek Tan97ebb422014-09-05 16:55:38 -070057import android.preference.PreferenceManager;
Ihab Awadf2177b72013-11-25 13:33:23 -080058import android.provider.Settings;
Amit Mahajan7dbbd822019-03-13 17:33:47 -070059import android.provider.Telephony;
Santos Cordon7a1885b2015-02-03 11:15:19 -080060import android.telecom.PhoneAccount;
Nancy Chen31f9ba12016-01-06 11:42:12 -080061import android.telecom.PhoneAccountHandle;
Andrew Lee9431b832015-03-09 18:46:45 -070062import android.telecom.TelecomManager;
Junda Liu12f7d802015-05-01 12:06:44 -070063import android.telephony.CarrierConfigManager;
Michele Berionne482f8202018-11-27 18:57:59 -080064import android.telephony.CarrierRestrictionRules;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070065import android.telephony.CellInfo;
Nathan Haroldf180aac2018-06-01 18:43:55 -070066import android.telephony.CellInfoGsm;
67import android.telephony.CellInfoWcdma;
Nathan Harold3ff88932018-08-14 10:19:49 -070068import android.telephony.CellLocation;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070069import android.telephony.ClientRequestStats;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -070070import android.telephony.ICellInfoCallback;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -070071import android.telephony.IccOpenLogicalChannelResponse;
Hall Liu1aa510f2017-11-22 17:40:08 -080072import android.telephony.LocationAccessPolicy;
Ta-wei Yen87c49842016-05-13 21:19:52 -070073import android.telephony.ModemActivityInfo;
Jake Hambye994d462014-02-03 13:10:13 -080074import android.telephony.NeighboringCellInfo;
yinxu504e1392017-04-12 16:03:22 -070075import android.telephony.NetworkScanRequest;
Michele4245e952019-02-04 11:36:23 -080076import android.telephony.PhoneCapability;
Hall Liud892bec2018-11-30 14:51:45 -080077import android.telephony.PhoneNumberRange;
Wink Saville5d475dd2014-10-17 15:00:58 -070078import android.telephony.RadioAccessFamily;
Hall Liub2ac8ef2019-02-28 15:56:23 -080079import android.telephony.RadioAccessSpecifier;
Tyler Gunn65d45c22017-06-05 11:22:26 -070080import android.telephony.Rlog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070081import android.telephony.ServiceState;
Nathan Harold46b42aa2017-03-10 19:38:22 -080082import android.telephony.SignalStrength;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080083import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080084import android.telephony.SubscriptionManager;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070085import android.telephony.TelephonyHistogram;
Ta-wei Yenb6929602016-05-24 15:48:27 -070086import android.telephony.TelephonyManager;
Hall Liub2ac8ef2019-02-28 15:56:23 -080087import android.telephony.TelephonyScanManager;
Jordan Liu5aa07002018-12-18 15:44:48 -080088import android.telephony.UiccCardInfo;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +000089import android.telephony.UiccSlotInfo;
Tyler Gunn65d45c22017-06-05 11:22:26 -070090import android.telephony.UssdResponse;
Ta-wei Yenb6929602016-05-24 15:48:27 -070091import android.telephony.VisualVoicemailSmsFilterSettings;
Nathan Harold3ff88932018-08-14 10:19:49 -070092import android.telephony.cdma.CdmaCellLocation;
Jack Yub5d8f642018-11-26 11:20:48 -080093import android.telephony.data.ApnSetting;
Jack Yu41407ee2019-05-13 16:54:09 -070094import android.telephony.data.ApnSetting.ApnType;
Jack Yub5d8f642018-11-26 11:20:48 -080095import android.telephony.emergency.EmergencyNumber;
Nathan Harold3ff88932018-08-14 10:19:49 -070096import android.telephony.gsm.GsmCellLocation;
Brad Ebinger1ce9c432019-07-16 13:19:44 -070097import android.telephony.ims.ImsException;
Brad Ebinger1c8542e2019-01-14 13:43:14 -080098import android.telephony.ims.ProvisioningManager;
Brad Ebinger35c841c2018-10-01 10:40:55 -070099import android.telephony.ims.aidl.IImsCapabilityCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -0800100import android.telephony.ims.aidl.IImsConfig;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -0700101import android.telephony.ims.aidl.IImsConfigCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -0800102import android.telephony.ims.aidl.IImsMmTelFeature;
103import android.telephony.ims.aidl.IImsRcsFeature;
104import android.telephony.ims.aidl.IImsRegistration;
Brad Ebinger35c841c2018-10-01 10:40:55 -0700105import android.telephony.ims.aidl.IImsRegistrationCallback;
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800106import android.telephony.ims.feature.MmTelFeature;
107import android.telephony.ims.stub.ImsConfigImplBase;
Brad Ebinger1f2b5082018-02-08 16:11:32 -0800108import android.telephony.ims.stub.ImsRegistrationImplBase;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700109import android.text.TextUtils;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800110import android.util.ArraySet;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700111import android.util.Log;
Jake Hambye994d462014-02-03 13:10:13 -0800112import android.util.Pair;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800113import android.util.Slog;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800114
Andrew Lee312e8172014-10-23 17:01:36 -0700115import com.android.ims.ImsManager;
Brad Ebinger34bef922017-11-09 10:27:08 -0800116import com.android.ims.internal.IImsServiceFeatureCallback;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700117import com.android.internal.telephony.CallManager;
Tyler Gunn52dcf772017-04-26 11:30:31 -0700118import com.android.internal.telephony.CallStateException;
pkanwar79ec0542017-07-31 14:10:01 -0700119import com.android.internal.telephony.CarrierInfoManager;
chen xu651eec72018-11-11 19:03:44 -0800120import com.android.internal.telephony.CarrierResolver;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700121import com.android.internal.telephony.CellNetworkScanResult;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700122import com.android.internal.telephony.CommandException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700123import com.android.internal.telephony.DefaultPhoneNotifier;
Nathan Harold48d6fd52019-02-06 19:01:40 -0800124import com.android.internal.telephony.HalVersion;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700125import com.android.internal.telephony.IIntegerConsumer;
Hall Liud892bec2018-11-30 14:51:45 -0800126import com.android.internal.telephony.INumberVerificationCallback;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700127import com.android.internal.telephony.ITelephony;
Jake Hambye994d462014-02-03 13:10:13 -0800128import com.android.internal.telephony.IccCard;
Jack Yu5f7092c2018-04-13 14:05:37 -0700129import com.android.internal.telephony.LocaleTracker;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100130import com.android.internal.telephony.MccTable;
yinxub1bed742017-04-17 11:45:04 -0700131import com.android.internal.telephony.NetworkScanRequestTracker;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700132import com.android.internal.telephony.OperatorInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700133import com.android.internal.telephony.Phone;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700134import com.android.internal.telephony.PhoneConfigurationManager;
Nathan Harolda667c152016-12-14 11:27:20 -0800135import com.android.internal.telephony.PhoneConstantConversions;
Ta-wei Yen87c49842016-05-13 21:19:52 -0700136import com.android.internal.telephony.PhoneConstants;
Wink Saville36469e72014-06-11 15:17:00 -0700137import com.android.internal.telephony.PhoneFactory;
Wink Saville5d475dd2014-10-17 15:00:58 -0700138import com.android.internal.telephony.ProxyController;
Sanket Padawe99ef1e32016-05-18 16:12:33 -0700139import com.android.internal.telephony.RIL;
Svet Ganovb320e182015-04-16 12:30:10 -0700140import com.android.internal.telephony.RILConstants;
Jack Yu5f7092c2018-04-13 14:05:37 -0700141import com.android.internal.telephony.ServiceStateTracker;
Makoto Onukida3bf792018-09-18 16:06:29 -0700142import com.android.internal.telephony.SmsApplication;
143import com.android.internal.telephony.SmsApplication.SmsApplicationData;
Amit Mahajandccb3f12019-05-13 13:48:32 -0700144import com.android.internal.telephony.SmsController;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700145import com.android.internal.telephony.SmsPermissions;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800146import com.android.internal.telephony.SubscriptionController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800147import com.android.internal.telephony.TelephonyPermissions;
Malcolm Chendc8c10e2019-04-10 18:25:07 -0700148import com.android.internal.telephony.dataconnection.ApnSettingUtils;
sqianf4ca7ed2019-01-15 18:32:07 -0800149import com.android.internal.telephony.emergency.EmergencyNumberTracker;
Derek Tan740e1672017-06-27 14:56:27 -0700150import com.android.internal.telephony.euicc.EuiccConnector;
Brad Ebinger9c0eb502019-01-23 15:06:19 -0800151import com.android.internal.telephony.ims.ImsResolver;
Pengquan Meng6c2dc9f2019-02-06 11:12:53 -0800152import com.android.internal.telephony.metrics.TelephonyMetrics;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700153import com.android.internal.telephony.uicc.IccIoResult;
154import com.android.internal.telephony.uicc.IccUtils;
Nathan Haroldb3014052017-01-25 15:57:32 -0800155import com.android.internal.telephony.uicc.SIMRecords;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700156import com.android.internal.telephony.uicc.UiccCard;
Nathan Haroldb3014052017-01-25 15:57:32 -0800157import com.android.internal.telephony.uicc.UiccCardApplication;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700158import com.android.internal.telephony.uicc.UiccController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800159import com.android.internal.telephony.uicc.UiccProfile;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000160import com.android.internal.telephony.uicc.UiccSlot;
fionaxu7ed723d2017-05-30 18:58:54 -0700161import com.android.internal.telephony.util.VoicemailNotificationSettingsUtil;
Jake Hambye994d462014-02-03 13:10:13 -0800162import com.android.internal.util.HexDump;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700163import com.android.phone.settings.PickSmsSubscriptionActivity;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700164import com.android.phone.vvm.PhoneAccountHandleConverter;
Ta-wei Yen527a9c02017-01-06 15:29:25 -0800165import com.android.phone.vvm.RemoteVvmTaskManager;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700166import com.android.phone.vvm.VisualVoicemailSettingsUtil;
Ta-wei Yenc8905312017-03-28 11:14:45 -0700167import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800168
Ta-wei Yenc236d6b2016-06-21 13:33:12 -0700169import java.io.FileDescriptor;
170import java.io.PrintWriter;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700171import java.util.ArrayList;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800172import java.util.Arrays;
Makoto Onukida3bf792018-09-18 16:06:29 -0700173import java.util.Collection;
sqian11b7a0e2018-12-05 18:48:28 -0800174import java.util.HashMap;
sqianf4ca7ed2019-01-15 18:32:07 -0800175import java.util.HashSet;
Jake Hambye994d462014-02-03 13:10:13 -0800176import java.util.List;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100177import java.util.Locale;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800178import java.util.Map;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700179import java.util.NoSuchElementException;
sqianf4ca7ed2019-01-15 18:32:07 -0800180import java.util.Set;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700181
182/**
183 * Implementation of the ITelephony interface.
184 */
Santos Cordon117fee72014-05-16 17:56:12 -0700185public class PhoneInterfaceManager extends ITelephony.Stub {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700186 private static final String LOG_TAG = "PhoneInterfaceManager";
187 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
188 private static final boolean DBG_LOC = false;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800189 private static final boolean DBG_MERGE = false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700190
191 // Message codes used with mMainThreadHandler
192 private static final int CMD_HANDLE_PIN_MMI = 1;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700193 private static final int CMD_TRANSMIT_APDU_LOGICAL_CHANNEL = 7;
194 private static final int EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE = 8;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700195 private static final int CMD_OPEN_CHANNEL = 9;
196 private static final int EVENT_OPEN_CHANNEL_DONE = 10;
197 private static final int CMD_CLOSE_CHANNEL = 11;
198 private static final int EVENT_CLOSE_CHANNEL_DONE = 12;
Jake Hambye994d462014-02-03 13:10:13 -0800199 private static final int CMD_NV_READ_ITEM = 13;
200 private static final int EVENT_NV_READ_ITEM_DONE = 14;
201 private static final int CMD_NV_WRITE_ITEM = 15;
202 private static final int EVENT_NV_WRITE_ITEM_DONE = 16;
203 private static final int CMD_NV_WRITE_CDMA_PRL = 17;
204 private static final int EVENT_NV_WRITE_CDMA_PRL_DONE = 18;
chen xu6dac5ab2018-10-26 17:39:23 -0700205 private static final int CMD_RESET_MODEM_CONFIG = 19;
206 private static final int EVENT_RESET_MODEM_CONFIG_DONE = 20;
Jake Hamby7c27be32014-03-03 13:25:59 -0800207 private static final int CMD_GET_PREFERRED_NETWORK_TYPE = 21;
208 private static final int EVENT_GET_PREFERRED_NETWORK_TYPE_DONE = 22;
209 private static final int CMD_SET_PREFERRED_NETWORK_TYPE = 23;
210 private static final int EVENT_SET_PREFERRED_NETWORK_TYPE_DONE = 24;
Sailesh Nepal35b59452014-03-06 09:26:56 -0800211 private static final int CMD_SEND_ENVELOPE = 25;
212 private static final int EVENT_SEND_ENVELOPE_DONE = 26;
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000213 private static final int CMD_INVOKE_OEM_RIL_REQUEST_RAW = 27;
214 private static final int EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE = 28;
Derek Tan6b088ee2014-09-05 14:15:18 -0700215 private static final int CMD_TRANSMIT_APDU_BASIC_CHANNEL = 29;
216 private static final int EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE = 30;
217 private static final int CMD_EXCHANGE_SIM_IO = 31;
218 private static final int EVENT_EXCHANGE_SIM_IO_DONE = 32;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800219 private static final int CMD_SET_VOICEMAIL_NUMBER = 33;
220 private static final int EVENT_SET_VOICEMAIL_NUMBER_DONE = 34;
Stuart Scott54788802015-03-30 13:18:01 -0700221 private static final int CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC = 35;
222 private static final int EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE = 36;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700223 private static final int CMD_GET_MODEM_ACTIVITY_INFO = 37;
224 private static final int EVENT_GET_MODEM_ACTIVITY_INFO_DONE = 38;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700225 private static final int CMD_PERFORM_NETWORK_SCAN = 39;
226 private static final int EVENT_PERFORM_NETWORK_SCAN_DONE = 40;
227 private static final int CMD_SET_NETWORK_SELECTION_MODE_MANUAL = 41;
228 private static final int EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE = 42;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700229 private static final int CMD_SET_ALLOWED_CARRIERS = 43;
230 private static final int EVENT_SET_ALLOWED_CARRIERS_DONE = 44;
231 private static final int CMD_GET_ALLOWED_CARRIERS = 45;
232 private static final int EVENT_GET_ALLOWED_CARRIERS_DONE = 46;
pkanwar32d516d2016-10-14 19:37:38 -0700233 private static final int CMD_HANDLE_USSD_REQUEST = 47;
Nathan Haroldb3014052017-01-25 15:57:32 -0800234 private static final int CMD_GET_FORBIDDEN_PLMNS = 48;
235 private static final int EVENT_GET_FORBIDDEN_PLMNS_DONE = 49;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000236 private static final int CMD_SWITCH_SLOTS = 50;
237 private static final int EVENT_SWITCH_SLOTS_DONE = 51;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700238 private static final int CMD_GET_NETWORK_SELECTION_MODE = 52;
239 private static final int EVENT_GET_NETWORK_SELECTION_MODE_DONE = 53;
240 private static final int CMD_GET_CDMA_ROAMING_MODE = 54;
241 private static final int EVENT_GET_CDMA_ROAMING_MODE_DONE = 55;
242 private static final int CMD_SET_CDMA_ROAMING_MODE = 56;
243 private static final int EVENT_SET_CDMA_ROAMING_MODE_DONE = 57;
244 private static final int CMD_SET_CDMA_SUBSCRIPTION_MODE = 58;
245 private static final int EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE = 59;
Nathan Harold3ff88932018-08-14 10:19:49 -0700246 private static final int CMD_GET_ALL_CELL_INFO = 60;
247 private static final int EVENT_GET_ALL_CELL_INFO_DONE = 61;
248 private static final int CMD_GET_CELL_LOCATION = 62;
249 private static final int EVENT_GET_CELL_LOCATION_DONE = 63;
chen xu6dac5ab2018-10-26 17:39:23 -0700250 private static final int CMD_MODEM_REBOOT = 64;
251 private static final int EVENT_CMD_MODEM_REBOOT_DONE = 65;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -0700252 private static final int CMD_REQUEST_CELL_INFO_UPDATE = 66;
253 private static final int EVENT_REQUEST_CELL_INFO_UPDATE_DONE = 67;
Malcolm Chen8e4ed912019-01-15 20:22:16 -0800254 private static final int CMD_REQUEST_ENABLE_MODEM = 68;
255 private static final int EVENT_ENABLE_MODEM_DONE = 69;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700256 private static final int CMD_GET_MODEM_STATUS = 70;
257 private static final int EVENT_GET_MODEM_STATUS_DONE = 71;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700258
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -0800259 // Parameters of select command.
260 private static final int SELECT_COMMAND = 0xA4;
261 private static final int SELECT_P1 = 0x04;
262 private static final int SELECT_P2 = 0;
263 private static final int SELECT_P3 = 0x10;
264
Pengquan Meng85728fb2018-03-12 16:31:21 -0700265 private static final String DEFAULT_NETWORK_MODE_PROPERTY_NAME = "ro.telephony.default_network";
266 private static final String DEFAULT_DATA_ROAMING_PROPERTY_NAME = "ro.com.android.dataroaming";
267 private static final String DEFAULT_MOBILE_DATA_PROPERTY_NAME = "ro.com.android.mobiledata";
268
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700269 /** The singleton instance. */
270 private static PhoneInterfaceManager sInstance;
271
Wink Saville3ab207e2014-11-20 13:07:20 -0800272 private PhoneGlobals mApp;
Wink Saville3ab207e2014-11-20 13:07:20 -0800273 private CallManager mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700274 private UserManager mUserManager;
Wink Saville3ab207e2014-11-20 13:07:20 -0800275 private AppOpsManager mAppOps;
276 private MainThreadHandler mMainThreadHandler;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800277 private SubscriptionController mSubscriptionController;
Wink Saville3ab207e2014-11-20 13:07:20 -0800278 private SharedPreferences mTelephonySharedPreferences;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700279 private PhoneConfigurationManager mPhoneConfigurationManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700280
Derek Tan97ebb422014-09-05 16:55:38 -0700281 private static final String PREF_CARRIERS_ALPHATAG_PREFIX = "carrier_alphtag_";
282 private static final String PREF_CARRIERS_NUMBER_PREFIX = "carrier_number_";
Jeff Sharkey85190e62014-12-05 09:40:12 -0800283 private static final String PREF_CARRIERS_SUBSCRIBER_PREFIX = "carrier_subscriber_";
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800284 private static final String PREF_PROVISION_IMS_MMTEL_PREFIX = "provision_ims_mmtel_";
Derek Tan89e89d42014-07-08 17:00:10 -0700285
Michelecea4cf22018-12-21 15:00:11 -0800286 // String to store multi SIM allowed
287 private static final String PREF_MULTI_SIM_RESTRICTED = "multisim_restricted";
288
Derek Tan740e1672017-06-27 14:56:27 -0700289 // The AID of ISD-R.
290 private static final String ISDR_AID = "A0000005591010FFFFFFFF8900000100";
291
yinxub1bed742017-04-17 11:45:04 -0700292 private NetworkScanRequestTracker mNetworkScanRequestTracker;
293
David Kelly5e06a7f2018-03-12 14:10:59 +0000294 private static final int TYPE_ALLOCATION_CODE_LENGTH = 8;
295 private static final int MANUFACTURER_CODE_LENGTH = 8;
296
Derek Tan89e89d42014-07-08 17:00:10 -0700297 /**
Shishir Agrawal566b7612013-10-28 14:41:00 -0700298 * A request object to use for transmitting data to an ICC.
299 */
300 private static final class IccAPDUArgument {
301 public int channel, cla, command, p1, p2, p3;
302 public String data;
303
304 public IccAPDUArgument(int channel, int cla, int command,
305 int p1, int p2, int p3, String data) {
306 this.channel = channel;
307 this.cla = cla;
308 this.command = command;
309 this.p1 = p1;
310 this.p2 = p2;
311 this.p3 = p3;
312 this.data = data;
313 }
314 }
315
316 /**
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700317 * A request object to use for transmitting data to an ICC.
318 */
319 private static final class ManualNetworkSelectionArgument {
320 public OperatorInfo operatorInfo;
321 public boolean persistSelection;
322
323 public ManualNetworkSelectionArgument(OperatorInfo operatorInfo, boolean persistSelection) {
324 this.operatorInfo = operatorInfo;
325 this.persistSelection = persistSelection;
326 }
327 }
328
329 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700330 * A request object for use with {@link MainThreadHandler}. Requesters should wait() on the
331 * request after sending. The main thread will notify the request when it is complete.
332 */
333 private static final class MainThreadRequest {
334 /** The argument to use for the request */
335 public Object argument;
336 /** The result of the request that is run on the main thread */
337 public Object result;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800338 // The subscriber id that this request applies to. Defaults to
339 // SubscriptionManager.INVALID_SUBSCRIPTION_ID
340 public Integer subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700341
Nathan Harold92bed182018-10-12 18:16:49 -0700342 // In cases where subId is unavailable, the caller needs to specify the phone.
343 public Phone phone;
344
vagdeviaf9a5b92018-08-15 16:01:53 -0700345 public WorkSource workSource;
346
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700347 public MainThreadRequest(Object argument) {
348 this.argument = argument;
349 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800350
Nathan Harold92bed182018-10-12 18:16:49 -0700351 MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
352 this.argument = argument;
353 if (phone != null) {
354 this.phone = phone;
355 }
356 this.workSource = workSource;
357 }
358
vagdeviaf9a5b92018-08-15 16:01:53 -0700359 MainThreadRequest(Object argument, Integer subId, WorkSource workSource) {
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800360 this.argument = argument;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800361 if (subId != null) {
362 this.subId = subId;
363 }
vagdeviaf9a5b92018-08-15 16:01:53 -0700364 this.workSource = workSource;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800365 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700366 }
367
Sailesh Nepalcc0375f2013-11-13 09:15:18 -0800368 private static final class IncomingThirdPartyCallArgs {
369 public final ComponentName component;
370 public final String callId;
371 public final String callerDisplayName;
372
373 public IncomingThirdPartyCallArgs(ComponentName component, String callId,
374 String callerDisplayName) {
375 this.component = component;
376 this.callId = callId;
377 this.callerDisplayName = callerDisplayName;
378 }
379 }
380
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700381 /**
382 * A handler that processes messages on the main thread in the phone process. Since many
383 * of the Phone calls are not thread safe this is needed to shuttle the requests from the
384 * inbound binder threads to the main thread in the phone process. The Binder thread
385 * may provide a {@link MainThreadRequest} object in the msg.obj field that they are waiting
386 * on, which will be notified when the operation completes and will contain the result of the
387 * request.
388 *
389 * <p>If a MainThreadRequest object is provided in the msg.obj field,
390 * note that request.result must be set to something non-null for the calling thread to
391 * unblock.
392 */
393 private final class MainThreadHandler extends Handler {
394 @Override
395 public void handleMessage(Message msg) {
396 MainThreadRequest request;
397 Message onCompleted;
398 AsyncResult ar;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800399 UiccCard uiccCard;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700400 IccAPDUArgument iccArgument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800401 final Phone defaultPhone = getDefaultPhone();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700402
403 switch (msg.what) {
Pengquan Menga1bb6272018-09-06 09:59:22 -0700404 case CMD_HANDLE_USSD_REQUEST: {
405 request = (MainThreadRequest) msg.obj;
406 final Phone phone = getPhoneFromRequest(request);
407 Pair<String, ResultReceiver> ussdObject = (Pair) request.argument;
408 String ussdRequest = ussdObject.first;
409 ResultReceiver wrappedCallback = ussdObject.second;
Tyler Gunn65d45c22017-06-05 11:22:26 -0700410
Pengquan Menga1bb6272018-09-06 09:59:22 -0700411 if (!isUssdApiAllowed(request.subId)) {
412 // Carrier does not support use of this API, return failure.
413 Rlog.w(LOG_TAG, "handleUssdRequest: carrier does not support USSD apis.");
414 UssdResponse response = new UssdResponse(ussdRequest, null);
415 Bundle returnData = new Bundle();
416 returnData.putParcelable(TelephonyManager.USSD_RESPONSE, response);
417 wrappedCallback.send(TelephonyManager.USSD_RETURN_FAILURE, returnData);
Tyler Gunn65d45c22017-06-05 11:22:26 -0700418
Pengquan Menga1bb6272018-09-06 09:59:22 -0700419 request.result = true;
420 notifyRequester(request);
421 return;
422 }
Tyler Gunn65d45c22017-06-05 11:22:26 -0700423
Pengquan Menga1bb6272018-09-06 09:59:22 -0700424 try {
425 request.result = phone != null
426 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
427 } catch (CallStateException cse) {
428 request.result = false;
429 }
430 // Wake up the requesting thread
431 notifyRequester(request);
432 break;
pkanwar32d516d2016-10-14 19:37:38 -0700433 }
434
Yorke Lee716f67e2015-06-17 15:39:16 -0700435 case CMD_HANDLE_PIN_MMI: {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700436 request = (MainThreadRequest) msg.obj;
Yorke Lee716f67e2015-06-17 15:39:16 -0700437 final Phone phone = getPhoneFromRequest(request);
438 request.result = phone != null ?
439 getPhoneFromRequest(request).handlePinMmi((String) request.argument)
440 : false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700441 // Wake up the requesting thread
Pengquan Menga1bb6272018-09-06 09:59:22 -0700442 notifyRequester(request);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700443 break;
Yorke Lee716f67e2015-06-17 15:39:16 -0700444 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700445
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700446 case CMD_TRANSMIT_APDU_LOGICAL_CHANNEL:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700447 request = (MainThreadRequest) msg.obj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700448 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800449 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700450 if (uiccCard == null) {
451 loge("iccTransmitApduLogicalChannel: No UICC");
452 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700453 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700454 } else {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700455 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE,
456 request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700457 uiccCard.iccTransmitApduLogicalChannel(
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700458 iccArgument.channel, iccArgument.cla, iccArgument.command,
459 iccArgument.p1, iccArgument.p2, iccArgument.p3, iccArgument.data,
Shishir Agrawal566b7612013-10-28 14:41:00 -0700460 onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700461 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700462 break;
463
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700464 case EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700465 ar = (AsyncResult) msg.obj;
466 request = (MainThreadRequest) ar.userObj;
467 if (ar.exception == null && ar.result != null) {
468 request.result = ar.result;
469 } else {
470 request.result = new IccIoResult(0x6F, 0, (byte[])null);
471 if (ar.result == null) {
472 loge("iccTransmitApduLogicalChannel: Empty response");
Jake Hambye994d462014-02-03 13:10:13 -0800473 } else if (ar.exception instanceof CommandException) {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700474 loge("iccTransmitApduLogicalChannel: CommandException: " +
Jake Hambye994d462014-02-03 13:10:13 -0800475 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700476 } else {
477 loge("iccTransmitApduLogicalChannel: Unknown exception");
478 }
479 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700480 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700481 break;
482
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700483 case CMD_TRANSMIT_APDU_BASIC_CHANNEL:
484 request = (MainThreadRequest) msg.obj;
485 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800486 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700487 if (uiccCard == null) {
488 loge("iccTransmitApduBasicChannel: No UICC");
489 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700490 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700491 } else {
492 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE,
493 request);
494 uiccCard.iccTransmitApduBasicChannel(
495 iccArgument.cla, iccArgument.command, iccArgument.p1, iccArgument.p2,
496 iccArgument.p3, iccArgument.data, onCompleted);
497 }
498 break;
499
500 case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
501 ar = (AsyncResult) msg.obj;
502 request = (MainThreadRequest) ar.userObj;
503 if (ar.exception == null && ar.result != null) {
504 request.result = ar.result;
505 } else {
506 request.result = new IccIoResult(0x6F, 0, (byte[])null);
507 if (ar.result == null) {
508 loge("iccTransmitApduBasicChannel: Empty response");
509 } else if (ar.exception instanceof CommandException) {
510 loge("iccTransmitApduBasicChannel: CommandException: " +
511 ar.exception);
512 } else {
513 loge("iccTransmitApduBasicChannel: Unknown exception");
514 }
515 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700516 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700517 break;
518
519 case CMD_EXCHANGE_SIM_IO:
520 request = (MainThreadRequest) msg.obj;
521 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800522 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700523 if (uiccCard == null) {
524 loge("iccExchangeSimIO: No UICC");
525 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700526 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700527 } else {
528 onCompleted = obtainMessage(EVENT_EXCHANGE_SIM_IO_DONE,
529 request);
530 uiccCard.iccExchangeSimIO(iccArgument.cla, /* fileID */
531 iccArgument.command, iccArgument.p1, iccArgument.p2, iccArgument.p3,
532 iccArgument.data, onCompleted);
533 }
534 break;
535
536 case EVENT_EXCHANGE_SIM_IO_DONE:
537 ar = (AsyncResult) msg.obj;
538 request = (MainThreadRequest) ar.userObj;
539 if (ar.exception == null && ar.result != null) {
540 request.result = ar.result;
541 } else {
542 request.result = new IccIoResult(0x6f, 0, (byte[])null);
543 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700544 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700545 break;
546
Derek Tan4d5e5c12014-02-04 11:54:58 -0800547 case CMD_SEND_ENVELOPE:
548 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800549 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700550 if (uiccCard == null) {
551 loge("sendEnvelopeWithStatus: No UICC");
552 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700553 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700554 } else {
555 onCompleted = obtainMessage(EVENT_SEND_ENVELOPE_DONE, request);
556 uiccCard.sendEnvelopeWithStatus((String)request.argument, onCompleted);
557 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800558 break;
559
560 case EVENT_SEND_ENVELOPE_DONE:
561 ar = (AsyncResult) msg.obj;
562 request = (MainThreadRequest) ar.userObj;
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700563 if (ar.exception == null && ar.result != null) {
564 request.result = ar.result;
Derek Tan4d5e5c12014-02-04 11:54:58 -0800565 } else {
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700566 request.result = new IccIoResult(0x6F, 0, (byte[])null);
567 if (ar.result == null) {
568 loge("sendEnvelopeWithStatus: Empty response");
569 } else if (ar.exception instanceof CommandException) {
570 loge("sendEnvelopeWithStatus: CommandException: " +
571 ar.exception);
572 } else {
573 loge("sendEnvelopeWithStatus: exception:" + ar.exception);
574 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800575 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700576 notifyRequester(request);
Derek Tan4d5e5c12014-02-04 11:54:58 -0800577 break;
578
Shishir Agrawal566b7612013-10-28 14:41:00 -0700579 case CMD_OPEN_CHANNEL:
580 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800581 uiccCard = getUiccCardFromRequest(request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800582 Pair<String, Integer> openChannelArgs = (Pair<String, Integer>) request.argument;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700583 if (uiccCard == null) {
584 loge("iccOpenLogicalChannel: No UICC");
Shishir Agrawalfc0492a2016-02-17 11:15:33 -0800585 request.result = new IccOpenLogicalChannelResponse(-1,
586 IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE, null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700587 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700588 } else {
589 onCompleted = obtainMessage(EVENT_OPEN_CHANNEL_DONE, request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800590 uiccCard.iccOpenLogicalChannel(openChannelArgs.first,
591 openChannelArgs.second, onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700592 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700593 break;
594
595 case EVENT_OPEN_CHANNEL_DONE:
596 ar = (AsyncResult) msg.obj;
597 request = (MainThreadRequest) ar.userObj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700598 IccOpenLogicalChannelResponse openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700599 if (ar.exception == null && ar.result != null) {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700600 int[] result = (int[]) ar.result;
601 int channelId = result[0];
602 byte[] selectResponse = null;
603 if (result.length > 1) {
604 selectResponse = new byte[result.length - 1];
605 for (int i = 1; i < result.length; ++i) {
606 selectResponse[i - 1] = (byte) result[i];
607 }
608 }
609 openChannelResp = new IccOpenLogicalChannelResponse(channelId,
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700610 IccOpenLogicalChannelResponse.STATUS_NO_ERROR, selectResponse);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700611 } else {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700612 if (ar.result == null) {
613 loge("iccOpenLogicalChannel: Empty response");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700614 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700615 if (ar.exception != null) {
616 loge("iccOpenLogicalChannel: Exception: " + ar.exception);
617 }
618
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700619 int errorCode = IccOpenLogicalChannelResponse.STATUS_UNKNOWN_ERROR;
Junda Liua754ba12015-05-20 01:17:52 -0700620 if (ar.exception instanceof CommandException) {
621 CommandException.Error error =
622 ((CommandException) (ar.exception)).getCommandError();
623 if (error == CommandException.Error.MISSING_RESOURCE) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700624 errorCode = IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
Junda Liua754ba12015-05-20 01:17:52 -0700625 } else if (error == CommandException.Error.NO_SUCH_ELEMENT) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700626 errorCode = IccOpenLogicalChannelResponse.STATUS_NO_SUCH_ELEMENT;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700627 }
628 }
629 openChannelResp = new IccOpenLogicalChannelResponse(
630 IccOpenLogicalChannelResponse.INVALID_CHANNEL, errorCode, null);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700631 }
Shishir Agrawal82c8a462014-07-31 18:13:17 -0700632 request.result = openChannelResp;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700633 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700634 break;
635
636 case CMD_CLOSE_CHANNEL:
637 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800638 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700639 if (uiccCard == null) {
640 loge("iccCloseLogicalChannel: No UICC");
Yoshiaki Naka2e29d822016-09-02 19:27:39 +0900641 request.result = false;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700642 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700643 } else {
644 onCompleted = obtainMessage(EVENT_CLOSE_CHANNEL_DONE, request);
645 uiccCard.iccCloseLogicalChannel((Integer) request.argument, onCompleted);
646 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700647 break;
648
649 case EVENT_CLOSE_CHANNEL_DONE:
Jake Hambye994d462014-02-03 13:10:13 -0800650 handleNullReturnEvent(msg, "iccCloseLogicalChannel");
651 break;
652
653 case CMD_NV_READ_ITEM:
654 request = (MainThreadRequest) msg.obj;
655 onCompleted = obtainMessage(EVENT_NV_READ_ITEM_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800656 defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
657 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800658 break;
659
660 case EVENT_NV_READ_ITEM_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700661 ar = (AsyncResult) msg.obj;
662 request = (MainThreadRequest) ar.userObj;
Jake Hambye994d462014-02-03 13:10:13 -0800663 if (ar.exception == null && ar.result != null) {
664 request.result = ar.result; // String
Shishir Agrawal566b7612013-10-28 14:41:00 -0700665 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800666 request.result = "";
667 if (ar.result == null) {
668 loge("nvReadItem: Empty response");
669 } else if (ar.exception instanceof CommandException) {
670 loge("nvReadItem: CommandException: " +
671 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700672 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800673 loge("nvReadItem: Unknown exception");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700674 }
675 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700676 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700677 break;
678
Jake Hambye994d462014-02-03 13:10:13 -0800679 case CMD_NV_WRITE_ITEM:
680 request = (MainThreadRequest) msg.obj;
681 onCompleted = obtainMessage(EVENT_NV_WRITE_ITEM_DONE, request);
682 Pair<Integer, String> idValue = (Pair<Integer, String>) request.argument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800683 defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
vagdeviaf9a5b92018-08-15 16:01:53 -0700684 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800685 break;
686
687 case EVENT_NV_WRITE_ITEM_DONE:
688 handleNullReturnEvent(msg, "nvWriteItem");
689 break;
690
691 case CMD_NV_WRITE_CDMA_PRL:
692 request = (MainThreadRequest) msg.obj;
693 onCompleted = obtainMessage(EVENT_NV_WRITE_CDMA_PRL_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800694 defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800695 break;
696
697 case EVENT_NV_WRITE_CDMA_PRL_DONE:
698 handleNullReturnEvent(msg, "nvWriteCdmaPrl");
699 break;
700
chen xu6dac5ab2018-10-26 17:39:23 -0700701 case CMD_RESET_MODEM_CONFIG:
Jake Hambye994d462014-02-03 13:10:13 -0800702 request = (MainThreadRequest) msg.obj;
chen xu6dac5ab2018-10-26 17:39:23 -0700703 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800704 defaultPhone.resetModemConfig(onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800705 break;
706
chen xu6dac5ab2018-10-26 17:39:23 -0700707 case EVENT_RESET_MODEM_CONFIG_DONE:
708 handleNullReturnEvent(msg, "resetModemConfig");
Jake Hambye994d462014-02-03 13:10:13 -0800709 break;
710
Jake Hamby7c27be32014-03-03 13:25:59 -0800711 case CMD_GET_PREFERRED_NETWORK_TYPE:
712 request = (MainThreadRequest) msg.obj;
713 onCompleted = obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE_DONE, request);
Stuart Scott54788802015-03-30 13:18:01 -0700714 getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800715 break;
716
717 case EVENT_GET_PREFERRED_NETWORK_TYPE_DONE:
718 ar = (AsyncResult) msg.obj;
719 request = (MainThreadRequest) ar.userObj;
720 if (ar.exception == null && ar.result != null) {
721 request.result = ar.result; // Integer
722 } else {
Sanket Padawecfc2d352016-01-05 19:52:14 -0800723 request.result = null;
Jake Hamby7c27be32014-03-03 13:25:59 -0800724 if (ar.result == null) {
725 loge("getPreferredNetworkType: Empty response");
726 } else if (ar.exception instanceof CommandException) {
727 loge("getPreferredNetworkType: CommandException: " +
728 ar.exception);
729 } else {
730 loge("getPreferredNetworkType: Unknown exception");
731 }
732 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700733 notifyRequester(request);
Jake Hamby7c27be32014-03-03 13:25:59 -0800734 break;
735
736 case CMD_SET_PREFERRED_NETWORK_TYPE:
737 request = (MainThreadRequest) msg.obj;
738 onCompleted = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE_DONE, request);
739 int networkType = (Integer) request.argument;
Stuart Scott54788802015-03-30 13:18:01 -0700740 getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800741 break;
742
743 case EVENT_SET_PREFERRED_NETWORK_TYPE_DONE:
744 handleNullReturnEvent(msg, "setPreferredNetworkType");
745 break;
746
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000747 case CMD_INVOKE_OEM_RIL_REQUEST_RAW:
748 request = (MainThreadRequest)msg.obj;
749 onCompleted = obtainMessage(EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800750 defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000751 break;
752
753 case EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE:
754 ar = (AsyncResult)msg.obj;
755 request = (MainThreadRequest)ar.userObj;
756 request.result = ar;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700757 notifyRequester(request);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000758 break;
759
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800760 case CMD_SET_VOICEMAIL_NUMBER:
761 request = (MainThreadRequest) msg.obj;
762 onCompleted = obtainMessage(EVENT_SET_VOICEMAIL_NUMBER_DONE, request);
763 Pair<String, String> tagNum = (Pair<String, String>) request.argument;
Stuart Scott584921c2015-01-15 17:10:34 -0800764 getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
765 onCompleted);
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800766 break;
767
768 case EVENT_SET_VOICEMAIL_NUMBER_DONE:
769 handleNullReturnEvent(msg, "setVoicemailNumber");
770 break;
771
Stuart Scott54788802015-03-30 13:18:01 -0700772 case CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC:
773 request = (MainThreadRequest) msg.obj;
774 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE,
775 request);
776 getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
777 break;
778
779 case EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE:
780 handleNullReturnEvent(msg, "setNetworkSelectionModeAutomatic");
781 break;
782
Shishir Agrawal302c8692015-06-19 13:49:39 -0700783 case CMD_PERFORM_NETWORK_SCAN:
784 request = (MainThreadRequest) msg.obj;
785 onCompleted = obtainMessage(EVENT_PERFORM_NETWORK_SCAN_DONE, request);
786 getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
787 break;
788
789 case EVENT_PERFORM_NETWORK_SCAN_DONE:
790 ar = (AsyncResult) msg.obj;
791 request = (MainThreadRequest) ar.userObj;
792 CellNetworkScanResult cellScanResult;
793 if (ar.exception == null && ar.result != null) {
794 cellScanResult = new CellNetworkScanResult(
795 CellNetworkScanResult.STATUS_SUCCESS,
796 (List<OperatorInfo>) ar.result);
797 } else {
798 if (ar.result == null) {
799 loge("getCellNetworkScanResults: Empty response");
800 }
801 if (ar.exception != null) {
802 loge("getCellNetworkScanResults: Exception: " + ar.exception);
803 }
804 int errorCode = CellNetworkScanResult.STATUS_UNKNOWN_ERROR;
805 if (ar.exception instanceof CommandException) {
806 CommandException.Error error =
807 ((CommandException) (ar.exception)).getCommandError();
808 if (error == CommandException.Error.RADIO_NOT_AVAILABLE) {
809 errorCode = CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE;
810 } else if (error == CommandException.Error.GENERIC_FAILURE) {
811 errorCode = CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE;
812 }
813 }
814 cellScanResult = new CellNetworkScanResult(errorCode, null);
815 }
816 request.result = cellScanResult;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700817 notifyRequester(request);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700818 break;
819
820 case CMD_SET_NETWORK_SELECTION_MODE_MANUAL:
821 request = (MainThreadRequest) msg.obj;
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700822 ManualNetworkSelectionArgument selArg =
823 (ManualNetworkSelectionArgument) request.argument;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700824 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE,
825 request);
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700826 getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
827 selArg.persistSelection, onCompleted);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700828 break;
829
830 case EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE:
Pengquan Menge3d01e22018-09-20 15:25:35 -0700831 ar = (AsyncResult) msg.obj;
832 request = (MainThreadRequest) ar.userObj;
833 if (ar.exception == null) {
834 request.result = true;
835 } else {
836 request.result = false;
837 loge("setNetworkSelectionModeManual " + ar.exception);
838 }
839 notifyRequester(request);
840 mApp.onNetworkSelectionChanged(request.subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700841 break;
842
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700843 case CMD_GET_MODEM_ACTIVITY_INFO:
844 request = (MainThreadRequest) msg.obj;
845 onCompleted = obtainMessage(EVENT_GET_MODEM_ACTIVITY_INFO_DONE, request);
James Mattisab947702019-04-03 14:18:34 -0700846 if (defaultPhone != null) {
847 defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
848 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700849 break;
850
851 case EVENT_GET_MODEM_ACTIVITY_INFO_DONE:
852 ar = (AsyncResult) msg.obj;
853 request = (MainThreadRequest) ar.userObj;
854 if (ar.exception == null && ar.result != null) {
855 request.result = ar.result;
856 } else {
857 if (ar.result == null) {
858 loge("queryModemActivityInfo: Empty response");
859 } else if (ar.exception instanceof CommandException) {
860 loge("queryModemActivityInfo: CommandException: " +
861 ar.exception);
862 } else {
863 loge("queryModemActivityInfo: Unknown exception");
864 }
865 }
Amit Mahajand4766222016-01-28 15:28:28 -0800866 // Result cannot be null. Return ModemActivityInfo with all fields set to 0.
867 if (request.result == null) {
868 request.result = new ModemActivityInfo(0, 0, 0, null, 0, 0);
869 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700870 notifyRequester(request);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700871 break;
872
Meng Wang1a7c35a2016-05-05 20:56:15 -0700873 case CMD_SET_ALLOWED_CARRIERS:
874 request = (MainThreadRequest) msg.obj;
Michele Berionne482f8202018-11-27 18:57:59 -0800875 CarrierRestrictionRules argument =
876 (CarrierRestrictionRules) request.argument;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700877 onCompleted = obtainMessage(EVENT_SET_ALLOWED_CARRIERS_DONE, request);
Michele Berionne482f8202018-11-27 18:57:59 -0800878 defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700879 break;
880
881 case EVENT_SET_ALLOWED_CARRIERS_DONE:
882 ar = (AsyncResult) msg.obj;
883 request = (MainThreadRequest) ar.userObj;
884 if (ar.exception == null && ar.result != null) {
885 request.result = ar.result;
886 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800887 request.result = TelephonyManager.SET_CARRIER_RESTRICTION_ERROR;
888 if (ar.exception instanceof CommandException) {
889 loge("setAllowedCarriers: CommandException: " + ar.exception);
890 CommandException.Error error =
891 ((CommandException) (ar.exception)).getCommandError();
892 if (error == CommandException.Error.REQUEST_NOT_SUPPORTED) {
893 request.result =
894 TelephonyManager.SET_CARRIER_RESTRICTION_NOT_SUPPORTED;
895 }
Meng Wang1a7c35a2016-05-05 20:56:15 -0700896 } else {
897 loge("setAllowedCarriers: Unknown exception");
898 }
899 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700900 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700901 break;
902
903 case CMD_GET_ALLOWED_CARRIERS:
904 request = (MainThreadRequest) msg.obj;
905 onCompleted = obtainMessage(EVENT_GET_ALLOWED_CARRIERS_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800906 defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700907 break;
908
909 case EVENT_GET_ALLOWED_CARRIERS_DONE:
910 ar = (AsyncResult) msg.obj;
911 request = (MainThreadRequest) ar.userObj;
912 if (ar.exception == null && ar.result != null) {
913 request.result = ar.result;
914 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800915 request.result = new IllegalStateException(
916 "Failed to get carrier restrictions");
Meng Wang1a7c35a2016-05-05 20:56:15 -0700917 if (ar.result == null) {
918 loge("getAllowedCarriers: Empty response");
919 } else if (ar.exception instanceof CommandException) {
920 loge("getAllowedCarriers: CommandException: " +
921 ar.exception);
922 } else {
923 loge("getAllowedCarriers: Unknown exception");
924 }
925 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700926 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700927 break;
928
Nathan Haroldb3014052017-01-25 15:57:32 -0800929 case EVENT_GET_FORBIDDEN_PLMNS_DONE:
930 ar = (AsyncResult) msg.obj;
931 request = (MainThreadRequest) ar.userObj;
932 if (ar.exception == null && ar.result != null) {
933 request.result = ar.result;
934 } else {
935 request.result = new IllegalArgumentException(
936 "Failed to retrieve Forbidden Plmns");
937 if (ar.result == null) {
938 loge("getForbiddenPlmns: Empty response");
939 } else {
940 loge("getForbiddenPlmns: Unknown exception");
941 }
942 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700943 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800944 break;
945
946 case CMD_GET_FORBIDDEN_PLMNS:
947 request = (MainThreadRequest) msg.obj;
948 uiccCard = getUiccCardFromRequest(request);
949 if (uiccCard == null) {
950 loge("getForbiddenPlmns() UiccCard is null");
951 request.result = new IllegalArgumentException(
952 "getForbiddenPlmns() UiccCard is null");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700953 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800954 break;
955 }
956 Integer appType = (Integer) request.argument;
957 UiccCardApplication uiccApp = uiccCard.getApplicationByType(appType);
958 if (uiccApp == null) {
959 loge("getForbiddenPlmns() no app with specified type -- "
960 + appType);
961 request.result = new IllegalArgumentException("Failed to get UICC App");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700962 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800963 break;
964 } else {
965 if (DBG) logv("getForbiddenPlmns() found app " + uiccApp.getAid()
966 + " specified type -- " + appType);
967 }
968 onCompleted = obtainMessage(EVENT_GET_FORBIDDEN_PLMNS_DONE, request);
969 ((SIMRecords) uiccApp.getIccRecords()).getForbiddenPlmns(
970 onCompleted);
971 break;
972
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000973 case CMD_SWITCH_SLOTS:
974 request = (MainThreadRequest) msg.obj;
975 int[] physicalSlots = (int[]) request.argument;
976 onCompleted = obtainMessage(EVENT_SWITCH_SLOTS_DONE, request);
977 UiccController.getInstance().switchSlots(physicalSlots, onCompleted);
978 break;
979
980 case EVENT_SWITCH_SLOTS_DONE:
981 ar = (AsyncResult) msg.obj;
982 request = (MainThreadRequest) ar.userObj;
983 request.result = (ar.exception == null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700984 notifyRequester(request);
985 break;
986 case CMD_GET_NETWORK_SELECTION_MODE:
987 request = (MainThreadRequest) msg.obj;
988 onCompleted = obtainMessage(EVENT_GET_NETWORK_SELECTION_MODE_DONE, request);
989 getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
990 break;
991
992 case EVENT_GET_NETWORK_SELECTION_MODE_DONE:
993 ar = (AsyncResult) msg.obj;
994 request = (MainThreadRequest) ar.userObj;
995 if (ar.exception != null) {
996 request.result = TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
997 } else {
998 int mode = ((int[]) ar.result)[0];
999 if (mode == 0) {
1000 request.result = TelephonyManager.NETWORK_SELECTION_MODE_AUTO;
1001 } else {
1002 request.result = TelephonyManager.NETWORK_SELECTION_MODE_MANUAL;
1003 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001004 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001005 notifyRequester(request);
1006 break;
1007 case CMD_GET_CDMA_ROAMING_MODE:
1008 request = (MainThreadRequest) msg.obj;
1009 onCompleted = obtainMessage(EVENT_GET_CDMA_ROAMING_MODE_DONE, request);
1010 getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1011 break;
1012 case EVENT_GET_CDMA_ROAMING_MODE_DONE:
1013 ar = (AsyncResult) msg.obj;
1014 request = (MainThreadRequest) ar.userObj;
1015 if (ar.exception != null) {
1016 request.result = TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT;
1017 } else {
1018 request.result = ((int[]) ar.result)[0];
1019 }
1020 notifyRequester(request);
1021 break;
1022 case CMD_SET_CDMA_ROAMING_MODE:
1023 request = (MainThreadRequest) msg.obj;
1024 onCompleted = obtainMessage(EVENT_SET_CDMA_ROAMING_MODE_DONE, request);
1025 int mode = (int) request.argument;
1026 getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1027 break;
1028 case EVENT_SET_CDMA_ROAMING_MODE_DONE:
1029 ar = (AsyncResult) msg.obj;
1030 request = (MainThreadRequest) ar.userObj;
1031 request.result = ar.exception == null;
1032 notifyRequester(request);
1033 break;
1034 case CMD_SET_CDMA_SUBSCRIPTION_MODE:
1035 request = (MainThreadRequest) msg.obj;
1036 onCompleted = obtainMessage(EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE, request);
1037 int subscriptionMode = (int) request.argument;
1038 getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);
1039 break;
1040 case EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE:
1041 ar = (AsyncResult) msg.obj;
1042 request = (MainThreadRequest) ar.userObj;
1043 request.result = ar.exception == null;
1044 notifyRequester(request);
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001045 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001046 case CMD_GET_ALL_CELL_INFO:
1047 request = (MainThreadRequest) msg.obj;
Nathan Harold3ff88932018-08-14 10:19:49 -07001048 onCompleted = obtainMessage(EVENT_GET_ALL_CELL_INFO_DONE, request);
Nathan Harold92bed182018-10-12 18:16:49 -07001049 request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
Nathan Harold3ff88932018-08-14 10:19:49 -07001050 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001051 case EVENT_GET_ALL_CELL_INFO_DONE:
1052 ar = (AsyncResult) msg.obj;
1053 request = (MainThreadRequest) ar.userObj;
Nathan Harold8d0f1742018-10-02 12:14:47 -07001054 // If a timeout occurs, the response will be null
1055 request.result = (ar.exception == null && ar.result != null)
1056 ? ar.result : new ArrayList<CellInfo>();
Nathan Harold3ff88932018-08-14 10:19:49 -07001057 synchronized (request) {
1058 request.notifyAll();
1059 }
1060 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001061 case CMD_REQUEST_CELL_INFO_UPDATE:
1062 request = (MainThreadRequest) msg.obj;
1063 request.phone.requestCellInfoUpdate(request.workSource,
1064 obtainMessage(EVENT_REQUEST_CELL_INFO_UPDATE_DONE, request));
1065 break;
1066 case EVENT_REQUEST_CELL_INFO_UPDATE_DONE:
1067 ar = (AsyncResult) msg.obj;
1068 request = (MainThreadRequest) ar.userObj;
1069 ICellInfoCallback cb = (ICellInfoCallback) request.argument;
1070 try {
1071 if (ar.exception != null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001072 Log.e(LOG_TAG, "Exception retrieving CellInfo=" + ar.exception);
Nathan Harolde82c4b82018-12-18 19:40:37 -08001073 cb.onError(TelephonyManager.CellInfoCallback.ERROR_MODEM_ERROR,
1074 new android.os.ParcelableException(ar.exception));
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001075 } else if (ar.result == null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001076 Log.w(LOG_TAG, "Timeout Waiting for CellInfo!");
Nathan Harolde82c4b82018-12-18 19:40:37 -08001077 cb.onError(TelephonyManager.CellInfoCallback.ERROR_TIMEOUT, null);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001078 } else {
1079 // use the result as returned
1080 cb.onCellInfo((List<CellInfo>) ar.result);
1081 }
1082 } catch (RemoteException re) {
1083 Log.w(LOG_TAG, "Discarded CellInfo due to Callback RemoteException");
1084 }
1085 break;
1086 case CMD_GET_CELL_LOCATION:
Nathan Harold3ff88932018-08-14 10:19:49 -07001087 request = (MainThreadRequest) msg.obj;
1088 WorkSource ws = (WorkSource) request.argument;
1089 Phone phone = getPhoneFromRequest(request);
1090 phone.getCellLocation(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1091 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001092 case EVENT_GET_CELL_LOCATION_DONE:
Nathan Harold3ff88932018-08-14 10:19:49 -07001093 ar = (AsyncResult) msg.obj;
1094 request = (MainThreadRequest) ar.userObj;
1095 if (ar.exception == null) {
1096 request.result = ar.result;
1097 } else {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001098 phone = getPhoneFromRequest(request);
Nathan Harold3ff88932018-08-14 10:19:49 -07001099 request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1100 ? new CdmaCellLocation() : new GsmCellLocation();
1101 }
1102
1103 synchronized (request) {
1104 request.notifyAll();
1105 }
1106 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001107 case CMD_MODEM_REBOOT:
1108 request = (MainThreadRequest) msg.obj;
1109 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001110 defaultPhone.rebootModem(onCompleted);
chen xu6dac5ab2018-10-26 17:39:23 -07001111 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001112 case EVENT_CMD_MODEM_REBOOT_DONE:
1113 handleNullReturnEvent(msg, "rebootModem");
1114 break;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001115 case CMD_REQUEST_ENABLE_MODEM:
1116 request = (MainThreadRequest) msg.obj;
1117 boolean enable = (boolean) request.argument;
1118 onCompleted = obtainMessage(EVENT_ENABLE_MODEM_DONE, request);
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001119 onCompleted.arg1 = enable ? 1 : 0;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001120 PhoneConfigurationManager.getInstance()
1121 .enablePhone(request.phone, enable, onCompleted);
1122 break;
1123 case EVENT_ENABLE_MODEM_DONE:
1124 ar = (AsyncResult) msg.obj;
1125 request = (MainThreadRequest) ar.userObj;
1126 request.result = (ar.exception == null);
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001127 int phoneId = request.phone.getPhoneId();
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001128 //update the cache as modem status has changed
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001129 if ((boolean) request.result) {
1130 mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1131 updateModemStateMetrics();
1132 } else {
1133 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1134 + ar.exception);
1135 }
1136 notifyRequester(request);
1137 break;
1138 case CMD_GET_MODEM_STATUS:
1139 request = (MainThreadRequest) msg.obj;
1140 onCompleted = obtainMessage(EVENT_GET_MODEM_STATUS_DONE, request);
1141 PhoneConfigurationManager.getInstance()
1142 .getPhoneStatusFromModem(request.phone, onCompleted);
1143 break;
1144 case EVENT_GET_MODEM_STATUS_DONE:
1145 ar = (AsyncResult) msg.obj;
1146 request = (MainThreadRequest) ar.userObj;
1147 int id = request.phone.getPhoneId();
1148 if (ar.exception == null && ar.result != null) {
1149 request.result = ar.result;
1150 //update the cache as modem status has changed
1151 mPhoneConfigurationManager.addToPhoneStatusCache(id,
1152 (boolean) request.result);
1153 } else {
1154 // Return true if modem status cannot be retrieved. For most cases,
1155 // modem status is on. And for older version modems, GET_MODEM_STATUS
1156 // and disable modem are not supported. Modem is always on.
1157 // TODO: this should be fixed in R to support a third
1158 // status UNKNOWN b/131631629
1159 request.result = true;
1160 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1161 + ar.exception);
1162 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001163 notifyRequester(request);
1164 break;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001165 default:
1166 Log.w(LOG_TAG, "MainThreadHandler: unexpected message code: " + msg.what);
1167 break;
1168 }
1169 }
Jake Hambye994d462014-02-03 13:10:13 -08001170
Pengquan Menga1bb6272018-09-06 09:59:22 -07001171 private void notifyRequester(MainThreadRequest request) {
1172 synchronized (request) {
1173 request.notifyAll();
1174 }
1175 }
1176
Jake Hambye994d462014-02-03 13:10:13 -08001177 private void handleNullReturnEvent(Message msg, String command) {
1178 AsyncResult ar = (AsyncResult) msg.obj;
1179 MainThreadRequest request = (MainThreadRequest) ar.userObj;
1180 if (ar.exception == null) {
1181 request.result = true;
1182 } else {
1183 request.result = false;
1184 if (ar.exception instanceof CommandException) {
1185 loge(command + ": CommandException: " + ar.exception);
1186 } else {
1187 loge(command + ": Unknown exception");
1188 }
1189 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001190 notifyRequester(request);
Jake Hambye994d462014-02-03 13:10:13 -08001191 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001192 }
1193
1194 /**
1195 * Posts the specified command to be executed on the main thread,
1196 * waits for the request to complete, and returns the result.
1197 * @see #sendRequestAsync
1198 */
1199 private Object sendRequest(int command, Object argument) {
Nathan Harold92bed182018-10-12 18:16:49 -07001200 return sendRequest(
1201 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001202 }
1203
1204 /**
1205 * Posts the specified command to be executed on the main thread,
1206 * waits for the request to complete, and returns the result.
1207 * @see #sendRequestAsync
1208 */
1209 private Object sendRequest(int command, Object argument, WorkSource workSource) {
1210 return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID,
Nathan Harold92bed182018-10-12 18:16:49 -07001211 null, workSource);
Wink Saville36469e72014-06-11 15:17:00 -07001212 }
1213
1214 /**
1215 * Posts the specified command to be executed on the main thread,
1216 * waits for the request to complete, and returns the result.
1217 * @see #sendRequestAsync
1218 */
Shishir Agrawal76d5da92014-11-09 16:17:25 -08001219 private Object sendRequest(int command, Object argument, Integer subId) {
Nathan Harold92bed182018-10-12 18:16:49 -07001220 return sendRequest(command, argument, subId, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001221 }
1222
1223 /**
1224 * Posts the specified command to be executed on the main thread,
1225 * waits for the request to complete, and returns the result.
1226 * @see #sendRequestAsync
1227 */
Nathan Harold92bed182018-10-12 18:16:49 -07001228 private Object sendRequest(int command, Object argument, int subId, WorkSource workSource) {
1229 return sendRequest(command, argument, subId, null, workSource);
1230 }
1231
1232 /**
1233 * Posts the specified command to be executed on the main thread,
1234 * waits for the request to complete, and returns the result.
1235 * @see #sendRequestAsync
1236 */
1237 private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
1238 return sendRequest(
1239 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone, workSource);
1240 }
1241
1242 /**
1243 * Posts the specified command to be executed on the main thread,
1244 * waits for the request to complete, and returns the result.
1245 * @see #sendRequestAsync
1246 */
1247 private Object sendRequest(
1248 int command, Object argument, Integer subId, Phone phone, WorkSource workSource) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001249 if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
1250 throw new RuntimeException("This method will deadlock if called from the main thread.");
1251 }
1252
Nathan Harold92bed182018-10-12 18:16:49 -07001253 MainThreadRequest request = null;
1254 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
1255 throw new IllegalArgumentException("subId and phone cannot both be specified!");
1256 } else if (phone != null) {
1257 request = new MainThreadRequest(argument, phone, workSource);
1258 } else {
1259 request = new MainThreadRequest(argument, subId, workSource);
1260 }
1261
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001262 Message msg = mMainThreadHandler.obtainMessage(command, request);
1263 msg.sendToTarget();
1264
1265 // Wait for the request to complete
1266 synchronized (request) {
1267 while (request.result == null) {
1268 try {
1269 request.wait();
1270 } catch (InterruptedException e) {
1271 // Do nothing, go back and wait until the request is complete
1272 }
1273 }
1274 }
1275 return request.result;
1276 }
1277
1278 /**
1279 * Asynchronous ("fire and forget") version of sendRequest():
1280 * Posts the specified command to be executed on the main thread, and
1281 * returns immediately.
1282 * @see #sendRequest
1283 */
1284 private void sendRequestAsync(int command) {
1285 mMainThreadHandler.sendEmptyMessage(command);
1286 }
1287
1288 /**
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001289 * Same as {@link #sendRequestAsync(int)} except it takes an argument.
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001290 * @see {@link #sendRequest(int)}
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001291 */
1292 private void sendRequestAsync(int command, Object argument) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001293 sendRequestAsync(command, argument, null, null);
1294 }
1295
1296 /**
1297 * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
1298 * @see {@link #sendRequest(int,Object)}
1299 */
1300 private void sendRequestAsync(
1301 int command, Object argument, Phone phone, WorkSource workSource) {
1302 MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001303 Message msg = mMainThreadHandler.obtainMessage(command, request);
1304 msg.sendToTarget();
1305 }
1306
1307 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001308 * Initialize the singleton PhoneInterfaceManager instance.
1309 * This is only done once, at startup, from PhoneApp.onCreate().
1310 */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001311 /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001312 synchronized (PhoneInterfaceManager.class) {
1313 if (sInstance == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001314 sInstance = new PhoneInterfaceManager(app);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001315 } else {
1316 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
1317 }
1318 return sInstance;
1319 }
1320 }
1321
1322 /** Private constructor; @see init() */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001323 private PhoneInterfaceManager(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001324 mApp = app;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001325 mCM = PhoneGlobals.getInstance().mCM;
Stuart Scott981d8582015-04-21 14:09:50 -07001326 mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001327 mAppOps = (AppOpsManager)app.getSystemService(Context.APP_OPS_SERVICE);
1328 mMainThreadHandler = new MainThreadHandler();
Tobias Thiererb19e1f12018-12-11 17:54:03 +00001329 mSubscriptionController = SubscriptionController.getInstance();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001330 mTelephonySharedPreferences =
1331 PreferenceManager.getDefaultSharedPreferences(mApp);
yinxub1bed742017-04-17 11:45:04 -07001332 mNetworkScanRequestTracker = new NetworkScanRequestTracker();
Malcolm Chen2c63d402018-08-14 16:00:53 -07001333 mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
Wink Saville3ab207e2014-11-20 13:07:20 -08001334
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001335 publish();
1336 }
1337
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001338 private Phone getDefaultPhone() {
1339 Phone thePhone = getPhone(getDefaultSubscription());
1340 return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
1341 }
1342
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001343 private void publish() {
1344 if (DBG) log("publish: " + this);
1345
1346 ServiceManager.addService("phone", this);
1347 }
1348
Stuart Scott584921c2015-01-15 17:10:34 -08001349 private Phone getPhoneFromRequest(MainThreadRequest request) {
Jordan Liu4c733742019-02-28 12:03:40 -08001350 if (request.phone != null) {
1351 return request.phone;
1352 } else {
1353 return getPhoneFromSubId(request.subId);
1354 }
1355 }
1356
1357 private Phone getPhoneFromSubId(int subId) {
1358 return (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID)
1359 ? getDefaultPhone() : getPhone(subId);
Stuart Scott584921c2015-01-15 17:10:34 -08001360 }
1361
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001362 private UiccCard getUiccCardFromRequest(MainThreadRequest request) {
1363 Phone phone = getPhoneFromRequest(request);
1364 return phone == null ? null :
1365 UiccController.getInstance().getUiccCard(phone.getPhoneId());
1366 }
1367
Wink Saville36469e72014-06-11 15:17:00 -07001368 // returns phone associated with the subId.
Wink Savilleb564aae2014-10-23 10:18:09 -07001369 private Phone getPhone(int subId) {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001370 return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
Wink Saville36469e72014-06-11 15:17:00 -07001371 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001372
1373 public void dial(String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001374 dialForSubscriber(getPreferredVoiceSubscription(), number);
Wink Saville36469e72014-06-11 15:17:00 -07001375 }
1376
Wink Savilleb564aae2014-10-23 10:18:09 -07001377 public void dialForSubscriber(int subId, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001378 if (DBG) log("dial: " + number);
1379 // No permission check needed here: This is just a wrapper around the
1380 // ACTION_DIAL intent, which is available to any app since it puts up
1381 // the UI before it does anything.
1382
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001383 final long identity = Binder.clearCallingIdentity();
1384 try {
1385 String url = createTelUrl(number);
1386 if (url == null) {
1387 return;
1388 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001389
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001390 // PENDING: should we just silently fail if phone is offhook or ringing?
1391 PhoneConstants.State state = mCM.getState(subId);
1392 if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
1393 Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
1394 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1395 mApp.startActivity(intent);
1396 }
1397 } finally {
1398 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001399 }
1400 }
1401
1402 public void call(String callingPackage, String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001403 callForSubscriber(getPreferredVoiceSubscription(), callingPackage, number);
Wink Saville36469e72014-06-11 15:17:00 -07001404 }
1405
Wink Savilleb564aae2014-10-23 10:18:09 -07001406 public void callForSubscriber(int subId, String callingPackage, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001407 if (DBG) log("call: " + number);
1408
1409 // This is just a wrapper around the ACTION_CALL intent, but we still
1410 // need to do a permission check since we're calling startActivity()
1411 // from the context of the phone app.
1412 enforceCallPermission();
1413
Jordan Liu1617b712019-07-10 15:06:26 -07001414 if (mAppOps.noteOp(AppOpsManager.OPSTR_CALL_PHONE, Binder.getCallingUid(), callingPackage)
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001415 != AppOpsManager.MODE_ALLOWED) {
1416 return;
1417 }
1418
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001419 final long identity = Binder.clearCallingIdentity();
1420 try {
1421 String url = createTelUrl(number);
1422 if (url == null) {
1423 return;
1424 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001425
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001426 boolean isValid = false;
1427 final List<SubscriptionInfo> slist = getActiveSubscriptionInfoListPrivileged();
1428 if (slist != null) {
1429 for (SubscriptionInfo subInfoRecord : slist) {
1430 if (subInfoRecord.getSubscriptionId() == subId) {
1431 isValid = true;
1432 break;
1433 }
Wink Saville3ab207e2014-11-20 13:07:20 -08001434 }
Wink Saville08874612014-08-31 19:19:58 -07001435 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001436 if (!isValid) {
1437 return;
1438 }
Wink Saville08874612014-08-31 19:19:58 -07001439
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001440 Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
1441 intent.putExtra(SUBSCRIPTION_KEY, subId);
1442 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1443 mApp.startActivity(intent);
1444 } finally {
1445 Binder.restoreCallingIdentity(identity);
1446 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001447 }
1448
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001449 public boolean supplyPin(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001450 return supplyPinForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001451 }
1452
Wink Savilleb564aae2014-10-23 10:18:09 -07001453 public boolean supplyPinForSubscriber(int subId, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001454 int [] resultArray = supplyPinReportResultForSubscriber(subId, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001455 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1456 }
1457
1458 public boolean supplyPuk(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001459 return supplyPukForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001460 }
1461
Wink Savilleb564aae2014-10-23 10:18:09 -07001462 public boolean supplyPukForSubscriber(int subId, String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001463 int [] resultArray = supplyPukReportResultForSubscriber(subId, puk, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001464 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1465 }
1466
1467 /** {@hide} */
1468 public int[] supplyPinReportResult(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001469 return supplyPinReportResultForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001470 }
1471
Wink Savilleb564aae2014-10-23 10:18:09 -07001472 public int[] supplyPinReportResultForSubscriber(int subId, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001473 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001474
1475 final long identity = Binder.clearCallingIdentity();
1476 try {
1477 final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
1478 checkSimPin.start();
1479 return checkSimPin.unlockSim(null, pin);
1480 } finally {
1481 Binder.restoreCallingIdentity(identity);
1482 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001483 }
1484
Wink Saville9de0f752013-10-22 19:04:03 -07001485 /** {@hide} */
1486 public int[] supplyPukReportResult(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001487 return supplyPukReportResultForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001488 }
1489
Wink Savilleb564aae2014-10-23 10:18:09 -07001490 public int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001491 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001492
1493 final long identity = Binder.clearCallingIdentity();
1494 try {
1495 final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
1496 checkSimPuk.start();
1497 return checkSimPuk.unlockSim(puk, pin);
1498 } finally {
1499 Binder.restoreCallingIdentity(identity);
1500 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001501 }
1502
1503 /**
Wink Saville9de0f752013-10-22 19:04:03 -07001504 * Helper thread to turn async call to SimCard#supplyPin into
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001505 * a synchronous one.
1506 */
1507 private static class UnlockSim extends Thread {
1508
1509 private final IccCard mSimCard;
1510
1511 private boolean mDone = false;
Wink Saville9de0f752013-10-22 19:04:03 -07001512 private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1513 private int mRetryCount = -1;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001514
1515 // For replies from SimCard interface
1516 private Handler mHandler;
1517
1518 // For async handler to identify request type
1519 private static final int SUPPLY_PIN_COMPLETE = 100;
1520
1521 public UnlockSim(IccCard simCard) {
1522 mSimCard = simCard;
1523 }
1524
1525 @Override
1526 public void run() {
1527 Looper.prepare();
1528 synchronized (UnlockSim.this) {
1529 mHandler = new Handler() {
1530 @Override
1531 public void handleMessage(Message msg) {
1532 AsyncResult ar = (AsyncResult) msg.obj;
1533 switch (msg.what) {
1534 case SUPPLY_PIN_COMPLETE:
1535 Log.d(LOG_TAG, "SUPPLY_PIN_COMPLETE");
1536 synchronized (UnlockSim.this) {
Wink Saville9de0f752013-10-22 19:04:03 -07001537 mRetryCount = msg.arg1;
1538 if (ar.exception != null) {
1539 if (ar.exception instanceof CommandException &&
1540 ((CommandException)(ar.exception)).getCommandError()
1541 == CommandException.Error.PASSWORD_INCORRECT) {
1542 mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1543 } else {
1544 mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1545 }
1546 } else {
1547 mResult = PhoneConstants.PIN_RESULT_SUCCESS;
1548 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001549 mDone = true;
1550 UnlockSim.this.notifyAll();
1551 }
1552 break;
1553 }
1554 }
1555 };
1556 UnlockSim.this.notifyAll();
1557 }
1558 Looper.loop();
1559 }
1560
1561 /*
1562 * Use PIN or PUK to unlock SIM card
1563 *
1564 * If PUK is null, unlock SIM card with PIN
1565 *
1566 * If PUK is not null, unlock SIM card with PUK and set PIN code
1567 */
Wink Saville9de0f752013-10-22 19:04:03 -07001568 synchronized int[] unlockSim(String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001569
1570 while (mHandler == null) {
1571 try {
1572 wait();
1573 } catch (InterruptedException e) {
1574 Thread.currentThread().interrupt();
1575 }
1576 }
1577 Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
1578
1579 if (puk == null) {
1580 mSimCard.supplyPin(pin, callback);
1581 } else {
1582 mSimCard.supplyPuk(puk, pin, callback);
1583 }
1584
1585 while (!mDone) {
1586 try {
1587 Log.d(LOG_TAG, "wait for done");
1588 wait();
1589 } catch (InterruptedException e) {
1590 // Restore the interrupted status
1591 Thread.currentThread().interrupt();
1592 }
1593 }
1594 Log.d(LOG_TAG, "done");
Wink Saville9de0f752013-10-22 19:04:03 -07001595 int[] resultArray = new int[2];
1596 resultArray[0] = mResult;
1597 resultArray[1] = mRetryCount;
1598 return resultArray;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001599 }
1600 }
1601
1602 public void updateServiceLocation() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001603 updateServiceLocationForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001604
1605 }
1606
Wink Savilleb564aae2014-10-23 10:18:09 -07001607 public void updateServiceLocationForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001608 // No permission check needed here: this call is harmless, and it's
1609 // needed for the ServiceState.requestStateUpdate() call (which is
1610 // already intentionally exposed to 3rd parties.)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001611 final long identity = Binder.clearCallingIdentity();
1612 try {
1613 final Phone phone = getPhone(subId);
1614 if (phone != null) {
1615 phone.updateServiceLocation();
1616 }
1617 } finally {
1618 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001619 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001620 }
1621
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001622 @Override
1623 public boolean isRadioOn(String callingPackage) {
1624 return isRadioOnForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001625 }
1626
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001627 @Override
1628 public boolean isRadioOnForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08001629 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08001630 mApp, subId, callingPackage, "isRadioOnForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001631 return false;
1632 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001633
1634 final long identity = Binder.clearCallingIdentity();
1635 try {
1636 return isRadioOnForSubscriber(subId);
1637 } finally {
1638 Binder.restoreCallingIdentity(identity);
1639 }
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001640 }
1641
1642 private boolean isRadioOnForSubscriber(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001643 final long identity = Binder.clearCallingIdentity();
1644 try {
1645 final Phone phone = getPhone(subId);
1646 if (phone != null) {
1647 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
1648 } else {
1649 return false;
1650 }
1651 } finally {
1652 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001653 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001654 }
1655
1656 public void toggleRadioOnOff() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001657 toggleRadioOnOffForSubscriber(getDefaultSubscription());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001658 }
Wink Saville36469e72014-06-11 15:17:00 -07001659
Wink Savilleb564aae2014-10-23 10:18:09 -07001660 public void toggleRadioOnOffForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001661 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001662
1663 final long identity = Binder.clearCallingIdentity();
1664 try {
1665 final Phone phone = getPhone(subId);
1666 if (phone != null) {
1667 phone.setRadioPower(!isRadioOnForSubscriber(subId));
1668 }
1669 } finally {
1670 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001671 }
Wink Saville36469e72014-06-11 15:17:00 -07001672 }
1673
1674 public boolean setRadio(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001675 return setRadioForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001676 }
1677
Wink Savilleb564aae2014-10-23 10:18:09 -07001678 public boolean setRadioForSubscriber(int subId, boolean turnOn) {
Wink Saville36469e72014-06-11 15:17:00 -07001679 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001680
1681 final long identity = Binder.clearCallingIdentity();
1682 try {
1683 final Phone phone = getPhone(subId);
1684 if (phone == null) {
1685 return false;
1686 }
1687 if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
1688 toggleRadioOnOffForSubscriber(subId);
1689 }
1690 return true;
1691 } finally {
1692 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001693 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001694 }
Wink Saville36469e72014-06-11 15:17:00 -07001695
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001696 public boolean needMobileRadioShutdown() {
1697 /*
1698 * If any of the Radios are available, it will need to be
1699 * shutdown. So return true if any Radio is available.
1700 */
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001701 final long identity = Binder.clearCallingIdentity();
1702 try {
1703 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1704 Phone phone = PhoneFactory.getPhone(i);
1705 if (phone != null && phone.isRadioAvailable()) return true;
1706 }
1707 logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
1708 return false;
1709 } finally {
1710 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001711 }
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001712 }
1713
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001714 @Override
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001715 public void shutdownMobileRadios() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001716 enforceModifyPermission();
1717
1718 final long identity = Binder.clearCallingIdentity();
1719 try {
1720 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1721 logv("Shutting down Phone " + i);
1722 shutdownRadioUsingPhoneId(i);
1723 }
1724 } finally {
1725 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001726 }
1727 }
1728
1729 private void shutdownRadioUsingPhoneId(int phoneId) {
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001730 Phone phone = PhoneFactory.getPhone(phoneId);
1731 if (phone != null && phone.isRadioAvailable()) {
1732 phone.shutdownRadio();
1733 }
1734 }
1735
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001736 public boolean setRadioPower(boolean turnOn) {
Jack Yub4e16162017-05-15 12:48:40 -07001737 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001738
1739 final long identity = Binder.clearCallingIdentity();
1740 try {
1741 final Phone defaultPhone = PhoneFactory.getDefaultPhone();
1742 if (defaultPhone != null) {
1743 defaultPhone.setRadioPower(turnOn);
1744 return true;
1745 } else {
1746 loge("There's no default phone.");
1747 return false;
1748 }
1749 } finally {
1750 Binder.restoreCallingIdentity(identity);
Wei Liu9ae2a062016-08-08 11:09:34 -07001751 }
Wink Saville36469e72014-06-11 15:17:00 -07001752 }
1753
Wink Savilleb564aae2014-10-23 10:18:09 -07001754 public boolean setRadioPowerForSubscriber(int subId, boolean turnOn) {
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(turnOn);
1762 return true;
1763 } else {
1764 return false;
1765 }
1766 } finally {
1767 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001768 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001769 }
1770
Wink Saville36469e72014-06-11 15:17:00 -07001771 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001772 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001773 public boolean enableDataConnectivity() {
1774 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001775
1776 final long identity = Binder.clearCallingIdentity();
1777 try {
1778 int subId = mSubscriptionController.getDefaultDataSubId();
1779 final Phone phone = getPhone(subId);
1780 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001781 phone.getDataEnabledSettings().setUserDataEnabled(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001782 return true;
1783 } else {
1784 return false;
1785 }
1786 } finally {
1787 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001788 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001789 }
1790
Wink Saville36469e72014-06-11 15:17:00 -07001791 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001792 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001793 public boolean disableDataConnectivity() {
1794 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001795
1796 final long identity = Binder.clearCallingIdentity();
1797 try {
1798 int subId = mSubscriptionController.getDefaultDataSubId();
1799 final Phone phone = getPhone(subId);
1800 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001801 phone.getDataEnabledSettings().setUserDataEnabled(false);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001802 return true;
1803 } else {
1804 return false;
1805 }
1806 } finally {
1807 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001808 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001809 }
1810
Sanket Padawe356d7632015-06-22 14:03:32 -07001811 @Override
Jack Yuacf8a132017-05-01 17:00:48 -07001812 public boolean isDataConnectivityPossible(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001813 final long identity = Binder.clearCallingIdentity();
1814 try {
1815 final Phone phone = getPhone(subId);
1816 if (phone != null) {
Jack Yub5d8f642018-11-26 11:20:48 -08001817 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001818 } else {
1819 return false;
1820 }
1821 } finally {
1822 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001823 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001824 }
1825
1826 public boolean handlePinMmi(String dialString) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001827 return handlePinMmiForSubscriber(getDefaultSubscription(), dialString);
Wink Saville36469e72014-06-11 15:17:00 -07001828 }
1829
pkanwarae03a6b2016-11-06 20:37:09 -08001830 public void handleUssdRequest(int subId, String ussdRequest, ResultReceiver wrappedCallback) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001831 enforceCallPermission();
1832
1833 final long identity = Binder.clearCallingIdentity();
1834 try {
1835 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1836 return;
1837 }
1838 Pair<String, ResultReceiver> ussdObject = new Pair(ussdRequest, wrappedCallback);
1839 sendRequest(CMD_HANDLE_USSD_REQUEST, ussdObject, subId);
1840 } finally {
1841 Binder.restoreCallingIdentity(identity);
1842 }
pkanwar32d516d2016-10-14 19:37:38 -07001843 };
1844
Wink Savilleb564aae2014-10-23 10:18:09 -07001845 public boolean handlePinMmiForSubscriber(int subId, String dialString) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001846 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001847
1848 final long identity = Binder.clearCallingIdentity();
1849 try {
1850 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1851 return false;
1852 }
1853 return (Boolean) sendRequest(CMD_HANDLE_PIN_MMI, dialString, subId);
1854 } finally {
1855 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001856 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001857 }
1858
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001859 public int getCallState() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001860 return getCallStateForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001861 }
1862
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001863 public int getCallStateForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001864 final long identity = Binder.clearCallingIdentity();
1865 try {
1866 Phone phone = PhoneFactory.getPhone(slotIndex);
1867 return phone == null ? TelephonyManager.CALL_STATE_IDLE :
1868 PhoneConstantConversions.convertCallState(phone.getState());
1869 } finally {
1870 Binder.restoreCallingIdentity(identity);
1871 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001872 }
1873
Sanket Padawe356d7632015-06-22 14:03:32 -07001874 @Override
Nathan Harolde037c472019-06-26 00:41:07 +00001875 public int getDataState() {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001876 return getDataStateForSubId(mSubscriptionController.getDefaultDataSubId());
1877 }
1878
1879 @Override
1880 public int getDataStateForSubId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001881 final long identity = Binder.clearCallingIdentity();
1882 try {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001883 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001884 if (phone != null) {
1885 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
1886 } else {
1887 return PhoneConstantConversions.convertDataState(
1888 PhoneConstants.DataState.DISCONNECTED);
1889 }
1890 } finally {
1891 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001892 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001893 }
1894
Sanket Padawe356d7632015-06-22 14:03:32 -07001895 @Override
Nathan Harolde037c472019-06-26 00:41:07 +00001896 public int getDataActivity() {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001897 return getDataActivityForSubId(mSubscriptionController.getDefaultDataSubId());
1898 }
1899
1900 @Override
1901 public int getDataActivityForSubId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001902 final long identity = Binder.clearCallingIdentity();
1903 try {
Nathan Haroldc4689b12019-06-14 16:58:30 -07001904 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001905 if (phone != null) {
1906 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
1907 } else {
1908 return TelephonyManager.DATA_ACTIVITY_NONE;
1909 }
1910 } finally {
1911 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001912 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001913 }
1914
1915 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001916 public Bundle getCellLocation(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001917 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08001918 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08001919
1920 LocationAccessPolicy.LocationPermissionResult locationResult =
1921 LocationAccessPolicy.checkLocationPermission(mApp,
1922 new LocationAccessPolicy.LocationPermissionQuery.Builder()
1923 .setCallingPackage(callingPackage)
1924 .setCallingPid(Binder.getCallingPid())
1925 .setCallingUid(Binder.getCallingUid())
1926 .setMethod("getCellLocation")
1927 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
1928 .build());
1929 switch (locationResult) {
1930 case DENIED_HARD:
1931 throw new SecurityException("Not allowed to access cell location");
1932 case DENIED_SOFT:
1933 return new Bundle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001934 }
1935
Narayan Kamathf04b5a12018-01-09 11:47:15 +00001936 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001937 final long identity = Binder.clearCallingIdentity();
1938 try {
1939 if (DBG_LOC) log("getCellLocation: is active user");
1940 Bundle data = new Bundle();
Nathan Harold3ff88932018-08-14 10:19:49 -07001941 int subId = mSubscriptionController.getDefaultDataSubId();
1942 CellLocation cl = (CellLocation) sendRequest(CMD_GET_CELL_LOCATION, workSource, subId);
1943 cl.fillInNotifierBundle(data);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001944 return data;
1945 } finally {
1946 Binder.restoreCallingIdentity(identity);
1947 }
Svetoslav64fad262015-04-14 14:35:21 -07001948 }
1949
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001950 @Override
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001951 public String getNetworkCountryIsoForPhone(int phoneId) {
1952 // Reporting the correct network country is ambiguous when IWLAN could conflict with
1953 // registered cell info, so return a NULL country instead.
1954 final long identity = Binder.clearCallingIdentity();
1955 try {
Malcolm Chen3732c2b2018-07-18 20:15:24 -07001956 if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
1957 // Get default phone in this case.
1958 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
1959 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001960 final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
Jack Yu5f7092c2018-04-13 14:05:37 -07001961 // Todo: fix this when we can get the actual cellular network info when the device
1962 // is on IWLAN.
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001963 if (TelephonyManager.NETWORK_TYPE_IWLAN
1964 == getVoiceNetworkTypeForSubscriber(subId, mApp.getPackageName())) {
1965 return "";
1966 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001967 Phone phone = PhoneFactory.getPhone(phoneId);
1968 if (phone != null) {
1969 ServiceStateTracker sst = phone.getServiceStateTracker();
sqian1c069d02019-07-31 20:23:45 -07001970 EmergencyNumberTracker emergencyNumberTracker = phone.getEmergencyNumberTracker();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001971 if (sst != null) {
1972 LocaleTracker lt = sst.getLocaleTracker();
1973 if (lt != null) {
sqian1c069d02019-07-31 20:23:45 -07001974 if (!TextUtils.isEmpty(lt.getCurrentCountry())) {
1975 return lt.getCurrentCountry();
1976 } else if (emergencyNumberTracker != null) {
1977 return emergencyNumberTracker.getEmergencyCountryIso();
1978 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001979 }
1980 }
1981 }
1982 return "";
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001983 } finally {
1984 Binder.restoreCallingIdentity(identity);
1985 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001986 }
1987
1988 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001989 public void enableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001990 enableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001991 }
1992
Sanket Padawe356d7632015-06-22 14:03:32 -07001993 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001994 public void enableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001995 mApp.enforceCallingOrSelfPermission(
1996 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001997
1998 final long identity = Binder.clearCallingIdentity();
1999 try {
2000 final Phone phone = getPhone(subId);
2001 if (phone != null) {
2002 phone.enableLocationUpdates();
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
2010 public void disableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07002011 disableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002012 }
2013
Sanket Padawe356d7632015-06-22 14:03:32 -07002014 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002015 public void disableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002016 mApp.enforceCallingOrSelfPermission(
2017 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002018
2019 final long identity = Binder.clearCallingIdentity();
2020 try {
2021 final Phone phone = getPhone(subId);
2022 if (phone != null) {
2023 phone.disableLocationUpdates();
2024 }
2025 } finally {
2026 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002027 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002028 }
2029
Nathan Harold31d7ff32018-10-15 20:20:30 -07002030 /**
2031 * Returns the target SDK version number for a given package name.
2032 *
Nathan Haroldec184742019-07-10 17:04:16 -07002033 * This call MUST be invoked before clearing the calling UID.
2034 *
Nathan Harold31d7ff32018-10-15 20:20:30 -07002035 * @return target SDK if the package is found or INT_MAX.
2036 */
2037 private int getTargetSdk(String packageName) {
2038 try {
Nathan Haroldec184742019-07-10 17:04:16 -07002039 final ApplicationInfo ai = mApp.getPackageManager().getApplicationInfoAsUser(
2040 packageName, 0, UserHandle.getUserId(Binder.getCallingUid()));
Nathan Harold31d7ff32018-10-15 20:20:30 -07002041 if (ai != null) return ai.targetSdkVersion;
2042 } catch (PackageManager.NameNotFoundException unexpected) {
Nathan Haroldec184742019-07-10 17:04:16 -07002043 loge("Failed to get package info for pkg="
2044 + packageName + ", uid=" + Binder.getCallingUid());
Nathan Harold31d7ff32018-10-15 20:20:30 -07002045 }
2046 return Integer.MAX_VALUE;
2047 }
2048
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002049 @Override
2050 @SuppressWarnings("unchecked")
Nathan Harold31d7ff32018-10-15 20:20:30 -07002051 public List<NeighboringCellInfo> getNeighboringCellInfo(String callingPackage) {
2052 final int targetSdk = getTargetSdk(callingPackage);
Nathan Harolddbea45a2018-08-30 14:35:07 -07002053 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2054 throw new SecurityException(
2055 "getNeighboringCellInfo() is unavailable to callers targeting Q+ SDK levels.");
2056 }
Nathan Haroldb4d55612018-07-20 13:13:08 -07002057
Jordan Liu1617b712019-07-10 15:06:26 -07002058 if (mAppOps.noteOp(AppOpsManager.OPSTR_NEIGHBORING_CELLS, Binder.getCallingUid(),
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002059 callingPackage) != AppOpsManager.MODE_ALLOWED) {
2060 return null;
2061 }
Svetoslav64fad262015-04-14 14:35:21 -07002062
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002063 if (DBG_LOC) log("getNeighboringCellInfo: is active user");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002064
Nathan Haroldf180aac2018-06-01 18:43:55 -07002065 List<CellInfo> info = getAllCellInfo(callingPackage);
2066 if (info == null) return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002067
Nathan Haroldf180aac2018-06-01 18:43:55 -07002068 List<NeighboringCellInfo> neighbors = new ArrayList<NeighboringCellInfo>();
2069 for (CellInfo ci : info) {
2070 if (ci instanceof CellInfoGsm) {
2071 neighbors.add(new NeighboringCellInfo((CellInfoGsm) ci));
2072 } else if (ci instanceof CellInfoWcdma) {
2073 neighbors.add(new NeighboringCellInfo((CellInfoWcdma) ci));
2074 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002075 }
Nathan Haroldf180aac2018-06-01 18:43:55 -07002076 return (neighbors.size()) > 0 ? neighbors : null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002077 }
2078
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002079 private List<CellInfo> getCachedCellInfo() {
2080 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2081 for (Phone phone : PhoneFactory.getPhones()) {
2082 List<CellInfo> info = phone.getAllCellInfo();
2083 if (info != null) cellInfos.addAll(info);
2084 }
2085 return cellInfos;
2086 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002087
2088 @Override
Svetoslav64fad262015-04-14 14:35:21 -07002089 public List<CellInfo> getAllCellInfo(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002090 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08002091 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002092
2093 LocationAccessPolicy.LocationPermissionResult locationResult =
2094 LocationAccessPolicy.checkLocationPermission(mApp,
2095 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2096 .setCallingPackage(callingPackage)
2097 .setCallingPid(Binder.getCallingPid())
2098 .setCallingUid(Binder.getCallingUid())
2099 .setMethod("getAllCellInfo")
Nathan Harold5ae50b52019-02-20 15:46:36 -08002100 .setMinSdkVersionForCoarse(Build.VERSION_CODES.BASE)
Hall Liuf19c44f2018-11-27 14:38:17 -08002101 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2102 .build());
2103 switch (locationResult) {
2104 case DENIED_HARD:
2105 throw new SecurityException("Not allowed to access cell info");
2106 case DENIED_SOFT:
2107 return new ArrayList<>();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002108 }
2109
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002110 final int targetSdk = getTargetSdk(callingPackage);
2111 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2112 return getCachedCellInfo();
2113 }
2114
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002115 if (DBG_LOC) log("getAllCellInfo: is active user");
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002116 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002117 final long identity = Binder.clearCallingIdentity();
2118 try {
2119 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2120 for (Phone phone : PhoneFactory.getPhones()) {
Nathan Harold3ff88932018-08-14 10:19:49 -07002121 final List<CellInfo> info = (List<CellInfo>) sendRequest(
Nathan Harold92bed182018-10-12 18:16:49 -07002122 CMD_GET_ALL_CELL_INFO, null, phone, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002123 if (info != null) cellInfos.addAll(info);
2124 }
2125 return cellInfos;
2126 } finally {
2127 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002128 }
2129 }
2130
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07002131 @Override
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002132 public void requestCellInfoUpdate(int subId, ICellInfoCallback cb, String callingPackage) {
2133 requestCellInfoUpdateInternal(
2134 subId, cb, callingPackage, getWorkSource(Binder.getCallingUid()));
2135 }
2136
2137 @Override
2138 public void requestCellInfoUpdateWithWorkSource(
2139 int subId, ICellInfoCallback cb, String callingPackage, WorkSource workSource) {
2140 enforceModifyPermission();
2141 requestCellInfoUpdateInternal(subId, cb, callingPackage, workSource);
2142 }
2143
2144 private void requestCellInfoUpdateInternal(
2145 int subId, ICellInfoCallback cb, String callingPackage, WorkSource workSource) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002146 mApp.getSystemService(AppOpsManager.class)
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002147 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002148
2149 LocationAccessPolicy.LocationPermissionResult locationResult =
2150 LocationAccessPolicy.checkLocationPermission(mApp,
2151 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2152 .setCallingPackage(callingPackage)
2153 .setCallingPid(Binder.getCallingPid())
2154 .setCallingUid(Binder.getCallingUid())
2155 .setMethod("requestCellInfoUpdate")
2156 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2157 .build());
2158 switch (locationResult) {
2159 case DENIED_HARD:
2160 throw new SecurityException("Not allowed to access cell info");
2161 case DENIED_SOFT:
Nathan Harold5320c422019-05-09 10:26:08 -07002162 try {
2163 cb.onCellInfo(new ArrayList<CellInfo>());
2164 } catch (RemoteException re) {
2165 // Drop without consequences
2166 }
Hall Liuf19c44f2018-11-27 14:38:17 -08002167 return;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002168 }
2169
Nathan Harolda939a962019-05-09 10:13:47 -07002170
2171 final Phone phone = getPhoneFromSubId(subId);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002172 if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
2173
2174 sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
2175 }
2176
2177 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002178 public void setCellInfoListRate(int rateInMillis) {
Jack Yua8d8cb82017-01-16 10:15:34 -08002179 enforceModifyPermission();
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002180 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002181
2182 final long identity = Binder.clearCallingIdentity();
2183 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002184 getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002185 } finally {
2186 Binder.restoreCallingIdentity(identity);
2187 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002188 }
2189
Shishir Agrawala9f32182016-04-12 12:00:16 -07002190 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002191 public String getImeiForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002192 Phone phone = PhoneFactory.getPhone(slotIndex);
2193 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002194 return null;
2195 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002196 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002197 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
2198 callingPackage, "getImeiForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002199 return null;
2200 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002201
2202 final long identity = Binder.clearCallingIdentity();
2203 try {
2204 return phone.getImei();
2205 } finally {
2206 Binder.restoreCallingIdentity(identity);
2207 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002208 }
2209
2210 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002211 public String getTypeAllocationCodeForSlot(int slotIndex) {
2212 Phone phone = PhoneFactory.getPhone(slotIndex);
2213 String tac = null;
2214 if (phone != null) {
2215 String imei = phone.getImei();
2216 tac = imei == null ? null : imei.substring(0, TYPE_ALLOCATION_CODE_LENGTH);
2217 }
2218 return tac;
2219 }
2220
2221 @Override
Jack Yu2af8d712017-03-15 17:14:14 -07002222 public String getMeidForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002223 Phone phone = PhoneFactory.getPhone(slotIndex);
2224 if (phone == null) {
Jack Yu2af8d712017-03-15 17:14:14 -07002225 return null;
2226 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002227
Jeff Davidson913390f2018-02-23 17:11:49 -08002228 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002229 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
2230 callingPackage, "getMeidForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002231 return null;
2232 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002233
2234 final long identity = Binder.clearCallingIdentity();
2235 try {
2236 return phone.getMeid();
2237 } finally {
2238 Binder.restoreCallingIdentity(identity);
2239 }
Jack Yu2af8d712017-03-15 17:14:14 -07002240 }
2241
2242 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002243 public String getManufacturerCodeForSlot(int slotIndex) {
2244 Phone phone = PhoneFactory.getPhone(slotIndex);
2245 String manufacturerCode = null;
2246 if (phone != null) {
2247 String meid = phone.getMeid();
2248 manufacturerCode = meid == null ? null : meid.substring(0, MANUFACTURER_CODE_LENGTH);
2249 }
2250 return manufacturerCode;
2251 }
2252
2253 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002254 public String getDeviceSoftwareVersionForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002255 Phone phone = PhoneFactory.getPhone(slotIndex);
2256 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002257 return null;
2258 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002259 int subId = phone.getSubId();
2260 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2261 mApp, subId, callingPackage, "getDeviceSoftwareVersionForSlot")) {
2262 return null;
2263 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002264
2265 final long identity = Binder.clearCallingIdentity();
2266 try {
2267 return phone.getDeviceSvn();
2268 } finally {
2269 Binder.restoreCallingIdentity(identity);
2270 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002271 }
2272
fionaxu43304da2017-11-27 22:51:16 -08002273 @Override
2274 public int getSubscriptionCarrierId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002275 final long identity = Binder.clearCallingIdentity();
2276 try {
2277 final Phone phone = getPhone(subId);
2278 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
2279 } finally {
2280 Binder.restoreCallingIdentity(identity);
2281 }
fionaxu43304da2017-11-27 22:51:16 -08002282 }
2283
2284 @Override
2285 public String getSubscriptionCarrierName(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002286 final long identity = Binder.clearCallingIdentity();
2287 try {
2288 final Phone phone = getPhone(subId);
2289 return phone == null ? null : phone.getCarrierName();
2290 } finally {
2291 Binder.restoreCallingIdentity(identity);
2292 }
fionaxu43304da2017-11-27 22:51:16 -08002293 }
2294
calvinpanffe225e2018-11-01 19:43:06 +08002295 @Override
chen xu0026ca62019-03-06 15:28:50 -08002296 public int getSubscriptionSpecificCarrierId(int subId) {
chen xu25637222018-11-04 17:17:00 -08002297 final long identity = Binder.clearCallingIdentity();
2298 try {
2299 final Phone phone = getPhone(subId);
2300 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
chen xu0026ca62019-03-06 15:28:50 -08002301 : phone.getSpecificCarrierId();
chen xu25637222018-11-04 17:17:00 -08002302 } finally {
2303 Binder.restoreCallingIdentity(identity);
2304 }
2305 }
2306
2307 @Override
chen xu0026ca62019-03-06 15:28:50 -08002308 public String getSubscriptionSpecificCarrierName(int subId) {
chen xu25637222018-11-04 17:17:00 -08002309 final long identity = Binder.clearCallingIdentity();
2310 try {
2311 final Phone phone = getPhone(subId);
chen xu0026ca62019-03-06 15:28:50 -08002312 return phone == null ? null : phone.getSpecificCarrierName();
chen xu25637222018-11-04 17:17:00 -08002313 } finally {
2314 Binder.restoreCallingIdentity(identity);
2315 }
2316 }
2317
chen xu651eec72018-11-11 19:03:44 -08002318 @Override
chen xu864e11c2018-12-06 22:10:03 -08002319 public int getCarrierIdFromMccMnc(int slotIndex, String mccmnc, boolean isSubscriptionMccMnc) {
2320 if (!isSubscriptionMccMnc) {
2321 enforceReadPrivilegedPermission("getCarrierIdFromMccMnc");
2322 }
chen xu651eec72018-11-11 19:03:44 -08002323 final Phone phone = PhoneFactory.getPhone(slotIndex);
2324 if (phone == null) {
2325 return TelephonyManager.UNKNOWN_CARRIER_ID;
2326 }
2327 final long identity = Binder.clearCallingIdentity();
2328 try {
2329 return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
2330 } finally {
2331 Binder.restoreCallingIdentity(identity);
2332 }
2333 }
2334
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002335 //
2336 // Internal helper methods.
2337 //
2338
Sanket Padaweee13a9b2016-03-08 17:30:28 -08002339 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002340 * Make sure the caller has the MODIFY_PHONE_STATE permission.
2341 *
2342 * @throws SecurityException if the caller does not have the required permission
2343 */
2344 private void enforceModifyPermission() {
2345 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
2346 }
2347
2348 /**
2349 * Make sure the caller has the CALL_PHONE permission.
2350 *
2351 * @throws SecurityException if the caller does not have the required permission
2352 */
2353 private void enforceCallPermission() {
2354 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
2355 }
2356
Stuart Scott8eef64f2015-04-08 15:13:54 -07002357 private void enforceConnectivityInternalPermission() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002358 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL,
Stuart Scott8eef64f2015-04-08 15:13:54 -07002359 "ConnectivityService");
2360 }
2361
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002362 private String createTelUrl(String number) {
2363 if (TextUtils.isEmpty(number)) {
2364 return null;
2365 }
2366
Jake Hambye994d462014-02-03 13:10:13 -08002367 return "tel:" + number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002368 }
2369
Ihab Awadf9e92732013-12-05 18:02:52 -08002370 private static void log(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002371 Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
2372 }
2373
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07002374 private static void logv(String msg) {
2375 Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
2376 }
2377
Ihab Awadf9e92732013-12-05 18:02:52 -08002378 private static void loge(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002379 Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
2380 }
2381
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002382 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002383 public int getActivePhoneType() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07002384 return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002385 }
2386
Sanket Padawe356d7632015-06-22 14:03:32 -07002387 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002388 public int getActivePhoneTypeForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002389 final long identity = Binder.clearCallingIdentity();
2390 try {
2391 final Phone phone = PhoneFactory.getPhone(slotIndex);
2392 if (phone == null) {
2393 return PhoneConstants.PHONE_TYPE_NONE;
2394 } else {
2395 return phone.getPhoneType();
2396 }
2397 } finally {
2398 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002399 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002400 }
2401
2402 /**
2403 * Returns the CDMA ERI icon index to display
2404 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002405 @Override
2406 public int getCdmaEriIconIndex(String callingPackage) {
2407 return getCdmaEriIconIndexForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002408 }
2409
Sanket Padawe356d7632015-06-22 14:03:32 -07002410 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002411 public int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002412 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002413 mApp, subId, callingPackage, "getCdmaEriIconIndexForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002414 return -1;
2415 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002416
2417 final long identity = Binder.clearCallingIdentity();
2418 try {
2419 final Phone phone = getPhone(subId);
2420 if (phone != null) {
2421 return phone.getCdmaEriIconIndex();
2422 } else {
2423 return -1;
2424 }
2425 } finally {
2426 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002427 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002428 }
2429
2430 /**
2431 * Returns the CDMA ERI icon mode,
2432 * 0 - ON
2433 * 1 - FLASHING
2434 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002435 @Override
2436 public int getCdmaEriIconMode(String callingPackage) {
2437 return getCdmaEriIconModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002438 }
2439
Sanket Padawe356d7632015-06-22 14:03:32 -07002440 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002441 public int getCdmaEriIconModeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002442 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002443 mApp, subId, callingPackage, "getCdmaEriIconModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002444 return -1;
2445 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002446
2447 final long identity = Binder.clearCallingIdentity();
2448 try {
2449 final Phone phone = getPhone(subId);
2450 if (phone != null) {
2451 return phone.getCdmaEriIconMode();
2452 } else {
2453 return -1;
2454 }
2455 } finally {
2456 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002457 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002458 }
2459
2460 /**
2461 * Returns the CDMA ERI text,
2462 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002463 @Override
2464 public String getCdmaEriText(String callingPackage) {
2465 return getCdmaEriTextForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002466 }
2467
Sanket Padawe356d7632015-06-22 14:03:32 -07002468 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002469 public String getCdmaEriTextForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002470 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002471 mApp, subId, callingPackage, "getCdmaEriIconTextForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002472 return null;
2473 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002474
2475 final long identity = Binder.clearCallingIdentity();
2476 try {
2477 final Phone phone = getPhone(subId);
2478 if (phone != null) {
2479 return phone.getCdmaEriText();
2480 } else {
2481 return null;
2482 }
2483 } finally {
2484 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002485 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002486 }
2487
2488 /**
Junda Liuca05d5d2014-08-14 22:36:34 -07002489 * Returns the CDMA MDN.
2490 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002491 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002492 public String getCdmaMdn(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002493 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2494 mApp, subId, "getCdmaMdn");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002495
2496 final long identity = Binder.clearCallingIdentity();
2497 try {
2498 final Phone phone = getPhone(subId);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002499 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002500 return phone.getLine1Number();
2501 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002502 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002503 return null;
2504 }
2505 } finally {
2506 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002507 }
2508 }
2509
2510 /**
2511 * Returns the CDMA MIN.
2512 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002513 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002514 public String getCdmaMin(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002515 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2516 mApp, subId, "getCdmaMin");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002517
2518 final long identity = Binder.clearCallingIdentity();
2519 try {
2520 final Phone phone = getPhone(subId);
2521 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2522 return phone.getCdmaMin();
2523 } else {
2524 return null;
2525 }
2526 } finally {
2527 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002528 }
2529 }
2530
Hall Liud892bec2018-11-30 14:51:45 -08002531 @Override
2532 public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
2533 INumberVerificationCallback callback, String callingPackage) {
2534 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
2535 != PERMISSION_GRANTED) {
2536 throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
2537 }
2538 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2539
2540 String authorizedPackage = NumberVerificationManager.getAuthorizedPackage(mApp);
2541 if (!TextUtils.equals(callingPackage, authorizedPackage)) {
2542 throw new SecurityException("Calling package must be configured in the device config");
2543 }
2544
2545 if (range == null) {
2546 throw new NullPointerException("Range must be non-null");
2547 }
2548
2549 timeoutMillis = Math.min(timeoutMillis,
Hall Liubd069e32019-02-28 18:56:30 -08002550 TelephonyManager.getMaxNumberVerificationTimeoutMillis());
Hall Liud892bec2018-11-30 14:51:45 -08002551
2552 NumberVerificationManager.getInstance().requestVerification(range, callback, timeoutMillis);
2553 }
2554
Junda Liuca05d5d2014-08-14 22:36:34 -07002555 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002556 * Returns true if CDMA provisioning needs to run.
2557 */
2558 public boolean needsOtaServiceProvisioning() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002559 final long identity = Binder.clearCallingIdentity();
2560 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002561 return getDefaultPhone().needsOtaServiceProvisioning();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002562 } finally {
2563 Binder.restoreCallingIdentity(identity);
2564 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002565 }
2566
2567 /**
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002568 * Sets the voice mail number of a given subId.
2569 */
2570 @Override
2571 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002572 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setVoiceMailNumber");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002573
2574 final long identity = Binder.clearCallingIdentity();
2575 try {
2576 Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
2577 new Pair<String, String>(alphaTag, number), new Integer(subId));
2578 return success;
2579 } finally {
2580 Binder.restoreCallingIdentity(identity);
2581 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002582 }
2583
Ta-wei Yen87c49842016-05-13 21:19:52 -07002584 @Override
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002585 public Bundle getVisualVoicemailSettings(String callingPackage, int subId) {
2586 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002587 String systemDialer = TelecomManager.from(mApp).getSystemDialerPackage();
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002588 if (!TextUtils.equals(callingPackage, systemDialer)) {
2589 throw new SecurityException("caller must be system dialer");
2590 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002591
2592 final long identity = Binder.clearCallingIdentity();
2593 try {
2594 PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
2595 if (phoneAccountHandle == null) {
2596 return null;
2597 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002598 return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002599 } finally {
2600 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002601 }
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002602 }
2603
2604 @Override
Ta-wei Yen409ac562017-03-06 16:00:44 -08002605 public String getVisualVoicemailPackageName(String callingPackage, int subId) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002606 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jeff Davidson7e17e312018-02-13 18:17:36 -08002607 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002608 mApp, subId, callingPackage, "getVisualVoicemailPackageName")) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002609 return null;
2610 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002611
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002612 final long identity = Binder.clearCallingIdentity();
2613 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002614 return RemoteVvmTaskManager.getRemotePackage(mApp, subId).getPackageName();
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002615 } finally {
2616 Binder.restoreCallingIdentity(identity);
2617 }
Ta-wei Yendca928f2017-01-10 16:17:08 -08002618 }
2619
2620 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002621 public void enableVisualVoicemailSmsFilter(String callingPackage, int subId,
2622 VisualVoicemailSmsFilterSettings settings) {
2623 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002624
2625 final long identity = Binder.clearCallingIdentity();
2626 try {
2627 VisualVoicemailSmsFilterConfig.enableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002628 mApp, callingPackage, subId, settings);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002629 } finally {
2630 Binder.restoreCallingIdentity(identity);
2631 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002632 }
2633
2634 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002635 public void disableVisualVoicemailSmsFilter(String callingPackage, int subId) {
2636 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002637
2638 final long identity = Binder.clearCallingIdentity();
2639 try {
2640 VisualVoicemailSmsFilterConfig.disableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002641 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002642 } finally {
2643 Binder.restoreCallingIdentity(identity);
2644 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002645 }
2646
2647 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002648 public VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(
2649 String callingPackage, int subId) {
2650 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002651
2652 final long identity = Binder.clearCallingIdentity();
2653 try {
2654 return VisualVoicemailSmsFilterConfig.getVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002655 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002656 } finally {
2657 Binder.restoreCallingIdentity(identity);
2658 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002659 }
2660
2661 @Override
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002662 public VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002663 enforceReadPrivilegedPermission("getActiveVisualVoicemailSmsFilterSettings");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002664
2665 final long identity = Binder.clearCallingIdentity();
2666 try {
2667 return VisualVoicemailSmsFilterConfig.getActiveVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002668 mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002669 } finally {
2670 Binder.restoreCallingIdentity(identity);
2671 }
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002672 }
2673
2674 @Override
2675 public void sendVisualVoicemailSmsForSubscriber(String callingPackage, int subId,
2676 String number, int port, String text, PendingIntent sentIntent) {
2677 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen527a9c02017-01-06 15:29:25 -08002678 enforceVisualVoicemailPackage(callingPackage, subId);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002679 enforceSendSmsPermission();
Amit Mahajandccb3f12019-05-13 13:48:32 -07002680 SmsController smsController = PhoneFactory.getSmsController();
2681 smsController.sendVisualVoicemailSmsForSubscriber(callingPackage, subId, number, port, text,
2682 sentIntent);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002683 }
Amit Mahajandccb3f12019-05-13 13:48:32 -07002684
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002685 /**
fionaxu0152e512016-11-14 13:36:14 -08002686 * Sets the voice activation state of a given subId.
2687 */
2688 @Override
2689 public void setVoiceActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002690 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2691 mApp, subId, "setVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002692
2693 final long identity = Binder.clearCallingIdentity();
2694 try {
2695 final Phone phone = getPhone(subId);
2696 if (phone != null) {
2697 phone.setVoiceActivationState(activationState);
2698 } else {
2699 loge("setVoiceActivationState fails with invalid subId: " + subId);
2700 }
2701 } finally {
2702 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002703 }
2704 }
2705
2706 /**
2707 * Sets the data activation state of a given subId.
2708 */
2709 @Override
2710 public void setDataActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002711 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2712 mApp, subId, "setDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002713
2714 final long identity = Binder.clearCallingIdentity();
2715 try {
2716 final Phone phone = getPhone(subId);
2717 if (phone != null) {
2718 phone.setDataActivationState(activationState);
2719 } else {
2720 loge("setVoiceActivationState fails with invalid subId: " + subId);
2721 }
2722 } finally {
2723 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002724 }
2725 }
2726
2727 /**
2728 * Returns the voice activation state of a given subId.
2729 */
2730 @Override
2731 public int getVoiceActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002732 enforceReadPrivilegedPermission("getVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002733
fionaxu0152e512016-11-14 13:36:14 -08002734 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002735 final long identity = Binder.clearCallingIdentity();
2736 try {
2737 if (phone != null) {
2738 return phone.getVoiceActivationState();
2739 } else {
2740 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2741 }
2742 } finally {
2743 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002744 }
2745 }
2746
2747 /**
2748 * Returns the data activation state of a given subId.
2749 */
2750 @Override
2751 public int getDataActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002752 enforceReadPrivilegedPermission("getDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002753
fionaxu0152e512016-11-14 13:36:14 -08002754 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002755 final long identity = Binder.clearCallingIdentity();
2756 try {
2757 if (phone != null) {
2758 return phone.getDataActivationState();
2759 } else {
2760 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2761 }
2762 } finally {
2763 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002764 }
2765 }
2766
2767 /**
Wink Saville36469e72014-06-11 15:17:00 -07002768 * Returns the unread count of voicemails for a subId
2769 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002770 @Override
Brad Ebingerf7664ba2018-11-29 12:43:38 -08002771 public int getVoiceMessageCountForSubscriber(int subId, String callingPackage) {
2772 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2773 mApp, subId, callingPackage, "getVoiceMessageCountForSubscriber")) {
2774 return 0;
2775 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002776 final long identity = Binder.clearCallingIdentity();
2777 try {
2778 final Phone phone = getPhone(subId);
2779 if (phone != null) {
2780 return phone.getVoiceMessageCount();
2781 } else {
2782 return 0;
2783 }
2784 } finally {
2785 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002786 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002787 }
2788
2789 /**
pkanwar8a4dcfb2017-01-19 13:43:16 -08002790 * returns true, if the device is in a state where both voice and data
2791 * are supported simultaneously. This can change based on location or network condition.
2792 */
2793 @Override
2794 public boolean isConcurrentVoiceAndDataAllowed(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002795 final long identity = Binder.clearCallingIdentity();
2796 try {
2797 final Phone phone = getPhone(subId);
2798 return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
2799 } finally {
2800 Binder.restoreCallingIdentity(identity);
2801 }
pkanwar8a4dcfb2017-01-19 13:43:16 -08002802 }
2803
2804 /**
fionaxu235cc5e2017-03-06 22:25:57 -08002805 * Send the dialer code if called from the current default dialer or the caller has
2806 * carrier privilege.
2807 * @param inputCode The dialer code to send
2808 */
2809 @Override
2810 public void sendDialerSpecialCode(String callingPackage, String inputCode) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002811 final Phone defaultPhone = getDefaultPhone();
fionaxu235cc5e2017-03-06 22:25:57 -08002812 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002813 String defaultDialer = TelecomManager.from(defaultPhone.getContext())
2814 .getDefaultDialerPackage();
fionaxu235cc5e2017-03-06 22:25:57 -08002815 if (!TextUtils.equals(callingPackage, defaultDialer)) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002816 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
2817 getDefaultSubscription(), "sendDialerSpecialCode");
fionaxu235cc5e2017-03-06 22:25:57 -08002818 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002819
2820 final long identity = Binder.clearCallingIdentity();
2821 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002822 defaultPhone.sendDialerSpecialCode(inputCode);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002823 } finally {
2824 Binder.restoreCallingIdentity(identity);
2825 }
fionaxu235cc5e2017-03-06 22:25:57 -08002826 }
2827
Pengquan Menga1bb6272018-09-06 09:59:22 -07002828 @Override
2829 public int getNetworkSelectionMode(int subId) {
Pengquan Menge92a50d2018-09-21 15:54:48 -07002830 if (!isActiveSubscription(subId)) {
2831 return TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
2832 }
2833
Pengquan Menga1bb6272018-09-06 09:59:22 -07002834 return (int) sendRequest(CMD_GET_NETWORK_SELECTION_MODE, null /* argument */, subId);
2835 }
2836
Brad Ebinger35c841c2018-10-01 10:40:55 -07002837 @Override
Brad Ebingerb2b65522019-03-15 13:48:47 -07002838 public boolean isInEmergencySmsMode() {
2839 enforceReadPrivilegedPermission("isInEmergencySmsMode");
2840 final long identity = Binder.clearCallingIdentity();
2841 try {
2842 for (Phone phone : PhoneFactory.getPhones()) {
2843 if (phone.isInEmergencySmsMode()) {
2844 return true;
2845 }
2846 }
2847 } finally {
2848 Binder.restoreCallingIdentity(identity);
2849 }
2850 return false;
2851 }
2852
2853 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002854 public void registerImsRegistrationCallback(int subId, IImsRegistrationCallback c)
2855 throws RemoteException {
2856 enforceReadPrivilegedPermission("registerImsRegistrationCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002857 final long token = Binder.clearCallingIdentity();
2858 try {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002859 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002860 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002861 .addRegistrationCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002862 } catch (ImsException e) {
2863 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002864 } finally {
2865 Binder.restoreCallingIdentity(token);
2866 }
2867 }
2868
2869 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002870 public void unregisterImsRegistrationCallback(int subId, IImsRegistrationCallback c) {
2871 enforceReadPrivilegedPermission("unregisterImsRegistrationCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002872 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2873 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2874 }
2875 Binder.withCleanCallingIdentity(() -> {
2876 try {
2877 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002878 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002879 .removeRegistrationCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002880 } catch (ImsException e) {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002881 Log.i(LOG_TAG, "unregisterImsRegistrationCallback: " + subId
2882 + "is inactive, ignoring unregister.");
2883 // If the subscription is no longer active, just return, since the callback
2884 // will already have been removed internally.
2885 }
2886 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002887 }
2888
2889 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002890 public void registerMmTelCapabilityCallback(int subId, IImsCapabilityCallback c)
2891 throws RemoteException {
2892 enforceReadPrivilegedPermission("registerMmTelCapabilityCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002893 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2894 final long token = Binder.clearCallingIdentity();
2895 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002896 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002897 .addCapabilitiesCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002898 } catch (ImsException e) {
2899 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002900 } finally {
2901 Binder.restoreCallingIdentity(token);
2902 }
2903 }
2904
2905 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002906 public void unregisterMmTelCapabilityCallback(int subId, IImsCapabilityCallback c) {
2907 enforceReadPrivilegedPermission("unregisterMmTelCapabilityCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002908
2909 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2910 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2911 }
2912 Binder.withCleanCallingIdentity(() -> {
2913 try {
2914 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002915 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002916 .removeCapabilitiesCallbackForSubscription(c, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002917 } catch (ImsException e) {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002918 Log.i(LOG_TAG, "unregisterMmTelCapabilityCallback: " + subId
2919 + "is inactive, ignoring unregister.");
2920 // If the subscription is no longer active, just return, since the callback
2921 // will already have been removed internally.
2922 }
2923 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002924 }
2925
2926 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002927 public boolean isCapable(int subId, int capability, int regTech) {
2928 enforceReadPrivilegedPermission("isCapable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002929 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2930 final long token = Binder.clearCallingIdentity();
2931 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002932 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002933 getSlotIndexOrException(subId)).queryMmTelCapability(capability, regTech);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002934 } catch (com.android.ims.ImsException e) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002935 Log.w(LOG_TAG, "IMS isCapable - service unavailable: " + e.getMessage());
2936 return false;
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002937 } catch (ImsException e) {
Brad Ebinger6b5ac222019-02-04 14:36:52 -08002938 Log.i(LOG_TAG, "isCapable: " + subId + " is inactive, returning false.");
2939 return false;
Brad Ebinger35c841c2018-10-01 10:40:55 -07002940 } finally {
2941 Binder.restoreCallingIdentity(token);
2942 }
2943 }
2944
2945 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002946 public boolean isAvailable(int subId, int capability, int regTech) {
2947 enforceReadPrivilegedPermission("isAvailable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002948 final long token = Binder.clearCallingIdentity();
2949 try {
2950 Phone phone = getPhone(subId);
2951 if (phone == null) return false;
2952 return phone.isImsCapabilityAvailable(capability, regTech);
2953 } finally {
2954 Binder.restoreCallingIdentity(token);
2955 }
2956 }
2957
2958 @Override
2959 public boolean isAdvancedCallingSettingEnabled(int subId) {
2960 enforceReadPrivilegedPermission("enforceReadPrivilegedPermission");
2961 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2962 final long token = Binder.clearCallingIdentity();
2963 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002964 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002965 getSlotIndexOrException(subId)).isEnhanced4gLteModeSettingEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002966 } catch (ImsException e) {
2967 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002968 } finally {
2969 Binder.restoreCallingIdentity(token);
2970 }
2971 }
2972
2973 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08002974 public void setAdvancedCallingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002975 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08002976 "setAdvancedCallingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002977 final long identity = Binder.clearCallingIdentity();
2978 try {
2979 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002980 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002981 getSlotIndexOrException(subId)).setEnhanced4gLteModeSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002982 } catch (ImsException e) {
2983 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002984 } finally {
2985 Binder.restoreCallingIdentity(identity);
2986 }
2987 }
2988
2989 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002990 public boolean isVtSettingEnabled(int subId) {
2991 enforceReadPrivilegedPermission("isVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002992 final long identity = Binder.clearCallingIdentity();
2993 try {
2994 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1ce9c432019-07-16 13:19:44 -07002995 return ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).isVtEnabledByUser();
2996 } catch (ImsException e) {
2997 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07002998 } finally {
2999 Binder.restoreCallingIdentity(identity);
3000 }
3001 }
3002
3003 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003004 public void setVtSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003005 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003006 "setVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003007 final long identity = Binder.clearCallingIdentity();
3008 try {
3009 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003010 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setVtSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003011 } catch (ImsException e) {
3012 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003013 } finally {
3014 Binder.restoreCallingIdentity(identity);
3015 }
3016 }
3017
3018 @Override
3019 public boolean isVoWiFiSettingEnabled(int subId) {
3020 enforceReadPrivilegedPermission("isVoWiFiSettingEnabled");
3021 final long identity = Binder.clearCallingIdentity();
3022 try {
3023 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003024 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003025 getSlotIndexOrException(subId)).isWfcEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003026 } catch (ImsException e) {
3027 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003028 } finally {
3029 Binder.restoreCallingIdentity(identity);
3030 }
3031 }
3032
3033 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003034 public void setVoWiFiSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003035 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003036 "setVoWiFiSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003037 final long identity = Binder.clearCallingIdentity();
3038 try {
3039 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003040 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setWfcSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003041 } catch (ImsException e) {
3042 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003043 } finally {
3044 Binder.restoreCallingIdentity(identity);
3045 }
3046 }
3047
3048 @Override
3049 public boolean isVoWiFiRoamingSettingEnabled(int subId) {
3050 enforceReadPrivilegedPermission("isVoWiFiRoamingSettingEnabled");
3051 final long identity = Binder.clearCallingIdentity();
3052 try {
3053 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003054 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003055 getSlotIndexOrException(subId)).isWfcRoamingEnabledByUser();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003056 } catch (ImsException e) {
3057 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003058 } finally {
3059 Binder.restoreCallingIdentity(identity);
3060 }
3061 }
3062
3063 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003064 public void setVoWiFiRoamingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003065 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003066 "setVoWiFiRoamingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003067 final long identity = Binder.clearCallingIdentity();
3068 try {
3069 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003070 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003071 getSlotIndexOrException(subId)).setWfcRoamingSetting(isEnabled);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003072 } catch (ImsException e) {
3073 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003074 } finally {
3075 Binder.restoreCallingIdentity(identity);
3076 }
3077 }
3078
3079 @Override
3080 public void setVoWiFiNonPersistent(int subId, boolean isCapable, int mode) {
3081 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3082 "setVoWiFiNonPersistent");
3083 final long identity = Binder.clearCallingIdentity();
3084 try {
3085 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003086 ImsManager.getInstance(mApp,
Brad Ebinger2d29c012019-05-07 18:33:46 -07003087 getSlotIndexOrException(subId)).setWfcNonPersistent(isCapable, mode);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003088 } catch (ImsException e) {
3089 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003090 } finally {
3091 Binder.restoreCallingIdentity(identity);
3092 }
3093 }
3094
3095 @Override
3096 public int getVoWiFiModeSetting(int subId) {
3097 enforceReadPrivilegedPermission("getVoWiFiModeSetting");
3098 final long identity = Binder.clearCallingIdentity();
3099 try {
3100 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003101 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003102 getSlotIndexOrException(subId)).getWfcMode(false /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003103 } catch (ImsException e) {
3104 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003105 } finally {
3106 Binder.restoreCallingIdentity(identity);
3107 }
3108 }
3109
3110 @Override
3111 public void setVoWiFiModeSetting(int subId, int mode) {
3112 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3113 "setVoWiFiModeSetting");
3114 final long identity = Binder.clearCallingIdentity();
3115 try {
3116 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003117 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003118 getSlotIndexOrException(subId)).setWfcMode(mode, false /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003119 } catch (ImsException e) {
3120 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003121 } finally {
3122 Binder.restoreCallingIdentity(identity);
3123 }
3124 }
3125
3126 @Override
3127 public int getVoWiFiRoamingModeSetting(int subId) {
3128 enforceReadPrivilegedPermission("getVoWiFiRoamingModeSetting");
3129 final long identity = Binder.clearCallingIdentity();
3130 try {
3131 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003132 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003133 getSlotIndexOrException(subId)).getWfcMode(true /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003134 } catch (ImsException e) {
3135 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003136 } finally {
3137 Binder.restoreCallingIdentity(identity);
3138 }
3139 }
3140
3141 @Override
3142 public void setVoWiFiRoamingModeSetting(int subId, int mode) {
3143 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3144 "setVoWiFiRoamingModeSetting");
3145 final long identity = Binder.clearCallingIdentity();
3146 try {
3147 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003148 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003149 getSlotIndexOrException(subId)).setWfcMode(mode, true /*isRoaming*/);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003150 } catch (ImsException e) {
3151 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003152 } finally {
3153 Binder.restoreCallingIdentity(identity);
3154 }
3155 }
3156
3157 @Override
3158 public void setRttCapabilitySetting(int subId, boolean isEnabled) {
3159 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3160 "setRttCapabilityEnabled");
3161 final long identity = Binder.clearCallingIdentity();
3162 try {
3163 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003164 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setRttEnabled(isEnabled);
3165 } catch (ImsException e) {
3166 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003167 } finally {
3168 Binder.restoreCallingIdentity(identity);
3169 }
3170 }
3171
3172 @Override
3173 public boolean isTtyOverVolteEnabled(int subId) {
3174 enforceReadPrivilegedPermission("isTtyOverVolteEnabled");
3175 final long identity = Binder.clearCallingIdentity();
3176 try {
3177 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003178 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003179 getSlotIndexOrException(subId)).isTtyOnVoLteCapable();
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003180 } catch (ImsException e) {
3181 throw new ServiceSpecificException(e.getCode());
Brad Ebinger35c841c2018-10-01 10:40:55 -07003182 } finally {
3183 Binder.restoreCallingIdentity(identity);
3184 }
3185 }
3186
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003187 @Override
3188 public void registerImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3189 enforceReadPrivilegedPermission("registerImsProvisioningChangedCallback");
3190 final long identity = Binder.clearCallingIdentity();
3191 try {
3192 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003193 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003194 .addProvisioningCallbackForSubscription(callback, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003195 } catch (ImsException e) {
3196 throw new ServiceSpecificException(e.getCode());
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003197 } finally {
3198 Binder.restoreCallingIdentity(identity);
3199 }
3200 }
3201
3202 @Override
3203 public void unregisterImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3204 enforceReadPrivilegedPermission("unregisterImsProvisioningChangedCallback");
3205 final long identity = Binder.clearCallingIdentity();
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003206 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3207 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3208 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003209 try {
3210 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003211 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003212 .removeProvisioningCallbackForSubscription(callback, subId);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003213 } catch (ImsException e) {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003214 Log.i(LOG_TAG, "unregisterImsProvisioningChangedCallback: " + subId
3215 + "is inactive, ignoring unregister.");
3216 // If the subscription is no longer active, just return, since the callback will already
3217 // have been removed internally.
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003218 } finally {
3219 Binder.restoreCallingIdentity(identity);
3220 }
3221 }
3222
3223 @Override
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003224 public void setImsProvisioningStatusForCapability(int subId, int capability, int tech,
3225 boolean isProvisioned) {
3226 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3227 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3228 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3229 }
3230 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3231 "setProvisioningStatusForCapability");
3232 final long identity = Binder.clearCallingIdentity();
3233 try {
3234 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3235 Phone phone = getPhone(subId);
3236 if (phone == null) {
3237 loge("setImsProvisioningStatusForCapability: phone instance null for subid "
3238 + subId);
3239 return;
3240 }
3241 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3242 return;
3243 }
3244
3245 // this capability requires provisioning, route to the correct API.
3246 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3247 switch (capability) {
3248 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3249 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3250 ims.setVolteProvisioned(isProvisioned);
3251 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3252 ims.setWfcProvisioned(isProvisioned);
3253 }
3254 break;
3255 }
3256 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3257 // There is currently no difference in VT provisioning type.
3258 ims.setVtProvisioned(isProvisioned);
3259 break;
3260 }
3261 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3262 // There is no "deprecated" UT provisioning mechanism through ImsConfig, so
3263 // change the capability of the feature instead if needed.
3264 if (isMmTelCapabilityProvisionedInCache(subId, capability, tech)
3265 == isProvisioned) {
3266 // No change in provisioning.
3267 return;
3268 }
3269 cacheMmTelCapabilityProvisioning(subId, capability, tech, isProvisioned);
3270 try {
3271 ims.changeMmTelCapability(capability, tech, isProvisioned);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003272 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003273 loge("setImsProvisioningStatusForCapability: couldn't change UT capability"
3274 + ", Exception" + e.getMessage());
3275 }
3276 break;
3277 }
3278 default: {
3279 throw new IllegalArgumentException("Tried to set provisioning for capability '"
3280 + capability + "', which does not require provisioning.");
3281 }
3282 }
3283
3284 } finally {
3285 Binder.restoreCallingIdentity(identity);
3286 }
3287 }
3288
3289 @Override
3290 public boolean getImsProvisioningStatusForCapability(int subId, int capability, int tech) {
3291 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3292 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3293 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3294 }
3295 enforceReadPrivilegedPermission("getProvisioningStatusForCapability");
3296 final long identity = Binder.clearCallingIdentity();
3297 try {
3298 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3299 Phone phone = getPhone(subId);
3300 if (phone == null) {
3301 loge("getImsProvisioningStatusForCapability: phone instance null for subid "
3302 + subId);
3303 // We will fail with "true" as the provisioning status because this is the default
3304 // if we do not require provisioning.
3305 return true;
3306 }
3307
3308 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3309 return true;
3310 }
3311
3312 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3313 switch (capability) {
3314 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3315 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3316 return ims.isVolteProvisionedOnDevice();
3317 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3318 return ims.isWfcProvisionedOnDevice();
3319 }
3320 // This should never happen, since we are checking tech above to make sure it
3321 // is either LTE or IWLAN.
3322 throw new IllegalArgumentException("Invalid radio technology for voice "
3323 + "capability.");
3324 }
3325 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3326 // There is currently no difference in VT provisioning type.
3327 return ims.isVtProvisionedOnDevice();
3328 }
3329 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3330 // There is no "deprecated" UT provisioning mechanism, so get from shared prefs.
3331 return isMmTelCapabilityProvisionedInCache(subId, capability, tech);
3332 }
3333 default: {
3334 throw new IllegalArgumentException("Tried to get provisioning for capability '"
3335 + capability + "', which does not require provisioning.");
3336 }
3337 }
3338
3339 } finally {
3340 Binder.restoreCallingIdentity(identity);
3341 }
3342 }
3343
3344 @Override
3345 public boolean isMmTelCapabilityProvisionedInCache(int subId, int capability, int tech) {
3346 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3347 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3348 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3349 }
3350 enforceReadPrivilegedPermission("isMmTelCapabilityProvisionedInCache");
3351 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3352 return (provisionedBits & capability) > 0;
3353 }
3354
3355 @Override
3356 public void cacheMmTelCapabilityProvisioning(int subId, int capability, int tech,
3357 boolean isProvisioned) {
3358 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3359 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3360 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3361 }
3362 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3363 "setProvisioningStatusForCapability");
3364 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3365 // If the current provisioning status for capability already matches isProvisioned,
3366 // do nothing.
3367 if (((provisionedBits & capability) > 0) == isProvisioned) {
3368 return;
3369 }
3370 if (isProvisioned) {
3371 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits | capability));
3372 } else {
3373 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits & ~capability));
3374 }
3375 }
3376
3377 /**
3378 * @return the bitfield containing the MmTel provisioning for the provided subscription and
3379 * technology. The bitfield should mirror the bitfield defined by
3380 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}.
3381 */
3382 private int getMmTelCapabilityProvisioningBitfield(int subId, int tech) {
3383 String key = getMmTelProvisioningKey(subId, tech);
3384 // Default is no capabilities are provisioned.
3385 return mTelephonySharedPreferences.getInt(key, 0 /*default*/);
3386 }
3387
3388 /**
3389 * Sets the MmTel capability provisioning bitfield (defined by
3390 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}) for the subscription and
3391 * technology specified.
3392 *
3393 * Note: This is a synchronous command and should not be called on UI thread.
3394 */
3395 private void setMmTelCapabilityProvisioningBitfield(int subId, int tech, int newField) {
3396 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
3397 String key = getMmTelProvisioningKey(subId, tech);
3398 editor.putInt(key, newField);
3399 editor.commit();
3400 }
3401
3402 private static String getMmTelProvisioningKey(int subId, int tech) {
3403 // resulting key is provision_ims_mmtel_{subId}_{tech}
3404 return PREF_PROVISION_IMS_MMTEL_PREFIX + subId + "_" + tech;
3405 }
3406
3407 /**
3408 * Query CarrierConfig to see if the specified capability requires provisioning for the
3409 * carrier associated with the subscription id.
3410 */
3411 private boolean doesImsCapabilityRequireProvisioning(Context context, int subId,
3412 int capability) {
3413 CarrierConfigManager configManager = new CarrierConfigManager(context);
3414 PersistableBundle c = configManager.getConfigForSubId(subId);
3415 boolean requireUtProvisioning = c.getBoolean(
Brad Ebinger076903f2019-05-13 10:00:22 -07003416 CarrierConfigManager.KEY_CARRIER_SUPPORTS_SS_OVER_UT_BOOL, false)
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003417 && c.getBoolean(CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL,
3418 false);
3419 boolean requireVoiceVtProvisioning = c.getBoolean(
3420 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, false);
3421
3422 // First check to make sure that the capability requires provisioning.
3423 switch (capability) {
3424 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE:
3425 // intentional fallthrough
3426 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3427 if (requireVoiceVtProvisioning) {
3428 // Voice and Video requires provisioning
3429 return true;
3430 }
3431 break;
3432 }
3433 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3434 if (requireUtProvisioning) {
3435 // UT requires provisioning
3436 return true;
3437 }
3438 break;
3439 }
3440 }
3441 return false;
3442 }
3443
3444 @Override
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003445 public int getImsProvisioningInt(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003446 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3447 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3448 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003449 enforceReadPrivilegedPermission("getImsProvisioningInt");
3450 final long identity = Binder.clearCallingIdentity();
3451 try {
3452 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003453 int slotId = getSlotIndex(subId);
3454 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3455 Log.w(LOG_TAG, "getImsProvisioningInt: called with an inactive subscription '"
3456 + subId + "' for key:" + key);
3457 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
3458 }
3459 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigInt(key);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003460 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003461 Log.w(LOG_TAG, "getImsProvisioningInt: ImsService is not available for subscription '"
3462 + subId + "' for key:" + key);
3463 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003464 } finally {
3465 Binder.restoreCallingIdentity(identity);
3466 }
3467 }
3468
3469 @Override
3470 public String getImsProvisioningString(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003471 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3472 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3473 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003474 enforceReadPrivilegedPermission("getImsProvisioningString");
3475 final long identity = Binder.clearCallingIdentity();
3476 try {
3477 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003478 int slotId = getSlotIndex(subId);
3479 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3480 Log.w(LOG_TAG, "getImsProvisioningString: called for an inactive subscription id '"
3481 + subId + "' for key:" + key);
3482 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_GENERIC;
3483 }
3484 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigString(key);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003485 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003486 Log.w(LOG_TAG, "getImsProvisioningString: ImsService is not available for sub '"
3487 + subId + "' for key:" + key);
3488 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_NOT_READY;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003489 } finally {
3490 Binder.restoreCallingIdentity(identity);
3491 }
3492 }
3493
3494 @Override
3495 public int setImsProvisioningInt(int subId, int key, int value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003496 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3497 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3498 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003499 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3500 "setImsProvisioningInt");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003501 final long identity = Binder.clearCallingIdentity();
3502 try {
3503 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003504 int slotId = getSlotIndex(subId);
3505 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3506 Log.w(LOG_TAG, "setImsProvisioningInt: called with an inactive subscription id '"
3507 + subId + "' for key:" + key);
3508 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3509 }
3510 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003511 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003512 Log.w(LOG_TAG, "setImsProvisioningInt: ImsService unavailable for sub '" + subId
3513 + "' for key:" + key);
3514 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003515 } finally {
3516 Binder.restoreCallingIdentity(identity);
3517 }
3518 }
3519
3520 @Override
3521 public int setImsProvisioningString(int subId, int key, String value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003522 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3523 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3524 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003525 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3526 "setImsProvisioningString");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003527 final long identity = Binder.clearCallingIdentity();
3528 try {
3529 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003530 int slotId = getSlotIndex(subId);
3531 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3532 Log.w(LOG_TAG, "setImsProvisioningString: called with an inactive subscription id '"
3533 + subId + "' for key:" + key);
3534 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3535 }
3536 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003537 } catch (com.android.ims.ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003538 Log.w(LOG_TAG, "setImsProvisioningString: ImsService unavailable for sub '" + subId
3539 + "' for key:" + key);
3540 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003541 } finally {
3542 Binder.restoreCallingIdentity(identity);
3543 }
3544 }
3545
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003546 private int getSlotIndexOrException(int subId) throws ImsException {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003547 int slotId = SubscriptionManager.getSlotIndex(subId);
3548 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
Brad Ebinger1ce9c432019-07-16 13:19:44 -07003549 throw new ImsException("Invalid Subscription Id, subId=" + subId,
3550 ImsException.CODE_ERROR_INVALID_SUBSCRIPTION);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003551 }
3552 return slotId;
3553 }
3554
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003555 private int getSlotIndex(int subId) {
3556 int slotId = SubscriptionManager.getSlotIndex(subId);
3557 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
3558 return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
3559 }
3560 return slotId;
3561 }
3562
Wink Saville36469e72014-06-11 15:17:00 -07003563 /**
Nathan Harold9042f0b2019-05-21 15:51:27 -07003564 * Returns the data network type for a subId; does not throw SecurityException.
Wink Saville36469e72014-06-11 15:17:00 -07003565 */
3566 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003567 public int getNetworkTypeForSubscriber(int subId, String callingPackage) {
Nathan Haroldef60dba2019-05-22 13:55:14 -07003568 final int targetSdk = getTargetSdk(callingPackage);
3569 if (targetSdk > android.os.Build.VERSION_CODES.Q) {
3570 return getDataNetworkTypeForSubscriber(subId, callingPackage);
3571 } else if (targetSdk == android.os.Build.VERSION_CODES.Q
Nathan Harold9042f0b2019-05-21 15:51:27 -07003572 && !TelephonyPermissions.checkCallingOrSelfReadPhoneStateNoThrow(
3573 mApp, subId, callingPackage, "getNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003574 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3575 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003576
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003577 final long identity = Binder.clearCallingIdentity();
3578 try {
3579 final Phone phone = getPhone(subId);
3580 if (phone != null) {
3581 return phone.getServiceState().getDataNetworkType();
3582 } else {
3583 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3584 }
3585 } finally {
3586 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003587 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003588 }
3589
3590 /**
3591 * Returns the data network type
3592 */
3593 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003594 public int getDataNetworkType(String callingPackage) {
3595 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003596 }
3597
3598 /**
3599 * Returns the data network type for a subId
3600 */
3601 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003602 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003603 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003604 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003605 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3606 }
3607
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003608 final long identity = Binder.clearCallingIdentity();
3609 try {
3610 final Phone phone = getPhone(subId);
3611 if (phone != null) {
3612 return phone.getServiceState().getDataNetworkType();
3613 } else {
3614 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3615 }
3616 } finally {
3617 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003618 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003619 }
3620
3621 /**
Wink Saville36469e72014-06-11 15:17:00 -07003622 * Returns the Voice network type for a subId
3623 */
3624 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003625 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003626 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003627 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003628 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3629 }
3630
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003631 final long identity = Binder.clearCallingIdentity();
3632 try {
3633 final Phone phone = getPhone(subId);
3634 if (phone != null) {
3635 return phone.getServiceState().getVoiceNetworkType();
3636 } else {
3637 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3638 }
3639 } finally {
3640 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003641 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003642 }
3643
3644 /**
3645 * @return true if a ICC card is present
3646 */
3647 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07003648 // FIXME Make changes to pass defaultSimId of type int
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003649 return hasIccCardUsingSlotIndex(mSubscriptionController.getSlotIndex(
3650 getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07003651 }
3652
3653 /**
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003654 * @return true if a ICC card is present for a slotIndex
Wink Saville36469e72014-06-11 15:17:00 -07003655 */
Sanket Padawe356d7632015-06-22 14:03:32 -07003656 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003657 public boolean hasIccCardUsingSlotIndex(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003658 final long identity = Binder.clearCallingIdentity();
3659 try {
3660 final Phone phone = PhoneFactory.getPhone(slotIndex);
3661 if (phone != null) {
3662 return phone.getIccCard().hasIccCard();
3663 } else {
3664 return false;
3665 }
3666 } finally {
3667 Binder.restoreCallingIdentity(identity);
Amit Mahajana6fc2a82015-01-06 11:53:51 -08003668 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003669 }
3670
3671 /**
3672 * Return if the current radio is LTE on CDMA. This
3673 * is a tri-state return value as for a period of time
3674 * the mode may be unknown.
3675 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003676 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003677 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08003678 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003679 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003680 @Override
3681 public int getLteOnCdmaMode(String callingPackage) {
3682 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003683 }
3684
Sanket Padawe356d7632015-06-22 14:03:32 -07003685 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003686 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003687 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003688 mApp, subId, callingPackage, "getLteOnCdmaModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003689 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3690 }
3691
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003692 final long identity = Binder.clearCallingIdentity();
3693 try {
3694 final Phone phone = getPhone(subId);
3695 if (phone == null) {
3696 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3697 } else {
3698 return phone.getLteOnCdmaMode();
3699 }
3700 } finally {
3701 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003702 }
Wink Saville36469e72014-06-11 15:17:00 -07003703 }
3704
Wink Saville36469e72014-06-11 15:17:00 -07003705 /**
3706 * {@hide}
3707 * Returns Default subId, 0 in the case of single standby.
3708 */
Wink Savilleb564aae2014-10-23 10:18:09 -07003709 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003710 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07003711 }
3712
Shishir Agrawala9f32182016-04-12 12:00:16 -07003713 private int getSlotForDefaultSubscription() {
3714 return mSubscriptionController.getPhoneId(getDefaultSubscription());
3715 }
3716
Wink Savilleb564aae2014-10-23 10:18:09 -07003717 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003718 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003719 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003720
Pengquan Menge92a50d2018-09-21 15:54:48 -07003721 private boolean isActiveSubscription(int subId) {
3722 return mSubscriptionController.isActiveSubId(subId);
3723 }
3724
Ihab Awadf2177b72013-11-25 13:33:23 -08003725 /**
3726 * @see android.telephony.TelephonyManager.WifiCallingChoices
3727 */
3728 public int getWhenToMakeWifiCalls() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003729 final long identity = Binder.clearCallingIdentity();
3730 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003731 return Settings.System.getInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003732 Settings.System.WHEN_TO_MAKE_WIFI_CALLS,
3733 getWhenToMakeWifiCallsDefaultPreference());
3734 } finally {
3735 Binder.restoreCallingIdentity(identity);
3736 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003737 }
3738
3739 /**
3740 * @see android.telephony.TelephonyManager.WifiCallingChoices
3741 */
3742 public void setWhenToMakeWifiCalls(int preference) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003743 final long identity = Binder.clearCallingIdentity();
3744 try {
3745 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003746 Settings.System.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003747 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
3748 } finally {
3749 Binder.restoreCallingIdentity(identity);
3750 }
Ihab Awadf9e92732013-12-05 18:02:52 -08003751 }
3752
Sailesh Nepald1e68152013-12-12 19:08:02 -08003753 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07003754 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08003755 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08003756 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08003757
Jordan Liu4c733742019-02-28 12:03:40 -08003758 private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
3759 int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
3760 if (phoneId == -1) {
3761 throw new IllegalArgumentException("Given slot index: " + slotIndex
3762 + " does not correspond to an active phone");
3763 }
3764 return PhoneFactory.getPhone(phoneId);
3765 }
3766
Shishir Agrawal566b7612013-10-28 14:41:00 -07003767 @Override
Derek Tan740e1672017-06-27 14:56:27 -07003768 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(
3769 int subId, String callingPackage, String aid, int p2) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003770 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3771 mApp, subId, "iccOpenLogicalChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003772 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003773 if (DBG) {
3774 log("iccOpenLogicalChannel: subId=" + subId + " aid=" + aid + " p2=" + p2);
3775 }
3776 return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
3777 p2);
3778 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003779
Jordan Liu4c733742019-02-28 12:03:40 -08003780
3781 @Override
3782 public IccOpenLogicalChannelResponse iccOpenLogicalChannelBySlot(
3783 int slotIndex, String callingPackage, String aid, int p2) {
3784 enforceModifyPermission();
3785 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3786 if (DBG) {
3787 log("iccOpenLogicalChannelBySlot: slot=" + slotIndex + " aid=" + aid + " p2=" + p2);
3788 }
3789 return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3790 callingPackage, aid, p2);
3791 }
3792
3793 private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
3794 String callingPackage, String aid, int p2) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003795 final long identity = Binder.clearCallingIdentity();
3796 try {
3797 if (TextUtils.equals(ISDR_AID, aid)) {
3798 // Only allows LPA to open logical channel to ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003799 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3800 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003801 if (bestComponent == null
3802 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3803 loge("The calling package is not allowed to access ISD-R.");
3804 throw new SecurityException(
3805 "The calling package is not allowed to access ISD-R.");
3806 }
Derek Tan740e1672017-06-27 14:56:27 -07003807 }
Derek Tan740e1672017-06-27 14:56:27 -07003808
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003809 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse) sendRequest(
Jordan Liu4c733742019-02-28 12:03:40 -08003810 CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
3811 null /* workSource */);
3812 if (DBG) log("iccOpenLogicalChannelWithPermission: " + response);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003813 return response;
3814 } finally {
3815 Binder.restoreCallingIdentity(identity);
3816 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003817 }
3818
3819 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003820 public boolean iccCloseLogicalChannel(int subId, int channel) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003821 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3822 mApp, subId, "iccCloseLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003823 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
3824 return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
3825 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003826
Jordan Liu4c733742019-02-28 12:03:40 -08003827 @Override
3828 public boolean iccCloseLogicalChannelBySlot(int slotIndex, int channel) {
3829 enforceModifyPermission();
3830 if (DBG) log("iccCloseLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel);
3831 return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3832 channel);
3833 }
3834
3835 private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003836 final long identity = Binder.clearCallingIdentity();
3837 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003838 if (channel < 0) {
3839 return false;
3840 }
Jordan Liu4c733742019-02-28 12:03:40 -08003841 Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
3842 null /* workSource */);
3843 if (DBG) log("iccCloseLogicalChannelWithPermission: " + success);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003844 return success;
3845 } finally {
3846 Binder.restoreCallingIdentity(identity);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003847 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003848 }
3849
3850 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003851 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07003852 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003853 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3854 mApp, subId, "iccTransmitApduLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003855 if (DBG) {
3856 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel
3857 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3858 + p3 + " data=" + data);
3859 }
3860 return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
3861 command, p1, p2, p3, data);
3862 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003863
Jordan Liu4c733742019-02-28 12:03:40 -08003864 @Override
3865 public String iccTransmitApduLogicalChannelBySlot(int slotIndex, int channel, int cla,
3866 int command, int p1, int p2, int p3, String data) {
3867 enforceModifyPermission();
3868 if (DBG) {
3869 log("iccTransmitApduLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel
3870 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3871 + p3 + " data=" + data);
3872 }
3873 return iccTransmitApduLogicalChannelWithPermission(
3874 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
3875 data);
3876 }
3877
3878 private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
3879 int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003880 final long identity = Binder.clearCallingIdentity();
3881 try {
Hall Liu4fd771b2019-05-02 09:16:29 -07003882 if (channel <= 0) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003883 return "";
3884 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003885
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003886 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003887 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
3888 null /* workSource */);
3889 if (DBG) log("iccTransmitApduLogicalChannelWithPermission: " + response);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003890
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003891 // Append the returned status code to the end of the response payload.
3892 String s = Integer.toHexString(
3893 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3894 if (response.payload != null) {
3895 s = IccUtils.bytesToHexString(response.payload) + s;
3896 }
3897 return s;
3898 } finally {
3899 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003900 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003901 }
Jake Hambye994d462014-02-03 13:10:13 -08003902
Evan Charltonc66da362014-05-16 14:06:40 -07003903 @Override
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003904 public String iccTransmitApduBasicChannel(int subId, String callingPackage, int cla,
3905 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003906 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3907 mApp, subId, "iccTransmitApduBasicChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003908 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003909 if (DBG) {
3910 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd="
3911 + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
3912 }
3913 return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
3914 cla, command, p1, p2, p3, data);
3915 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003916
Jordan Liu4c733742019-02-28 12:03:40 -08003917 @Override
3918 public String iccTransmitApduBasicChannelBySlot(int slotIndex, String callingPackage, int cla,
3919 int command, int p1, int p2, int p3, String data) {
3920 enforceModifyPermission();
3921 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3922 if (DBG) {
3923 log("iccTransmitApduBasicChannelBySlot: slotIndex=" + slotIndex + " cla=" + cla
3924 + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3
3925 + " data=" + data);
3926 }
3927
3928 return iccTransmitApduBasicChannelWithPermission(
3929 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
3930 p2, p3, data);
3931 }
3932
3933 // open APDU basic channel assuming the caller has sufficient permissions
3934 private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
3935 int cla, int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003936 final long identity = Binder.clearCallingIdentity();
3937 try {
3938 if (command == SELECT_COMMAND && p1 == SELECT_P1 && p2 == SELECT_P2 && p3 == SELECT_P3
3939 && TextUtils.equals(ISDR_AID, data)) {
3940 // Only allows LPA to select ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003941 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3942 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003943 if (bestComponent == null
3944 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3945 loge("The calling package is not allowed to select ISD-R.");
3946 throw new SecurityException(
3947 "The calling package is not allowed to select ISD-R.");
3948 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003949 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003950
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003951 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003952 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
3953 null /* workSource */);
3954 if (DBG) log("iccTransmitApduBasicChannelWithPermission: " + response);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003955
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003956 // Append the returned status code to the end of the response payload.
3957 String s = Integer.toHexString(
3958 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3959 if (response.payload != null) {
3960 s = IccUtils.bytesToHexString(response.payload) + s;
3961 }
3962 return s;
3963 } finally {
3964 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003965 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003966 }
3967
3968 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003969 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003970 String filePath) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003971 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3972 mApp, subId, "iccExchangeSimIO");
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003973
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003974 final long identity = Binder.clearCallingIdentity();
3975 try {
3976 if (DBG) {
3977 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " "
3978 + p1 + " " + p2 + " " + p3 + ":" + filePath);
3979 }
3980
3981 IccIoResult response =
3982 (IccIoResult) sendRequest(CMD_EXCHANGE_SIM_IO,
3983 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
3984 subId);
3985
3986 if (DBG) {
3987 log("Exchange SIM_IO [R]" + response);
3988 }
3989
3990 byte[] result = null;
3991 int length = 2;
3992 if (response.payload != null) {
3993 length = 2 + response.payload.length;
3994 result = new byte[length];
3995 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
3996 } else {
3997 result = new byte[length];
3998 }
3999
4000 result[length - 1] = (byte) response.sw2;
4001 result[length - 2] = (byte) response.sw1;
4002 return result;
4003 } finally {
4004 Binder.restoreCallingIdentity(identity);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004005 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004006 }
4007
Nathan Haroldb3014052017-01-25 15:57:32 -08004008 /**
4009 * Get the forbidden PLMN List from the given app type (ex APPTYPE_USIM)
4010 * on a particular subscription
4011 */
sqianb6e41952018-03-12 14:54:01 -07004012 public String[] getForbiddenPlmns(int subId, int appType, String callingPackage) {
4013 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
4014 mApp, subId, callingPackage, "getForbiddenPlmns")) {
4015 return null;
4016 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004017
4018 final long identity = Binder.clearCallingIdentity();
4019 try {
4020 if (appType != TelephonyManager.APPTYPE_USIM
4021 && appType != TelephonyManager.APPTYPE_SIM) {
4022 loge("getForbiddenPlmnList(): App Type must be USIM or SIM");
4023 return null;
4024 }
4025 Object response = sendRequest(
4026 CMD_GET_FORBIDDEN_PLMNS, new Integer(appType), subId);
4027 if (response instanceof String[]) {
4028 return (String[]) response;
4029 }
4030 // Response is an Exception of some kind,
4031 // which is signalled to the user as a NULL retval
Nathan Haroldb3014052017-01-25 15:57:32 -08004032 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004033 } finally {
4034 Binder.restoreCallingIdentity(identity);
Nathan Haroldb3014052017-01-25 15:57:32 -08004035 }
Nathan Haroldb3014052017-01-25 15:57:32 -08004036 }
4037
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004038 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004039 public String sendEnvelopeWithStatus(int subId, String content) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004040 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4041 mApp, subId, "sendEnvelopeWithStatus");
Evan Charltonc66da362014-05-16 14:06:40 -07004042
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004043 final long identity = Binder.clearCallingIdentity();
4044 try {
4045 IccIoResult response = (IccIoResult) sendRequest(CMD_SEND_ENVELOPE, content, subId);
4046 if (response.payload == null) {
4047 return "";
4048 }
Evan Charltonc66da362014-05-16 14:06:40 -07004049
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004050 // Append the returned status code to the end of the response payload.
4051 String s = Integer.toHexString(
4052 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4053 s = IccUtils.bytesToHexString(response.payload) + s;
4054 return s;
4055 } finally {
4056 Binder.restoreCallingIdentity(identity);
4057 }
Evan Charltonc66da362014-05-16 14:06:40 -07004058 }
4059
Jake Hambye994d462014-02-03 13:10:13 -08004060 /**
4061 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4062 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4063 *
4064 * @param itemID the ID of the item to read
4065 * @return the NV item as a String, or null on error.
4066 */
4067 @Override
4068 public String nvReadItem(int itemID) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004069 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004070 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4071 mApp, getDefaultSubscription(), "nvReadItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004072
4073 final long identity = Binder.clearCallingIdentity();
4074 try {
4075 if (DBG) log("nvReadItem: item " + itemID);
vagdeviaf9a5b92018-08-15 16:01:53 -07004076 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004077 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
4078 return value;
4079 } finally {
4080 Binder.restoreCallingIdentity(identity);
4081 }
Jake Hambye994d462014-02-03 13:10:13 -08004082 }
4083
4084 /**
4085 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4086 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4087 *
4088 * @param itemID the ID of the item to read
4089 * @param itemValue the value to write, as a String
4090 * @return true on success; false on any failure
4091 */
4092 @Override
4093 public boolean nvWriteItem(int itemID, String itemValue) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004094 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004095 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4096 mApp, getDefaultSubscription(), "nvWriteItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004097
4098 final long identity = Binder.clearCallingIdentity();
4099 try {
4100 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
4101 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
vagdeviaf9a5b92018-08-15 16:01:53 -07004102 new Pair<Integer, String>(itemID, itemValue), workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004103 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
4104 return success;
4105 } finally {
4106 Binder.restoreCallingIdentity(identity);
4107 }
Jake Hambye994d462014-02-03 13:10:13 -08004108 }
4109
4110 /**
4111 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
4112 * Used for device configuration by some CDMA operators.
4113 *
4114 * @param preferredRoamingList byte array containing the new PRL
4115 * @return true on success; false on any failure
4116 */
4117 @Override
4118 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004119 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4120 mApp, getDefaultSubscription(), "nvWriteCdmaPrl");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004121
4122 final long identity = Binder.clearCallingIdentity();
4123 try {
4124 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
4125 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
4126 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
4127 return success;
4128 } finally {
4129 Binder.restoreCallingIdentity(identity);
4130 }
Jake Hambye994d462014-02-03 13:10:13 -08004131 }
4132
4133 /**
chen xu6dac5ab2018-10-26 17:39:23 -07004134 * Rollback modem configurations to factory default except some config which are in whitelist.
Jake Hambye994d462014-02-03 13:10:13 -08004135 * Used for device configuration by some CDMA operators.
4136 *
chen xu6dac5ab2018-10-26 17:39:23 -07004137 * @param slotIndex - device slot.
4138 *
Jake Hambye994d462014-02-03 13:10:13 -08004139 * @return true on success; false on any failure
4140 */
4141 @Override
chen xu6dac5ab2018-10-26 17:39:23 -07004142 public boolean resetModemConfig(int slotIndex) {
4143 Phone phone = PhoneFactory.getPhone(slotIndex);
4144 if (phone != null) {
4145 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4146 mApp, phone.getSubId(), "resetModemConfig");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004147
chen xu6dac5ab2018-10-26 17:39:23 -07004148 final long identity = Binder.clearCallingIdentity();
4149 try {
4150 Boolean success = (Boolean) sendRequest(CMD_RESET_MODEM_CONFIG, null);
4151 if (DBG) log("resetModemConfig:" + ' ' + (success ? "ok" : "fail"));
4152 return success;
4153 } finally {
4154 Binder.restoreCallingIdentity(identity);
4155 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004156 }
chen xu6dac5ab2018-10-26 17:39:23 -07004157 return false;
4158 }
4159
4160 /**
4161 * Generate a radio modem reset. Used for device configuration by some CDMA operators.
4162 *
4163 * @param slotIndex - device slot.
4164 *
4165 * @return true on success; false on any failure
4166 */
4167 @Override
4168 public boolean rebootModem(int slotIndex) {
4169 Phone phone = PhoneFactory.getPhone(slotIndex);
4170 if (phone != null) {
4171 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4172 mApp, phone.getSubId(), "rebootModem");
4173
4174 final long identity = Binder.clearCallingIdentity();
4175 try {
4176 Boolean success = (Boolean) sendRequest(CMD_MODEM_REBOOT, null);
4177 if (DBG) log("rebootModem:" + ' ' + (success ? "ok" : "fail"));
4178 return success;
4179 } finally {
4180 Binder.restoreCallingIdentity(identity);
4181 }
4182 }
4183 return false;
Jake Hambye994d462014-02-03 13:10:13 -08004184 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004185
Svet Ganovb320e182015-04-16 12:30:10 -07004186 public String[] getPcscfAddress(String apnType, String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004187 final Phone defaultPhone = getDefaultPhone();
Jeff Davidson7e17e312018-02-13 18:17:36 -08004188 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004189 mApp, defaultPhone.getSubId(), callingPackage, "getPcscfAddress")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004190 return new String[0];
4191 }
4192
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004193 final long identity = Binder.clearCallingIdentity();
4194 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004195 return defaultPhone.getPcscfAddress(apnType);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004196 } finally {
4197 Binder.restoreCallingIdentity(identity);
4198 }
Wink Saville36469e72014-06-11 15:17:00 -07004199 }
4200
Brad Ebinger51f743a2017-01-23 13:50:20 -08004201 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004202 * Enables IMS for the framework. This will trigger IMS registration and ImsFeature capability
4203 * status updates, if not already enabled.
Brad Ebinger51f743a2017-01-23 13:50:20 -08004204 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004205 public void enableIms(int slotId) {
Brad Ebinger51f743a2017-01-23 13:50:20 -08004206 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004207
4208 final long identity = Binder.clearCallingIdentity();
4209 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004210 ImsResolver resolver = PhoneFactory.getImsResolver();
4211 if (resolver == null) {
4212 // may happen if the device does not support IMS.
4213 return;
4214 }
4215 resolver.enableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004216 } finally {
4217 Binder.restoreCallingIdentity(identity);
4218 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004219 }
4220
4221 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004222 * Disables IMS for the framework. This will trigger IMS de-registration and trigger ImsFeature
4223 * status updates to disabled.
Brad Ebinger34bef922017-11-09 10:27:08 -08004224 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004225 public void disableIms(int slotId) {
4226 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004227
4228 final long identity = Binder.clearCallingIdentity();
4229 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004230 ImsResolver resolver = PhoneFactory.getImsResolver();
4231 if (resolver == null) {
4232 // may happen if the device does not support IMS.
4233 return;
4234 }
4235 resolver.disableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004236 } finally {
4237 Binder.restoreCallingIdentity(identity);
4238 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004239 }
4240
4241 /**
4242 * Returns the {@link IImsMmTelFeature} that corresponds to the given slot Id for the MMTel
4243 * feature or {@link null} if the service is not available. If the feature is available, the
4244 * {@link IImsServiceFeatureCallback} callback is registered as a listener for feature updates.
4245 */
4246 public IImsMmTelFeature getMmTelFeatureAndListen(int slotId,
Brad Ebinger34bef922017-11-09 10:27:08 -08004247 IImsServiceFeatureCallback callback) {
4248 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004249
4250 final long identity = Binder.clearCallingIdentity();
4251 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004252 ImsResolver resolver = PhoneFactory.getImsResolver();
4253 if (resolver == null) {
4254 // may happen if the device does not support IMS.
4255 return null;
4256 }
4257 return resolver.getMmTelFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004258 } finally {
4259 Binder.restoreCallingIdentity(identity);
4260 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004261 }
4262
4263 /**
4264 * Returns the {@link IImsRcsFeature} that corresponds to the given slot Id for the RCS
4265 * feature during emergency calling or {@link null} if the service is not available. If the
4266 * feature is available, the {@link IImsServiceFeatureCallback} callback is registered as a
4267 * listener for feature updates.
4268 */
4269 public IImsRcsFeature getRcsFeatureAndListen(int slotId, IImsServiceFeatureCallback callback) {
4270 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004271
4272 final long identity = Binder.clearCallingIdentity();
4273 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004274 ImsResolver resolver = PhoneFactory.getImsResolver();
4275 if (resolver == null) {
4276 // may happen if the device does not support IMS.
4277 return null;
4278 }
4279 return resolver.getRcsFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004280 } finally {
4281 Binder.restoreCallingIdentity(identity);
4282 }
Brad Ebinger51f743a2017-01-23 13:50:20 -08004283 }
4284
Brad Ebinger5f64b052017-12-14 14:26:15 -08004285 /**
4286 * Returns the {@link IImsRegistration} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004287 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger5f64b052017-12-14 14:26:15 -08004288 */
4289 public IImsRegistration getImsRegistration(int slotId, int feature) throws RemoteException {
4290 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004291
4292 final long identity = Binder.clearCallingIdentity();
4293 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004294 ImsResolver resolver = PhoneFactory.getImsResolver();
4295 if (resolver == null) {
4296 // may happen if the device does not support IMS.
4297 return null;
4298 }
4299 return resolver.getImsRegistration(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004300 } finally {
4301 Binder.restoreCallingIdentity(identity);
4302 }
Brad Ebinger5f64b052017-12-14 14:26:15 -08004303 }
4304
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004305 /**
4306 * Returns the {@link IImsConfig} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004307 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004308 */
4309 public IImsConfig getImsConfig(int slotId, int feature) throws RemoteException {
4310 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004311
4312 final long identity = Binder.clearCallingIdentity();
4313 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004314 ImsResolver resolver = PhoneFactory.getImsResolver();
4315 if (resolver == null) {
4316 // may happen if the device does not support IMS.
4317 return null;
4318 }
4319 return resolver.getImsConfig(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004320 } finally {
4321 Binder.restoreCallingIdentity(identity);
4322 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004323 }
4324
Brad Ebinger884c07b2018-02-15 16:17:40 -08004325 /**
Brad Ebingerdac2f002018-04-03 15:17:52 -07004326 * Sets the ImsService Package Name that Telephony will bind to.
4327 *
4328 * @param slotId the slot ID that the ImsService should bind for.
4329 * @param isCarrierImsService true if the ImsService is the carrier override, false if the
4330 * ImsService is the device default ImsService.
4331 * @param packageName The package name of the application that contains the ImsService to bind
4332 * to.
4333 * @return true if setting the ImsService to bind to succeeded, false if it did not.
4334 * @hide
4335 */
4336 public boolean setImsService(int slotId, boolean isCarrierImsService, String packageName) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004337 int[] subIds = SubscriptionManager.getSubId(slotId);
4338 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4339 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4340 "setImsService");
4341
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004342 final long identity = Binder.clearCallingIdentity();
4343 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004344 ImsResolver resolver = PhoneFactory.getImsResolver();
4345 if (resolver == null) {
4346 // may happen if the device does not support IMS.
4347 return false;
4348 }
4349 return resolver.overrideImsServiceConfiguration(slotId, isCarrierImsService,
4350 packageName);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004351 } finally {
4352 Binder.restoreCallingIdentity(identity);
4353 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004354 }
4355
4356 /**
4357 * Return the ImsService configuration.
4358 *
4359 * @param slotId The slot that the ImsService is associated with.
4360 * @param isCarrierImsService true, if the ImsService is a carrier override, false if it is
4361 * the device default.
4362 * @return the package name of the ImsService configuration.
4363 */
4364 public String getImsService(int slotId, boolean isCarrierImsService) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004365 int[] subIds = SubscriptionManager.getSubId(slotId);
4366 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4367 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4368 "getImsService");
4369
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004370 final long identity = Binder.clearCallingIdentity();
4371 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004372 ImsResolver resolver = PhoneFactory.getImsResolver();
4373 if (resolver == null) {
4374 // may happen if the device does not support IMS.
4375 return "";
4376 }
4377 return resolver.getImsServiceConfiguration(slotId, isCarrierImsService);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004378 } finally {
4379 Binder.restoreCallingIdentity(identity);
4380 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004381 }
4382
Wink Saville36469e72014-06-11 15:17:00 -07004383 public void setImsRegistrationState(boolean registered) {
4384 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004385
4386 final long identity = Binder.clearCallingIdentity();
4387 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004388 getDefaultPhone().setImsRegistrationState(registered);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004389 } finally {
4390 Binder.restoreCallingIdentity(identity);
4391 }
Wink Saville36469e72014-06-11 15:17:00 -07004392 }
4393
4394 /**
Stuart Scott54788802015-03-30 13:18:01 -07004395 * Set the network selection mode to automatic.
4396 *
4397 */
4398 @Override
4399 public void setNetworkSelectionModeAutomatic(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004400 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4401 mApp, subId, "setNetworkSelectionModeAutomatic");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004402
Pengquan Menge92a50d2018-09-21 15:54:48 -07004403 if (!isActiveSubscription(subId)) {
4404 return;
4405 }
4406
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004407 final long identity = Binder.clearCallingIdentity();
4408 try {
4409 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
4410 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
4411 } finally {
4412 Binder.restoreCallingIdentity(identity);
4413 }
Stuart Scott54788802015-03-30 13:18:01 -07004414 }
4415
Pengquan Mengea84e042018-09-20 14:57:26 -07004416 /**
4417 * Ask the radio to connect to the input network and change selection mode to manual.
4418 *
4419 * @param subId the id of the subscription.
4420 * @param operatorInfo the operator information, included the PLMN, long name and short name of
4421 * the operator to attach to.
4422 * @param persistSelection whether the selection will persist until reboot. If true, only allows
4423 * attaching to the selected PLMN until reboot; otherwise, attach to the chosen PLMN and resume
4424 * normal network selection next time.
4425 * @return {@code true} on success; {@code true} on any failure.
Shishir Agrawal302c8692015-06-19 13:49:39 -07004426 */
4427 @Override
Pengquan Mengea84e042018-09-20 14:57:26 -07004428 public boolean setNetworkSelectionModeManual(
4429 int subId, OperatorInfo operatorInfo, boolean persistSelection) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004430 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4431 mApp, subId, "setNetworkSelectionModeManual");
Pengquan Menge92a50d2018-09-21 15:54:48 -07004432
4433 if (!isActiveSubscription(subId)) {
4434 return false;
4435 }
4436
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004437 final long identity = Binder.clearCallingIdentity();
4438 try {
Pengquan Mengea84e042018-09-20 14:57:26 -07004439 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operatorInfo,
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004440 persistSelection);
Pengquan Mengea84e042018-09-20 14:57:26 -07004441 if (DBG) {
4442 log("setNetworkSelectionModeManual: subId: " + subId
4443 + " operator: " + operatorInfo);
4444 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004445 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
4446 } finally {
4447 Binder.restoreCallingIdentity(identity);
4448 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004449 }
4450
4451 /**
4452 * Scans for available networks.
4453 */
4454 @Override
Hall Liuf19c44f2018-11-27 14:38:17 -08004455 public CellNetworkScanResult getCellNetworkScanResults(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004456 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4457 mApp, subId, "getCellNetworkScanResults");
Hall Liuf19c44f2018-11-27 14:38:17 -08004458 LocationAccessPolicy.LocationPermissionResult locationResult =
4459 LocationAccessPolicy.checkLocationPermission(mApp,
4460 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4461 .setCallingPackage(callingPackage)
4462 .setCallingPid(Binder.getCallingPid())
4463 .setCallingUid(Binder.getCallingUid())
4464 .setMethod("getCellNetworkScanResults")
4465 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4466 .build());
4467 switch (locationResult) {
4468 case DENIED_HARD:
4469 throw new SecurityException("Not allowed to access scan results -- location");
4470 case DENIED_SOFT:
4471 return null;
4472 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004473
Pengquan Menga1bb6272018-09-06 09:59:22 -07004474 long identity = Binder.clearCallingIdentity();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004475 try {
4476 if (DBG) log("getCellNetworkScanResults: subId " + subId);
Pengquan Menga1bb6272018-09-06 09:59:22 -07004477 return (CellNetworkScanResult) sendRequest(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004478 CMD_PERFORM_NETWORK_SCAN, null, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004479 } finally {
4480 Binder.restoreCallingIdentity(identity);
4481 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004482 }
4483
4484 /**
yinxub1bed742017-04-17 11:45:04 -07004485 * Starts a new network scan and returns the id of this scan.
yinxu504e1392017-04-12 16:03:22 -07004486 *
yinxub1bed742017-04-17 11:45:04 -07004487 * @param subId id of the subscription
4488 * @param request contains the radio access networks with bands/channels to scan
4489 * @param messenger callback messenger for scan results or errors
4490 * @param binder for the purpose of auto clean when the user thread crashes
yinxu504e1392017-04-12 16:03:22 -07004491 * @return the id of the requested scan which can be used to stop the scan.
4492 */
4493 @Override
4494 public int requestNetworkScan(int subId, NetworkScanRequest request, Messenger messenger,
Hall Liuf19c44f2018-11-27 14:38:17 -08004495 IBinder binder, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004496 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4497 mApp, subId, "requestNetworkScan");
Hall Liuf19c44f2018-11-27 14:38:17 -08004498 LocationAccessPolicy.LocationPermissionResult locationResult =
4499 LocationAccessPolicy.checkLocationPermission(mApp,
4500 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4501 .setCallingPackage(callingPackage)
4502 .setCallingPid(Binder.getCallingPid())
4503 .setCallingUid(Binder.getCallingUid())
4504 .setMethod("requestNetworkScan")
4505 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4506 .build());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004507 if (locationResult != LocationAccessPolicy.LocationPermissionResult.ALLOWED) {
Hall Liu558027f2019-05-15 19:14:05 -07004508 SecurityException e = checkNetworkRequestForSanitizedLocationAccess(request, subId);
Hall Liub2ac8ef2019-02-28 15:56:23 -08004509 if (e != null) {
4510 if (locationResult == LocationAccessPolicy.LocationPermissionResult.DENIED_HARD) {
4511 throw e;
4512 } else {
Hall Liu0e5abaf2019-04-04 01:25:30 -07004513 loge(e.getMessage());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004514 return TelephonyScanManager.INVALID_SCAN_ID;
4515 }
4516 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004517 }
Hall Liu912dfd32019-04-25 14:02:26 -07004518 int callingUid = Binder.getCallingUid();
4519 int callingPid = Binder.getCallingPid();
Ying Xu94a46582019-04-18 17:14:56 -07004520 final long identity = Binder.clearCallingIdentity();
4521 try {
4522 return mNetworkScanRequestTracker.startNetworkScan(
4523 request, messenger, binder, getPhone(subId),
Hall Liu912dfd32019-04-25 14:02:26 -07004524 callingUid, callingPid, callingPackage);
Ying Xu94a46582019-04-18 17:14:56 -07004525 } finally {
4526 Binder.restoreCallingIdentity(identity);
4527 }
yinxu504e1392017-04-12 16:03:22 -07004528 }
4529
Hall Liub2ac8ef2019-02-28 15:56:23 -08004530 private SecurityException checkNetworkRequestForSanitizedLocationAccess(
Hall Liu558027f2019-05-15 19:14:05 -07004531 NetworkScanRequest request, int subId) {
4532 boolean hasCarrierPriv = getCarrierPrivilegeStatusForUid(subId, Binder.getCallingUid())
4533 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
4534 boolean hasNetworkScanPermission =
4535 mApp.checkCallingOrSelfPermission(android.Manifest.permission.NETWORK_SCAN)
4536 == PERMISSION_GRANTED;
4537
4538 if (!hasCarrierPriv && !hasNetworkScanPermission) {
4539 return new SecurityException("permission.NETWORK_SCAN or carrier privileges is needed"
4540 + " for network scans without location access.");
Hall Liub2ac8ef2019-02-28 15:56:23 -08004541 }
4542
4543 if (request.getSpecifiers() != null && request.getSpecifiers().length > 0) {
4544 for (RadioAccessSpecifier ras : request.getSpecifiers()) {
Hall Liub2ac8ef2019-02-28 15:56:23 -08004545 if (ras.getChannels() != null && ras.getChannels().length > 0) {
4546 return new SecurityException("Specific channels must not be"
4547 + " scanned without location access.");
4548 }
4549 }
4550 }
4551
Hall Liub2ac8ef2019-02-28 15:56:23 -08004552 return null;
4553 }
4554
yinxu504e1392017-04-12 16:03:22 -07004555 /**
4556 * Stops an existing network scan with the given scanId.
yinxub1bed742017-04-17 11:45:04 -07004557 *
4558 * @param subId id of the subscription
4559 * @param scanId id of the scan that needs to be stopped
yinxu504e1392017-04-12 16:03:22 -07004560 */
4561 @Override
4562 public void stopNetworkScan(int subId, int scanId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004563 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4564 mApp, subId, "stopNetworkScan");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004565
Hall Liu912dfd32019-04-25 14:02:26 -07004566 int callingUid = Binder.getCallingUid();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004567 final long identity = Binder.clearCallingIdentity();
4568 try {
Hall Liu912dfd32019-04-25 14:02:26 -07004569 mNetworkScanRequestTracker.stopNetworkScan(scanId, callingUid);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004570 } finally {
4571 Binder.restoreCallingIdentity(identity);
4572 }
yinxu504e1392017-04-12 16:03:22 -07004573 }
4574
4575 /**
Junda Liu84d15a22014-07-02 11:21:04 -07004576 * Get the calculated preferred network type.
4577 * Used for debugging incorrect network type.
4578 *
4579 * @return the preferred network type, defined in RILConstants.java.
4580 */
4581 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004582 public int getCalculatedPreferredNetworkType(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004583 final Phone defaultPhone = getDefaultPhone();
4584 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
4585 callingPackage, "getCalculatedPreferredNetworkType")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004586 return RILConstants.PREFERRED_NETWORK_MODE;
4587 }
4588
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004589 final long identity = Binder.clearCallingIdentity();
4590 try {
4591 // FIXME: need to get SubId from somewhere.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004592 return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004593 } finally {
4594 Binder.restoreCallingIdentity(identity);
4595 }
Junda Liu84d15a22014-07-02 11:21:04 -07004596 }
4597
4598 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08004599 * Get the preferred network type.
4600 * Used for device configuration by some CDMA operators.
4601 *
4602 * @return the preferred network type, defined in RILConstants.java.
4603 */
4604 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004605 public int getPreferredNetworkType(int subId) {
Pengquan Menga4009cb2018-12-20 11:00:24 -08004606 TelephonyPermissions
4607 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
4608 mApp, subId, "getPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004609
4610 final long identity = Binder.clearCallingIdentity();
4611 try {
4612 if (DBG) log("getPreferredNetworkType");
4613 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
4614 int networkType = (result != null ? result[0] : -1);
4615 if (DBG) log("getPreferredNetworkType: " + networkType);
4616 return networkType;
4617 } finally {
4618 Binder.restoreCallingIdentity(identity);
4619 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004620 }
4621
4622 /**
4623 * Set the preferred network type.
4624 * Used for device configuration by some CDMA operators.
4625 *
4626 * @param networkType the preferred network type, defined in RILConstants.java.
4627 * @return true on success; false on any failure.
4628 */
4629 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004630 public boolean setPreferredNetworkType(int subId, int networkType) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004631 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4632 mApp, subId, "setPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004633
4634 final long identity = Binder.clearCallingIdentity();
4635 try {
4636 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
4637 Boolean success = (Boolean) sendRequest(
4638 CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
4639 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
4640 if (success) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004641 Settings.Global.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004642 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
4643 }
4644 return success;
4645 } finally {
4646 Binder.restoreCallingIdentity(identity);
Junda Liu80bc0d12014-07-14 16:36:44 -07004647 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004648 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004649
4650 /**
Miaoa84611c2019-03-15 09:21:10 +08004651 * Check whether DUN APN is required for tethering with subId.
Junda Liu475951f2014-11-07 16:45:03 -08004652 *
Miaoa84611c2019-03-15 09:21:10 +08004653 * @param subId the id of the subscription to require tethering.
Amit Mahajanfe58cdf2017-07-11 12:01:53 -07004654 * @return {@code true} if DUN APN is required for tethering.
Junda Liu475951f2014-11-07 16:45:03 -08004655 * @hide
4656 */
4657 @Override
Miaoa84611c2019-03-15 09:21:10 +08004658 public boolean getTetherApnRequiredForSubscriber(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004659 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004660 final long identity = Binder.clearCallingIdentity();
Miaoa84611c2019-03-15 09:21:10 +08004661 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004662 try {
Miaoa84611c2019-03-15 09:21:10 +08004663 if (phone != null) {
4664 return phone.hasMatchedTetherApnSetting();
4665 } else {
4666 return false;
4667 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004668 } finally {
4669 Binder.restoreCallingIdentity(identity);
Junda Liu475951f2014-11-07 16:45:03 -08004670 }
Junda Liu475951f2014-11-07 16:45:03 -08004671 }
4672
4673 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07004674 * Set mobile data enabled
4675 * Used by the user through settings etc to turn on/off mobile data
4676 *
4677 * @param enable {@code true} turn turn data on, else {@code false}
4678 */
4679 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004680 public void setUserDataEnabled(int subId, boolean enable) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004681 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4682 mApp, subId, "setUserDataEnabled");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004683
4684 final long identity = Binder.clearCallingIdentity();
4685 try {
4686 int phoneId = mSubscriptionController.getPhoneId(subId);
4687 if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4688 Phone phone = PhoneFactory.getPhone(phoneId);
4689 if (phone != null) {
4690 if (DBG) log("setUserDataEnabled: subId=" + subId + " enable=" + enable);
Jack Yud79fba22018-12-13 11:51:28 -08004691 phone.getDataEnabledSettings().setUserDataEnabled(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004692 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004693 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004694 }
4695 } finally {
4696 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004697 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004698 }
4699
4700 /**
Malcolm Chen964682d2017-11-28 16:20:07 -08004701 * Get the user enabled state of Mobile Data.
4702 *
4703 * TODO: remove and use isUserDataEnabled.
4704 * This can't be removed now because some vendor codes
4705 * calls through ITelephony directly while they should
4706 * use TelephonyManager.
4707 *
4708 * @return true on enabled
4709 */
4710 @Override
4711 public boolean getDataEnabled(int subId) {
4712 return isUserDataEnabled(subId);
4713 }
4714
4715 /**
4716 * Get whether mobile data is enabled per user setting.
4717 *
4718 * There are other factors deciding whether mobile data is actually enabled, but they are
4719 * not considered here. See {@link #isDataEnabled(int)} for more details.
Robert Greenwalt646120a2014-05-23 11:54:03 -07004720 *
Jeff Davidsona1920712016-11-18 17:05:56 -08004721 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
Robert Greenwalted86e582014-05-21 20:03:20 -07004722 *
4723 * @return {@code true} if data is enabled else {@code false}
4724 */
4725 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004726 public boolean isUserDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07004727 try {
4728 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4729 null);
4730 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004731 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4732 mApp, subId, "isUserDataEnabled");
Robert Greenwalt646120a2014-05-23 11:54:03 -07004733 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004734
4735 final long identity = Binder.clearCallingIdentity();
4736 try {
4737 int phoneId = mSubscriptionController.getPhoneId(subId);
4738 if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4739 Phone phone = PhoneFactory.getPhone(phoneId);
4740 if (phone != null) {
4741 boolean retVal = phone.isUserDataEnabled();
4742 if (DBG) log("isUserDataEnabled: subId=" + subId + " retVal=" + retVal);
4743 return retVal;
4744 } else {
4745 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
4746 return false;
4747 }
4748 } finally {
4749 Binder.restoreCallingIdentity(identity);
Malcolm Chen964682d2017-11-28 16:20:07 -08004750 }
4751 }
4752
4753 /**
4754 * Get whether mobile data is enabled.
4755 *
4756 * Comparable to {@link #isUserDataEnabled(int)}, this considers all factors deciding
4757 * whether mobile data is actually enabled.
4758 *
4759 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
4760 *
4761 * @return {@code true} if data is enabled else {@code false}
4762 */
4763 @Override
4764 public boolean isDataEnabled(int subId) {
4765 try {
4766 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4767 null);
4768 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004769 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4770 mApp, subId, "isDataEnabled");
Malcolm Chen964682d2017-11-28 16:20:07 -08004771 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004772
4773 final long identity = Binder.clearCallingIdentity();
4774 try {
4775 int phoneId = mSubscriptionController.getPhoneId(subId);
4776 if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4777 Phone phone = PhoneFactory.getPhone(phoneId);
4778 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08004779 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004780 if (DBG) log("isDataEnabled: subId=" + subId + " retVal=" + retVal);
4781 return retVal;
4782 } else {
4783 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
4784 return false;
4785 }
4786 } finally {
4787 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004788 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004789 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004790
4791 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004792 public int getCarrierPrivilegeStatus(int subId) {
4793 final Phone phone = getPhone(subId);
4794 if (phone == null) {
4795 loge("getCarrierPrivilegeStatus: Invalid subId");
4796 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4797 }
4798 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004799 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08004800 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004801 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4802 }
4803 return card.getCarrierPrivilegeStatusForCurrentTransaction(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004804 phone.getContext().getPackageManager());
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004805 }
Junda Liu29340342014-07-10 15:23:27 -07004806
4807 @Override
Jeff Davidson7e17e312018-02-13 18:17:36 -08004808 public int getCarrierPrivilegeStatusForUid(int subId, int uid) {
4809 final Phone phone = getPhone(subId);
4810 if (phone == null) {
4811 loge("getCarrierPrivilegeStatus: Invalid subId");
4812 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4813 }
4814 UiccProfile profile =
4815 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
4816 if (profile == null) {
4817 loge("getCarrierPrivilegeStatus: No UICC");
4818 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4819 }
4820 return profile.getCarrierPrivilegeStatusForUid(phone.getContext().getPackageManager(), uid);
4821 }
4822
4823 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07004824 public int checkCarrierPrivilegesForPackage(int subId, String pkgName) {
4825 if (TextUtils.isEmpty(pkgName)) {
Junda Liu317d70b2016-03-08 09:33:53 -08004826 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
chen xuf7e9fe82019-05-09 19:31:02 -07004827 }
4828
4829 int phoneId = SubscriptionManager.getPhoneId(subId);
4830 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004831 if (card == null) {
chen xuf7e9fe82019-05-09 19:31:02 -07004832 loge("checkCarrierPrivilegesForPackage: No UICC on subId " + subId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004833 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4834 }
chen xuf7e9fe82019-05-09 19:31:02 -07004835
4836 return card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004837 }
4838
4839 @Override
4840 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08004841 if (TextUtils.isEmpty(pkgName))
4842 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07004843 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4844 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4845 UiccCard card = UiccController.getInstance().getUiccCard(i);
4846 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07004847 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07004848 continue;
4849 }
4850
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004851 result = card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004852 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
4853 break;
4854 }
4855 }
4856
4857 return result;
Junda Liu29340342014-07-10 15:23:27 -07004858 }
Derek Tan89e89d42014-07-08 17:00:10 -07004859
4860 @Override
Junda Liue64de782015-04-16 17:19:16 -07004861 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
4862 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
4863 loge("phoneId " + phoneId + " is not valid.");
4864 return null;
4865 }
4866 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004867 if (card == null) {
Diego Pontorieroaf74c862014-08-28 11:51:16 -07004868 loge("getCarrierPackageNamesForIntent: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004869 return null ;
4870 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004871 return card.getCarrierPackageNamesForIntent(mApp.getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004872 }
4873
Amith Yamasani6e118872016-02-19 12:53:51 -08004874 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07004875 public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004876 PackageManager pm = mApp.getPackageManager();
Amith Yamasani6e118872016-02-19 12:53:51 -08004877 List<String> privilegedPackages = new ArrayList<>();
4878 List<PackageInfo> packages = null;
chen xuf7e9fe82019-05-09 19:31:02 -07004879 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
4880 // has UICC in that slot.
4881 if (card != null) {
Amith Yamasani6e118872016-02-19 12:53:51 -08004882 if (card.hasCarrierPrivilegeRules()) {
4883 if (packages == null) {
4884 // Only check packages in user 0 for now
4885 packages = pm.getInstalledPackagesAsUser(
4886 PackageManager.MATCH_DISABLED_COMPONENTS
chen xuf7e9fe82019-05-09 19:31:02 -07004887 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
4888 | PackageManager.GET_SIGNATURES, UserHandle.USER_SYSTEM);
Amith Yamasani6e118872016-02-19 12:53:51 -08004889 }
4890 for (int p = packages.size() - 1; p >= 0; p--) {
4891 PackageInfo pkgInfo = packages.get(p);
4892 if (pkgInfo != null && pkgInfo.packageName != null
4893 && card.getCarrierPrivilegeStatus(pkgInfo)
chen xuf7e9fe82019-05-09 19:31:02 -07004894 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Amith Yamasani6e118872016-02-19 12:53:51 -08004895 privilegedPackages.add(pkgInfo.packageName);
4896 }
4897 }
4898 }
4899 }
4900 return privilegedPackages;
4901 }
4902
chen xuf7e9fe82019-05-09 19:31:02 -07004903 @Override
4904 public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
4905 List<String> privilegedPackages = new ArrayList<>();
4906 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4907 privilegedPackages.addAll(getPackagesWithCarrierPrivileges(i));
4908 }
4909 return privilegedPackages;
4910 }
4911
Wink Savilleb564aae2014-10-23 10:18:09 -07004912 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07004913 final Phone phone = getPhone(subId);
4914 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07004915 if (card == null) {
4916 loge("getIccId: No UICC");
4917 return null;
4918 }
4919 String iccId = card.getIccId();
4920 if (TextUtils.isEmpty(iccId)) {
4921 loge("getIccId: ICC ID is null or empty.");
4922 return null;
4923 }
4924 return iccId;
4925 }
4926
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004927 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08004928 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
4929 String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004930 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
4931 subId, "setLine1NumberForDisplayForSubscriber");
Derek Tan97ebb422014-09-05 16:55:38 -07004932
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004933 final long identity = Binder.clearCallingIdentity();
4934 try {
4935 final String iccId = getIccId(subId);
4936 final Phone phone = getPhone(subId);
4937 if (phone == null) {
4938 return false;
4939 }
4940 final String subscriberId = phone.getSubscriberId();
4941
4942 if (DBG_MERGE) {
4943 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
4944 + subscriberId + " to " + number);
4945 }
4946
4947 if (TextUtils.isEmpty(iccId)) {
4948 return false;
4949 }
4950
4951 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
4952
4953 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
4954 if (alphaTag == null) {
4955 editor.remove(alphaTagPrefKey);
4956 } else {
4957 editor.putString(alphaTagPrefKey, alphaTag);
4958 }
4959
4960 // Record both the line number and IMSI for this ICCID, since we need to
4961 // track all merged IMSIs based on line number
4962 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4963 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
4964 if (number == null) {
4965 editor.remove(numberPrefKey);
4966 editor.remove(subscriberPrefKey);
4967 } else {
4968 editor.putString(numberPrefKey, number);
4969 editor.putString(subscriberPrefKey, subscriberId);
4970 }
4971
4972 editor.commit();
4973 return true;
4974 } finally {
4975 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07004976 }
Derek Tan7226c842014-07-02 17:42:23 -07004977 }
4978
4979 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004980 public String getLine1NumberForDisplay(int subId, String callingPackage) {
Makoto Onukifee69342015-06-29 14:44:50 -07004981 // This is open to apps with WRITE_SMS.
Jeff Davidson7e17e312018-02-13 18:17:36 -08004982 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
Jeff Davidson913390f2018-02-23 17:11:49 -08004983 mApp, subId, callingPackage, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08004984 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07004985 return null;
4986 }
Derek Tan97ebb422014-09-05 16:55:38 -07004987
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004988 final long identity = Binder.clearCallingIdentity();
4989 try {
4990 String iccId = getIccId(subId);
4991 if (iccId != null) {
4992 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4993 if (DBG_MERGE) {
4994 log("getLine1NumberForDisplay returning "
4995 + mTelephonySharedPreferences.getString(numberPrefKey, null));
4996 }
4997 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Amit Mahajan9cf11512015-11-09 11:40:48 -08004998 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004999 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
5000 return null;
5001 } finally {
5002 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07005003 }
Derek Tan7226c842014-07-02 17:42:23 -07005004 }
5005
5006 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005007 public String getLine1AlphaTagForDisplay(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005008 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005009 mApp, subId, callingPackage, "getLine1AlphaTagForDisplay")) {
Svet Ganovb320e182015-04-16 12:30:10 -07005010 return null;
5011 }
Derek Tan97ebb422014-09-05 16:55:38 -07005012
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005013 final long identity = Binder.clearCallingIdentity();
5014 try {
5015 String iccId = getIccId(subId);
5016 if (iccId != null) {
5017 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
5018 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
5019 }
5020 return null;
5021 } finally {
5022 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07005023 }
Derek Tan7226c842014-07-02 17:42:23 -07005024 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005025
5026 @Override
Jordan Liub49b04b2019-05-06 14:45:15 -07005027 public String[] getMergedSubscriberIds(int subId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005028 // This API isn't public, so no need to provide a valid subscription ID - we're not worried
5029 // about carrier-privileged callers not having access.
Jeff Davidson7e17e312018-02-13 18:17:36 -08005030 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005031 mApp, SubscriptionManager.INVALID_SUBSCRIPTION_ID, callingPackage,
5032 "getMergedSubscriberIds")) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005033 return null;
5034 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005035
Jordan Liub49b04b2019-05-06 14:45:15 -07005036 // Clear calling identity, when calling TelephonyManager, because callerUid must be
5037 // the process, where TelephonyManager was instantiated.
5038 // Otherwise AppOps check will fail.
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005039 final long identity = Binder.clearCallingIdentity();
5040 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005041 final Context context = mApp;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005042 final TelephonyManager tele = TelephonyManager.from(context);
5043 final SubscriptionManager sub = SubscriptionManager.from(context);
5044
5045 // Figure out what subscribers are currently active
5046 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005047
Jordan Liub49b04b2019-05-06 14:45:15 -07005048 // Only consider subs which match the current subId
5049 // This logic can be simplified. See b/131189269 for progress.
5050 if (isActiveSubscription(subId)) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005051 activeSubscriberIds.add(tele.getSubscriberId(subId));
5052 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005053
5054 // First pass, find a number override for an active subscriber
5055 String mergeNumber = null;
5056 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
5057 for (String key : prefs.keySet()) {
5058 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
5059 final String subscriberId = (String) prefs.get(key);
5060 if (activeSubscriberIds.contains(subscriberId)) {
5061 final String iccId = key.substring(
5062 PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
5063 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5064 mergeNumber = (String) prefs.get(numberKey);
5065 if (DBG_MERGE) {
5066 Slog.d(LOG_TAG, "Found line number " + mergeNumber
5067 + " for active subscriber " + subscriberId);
5068 }
5069 if (!TextUtils.isEmpty(mergeNumber)) {
5070 break;
5071 }
5072 }
5073 }
5074 }
5075
5076 // Shortcut when no active merged subscribers
5077 if (TextUtils.isEmpty(mergeNumber)) {
5078 return null;
5079 }
5080
5081 // Second pass, find all subscribers under that line override
5082 final ArraySet<String> result = new ArraySet<>();
5083 for (String key : prefs.keySet()) {
5084 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
5085 final String number = (String) prefs.get(key);
5086 if (mergeNumber.equals(number)) {
5087 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
5088 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
5089 final String subscriberId = (String) prefs.get(subscriberKey);
5090 if (!TextUtils.isEmpty(subscriberId)) {
5091 result.add(subscriberId);
5092 }
5093 }
5094 }
5095 }
5096
5097 final String[] resultArray = result.toArray(new String[result.size()]);
5098 Arrays.sort(resultArray);
5099 if (DBG_MERGE) {
5100 Slog.d(LOG_TAG,
5101 "Found subscribers " + Arrays.toString(resultArray) + " after merge");
5102 }
5103 return resultArray;
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005104 } finally {
5105 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08005106 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005107 }
5108
5109 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005110 public boolean setOperatorBrandOverride(int subId, String brand) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005111 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
5112 subId, "setOperatorBrandOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005113
5114 final long identity = Binder.clearCallingIdentity();
5115 try {
5116 final Phone phone = getPhone(subId);
5117 return phone == null ? false : phone.setOperatorBrandOverride(brand);
5118 } finally {
5119 Binder.restoreCallingIdentity(identity);
5120 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005121 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05005122
5123 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005124 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005125 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
5126 List<String> cdmaNonRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005127 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setRoamingOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005128
5129 final long identity = Binder.clearCallingIdentity();
5130 try {
5131 final Phone phone = getPhone(subId);
5132 if (phone == null) {
5133 return false;
5134 }
5135 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
5136 cdmaNonRoamingList);
5137 } finally {
5138 Binder.restoreCallingIdentity(identity);
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005139 }
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005140 }
5141
5142 @Override
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005143 @Deprecated
5144 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
5145 enforceModifyPermission();
5146
5147 int returnValue = 0;
5148 try {
vagdeviaf9a5b92018-08-15 16:01:53 -07005149 AsyncResult result = (AsyncResult) sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005150 if(result.exception == null) {
5151 if (result.result != null) {
5152 byte[] responseData = (byte[])(result.result);
5153 if(responseData.length > oemResp.length) {
5154 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
5155 responseData.length + "bytes. Buffer Size is " +
5156 oemResp.length + "bytes.");
5157 }
5158 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
5159 returnValue = responseData.length;
5160 }
5161 } else {
5162 CommandException ex = (CommandException) result.exception;
5163 returnValue = ex.getCommandError().ordinal();
5164 if(returnValue > 0) returnValue *= -1;
5165 }
5166 } catch (RuntimeException e) {
5167 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
5168 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
5169 if(returnValue > 0) returnValue *= -1;
5170 }
5171
5172 return returnValue;
5173 }
5174
5175 @Override
Wink Saville5d475dd2014-10-17 15:00:58 -07005176 public void setRadioCapability(RadioAccessFamily[] rafs) {
5177 try {
5178 ProxyController.getInstance().setRadioCapability(rafs);
5179 } catch (RuntimeException e) {
5180 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
5181 }
5182 }
5183
5184 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07005185 public int getRadioAccessFamily(int phoneId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005186 Phone phone = PhoneFactory.getPhone(phoneId);
chen xub97461a2018-10-26 14:17:57 -07005187 int raf = RadioAccessFamily.RAF_UNKNOWN;
Jeff Davidson913390f2018-02-23 17:11:49 -08005188 if (phone == null) {
chen xub97461a2018-10-26 14:17:57 -07005189 return raf;
Jeff Davidson913390f2018-02-23 17:11:49 -08005190 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005191 final long identity = Binder.clearCallingIdentity();
5192 try {
chen xub97461a2018-10-26 14:17:57 -07005193 TelephonyPermissions
5194 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5195 mApp, phone.getSubId(), "getRadioAccessFamily");
5196 raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005197 } finally {
5198 Binder.restoreCallingIdentity(identity);
5199 }
chen xub97461a2018-10-26 14:17:57 -07005200 return raf;
Wink Saville5d475dd2014-10-17 15:00:58 -07005201 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005202
5203 @Override
5204 public void enableVideoCalling(boolean enable) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005205 final Phone defaultPhone = getDefaultPhone();
Andrew Leedf14ead2014-10-17 14:22:52 -07005206 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005207
5208 final long identity = Binder.clearCallingIdentity();
5209 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005210 ImsManager.getInstance(defaultPhone.getContext(),
5211 defaultPhone.getPhoneId()).setVtSetting(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005212 } finally {
5213 Binder.restoreCallingIdentity(identity);
5214 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005215 }
5216
5217 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005218 public boolean isVideoCallingEnabled(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005219 final Phone defaultPhone = getDefaultPhone();
Amit Mahajan578e53d2018-03-20 16:18:38 +00005220 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005221 mApp, defaultPhone.getSubId(), callingPackage, "isVideoCallingEnabled")) {
Amit Mahajan578e53d2018-03-20 16:18:38 +00005222 return false;
5223 }
Svet Ganovb320e182015-04-16 12:30:10 -07005224
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005225 final long identity = Binder.clearCallingIdentity();
5226 try {
5227 // Check the user preference and the system-level IMS setting. Even if the user has
5228 // enabled video calling, if IMS is disabled we aren't able to support video calling.
5229 // In the long run, we may instead need to check if there exists a connection service
5230 // which can support video calling.
5231 ImsManager imsManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005232 ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005233 return imsManager.isVtEnabledByPlatform()
5234 && imsManager.isEnhanced4gLteModeSettingEnabledByUser()
5235 && imsManager.isVtEnabledByUser();
5236 } finally {
5237 Binder.restoreCallingIdentity(identity);
5238 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005239 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06005240
Andrew Leea1239f22015-03-02 17:44:07 -08005241 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005242 public boolean canChangeDtmfToneLength(int subId, String callingPackage) {
5243 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5244 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5245 return false;
5246 }
5247
5248 final long identity = Binder.clearCallingIdentity();
5249 try {
5250 CarrierConfigManager configManager =
5251 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005252 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005253 .getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
5254 } finally {
5255 Binder.restoreCallingIdentity(identity);
5256 }
Andrew Leea1239f22015-03-02 17:44:07 -08005257 }
5258
5259 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005260 public boolean isWorldPhone(int subId, String callingPackage) {
5261 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5262 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5263 return false;
5264 }
5265
5266 final long identity = Binder.clearCallingIdentity();
5267 try {
5268 CarrierConfigManager configManager =
5269 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005270 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005271 .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
5272 } finally {
5273 Binder.restoreCallingIdentity(identity);
5274 }
Andrew Leea1239f22015-03-02 17:44:07 -08005275 }
5276
Andrew Lee9431b832015-03-09 18:46:45 -07005277 @Override
5278 public boolean isTtyModeSupported() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005279 TelecomManager telecomManager = TelecomManager.from(mApp);
Wooki Wu1f82f7a2016-02-15 15:59:58 +08005280 return telecomManager.isTtySupported();
Andrew Lee9431b832015-03-09 18:46:45 -07005281 }
5282
5283 @Override
5284 public boolean isHearingAidCompatibilitySupported() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005285 final long identity = Binder.clearCallingIdentity();
5286 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005287 return mApp.getResources().getBoolean(R.bool.hac_enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005288 } finally {
5289 Binder.restoreCallingIdentity(identity);
5290 }
Andrew Lee9431b832015-03-09 18:46:45 -07005291 }
5292
Hall Liuf6668912018-10-31 17:05:23 -07005293 /**
5294 * Determines whether the device currently supports RTT (Real-time text). Based both on carrier
5295 * support for the feature and device firmware support.
5296 *
5297 * @return {@code true} if the device and carrier both support RTT, {@code false} otherwise.
5298 */
5299 @Override
5300 public boolean isRttSupported(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005301 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005302 final Phone phone = getPhone(subscriptionId);
5303 if (phone == null) {
5304 loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
5305 return false;
5306 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005307 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005308 boolean isCarrierSupported = mApp.getCarrierConfigForSubId(subscriptionId).getBoolean(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005309 CarrierConfigManager.KEY_RTT_SUPPORTED_BOOL);
5310 boolean isDeviceSupported =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005311 phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005312 return isCarrierSupported && isDeviceSupported;
5313 } finally {
5314 Binder.restoreCallingIdentity(identity);
5315 }
Hall Liu98187582018-01-22 19:15:32 -08005316 }
5317
Hall Liuf6668912018-10-31 17:05:23 -07005318 /**
Hall Liu6a06be62019-07-23 18:39:00 -07005319 * Determines whether the user has turned on RTT. If the carrier wants to ignore the user-set
5320 * RTT setting, will return true if the device and carrier both support RTT.
5321 * Otherwise. only returns true if the device and carrier both also support RTT.
Hall Liuf6668912018-10-31 17:05:23 -07005322 */
5323 public boolean isRttEnabled(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005324 final long identity = Binder.clearCallingIdentity();
5325 try {
Hall Liu6a06be62019-07-23 18:39:00 -07005326 boolean isRttSupported = isRttSupported(subscriptionId);
5327 boolean isUserRttSettingOn = Settings.Secure.getInt(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005328 mApp.getContentResolver(), Settings.Secure.RTT_CALLING_MODE, 0) != 0;
Hall Liu6a06be62019-07-23 18:39:00 -07005329 boolean shouldIgnoreUserRttSetting = mApp.getCarrierConfigForSubId(subscriptionId)
5330 .getBoolean(CarrierConfigManager.KEY_IGNORE_RTT_MODE_SETTING_BOOL);
5331 return isRttSupported && (isUserRttSettingOn || shouldIgnoreUserRttSetting);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005332 } finally {
5333 Binder.restoreCallingIdentity(identity);
5334 }
Hall Liu3ad5f012018-04-06 16:23:39 -07005335 }
5336
Sanket Padawe7310cc72015-01-14 09:53:20 -08005337 /**
5338 * Returns the unique device ID of phone, for example, the IMEI for
5339 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
5340 *
5341 * <p>Requires Permission:
5342 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
5343 */
5344 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005345 public String getDeviceId(String callingPackage) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005346 final Phone phone = PhoneFactory.getPhone(0);
Jeff Davidson913390f2018-02-23 17:11:49 -08005347 if (phone == null) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005348 return null;
5349 }
Jeff Davidson913390f2018-02-23 17:11:49 -08005350 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07005351 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
5352 callingPackage, "getDeviceId")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005353 return null;
5354 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005355
5356 final long identity = Binder.clearCallingIdentity();
5357 try {
5358 return phone.getDeviceId();
5359 } finally {
5360 Binder.restoreCallingIdentity(identity);
5361 }
Sanket Padawe7310cc72015-01-14 09:53:20 -08005362 }
5363
Ping Sunc67b7c22016-03-02 19:16:45 +08005364 /**
5365 * {@hide}
5366 * Returns the IMS Registration Status on a particular subid
5367 *
5368 * @param subId
5369 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005370 public boolean isImsRegistered(int subId) {
Ping Sunc67b7c22016-03-02 19:16:45 +08005371 Phone phone = getPhone(subId);
5372 if (phone != null) {
5373 return phone.isImsRegistered();
5374 } else {
5375 return false;
5376 }
5377 }
5378
Santos Cordon7a1885b2015-02-03 11:15:19 -08005379 @Override
5380 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005381 final long identity = Binder.clearCallingIdentity();
5382 try {
5383 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
5384 } finally {
5385 Binder.restoreCallingIdentity(identity);
5386 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08005387 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07005388
Tyler Gunnf70ed162019-04-03 15:28:53 -07005389 @Override
5390 public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
5391 final long identity = Binder.clearCallingIdentity();
5392 try {
5393 Phone phone = getPhone(subscriptionId);
5394 if (phone == null) {
5395 return null;
5396 }
5397 return PhoneUtils.makePstnPhoneAccountHandle(phone);
5398 } finally {
5399 Binder.restoreCallingIdentity(identity);
5400 }
5401 }
5402
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005403 /**
5404 * @return the VoWiFi calling availability.
Nathan Haroldc55097a2015-03-11 18:14:50 -07005405 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005406 public boolean isWifiCallingAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005407 final long identity = Binder.clearCallingIdentity();
5408 try {
5409 Phone phone = getPhone(subId);
5410 if (phone != null) {
5411 return phone.isWifiCallingEnabled();
5412 } else {
5413 return false;
5414 }
5415 } finally {
5416 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005417 }
Nathan Haroldc55097a2015-03-11 18:14:50 -07005418 }
5419
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005420 /**
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005421 * @return the VT calling availability.
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005422 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005423 public boolean isVideoTelephonyAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005424 final long identity = Binder.clearCallingIdentity();
5425 try {
5426 Phone phone = getPhone(subId);
5427 if (phone != null) {
5428 return phone.isVideoEnabled();
5429 } else {
5430 return false;
5431 }
5432 } finally {
5433 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005434 }
5435 }
5436
5437 /**
5438 * @return the IMS registration technology for the MMTEL feature. Valid return values are
5439 * defined in {@link ImsRegistrationImplBase}.
5440 */
5441 public @ImsRegistrationImplBase.ImsRegistrationTech int getImsRegTechnologyForMmTel(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005442 final long identity = Binder.clearCallingIdentity();
5443 try {
5444 Phone phone = getPhone(subId);
5445 if (phone != null) {
5446 return phone.getImsRegistrationTech();
5447 } else {
5448 return ImsRegistrationImplBase.REGISTRATION_TECH_NONE;
5449 }
5450 } finally {
5451 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005452 }
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005453 }
5454
Stuart Scott8eef64f2015-04-08 15:13:54 -07005455 @Override
5456 public void factoryReset(int subId) {
5457 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07005458 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
5459 return;
5460 }
5461
Svet Ganovcc087f82015-05-12 20:35:54 -07005462 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005463
Svet Ganovcc087f82015-05-12 20:35:54 -07005464 try {
Stuart Scott981d8582015-04-21 14:09:50 -07005465 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
5466 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Pengquan Meng85728fb2018-03-12 16:31:21 -07005467 setUserDataEnabled(subId, getDefaultDataEnabled());
Svet Ganovcc087f82015-05-12 20:35:54 -07005468 setNetworkSelectionModeAutomatic(subId);
Pengquan Meng85728fb2018-03-12 16:31:21 -07005469 setPreferredNetworkType(subId, getDefaultNetworkType(subId));
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005470 setDataRoamingEnabled(subId, getDefaultDataRoamingEnabled(subId));
5471 CarrierInfoManager.deleteAllCarrierKeysForImsiEncryption(mApp);
Svet Ganovcc087f82015-05-12 20:35:54 -07005472 }
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005473 // There has been issues when Sms raw table somehow stores orphan
5474 // fragments. They lead to garbled message when new fragments come
5475 // in and combined with those stale ones. In case this happens again,
5476 // user can reset all network settings which will clean up this table.
5477 cleanUpSmsRawTable(getDefaultPhone().getContext());
Svet Ganovcc087f82015-05-12 20:35:54 -07005478 } finally {
5479 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07005480 }
5481 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005482
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005483 private void cleanUpSmsRawTable(Context context) {
5484 ContentResolver resolver = context.getContentResolver();
5485 Uri uri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw/permanentDelete");
5486 resolver.delete(uri, null, null);
5487 }
5488
Narayan Kamath1c496c22015-04-16 14:40:19 +01005489 @Override
chen xu5d3637b2019-01-21 23:31:38 -08005490 public String getSimLocaleForSubscriber(int subId) {
5491 enforceReadPrivilegedPermission("getSimLocaleForSubscriber, subId: " + subId);
5492 final Phone phone = getPhone(subId);
5493 if (phone == null) {
5494 log("getSimLocaleForSubscriber, invalid subId");
chen xu2bb91e42019-01-24 14:35:54 -08005495 return null;
chen xu5d3637b2019-01-21 23:31:38 -08005496 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005497 final long identity = Binder.clearCallingIdentity();
5498 try {
chen xu5d3637b2019-01-21 23:31:38 -08005499 final SubscriptionInfo info = mSubscriptionController.getActiveSubscriptionInfo(subId,
5500 phone.getContext().getOpPackageName());
chen xu6291c472019-02-04 12:55:53 -08005501 if (info == null) {
5502 log("getSimLocaleForSubscriber, inactive subId: " + subId);
5503 return null;
5504 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005505 // Try and fetch the locale from the carrier properties or from the SIM language
5506 // preferences (EF-PL and EF-LI)...
5507 final int mcc = info.getMcc();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005508 String simLanguage = null;
chen xu5d3637b2019-01-21 23:31:38 -08005509 final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
5510 if (localeFromDefaultSim != null) {
5511 if (!localeFromDefaultSim.getCountry().isEmpty()) {
5512 if (DBG) log("Using locale from subId: " + subId + " locale: "
5513 + localeFromDefaultSim);
5514 return localeFromDefaultSim.toLanguageTag();
5515 } else {
5516 simLanguage = localeFromDefaultSim.getLanguage();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005517 }
5518 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005519
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005520 // The SIM language preferences only store a language (e.g. fr = French), not an
5521 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
5522 // the SIM and carrier preferences does not include a country we add the country
5523 // determined from the SIM MCC to provide an exact locale.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005524 final Locale mccLocale = MccTable.getLocaleFromMcc(mApp, mcc, simLanguage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005525 if (mccLocale != null) {
chen xu5d3637b2019-01-21 23:31:38 -08005526 if (DBG) log("No locale from SIM, using mcc locale:" + mccLocale);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005527 return mccLocale.toLanguageTag();
5528 }
5529
5530 if (DBG) log("No locale found - returning null");
5531 return null;
5532 } finally {
5533 Binder.restoreCallingIdentity(identity);
5534 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005535 }
5536
5537 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005538 return mSubscriptionController.getAllSubInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005539 }
5540
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005541 /**
5542 * NOTE: this method assumes permission checks are done and caller identity has been cleared.
5543 */
5544 private List<SubscriptionInfo> getActiveSubscriptionInfoListPrivileged() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005545 return mSubscriptionController.getActiveSubscriptionInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005546 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005547
Chenjie Yu1ba97252018-01-11 18:16:20 -08005548 private final ModemActivityInfo mLastModemActivityInfo =
5549 new ModemActivityInfo(0, 0, 0, new int[0], 0, 0);
5550
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005551 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07005552 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
5553 * representing the state of the modem.
5554 *
Chenjie Yu1ba97252018-01-11 18:16:20 -08005555 * NOTE: The underlying implementation clears the modem state, so there should only ever be one
5556 * caller to it. Everyone should call this class to get cumulative data.
Adam Lesinski903a54c2016-04-11 14:49:52 -07005557 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005558 */
5559 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07005560 public void requestModemActivityInfo(ResultReceiver result) {
5561 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005562 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005563
5564 final long identity = Binder.clearCallingIdentity();
5565 try {
5566 ModemActivityInfo ret = null;
5567 synchronized (mLastModemActivityInfo) {
5568 ModemActivityInfo info = (ModemActivityInfo) sendRequest(
5569 CMD_GET_MODEM_ACTIVITY_INFO,
vagdeviaf9a5b92018-08-15 16:01:53 -07005570 null, workSource);
Siddharth Rayb8114062018-06-17 15:02:38 -07005571 if (isModemActivityInfoValid(info)) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005572 int[] mergedTxTimeMs = new int[ModemActivityInfo.TX_POWER_LEVELS];
5573 for (int i = 0; i < mergedTxTimeMs.length; i++) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005574 mergedTxTimeMs[i] = info.getTxTimeMillis()[i]
5575 + mLastModemActivityInfo.getTxTimeMillis()[i];
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005576 }
5577 mLastModemActivityInfo.setTimestamp(info.getTimestamp());
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005578 mLastModemActivityInfo.setSleepTimeMillis(info.getSleepTimeMillis()
5579 + mLastModemActivityInfo.getSleepTimeMillis());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005580 mLastModemActivityInfo.setIdleTimeMillis(
5581 info.getIdleTimeMillis() + mLastModemActivityInfo.getIdleTimeMillis());
5582 mLastModemActivityInfo.setTxTimeMillis(mergedTxTimeMs);
5583 mLastModemActivityInfo.setRxTimeMillis(
5584 info.getRxTimeMillis() + mLastModemActivityInfo.getRxTimeMillis());
5585 mLastModemActivityInfo.setEnergyUsed(
5586 info.getEnergyUsed() + mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005587 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005588 ret = new ModemActivityInfo(mLastModemActivityInfo.getTimestamp(),
5589 mLastModemActivityInfo.getSleepTimeMillis(),
5590 mLastModemActivityInfo.getIdleTimeMillis(),
5591 mLastModemActivityInfo.getTxTimeMillis(),
5592 mLastModemActivityInfo.getRxTimeMillis(),
5593 mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005594 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005595 Bundle bundle = new Bundle();
5596 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, ret);
5597 result.send(0, bundle);
5598 } finally {
5599 Binder.restoreCallingIdentity(identity);
Chenjie Yu1ba97252018-01-11 18:16:20 -08005600 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005601 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005602
Siddharth Rayb8114062018-06-17 15:02:38 -07005603 // Checks that ModemActivityInfo is valid. Sleep time, Idle time, Rx time and Tx time should be
5604 // less than total activity duration.
5605 private boolean isModemActivityInfoValid(ModemActivityInfo info) {
5606 if (info == null) {
5607 return false;
5608 }
5609 int activityDurationMs =
5610 (int) (info.getTimestamp() - mLastModemActivityInfo.getTimestamp());
5611 int totalTxTimeMs = 0;
5612 for (int i = 0; i < info.getTxTimeMillis().length; i++) {
5613 totalTxTimeMs += info.getTxTimeMillis()[i];
5614 }
5615 return (info.isValid()
5616 && (info.getSleepTimeMillis() <= activityDurationMs)
5617 && (info.getIdleTimeMillis() <= activityDurationMs)
5618 && (info.getRxTimeMillis() <= activityDurationMs)
5619 && (totalTxTimeMs <= activityDurationMs));
5620 }
5621
Jack Yu85bd38a2015-11-09 11:34:32 -08005622 /**
5623 * {@hide}
5624 * Returns the service state information on specified subscription.
5625 */
5626 @Override
5627 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005628 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005629 mApp, subId, callingPackage, "getServiceStateForSubscriber")) {
Jack Yu85bd38a2015-11-09 11:34:32 -08005630 return null;
5631 }
5632
Hall Liuf19c44f2018-11-27 14:38:17 -08005633 LocationAccessPolicy.LocationPermissionResult fineLocationResult =
5634 LocationAccessPolicy.checkLocationPermission(mApp,
5635 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5636 .setCallingPackage(callingPackage)
5637 .setCallingPid(Binder.getCallingPid())
5638 .setCallingUid(Binder.getCallingUid())
5639 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005640 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005641 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
5642 .build());
5643
5644 LocationAccessPolicy.LocationPermissionResult coarseLocationResult =
5645 LocationAccessPolicy.checkLocationPermission(mApp,
5646 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5647 .setCallingPackage(callingPackage)
5648 .setCallingPid(Binder.getCallingPid())
5649 .setCallingUid(Binder.getCallingUid())
5650 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005651 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005652 .setMinSdkVersionForCoarse(Build.VERSION_CODES.Q)
5653 .build());
5654 // We don't care about hard or soft here -- all we need to know is how much info to scrub.
5655 boolean hasFinePermission =
5656 fineLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5657 boolean hasCoarsePermission =
5658 coarseLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5659
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005660 final long identity = Binder.clearCallingIdentity();
5661 try {
5662 final Phone phone = getPhone(subId);
5663 if (phone == null) {
5664 return null;
5665 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005666
Hall Liuf19c44f2018-11-27 14:38:17 -08005667 ServiceState ss = phone.getServiceState();
5668
5669 // Scrub out the location info in ServiceState depending on what level of access
5670 // the caller has.
5671 if (hasFinePermission) return ss;
5672 if (hasCoarsePermission) return ss.sanitizeLocationInfo(false);
5673 return ss.sanitizeLocationInfo(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005674 } finally {
5675 Binder.restoreCallingIdentity(identity);
5676 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005677 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005678
5679 /**
5680 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
5681 *
5682 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5683 * voicemail ringtone.
5684 * @return The URI for the ringtone to play when receiving a voicemail from a specific
5685 * PhoneAccount.
5686 */
5687 @Override
5688 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005689 final long identity = Binder.clearCallingIdentity();
5690 try {
5691 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5692 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005693 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005694 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005695
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005696 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
5697 } finally {
5698 Binder.restoreCallingIdentity(identity);
5699 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005700 }
5701
5702 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005703 * Sets the per-account voicemail ringtone.
5704 *
5705 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5706 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5707 *
5708 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5709 * voicemail ringtone.
5710 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific
5711 * PhoneAccount.
5712 */
5713 @Override
5714 public void setVoicemailRingtoneUri(String callingPackage,
5715 PhoneAccountHandle phoneAccountHandle, Uri uri) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005716 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005717 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5718 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005719 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005720 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5721 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5722 "setVoicemailRingtoneUri");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005723 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005724
5725 final long identity = Binder.clearCallingIdentity();
5726 try {
5727 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5728 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005729 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005730 }
5731 VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
5732 } finally {
5733 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005734 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005735 }
5736
5737 /**
Nancy Chen31f9ba12016-01-06 11:42:12 -08005738 * Returns whether vibration is set for voicemail notification in Phone settings.
5739 *
5740 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5741 * voicemail vibration setting.
5742 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
5743 */
5744 @Override
5745 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005746 final long identity = Binder.clearCallingIdentity();
5747 try {
5748 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5749 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005750 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005751 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005752
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005753 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
5754 } finally {
5755 Binder.restoreCallingIdentity(identity);
5756 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005757 }
5758
Youhan Wange64578a2016-05-02 15:32:42 -07005759 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005760 * Sets the per-account voicemail vibration.
5761 *
5762 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5763 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5764 *
5765 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5766 * voicemail vibration setting.
5767 * @param enabled Whether to enable or disable vibration for voicemail notifications from a
5768 * specific PhoneAccount.
5769 */
5770 @Override
5771 public void setVoicemailVibrationEnabled(String callingPackage,
5772 PhoneAccountHandle phoneAccountHandle, boolean enabled) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005773 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005774 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5775 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005776 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005777 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5778 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5779 "setVoicemailVibrationEnabled");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005780 }
5781
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005782 final long identity = Binder.clearCallingIdentity();
5783 try {
5784 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5785 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005786 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005787 }
5788 VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
5789 } finally {
5790 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005791 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005792 }
5793
5794 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005795 * Make sure either called from same process as self (phone) or IPC caller has read privilege.
5796 *
5797 * @throws SecurityException if the caller does not have the required permission
5798 */
Brad Ebinger35c841c2018-10-01 10:40:55 -07005799 private void enforceReadPrivilegedPermission(String message) {
Youhan Wange64578a2016-05-02 15:32:42 -07005800 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
Brad Ebinger35c841c2018-10-01 10:40:55 -07005801 message);
Youhan Wange64578a2016-05-02 15:32:42 -07005802 }
5803
5804 /**
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005805 * Make sure either called from same process as self (phone) or IPC caller has send SMS
5806 * permission.
5807 *
5808 * @throws SecurityException if the caller does not have the required permission
5809 */
5810 private void enforceSendSmsPermission() {
5811 mApp.enforceCallingOrSelfPermission(permission.SEND_SMS, null);
5812 }
5813
5814 /**
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005815 * Make sure called from the package in charge of visual voicemail.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005816 *
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005817 * @throws SecurityException if the caller is not the visual voicemail package.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005818 */
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005819 private void enforceVisualVoicemailPackage(String callingPackage, int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005820 final long identity = Binder.clearCallingIdentity();
5821 try {
5822 ComponentName componentName =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005823 RemoteVvmTaskManager.getRemotePackage(mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005824 if (componentName == null) {
5825 throw new SecurityException(
5826 "Caller not current active visual voicemail package[null]");
5827 }
5828 String vvmPackage = componentName.getPackageName();
5829 if (!callingPackage.equals(vvmPackage)) {
5830 throw new SecurityException("Caller not current active visual voicemail package["
5831 + vvmPackage + "]");
5832 }
5833 } finally {
5834 Binder.restoreCallingIdentity(identity);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005835 }
5836 }
5837
5838 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005839 * Return the application ID for the app type.
5840 *
5841 * @param subId the subscription ID that this request applies to.
5842 * @param appType the uicc app type.
5843 * @return Application ID for specificied app type, or null if no uicc.
5844 */
5845 @Override
5846 public String getAidForAppType(int subId, int appType) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005847 enforceReadPrivilegedPermission("getAidForAppType");
Youhan Wange64578a2016-05-02 15:32:42 -07005848 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005849
5850 final long identity = Binder.clearCallingIdentity();
Youhan Wange64578a2016-05-02 15:32:42 -07005851 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005852 if (phone == null) {
5853 return null;
5854 }
5855 String aid = null;
5856 try {
5857 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
5858 .getApplicationByType(appType).getAid();
5859 } catch (Exception e) {
5860 Log.e(LOG_TAG, "Not getting aid. Exception ex=" + e);
5861 }
5862 return aid;
5863 } finally {
5864 Binder.restoreCallingIdentity(identity);
Youhan Wange64578a2016-05-02 15:32:42 -07005865 }
Youhan Wange64578a2016-05-02 15:32:42 -07005866 }
5867
Youhan Wang4001d252016-05-11 10:29:41 -07005868 /**
5869 * Return the Electronic Serial Number.
5870 *
5871 * @param subId the subscription ID that this request applies to.
5872 * @return ESN or null if error.
5873 */
5874 @Override
5875 public String getEsn(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005876 enforceReadPrivilegedPermission("getEsn");
Youhan Wang4001d252016-05-11 10:29:41 -07005877 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005878
5879 final long identity = Binder.clearCallingIdentity();
Youhan Wang4001d252016-05-11 10:29:41 -07005880 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005881 if (phone == null) {
5882 return null;
5883 }
5884 String esn = null;
5885 try {
5886 esn = phone.getEsn();
5887 } catch (Exception e) {
5888 Log.e(LOG_TAG, "Not getting ESN. Exception ex=" + e);
5889 }
5890 return esn;
5891 } finally {
5892 Binder.restoreCallingIdentity(identity);
Youhan Wang4001d252016-05-11 10:29:41 -07005893 }
Youhan Wang4001d252016-05-11 10:29:41 -07005894 }
5895
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005896 /**
Youhan Wang66ad5d72016-07-18 17:56:58 -07005897 * Return the Preferred Roaming List Version.
5898 *
5899 * @param subId the subscription ID that this request applies to.
5900 * @return PRLVersion or null if error.
5901 */
5902 @Override
5903 public String getCdmaPrlVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005904 enforceReadPrivilegedPermission("getCdmaPrlVersion");
Youhan Wang66ad5d72016-07-18 17:56:58 -07005905 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005906
5907 final long identity = Binder.clearCallingIdentity();
Youhan Wang66ad5d72016-07-18 17:56:58 -07005908 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005909 if (phone == null) {
5910 return null;
5911 }
5912 String cdmaPrlVersion = null;
5913 try {
5914 cdmaPrlVersion = phone.getCdmaPrlVersion();
5915 } catch (Exception e) {
5916 Log.e(LOG_TAG, "Not getting PRLVersion", e);
5917 }
5918 return cdmaPrlVersion;
5919 } finally {
5920 Binder.restoreCallingIdentity(identity);
Youhan Wang66ad5d72016-07-18 17:56:58 -07005921 }
Youhan Wang66ad5d72016-07-18 17:56:58 -07005922 }
5923
5924 /**
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005925 * Get snapshot of Telephony histograms
5926 * @return List of Telephony histograms
5927 * @hide
5928 */
5929 @Override
5930 public List<TelephonyHistogram> getTelephonyHistograms() {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005931 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5932 mApp, getDefaultSubscription(), "getTelephonyHistograms");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005933
5934 final long identity = Binder.clearCallingIdentity();
5935 try {
5936 return RIL.getTelephonyRILTimingHistograms();
5937 } finally {
5938 Binder.restoreCallingIdentity(identity);
5939 }
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005940 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005941
5942 /**
5943 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005944 * Set the allowed carrier list and the excluded carrier list, indicating the priority between
5945 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005946 * Require system privileges. In the future we may add this to carrier APIs.
5947 *
Michele Berionne482f8202018-11-27 18:57:59 -08005948 * @return Integer with the result of the operation, as defined in {@link TelephonyManager}.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005949 */
5950 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005951 @TelephonyManager.SetCarrierRestrictionResult
5952 public int setAllowedCarriers(CarrierRestrictionRules carrierRestrictionRules) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07005953 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005954 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005955
Michele Berionne482f8202018-11-27 18:57:59 -08005956 if (carrierRestrictionRules == null) {
5957 throw new NullPointerException("carrier restriction cannot be null");
Meng Wang9b7c4e92017-02-17 11:41:27 -08005958 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005959
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005960 final long identity = Binder.clearCallingIdentity();
5961 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005962 return (int) sendRequest(CMD_SET_ALLOWED_CARRIERS, carrierRestrictionRules,
vagdeviaf9a5b92018-08-15 16:01:53 -07005963 workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005964 } finally {
5965 Binder.restoreCallingIdentity(identity);
5966 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005967 }
5968
5969 /**
5970 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005971 * Get the allowed carrier list and the excluded carrier list, including the priority between
5972 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005973 * Require system privileges. In the future we may add this to carrier APIs.
5974 *
Michele Berionne482f8202018-11-27 18:57:59 -08005975 * @return {@link android.telephony.CarrierRestrictionRules}
Meng Wang1a7c35a2016-05-05 20:56:15 -07005976 */
5977 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005978 public CarrierRestrictionRules getAllowedCarriers() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005979 enforceReadPrivilegedPermission("getAllowedCarriers");
vagdeviaf9a5b92018-08-15 16:01:53 -07005980 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005981
5982 final long identity = Binder.clearCallingIdentity();
5983 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005984 Object response = sendRequest(CMD_GET_ALLOWED_CARRIERS, null, workSource);
5985 if (response instanceof CarrierRestrictionRules) {
5986 return (CarrierRestrictionRules) response;
5987 }
5988 // Response is an Exception of some kind,
5989 // which is signalled to the user as a NULL retval
5990 return null;
5991 } catch (Exception e) {
5992 Log.e(LOG_TAG, "getAllowedCarriers. Exception ex=" + e);
5993 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005994 } finally {
5995 Binder.restoreCallingIdentity(identity);
5996 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005997 }
5998
fionaxu59545b42016-05-25 15:53:37 -07005999 /**
6000 * Action set from carrier signalling broadcast receivers to enable/disable metered apns
6001 * @param subId the subscription ID that this action applies to.
6002 * @param enabled control enable or disable metered apns.
6003 * {@hide}
6004 */
6005 @Override
6006 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) {
6007 enforceModifyPermission();
6008 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006009
6010 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07006011 if (phone == null) {
6012 loge("carrierAction: SetMeteredApnsEnabled fails with invalid subId: " + subId);
6013 return;
6014 }
6015 try {
6016 phone.carrierActionSetMeteredApnsEnabled(enabled);
6017 } catch (Exception e) {
6018 Log.e(LOG_TAG, "carrierAction: SetMeteredApnsEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006019 } finally {
6020 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006021 }
6022 }
6023
6024 /**
6025 * Action set from carrier signalling broadcast receivers to enable/disable radio
6026 * @param subId the subscription ID that this action applies to.
6027 * @param enabled control enable or disable radio.
6028 * {@hide}
6029 */
6030 @Override
6031 public void carrierActionSetRadioEnabled(int subId, boolean enabled) {
6032 enforceModifyPermission();
6033 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006034
6035 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07006036 if (phone == null) {
6037 loge("carrierAction: SetRadioEnabled fails with invalid sibId: " + subId);
6038 return;
6039 }
6040 try {
6041 phone.carrierActionSetRadioEnabled(enabled);
6042 } catch (Exception e) {
6043 Log.e(LOG_TAG, "carrierAction: SetRadioEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006044 } finally {
6045 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006046 }
6047 }
6048
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006049 /**
fionaxu8da9cb12017-05-23 15:02:46 -07006050 * Action set from carrier signalling broadcast receivers to start/stop reporting the default
6051 * network status based on which carrier apps could apply actions accordingly,
6052 * enable/disable default url handler for example.
6053 *
6054 * @param subId the subscription ID that this action applies to.
6055 * @param report control start/stop reporting the default network status.
6056 * {@hide}
6057 */
6058 @Override
6059 public void carrierActionReportDefaultNetworkStatus(int subId, boolean report) {
6060 enforceModifyPermission();
6061 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006062
6063 final long identity = Binder.clearCallingIdentity();
fionaxu8da9cb12017-05-23 15:02:46 -07006064 if (phone == null) {
6065 loge("carrierAction: ReportDefaultNetworkStatus fails with invalid sibId: " + subId);
6066 return;
6067 }
6068 try {
6069 phone.carrierActionReportDefaultNetworkStatus(report);
6070 } catch (Exception e) {
6071 Log.e(LOG_TAG, "carrierAction: ReportDefaultNetworkStatus fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006072 } finally {
6073 Binder.restoreCallingIdentity(identity);
fionaxu8da9cb12017-05-23 15:02:46 -07006074 }
6075 }
6076
6077 /**
fionaxud9622282017-07-17 17:51:30 -07006078 * Action set from carrier signalling broadcast receivers to reset all carrier actions
6079 * @param subId the subscription ID that this action applies to.
6080 * {@hide}
6081 */
6082 @Override
6083 public void carrierActionResetAll(int subId) {
6084 enforceModifyPermission();
6085 final Phone phone = getPhone(subId);
6086 if (phone == null) {
6087 loge("carrierAction: ResetAll fails with invalid sibId: " + subId);
6088 return;
6089 }
6090 try {
6091 phone.carrierActionResetAll();
6092 } catch (Exception e) {
6093 Log.e(LOG_TAG, "carrierAction: ResetAll fails. Exception ex=" + e);
6094 }
6095 }
6096
6097 /**
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006098 * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
6099 * bug report is being generated.
6100 */
6101 @Override
Ta-wei Yen99282e02016-06-21 18:19:35 -07006102 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006103 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
6104 != PackageManager.PERMISSION_GRANTED) {
dcashman22b950d2016-06-27 11:39:02 -07006105 writer.println("Permission Denial: can't dump Phone from pid="
6106 + Binder.getCallingPid()
6107 + ", uid=" + Binder.getCallingUid()
6108 + "without permission "
6109 + android.Manifest.permission.DUMP);
6110 return;
6111 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006112 DumpsysHandler.dump(mApp, fd, writer, args);
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006113 }
Jack Yueb89b242016-06-22 13:27:47 -07006114
Brad Ebingerdac2f002018-04-03 15:17:52 -07006115 @Override
6116 public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
6117 String[] args, ShellCallback callback, ResultReceiver resultReceiver)
6118 throws RemoteException {
6119 (new TelephonyShellCommand(this)).exec(this, in, out, err, args, callback, resultReceiver);
6120 }
6121
Jack Yueb89b242016-06-22 13:27:47 -07006122 /**
Jack Yu84291ec2017-05-26 16:07:50 -07006123 * Get aggregated video call data usage since boot.
6124 *
6125 * @param perUidStats True if requesting data usage per uid, otherwise overall usage.
6126 * @return Snapshot of video call data usage
Jack Yueb89b242016-06-22 13:27:47 -07006127 * {@hide}
6128 */
6129 @Override
Jack Yu84291ec2017-05-26 16:07:50 -07006130 public NetworkStats getVtDataUsage(int subId, boolean perUidStats) {
Jack Yueb89b242016-06-22 13:27:47 -07006131 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_NETWORK_USAGE_HISTORY,
6132 null);
6133
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006134 final long identity = Binder.clearCallingIdentity();
6135 try {
6136 // NetworkStatsService keeps tracking the active network interface and identity. It
6137 // records the delta with the corresponding network identity.
6138 // We just return the total video call data usage snapshot since boot.
6139 Phone phone = getPhone(subId);
6140 if (phone != null) {
6141 return phone.getVtDataUsage(perUidStats);
6142 }
6143 return null;
6144 } finally {
6145 Binder.restoreCallingIdentity(identity);
Jack Yueb89b242016-06-22 13:27:47 -07006146 }
Jack Yueb89b242016-06-22 13:27:47 -07006147 }
Jack Yu75ab2952016-07-08 14:29:33 -07006148
6149 /**
6150 * Policy control of data connection. Usually used when data limit is passed.
6151 * @param enabled True if enabling the data, otherwise disabling.
6152 * @param subId Subscription index
6153 * {@hide}
6154 */
6155 @Override
6156 public void setPolicyDataEnabled(boolean enabled, int subId) {
6157 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006158
6159 final long identity = Binder.clearCallingIdentity();
6160 try {
6161 Phone phone = getPhone(subId);
6162 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08006163 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006164 }
6165 } finally {
6166 Binder.restoreCallingIdentity(identity);
Jack Yu75ab2952016-07-08 14:29:33 -07006167 }
6168 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006169
6170 /**
6171 * Get Client request stats
6172 * @return List of Client Request Stats
6173 * @hide
6174 */
6175 @Override
6176 public List<ClientRequestStats> getClientRequestStats(String callingPackage, int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006177 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08006178 mApp, subId, callingPackage, "getClientRequestStats")) {
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006179 return null;
6180 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006181 Phone phone = getPhone(subId);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006182
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006183 final long identity = Binder.clearCallingIdentity();
6184 try {
6185 if (phone != null) {
6186 return phone.getClientRequestStats();
6187 }
6188
6189 return null;
6190 } finally {
6191 Binder.restoreCallingIdentity(identity);
6192 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006193 }
6194
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006195 private WorkSource getWorkSource(int uid) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006196 String packageName = mApp.getPackageManager().getNameForUid(uid);
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006197 return new WorkSource(uid, packageName);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006198 }
Jack Yueb4124c2017-02-16 15:32:43 -08006199
6200 /**
Grace Chen70990072017-03-24 17:21:30 -07006201 * Set SIM card power state.
Jack Yueb4124c2017-02-16 15:32:43 -08006202 *
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006203 * @param slotIndex SIM slot id.
Grace Chen70990072017-03-24 17:21:30 -07006204 * @param state State of SIM (power down, power up, pass through)
6205 * - {@link android.telephony.TelephonyManager#CARD_POWER_DOWN}
6206 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP}
6207 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP_PASS_THROUGH}
Jack Yueb4124c2017-02-16 15:32:43 -08006208 *
6209 **/
6210 @Override
Grace Chen70990072017-03-24 17:21:30 -07006211 public void setSimPowerStateForSlot(int slotIndex, int state) {
Jack Yueb4124c2017-02-16 15:32:43 -08006212 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006213 Phone phone = PhoneFactory.getPhone(slotIndex);
6214
vagdeviaf9a5b92018-08-15 16:01:53 -07006215 WorkSource workSource = getWorkSource(Binder.getCallingUid());
6216
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006217 final long identity = Binder.clearCallingIdentity();
6218 try {
6219 if (phone != null) {
vagdeviaf9a5b92018-08-15 16:01:53 -07006220 phone.setSimPowerState(state, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006221 }
6222 } finally {
6223 Binder.restoreCallingIdentity(identity);
Jack Yueb4124c2017-02-16 15:32:43 -08006224 }
6225 }
Shuo Qiandd210312017-04-12 22:11:33 +00006226
Tyler Gunn65d45c22017-06-05 11:22:26 -07006227 private boolean isUssdApiAllowed(int subId) {
6228 CarrierConfigManager configManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006229 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Tyler Gunn65d45c22017-06-05 11:22:26 -07006230 if (configManager == null) {
6231 return false;
6232 }
6233 PersistableBundle pb = configManager.getConfigForSubId(subId);
6234 if (pb == null) {
6235 return false;
6236 }
6237 return pb.getBoolean(
6238 CarrierConfigManager.KEY_ALLOW_USSD_REQUESTS_VIA_TELEPHONY_MANAGER_BOOL);
6239 }
6240
Shuo Qiandd210312017-04-12 22:11:33 +00006241 /**
6242 * Check if phone is in emergency callback mode
6243 * @return true if phone is in emergency callback mode
6244 * @param subId sub id
6245 */
goneil9c5f4872017-12-05 14:07:56 -08006246 @Override
Shuo Qiandd210312017-04-12 22:11:33 +00006247 public boolean getEmergencyCallbackMode(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006248 enforceReadPrivilegedPermission("getEmergencyCallbackMode");
Shuo Qiandd210312017-04-12 22:11:33 +00006249 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006250
6251 final long identity = Binder.clearCallingIdentity();
6252 try {
6253 if (phone != null) {
6254 return phone.isInEcm();
6255 } else {
6256 return false;
6257 }
6258 } finally {
6259 Binder.restoreCallingIdentity(identity);
Shuo Qiandd210312017-04-12 22:11:33 +00006260 }
6261 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006262
6263 /**
6264 * Get the current signal strength information for the given subscription.
6265 * Because this information is not updated when the device is in a low power state
6266 * it should not be relied-upon to be current.
6267 * @param subId Subscription index
6268 * @return the most recent cached signal strength info from the modem
6269 */
6270 @Override
6271 public SignalStrength getSignalStrength(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006272 final long identity = Binder.clearCallingIdentity();
6273 try {
6274 Phone p = getPhone(subId);
6275 if (p == null) {
6276 return null;
6277 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006278
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006279 return p.getSignalStrength();
6280 } finally {
6281 Binder.restoreCallingIdentity(identity);
6282 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006283 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006284
Pengquan Meng77b7f132018-08-22 14:49:57 -07006285 /**
Chen Xuf792fd62018-10-17 17:54:36 +00006286 * Get the current modem radio state for the given slot.
6287 * @param slotIndex slot index.
6288 * @param callingPackage the name of the package making the call.
6289 * @return the current radio power state from the modem
6290 */
6291 @Override
6292 public int getRadioPowerState(int slotIndex, String callingPackage) {
6293 Phone phone = PhoneFactory.getPhone(slotIndex);
6294 if (phone != null) {
6295 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6296 mApp, phone.getSubId(), callingPackage, "getRadioPowerState")) {
6297 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6298 }
6299
6300 final long identity = Binder.clearCallingIdentity();
6301 try {
6302 return phone.getRadioPowerState();
6303 } finally {
6304 Binder.restoreCallingIdentity(identity);
6305 }
6306 }
6307 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6308 }
6309
6310 /**
Pengquan Meng77b7f132018-08-22 14:49:57 -07006311 * Checks if data roaming is enabled on the subscription with id {@code subId}.
6312 *
6313 * <p>Requires one of the following permissions:
6314 * {@link android.Manifest.permission#ACCESS_NETWORK_STATE},
6315 * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
6316 * privileges.
6317 *
6318 * @param subId subscription id
6319 * @return {@code true} if data roaming is enabled on this subscription, otherwise return
6320 * {@code false}.
6321 */
6322 @Override
6323 public boolean isDataRoamingEnabled(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006324 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
6325 null /* message */);
6326
Pengquan Menga1bb6272018-09-06 09:59:22 -07006327 boolean isEnabled = false;
6328 final long identity = Binder.clearCallingIdentity();
Pengquan Meng77b7f132018-08-22 14:49:57 -07006329 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006330 Phone phone = getPhone(subId);
6331 isEnabled = phone != null ? phone.getDataRoamingEnabled() : false;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006332 } catch (Exception e) {
6333 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6334 mApp, subId, "isDataRoamingEnabled");
Pengquan Menga1bb6272018-09-06 09:59:22 -07006335 } finally {
6336 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006337 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006338 return isEnabled;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006339 }
6340
6341
6342 /**
6343 * Enables/Disables the data roaming on the subscription with id {@code subId}.
6344 *
6345 * <p> Requires permission:
6346 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
6347 * privileges.
6348 *
6349 * @param subId subscription id
6350 * @param isEnabled {@code true} means enable, {@code false} means disable.
6351 */
6352 @Override
6353 public void setDataRoamingEnabled(int subId, boolean isEnabled) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006354 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6355 mApp, subId, "setDataRoamingEnabled");
6356
Pengquan Menga1bb6272018-09-06 09:59:22 -07006357 final long identity = Binder.clearCallingIdentity();
6358 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006359 Phone phone = getPhone(subId);
6360 if (phone != null) {
6361 phone.setDataRoamingEnabled(isEnabled);
6362 }
6363 } finally {
6364 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006365 }
6366 }
6367
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006368 @Override
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006369 public boolean isManualNetworkSelectionAllowed(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006370 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6371 mApp, subId, "isManualNetworkSelectionAllowed");
6372
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006373 boolean isAllowed = true;
6374 final long identity = Binder.clearCallingIdentity();
6375 try {
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006376 Phone phone = getPhone(subId);
6377 if (phone != null) {
6378 isAllowed = phone.isCspPlmnEnabled();
6379 }
6380 } finally {
6381 Binder.restoreCallingIdentity(identity);
6382 }
6383 return isAllowed;
6384 }
6385
6386 @Override
Jordan Liu75f43ea2019-01-17 16:56:37 -08006387 public List<UiccCardInfo> getUiccCardsInfo(String callingPackage) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006388 boolean hasReadPermission = false;
Jordan Liuc65bc952019-02-12 17:54:02 -08006389 try {
6390 enforceReadPrivilegedPermission("getUiccCardsInfo");
Jordan Liu1e142fc2019-04-22 15:10:43 -07006391 hasReadPermission = true;
Jordan Liuc65bc952019-02-12 17:54:02 -08006392 } catch (SecurityException e) {
6393 // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
6394 // has carrier privileges on an active UICC
6395 if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
6396 != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006397 throw new SecurityException("Caller does not have permission.");
Jordan Liuc65bc952019-02-12 17:54:02 -08006398 }
Jordan Liu75f43ea2019-01-17 16:56:37 -08006399 }
Jordan Liu5aa07002018-12-18 15:44:48 -08006400
6401 final long identity = Binder.clearCallingIdentity();
6402 try {
Jordan Liu75f43ea2019-01-17 16:56:37 -08006403 UiccController uiccController = UiccController.getInstance();
6404 ArrayList<UiccCardInfo> cardInfos = uiccController.getAllUiccCardInfos();
Jordan Liu1e142fc2019-04-22 15:10:43 -07006405 if (hasReadPermission) {
6406 return cardInfos;
Jordan Liu75f43ea2019-01-17 16:56:37 -08006407 }
Jordan Liu1e142fc2019-04-22 15:10:43 -07006408
6409 // Remove private info if the caller doesn't have access
6410 ArrayList<UiccCardInfo> filteredInfos = new ArrayList<>();
6411 for (UiccCardInfo cardInfo : cardInfos) {
6412 // For an inactive eUICC, the UiccCard will be null even though the UiccCardInfo
6413 // is available
6414 UiccCard card = uiccController.getUiccCardForSlot(cardInfo.getSlotIndex());
6415 if (card == null || card.getUiccProfile() == null) {
6416 // assume no access if the card or profile is unavailable
6417 filteredInfos.add(cardInfo.getUnprivileged());
6418 continue;
6419 }
6420 UiccProfile profile = card.getUiccProfile();
6421 if (profile.getCarrierPrivilegeStatus(mApp.getPackageManager(), callingPackage)
6422 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
6423 filteredInfos.add(cardInfo);
6424 } else {
6425 filteredInfos.add(cardInfo.getUnprivileged());
6426 }
6427 }
6428 return filteredInfos;
Jordan Liu5aa07002018-12-18 15:44:48 -08006429 } finally {
6430 Binder.restoreCallingIdentity(identity);
6431 }
6432 }
6433
6434 @Override
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006435 public UiccSlotInfo[] getUiccSlotsInfo() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006436 enforceReadPrivilegedPermission("getUiccSlotsInfo");
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006437
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006438 final long identity = Binder.clearCallingIdentity();
6439 try {
6440 UiccSlot[] slots = UiccController.getInstance().getUiccSlots();
6441 if (slots == null) {
6442 Rlog.i(LOG_TAG, "slots is null.");
6443 return null;
6444 }
6445
6446 UiccSlotInfo[] infos = new UiccSlotInfo[slots.length];
6447 for (int i = 0; i < slots.length; i++) {
6448 UiccSlot slot = slots[i];
6449 if (slot == null) {
6450 continue;
6451 }
6452
Jordan Liu7be7e652019-05-06 18:55:02 +00006453 String cardId;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006454 UiccCard card = slot.getUiccCard();
6455 if (card != null) {
6456 cardId = card.getCardId();
Jordan Liu7be7e652019-05-06 18:55:02 +00006457 } else {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006458 cardId = slot.getIccId();
6459 }
6460
Jordan Liu857451f2019-05-09 16:35:35 -07006461 if (cardId != null) {
6462 // if cardId is an ICCID, strip off trailing Fs before exposing to user
6463 // if cardId is an EID, it's all digits so this is fine
6464 cardId = IccUtils.stripTrailingFs(cardId);
6465 }
6466
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006467 int cardState = 0;
6468 switch (slot.getCardState()) {
6469 case CARDSTATE_ABSENT:
6470 cardState = UiccSlotInfo.CARD_STATE_INFO_ABSENT;
6471 break;
6472 case CARDSTATE_PRESENT:
6473 cardState = UiccSlotInfo.CARD_STATE_INFO_PRESENT;
6474 break;
6475 case CARDSTATE_ERROR:
6476 cardState = UiccSlotInfo.CARD_STATE_INFO_ERROR;
6477 break;
6478 case CARDSTATE_RESTRICTED:
6479 cardState = UiccSlotInfo.CARD_STATE_INFO_RESTRICTED;
6480 break;
6481 default:
6482 break;
6483
6484 }
6485
6486 infos[i] = new UiccSlotInfo(
6487 slot.isActive(),
6488 slot.isEuicc(),
6489 cardId,
6490 cardState,
6491 slot.getPhoneId(),
Jordan Liua2619582019-02-14 12:56:40 -08006492 slot.isExtendedApduSupported(),
6493 slot.isRemovable());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006494 }
6495 return infos;
6496 } finally {
6497 Binder.restoreCallingIdentity(identity);
Holly Jiuyu Sun1d957c52018-04-04 13:52:42 -07006498 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006499 }
6500
6501 @Override
6502 public boolean switchSlots(int[] physicalSlots) {
6503 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006504
6505 final long identity = Binder.clearCallingIdentity();
6506 try {
6507 return (Boolean) sendRequest(CMD_SWITCH_SLOTS, physicalSlots);
6508 } finally {
6509 Binder.restoreCallingIdentity(identity);
6510 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006511 }
Jack Yu4c988042018-02-27 15:30:01 -08006512
6513 @Override
Jordan Liu7de49fa2018-12-06 14:48:49 -08006514 public int getCardIdForDefaultEuicc(int subId, String callingPackage) {
Jordan Liu7de49fa2018-12-06 14:48:49 -08006515 final long identity = Binder.clearCallingIdentity();
6516 try {
6517 return UiccController.getInstance().getCardIdForDefaultEuicc();
6518 } finally {
6519 Binder.restoreCallingIdentity(identity);
6520 }
6521 }
6522
6523 @Override
Jack Yu4c988042018-02-27 15:30:01 -08006524 public void setRadioIndicationUpdateMode(int subId, int filters, int mode) {
6525 enforceModifyPermission();
6526 final Phone phone = getPhone(subId);
6527 if (phone == null) {
6528 loge("setRadioIndicationUpdateMode fails with invalid subId: " + subId);
6529 return;
6530 }
6531
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006532 final long identity = Binder.clearCallingIdentity();
6533 try {
6534 phone.setRadioIndicationUpdateMode(filters, mode);
6535 } finally {
6536 Binder.restoreCallingIdentity(identity);
6537 }
Jack Yu4c988042018-02-27 15:30:01 -08006538 }
Pengquan Meng85728fb2018-03-12 16:31:21 -07006539
6540 /**
goneil47ffb6e2018-04-06 15:40:58 -07006541 * A test API to reload the UICC profile.
6542 *
6543 * <p>Requires that the calling app has permission
6544 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6545 * @hide
6546 */
6547 @Override
6548 public void refreshUiccProfile(int subId) {
6549 enforceModifyPermission();
6550
6551 final long identity = Binder.clearCallingIdentity();
6552 try {
6553 Phone phone = getPhone(subId);
6554 if (phone == null) {
6555 return;
6556 }
6557 UiccCard uiccCard = phone.getUiccCard();
6558 if (uiccCard == null) {
6559 return;
6560 }
6561 UiccProfile uiccProfile = uiccCard.getUiccProfile();
6562 if (uiccProfile == null) {
6563 return;
6564 }
6565 uiccProfile.refresh();
6566 } finally {
6567 Binder.restoreCallingIdentity(identity);
6568 }
6569 }
6570
6571 /**
Pengquan Meng85728fb2018-03-12 16:31:21 -07006572 * Returns false if the mobile data is disabled by default, otherwise return true.
6573 */
6574 private boolean getDefaultDataEnabled() {
6575 return "true".equalsIgnoreCase(
6576 SystemProperties.get(DEFAULT_MOBILE_DATA_PROPERTY_NAME, "true"));
6577 }
6578
6579 /**
6580 * Returns true if the data roaming is enabled by default, i.e the system property
6581 * of {@link #DEFAULT_DATA_ROAMING_PROPERTY_NAME} is true or the config of
6582 * {@link CarrierConfigManager#KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL} is true.
6583 */
6584 private boolean getDefaultDataRoamingEnabled(int subId) {
6585 final CarrierConfigManager configMgr = (CarrierConfigManager)
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006586 mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Pengquan Meng85728fb2018-03-12 16:31:21 -07006587 boolean isDataRoamingEnabled = "true".equalsIgnoreCase(
6588 SystemProperties.get(DEFAULT_DATA_ROAMING_PROPERTY_NAME, "false"));
6589 isDataRoamingEnabled |= configMgr.getConfigForSubId(subId).getBoolean(
6590 CarrierConfigManager.KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL);
6591 return isDataRoamingEnabled;
6592 }
6593
6594 /**
6595 * Returns the default network type for the given {@code subId}, if the default network type is
6596 * not set, return {@link Phone#PREFERRED_NT_MODE}.
6597 */
6598 private int getDefaultNetworkType(int subId) {
6599 return Integer.parseInt(
6600 TelephonyManager.getTelephonyProperty(
6601 mSubscriptionController.getPhoneId(subId),
6602 DEFAULT_NETWORK_MODE_PROPERTY_NAME,
6603 String.valueOf(Phone.PREFERRED_NT_MODE)));
6604 }
fionaxua13278b2018-03-21 00:08:13 -07006605
6606 @Override
6607 public void setCarrierTestOverride(int subId, String mccmnc, String imsi, String iccid, String
chen xueaba88a2019-03-15 13:15:10 -07006608 gid1, String gid2, String plmn, String spn, String carrierPrivilegeRules, String apn) {
fionaxua13278b2018-03-21 00:08:13 -07006609 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006610
6611 final long identity = Binder.clearCallingIdentity();
6612 try {
6613 final Phone phone = getPhone(subId);
6614 if (phone == null) {
6615 loge("setCarrierTestOverride fails with invalid subId: " + subId);
6616 return;
6617 }
chen xueaba88a2019-03-15 13:15:10 -07006618 phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
6619 carrierPrivilegeRules, apn);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006620 } finally {
6621 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006622 }
fionaxua13278b2018-03-21 00:08:13 -07006623 }
6624
6625 @Override
6626 public int getCarrierIdListVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006627 enforceReadPrivilegedPermission("getCarrierIdListVersion");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006628
6629 final long identity = Binder.clearCallingIdentity();
6630 try {
6631 final Phone phone = getPhone(subId);
6632 if (phone == null) {
6633 loge("getCarrierIdListVersion fails with invalid subId: " + subId);
6634 return TelephonyManager.UNKNOWN_CARRIER_ID_LIST_VERSION;
6635 }
6636 return phone.getCarrierIdListVersion();
6637 } finally {
6638 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006639 }
fionaxua13278b2018-03-21 00:08:13 -07006640 }
Malcolm Chen2c63d402018-08-14 16:00:53 -07006641
6642 @Override
6643 public int getNumberOfModemsWithSimultaneousDataConnections(int subId, String callingPackage) {
6644 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6645 mApp, subId, callingPackage, "getNumberOfModemsWithSimultaneousDataConnections")) {
6646 return -1;
6647 }
6648
6649 final long identity = Binder.clearCallingIdentity();
6650 try {
6651 return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
6652 } finally {
6653 Binder.restoreCallingIdentity(identity);
6654 }
6655 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006656
6657 @Override
6658 public int getCdmaRoamingMode(int subId) {
6659 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6660 mApp, subId, "getCdmaRoamingMode");
6661
6662 final long identity = Binder.clearCallingIdentity();
6663 try {
6664 return (int) sendRequest(CMD_GET_CDMA_ROAMING_MODE, null /* argument */, subId);
6665 } finally {
6666 Binder.restoreCallingIdentity(identity);
6667 }
6668 }
6669
6670 @Override
6671 public boolean setCdmaRoamingMode(int subId, int mode) {
6672 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6673 mApp, subId, "setCdmaRoamingMode");
6674
6675 final long identity = Binder.clearCallingIdentity();
6676 try {
6677 return (boolean) sendRequest(CMD_SET_CDMA_ROAMING_MODE, mode, subId);
6678 } finally {
6679 Binder.restoreCallingIdentity(identity);
6680 }
6681 }
6682
6683 @Override
6684 public boolean setCdmaSubscriptionMode(int subId, int mode) {
6685 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6686 mApp, subId, "setCdmaSubscriptionMode");
6687
6688 final long identity = Binder.clearCallingIdentity();
6689 try {
6690 return (boolean) sendRequest(CMD_SET_CDMA_SUBSCRIPTION_MODE, mode, subId);
6691 } finally {
6692 Binder.restoreCallingIdentity(identity);
6693 }
6694 }
Makoto Onukida3bf792018-09-18 16:06:29 -07006695
6696 private void ensureUserRunning(int userId) {
6697 if (!mUserManager.isUserRunning(userId)) {
6698 throw new IllegalStateException("User " + userId + " does not exist or not running");
6699 }
6700 }
6701
6702 /**
6703 * Returns a list of SMS apps on a given user.
6704 *
6705 * Only the shell user (UID 2000 or 0) can call it.
6706 * Target user must be running.
6707 */
6708 @Override
6709 public String[] getSmsApps(int userId) {
6710 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getSmsApps");
6711 ensureUserRunning(userId);
6712
6713 final Collection<SmsApplicationData> apps =
6714 SmsApplication.getApplicationCollectionAsUser(mApp, userId);
6715
6716 String[] ret = new String[apps.size()];
6717 int i = 0;
6718 for (SmsApplicationData app : apps) {
6719 ret[i++] = app.mPackageName;
6720 }
6721 return ret;
6722 }
6723
6724 /**
6725 * Returns the default SMS app package name on a given user.
6726 *
6727 * Only the shell user (UID 2000 or 0) can call it.
6728 * Target user must be running.
6729 */
6730 @Override
6731 public String getDefaultSmsApp(int userId) {
6732 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getDefaultSmsApp");
6733 ensureUserRunning(userId);
6734
6735 final ComponentName cn = SmsApplication.getDefaultSmsApplicationAsUser(mApp,
6736 /* updateIfNeeded= */ true, userId);
6737 return cn == null ? null : cn.getPackageName();
6738 }
6739
6740 /**
6741 * Set a package as the default SMS app on a given user.
6742 *
6743 * Only the shell user (UID 2000 or 0) can call it.
6744 * Target user must be running.
6745 */
6746 @Override
6747 public void setDefaultSmsApp(int userId, String packageName) {
6748 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "setDefaultSmsApp");
6749 ensureUserRunning(userId);
6750
6751 boolean found = false;
6752 for (String pkg : getSmsApps(userId)) {
6753 if (TextUtils.equals(packageName, pkg)) {
6754 found = true;
6755 break;
6756 }
6757 }
6758 if (!found) {
6759 throw new IllegalArgumentException("Package " + packageName + " is not an SMS app");
6760 }
6761
6762 SmsApplication.setDefaultApplicationAsUser(packageName, mApp, userId);
6763 }
sqianc5eccab2018-10-19 18:46:41 -07006764
6765 @Override
sqian8c685422019-02-22 15:55:18 -08006766 public Map<Integer, List<EmergencyNumber>> getEmergencyNumberList(
sqianc5eccab2018-10-19 18:46:41 -07006767 String callingPackage) {
sqian11b7a0e2018-12-05 18:48:28 -08006768 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
sqian8c685422019-02-22 15:55:18 -08006769 mApp, getDefaultSubscription(), callingPackage, "getEmergencyNumberList")) {
sqian11b7a0e2018-12-05 18:48:28 -08006770 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6771 }
6772 final long identity = Binder.clearCallingIdentity();
6773 try {
sqian854d44b2018-12-12 16:48:18 -08006774 Map<Integer, List<EmergencyNumber>> emergencyNumberListInternal = new HashMap<>();
6775 for (Phone phone: PhoneFactory.getPhones()) {
6776 if (phone.getEmergencyNumberTracker() != null
6777 && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
6778 emergencyNumberListInternal.put(
6779 phone.getSubId(),
6780 phone.getEmergencyNumberTracker().getEmergencyNumberList());
6781 }
sqian11b7a0e2018-12-05 18:48:28 -08006782 }
sqian854d44b2018-12-12 16:48:18 -08006783 return emergencyNumberListInternal;
sqian11b7a0e2018-12-05 18:48:28 -08006784 } finally {
6785 Binder.restoreCallingIdentity(identity);
6786 }
sqianc5eccab2018-10-19 18:46:41 -07006787 }
6788
6789 @Override
sqian8c685422019-02-22 15:55:18 -08006790 public boolean isEmergencyNumber(String number, boolean exactMatch) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006791 final Phone defaultPhone = getDefaultPhone();
sqian11b7a0e2018-12-05 18:48:28 -08006792 if (!exactMatch) {
6793 TelephonyPermissions
6794 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
sqian8c685422019-02-22 15:55:18 -08006795 mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
sqian11b7a0e2018-12-05 18:48:28 -08006796 }
6797 final long identity = Binder.clearCallingIdentity();
6798 try {
sqian854d44b2018-12-12 16:48:18 -08006799 for (Phone phone: PhoneFactory.getPhones()) {
6800 if (phone.getEmergencyNumberTracker() != null
6801 && phone.getEmergencyNumberTracker() != null) {
6802 if (phone.getEmergencyNumberTracker().isEmergencyNumber(
6803 number, exactMatch)) {
6804 return true;
sqian11b7a0e2018-12-05 18:48:28 -08006805 }
6806 }
sqian11b7a0e2018-12-05 18:48:28 -08006807 }
6808 return false;
6809 } finally {
6810 Binder.restoreCallingIdentity(identity);
6811 }
6812 }
6813
sqianf4ca7ed2019-01-15 18:32:07 -08006814 /**
6815 * Update emergency number list for test mode.
6816 */
6817 @Override
6818 public void updateEmergencyNumberListTestMode(int action, EmergencyNumber num) {
6819 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6820 "updateEmergencyNumberListTestMode");
6821
6822 final long identity = Binder.clearCallingIdentity();
6823 try {
6824 for (Phone phone: PhoneFactory.getPhones()) {
6825 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6826 if (tracker != null) {
6827 tracker.executeEmergencyNumberTestModeCommand(action, num);
6828 }
6829 }
6830 } finally {
6831 Binder.restoreCallingIdentity(identity);
6832 }
6833 }
6834
6835 /**
6836 * Get the full emergency number list for test mode.
6837 */
6838 @Override
6839 public List<String> getEmergencyNumberListTestMode() {
6840 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6841 "getEmergencyNumberListTestMode");
6842
6843 final long identity = Binder.clearCallingIdentity();
6844 try {
6845 Set<String> emergencyNumbers = new HashSet<>();
6846 for (Phone phone: PhoneFactory.getPhones()) {
6847 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6848 if (tracker != null) {
6849 for (EmergencyNumber num : tracker.getEmergencyNumberList()) {
6850 emergencyNumbers.add(num.getNumber());
6851 }
6852 }
6853 }
6854 return new ArrayList<>(emergencyNumbers);
6855 } finally {
6856 Binder.restoreCallingIdentity(identity);
6857 }
6858 }
6859
chen xud6b45bd2018-10-30 22:27:10 -07006860 @Override
6861 public List<String> getCertsFromCarrierPrivilegeAccessRules(int subId) {
6862 enforceReadPrivilegedPermission("getCertsFromCarrierPrivilegeAccessRules");
6863 Phone phone = getPhone(subId);
6864 if (phone == null) {
6865 return null;
6866 }
6867 final long identity = Binder.clearCallingIdentity();
6868 try {
6869 UiccProfile profile = UiccController.getInstance()
6870 .getUiccProfileForPhone(phone.getPhoneId());
6871 if (profile != null) {
6872 return profile.getCertsFromCarrierPrivilegeAccessRules();
6873 }
6874 } finally {
6875 Binder.restoreCallingIdentity(identity);
6876 }
6877 return null;
6878 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08006879
6880 /**
6881 * Enable or disable a modem stack.
6882 */
6883 @Override
6884 public boolean enableModemForSlot(int slotIndex, boolean enable) {
6885 enforceModifyPermission();
6886
6887 final long identity = Binder.clearCallingIdentity();
6888 try {
6889 Phone phone = PhoneFactory.getPhone(slotIndex);
6890 if (phone == null) {
6891 return false;
6892 } else {
6893 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
6894 }
6895 } finally {
6896 Binder.restoreCallingIdentity(identity);
6897 }
6898 }
Michelecea4cf22018-12-21 15:00:11 -08006899
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006900 /**
6901 * Whether a modem stack is enabled or not.
6902 */
6903 @Override
6904 public boolean isModemEnabledForSlot(int slotIndex, String callingPackage) {
6905 Phone phone = PhoneFactory.getPhone(slotIndex);
6906 if (phone == null) return false;
6907
6908 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6909 mApp, phone.getSubId(), callingPackage, "isModemEnabledForSlot")) {
6910 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6911 }
6912
6913 final long identity = Binder.clearCallingIdentity();
6914 try {
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07006915 try {
6916 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
6917 } catch (NoSuchElementException ex) {
6918 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
6919 }
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006920 } finally {
6921 Binder.restoreCallingIdentity(identity);
6922 }
6923 }
6924
Michelecea4cf22018-12-21 15:00:11 -08006925 @Override
Michele0ea7d782019-03-19 14:58:42 -07006926 public void setMultiSimCarrierRestriction(boolean isMultiSimCarrierRestricted) {
Michelecea4cf22018-12-21 15:00:11 -08006927 enforceModifyPermission();
6928
6929 final long identity = Binder.clearCallingIdentity();
6930 try {
6931 mTelephonySharedPreferences.edit()
Michele0ea7d782019-03-19 14:58:42 -07006932 .putBoolean(PREF_MULTI_SIM_RESTRICTED, isMultiSimCarrierRestricted)
Michelecea4cf22018-12-21 15:00:11 -08006933 .commit();
6934 } finally {
6935 Binder.restoreCallingIdentity(identity);
6936 }
6937 }
6938
6939 @Override
Michele0ea7d782019-03-19 14:58:42 -07006940 @TelephonyManager.IsMultiSimSupportedResult
6941 public int isMultiSimSupported(String callingPackage) {
Michele4245e952019-02-04 11:36:23 -08006942 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
Michele0ea7d782019-03-19 14:58:42 -07006943 getDefaultPhone().getSubId(), callingPackage, "isMultiSimSupported")) {
6944 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele4245e952019-02-04 11:36:23 -08006945 }
Michelecea4cf22018-12-21 15:00:11 -08006946
6947 final long identity = Binder.clearCallingIdentity();
6948 try {
Michele0ea7d782019-03-19 14:58:42 -07006949 return isMultiSimSupportedInternal();
Michelecea4cf22018-12-21 15:00:11 -08006950 } finally {
6951 Binder.restoreCallingIdentity(identity);
6952 }
6953 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006954
Michele0ea7d782019-03-19 14:58:42 -07006955 @TelephonyManager.IsMultiSimSupportedResult
6956 private int isMultiSimSupportedInternal() {
Michele30b57b22019-03-01 12:01:14 -08006957 // If the device has less than 2 SIM cards, indicate that multisim is restricted.
6958 int numPhysicalSlots = UiccController.getInstance().getUiccSlots().length;
6959 if (numPhysicalSlots < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006960 loge("isMultiSimSupportedInternal: requires at least 2 cards");
6961 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006962 }
6963 // Check if the hardware supports multisim functionality. If usage of multisim is not
6964 // supported by the modem, indicate that it is restricted.
6965 PhoneCapability staticCapability =
6966 mPhoneConfigurationManager.getStaticPhoneCapability();
6967 if (staticCapability == null) {
Michele0ea7d782019-03-19 14:58:42 -07006968 loge("isMultiSimSupportedInternal: no static configuration available");
6969 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006970 }
6971 if (staticCapability.logicalModemList.size() < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006972 loge("isMultiSimSupportedInternal: maximum number of modem is < 2");
6973 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006974 }
6975 // Check if support of multiple SIMs is restricted by carrier
6976 if (mTelephonySharedPreferences.getBoolean(PREF_MULTI_SIM_RESTRICTED, false)) {
Michele0ea7d782019-03-19 14:58:42 -07006977 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_CARRIER;
Michele30b57b22019-03-01 12:01:14 -08006978 }
6979
Michele0ea7d782019-03-19 14:58:42 -07006980 return TelephonyManager.MULTISIM_ALLOWED;
Michele30b57b22019-03-01 12:01:14 -08006981 }
6982
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006983 /**
6984 * Switch configs to enable multi-sim or switch back to single-sim
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006985 * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
6986 * permission, but the other way around is possible with either MODIFY_PHONE_STATE
6987 * or carrier privileges
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006988 * @param numOfSims number of active sims we want to switch to
6989 */
6990 @Override
6991 public void switchMultiSimConfig(int numOfSims) {
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006992 if (numOfSims == 1) {
6993 enforceModifyPermission();
6994 } else {
6995 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6996 mApp, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "switchMultiSimConfig");
6997 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006998 final long identity = Binder.clearCallingIdentity();
Michele30b57b22019-03-01 12:01:14 -08006999
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007000 try {
Michele30b57b22019-03-01 12:01:14 -08007001 //only proceed if multi-sim is not restricted
Michele0ea7d782019-03-19 14:58:42 -07007002 if (isMultiSimSupportedInternal() != TelephonyManager.MULTISIM_ALLOWED) {
Michele30b57b22019-03-01 12:01:14 -08007003 loge("switchMultiSimConfig not possible. It is restricted or not supported.");
7004 return;
7005 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08007006 mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
7007 } finally {
7008 Binder.restoreCallingIdentity(identity);
7009 }
7010 }
7011
7012 /**
chen xub4baa772019-04-03 10:23:41 -07007013 * Get whether making changes to modem configurations will trigger reboot.
7014 * Return value defaults to true.
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08007015 */
7016 @Override
chen xub4baa772019-04-03 10:23:41 -07007017 public boolean doesSwitchMultiSimConfigTriggerReboot(int subId, String callingPackage) {
7018 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
7019 mApp, subId, callingPackage, "doesSwitchMultiSimConfigTriggerReboot")) {
7020 return false;
7021 }
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08007022 final long identity = Binder.clearCallingIdentity();
7023 try {
7024 return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
7025 } finally {
7026 Binder.restoreCallingIdentity(identity);
7027 }
7028 }
7029
Nathan Harold29f5f052019-02-15 13:41:57 -08007030 private void updateModemStateMetrics() {
7031 TelephonyMetrics metrics = TelephonyMetrics.getInstance();
7032 // TODO: check the state for each modem if the api is ready.
7033 metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
7034 }
7035
Pengquan Meng3889a572019-01-23 11:16:29 -08007036 @Override
7037 public int[] getSlotsMapping() {
7038 enforceReadPrivilegedPermission("getSlotsMapping");
7039
7040 final long identity = Binder.clearCallingIdentity();
7041 try {
7042 int phoneCount = TelephonyManager.getDefault().getPhoneCount();
7043 // All logical slots should have a mapping to a physical slot.
7044 int[] logicalSlotsMapping = new int[phoneCount];
7045 UiccSlotInfo[] slotInfos = getUiccSlotsInfo();
7046 for (int i = 0; i < slotInfos.length; i++) {
7047 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
7048 logicalSlotsMapping[slotInfos[i].getLogicalSlotIdx()] = i;
7049 }
7050 }
7051 return logicalSlotsMapping;
7052 } finally {
7053 Binder.restoreCallingIdentity(identity);
7054 }
7055 }
Nathan Harold48d6fd52019-02-06 19:01:40 -08007056
7057 /**
7058 * Get the IRadio HAL Version
7059 */
7060 @Override
7061 public int getRadioHalVersion() {
7062 Phone phone = getDefaultPhone();
7063 if (phone == null) return -1;
7064 HalVersion hv = phone.getHalVersion();
7065 if (hv.equals(HalVersion.UNKNOWN)) return -1;
7066 return hv.major * 100 + hv.minor;
7067 }
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007068
7069 /**
Malcolm Chene5ad5792019-04-18 13:51:02 -07007070 * Return whether data is enabled for certain APN type. This will tell if framework will accept
7071 * corresponding network requests on a subId.
7072 *
7073 * Data is enabled if:
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007074 * 1) user data is turned on, or
Malcolm Chene5ad5792019-04-18 13:51:02 -07007075 * 2) APN is un-metered for this subscription, or
7076 * 3) APN type is whitelisted. E.g. MMS is whitelisted if
7077 * {@link SubscriptionManager#setAlwaysAllowMmsData} is turned on.
7078 *
7079 * @return whether data is allowed for a apn type.
7080 *
7081 * @hide
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007082 */
7083 @Override
Malcolm Chene5ad5792019-04-18 13:51:02 -07007084 public boolean isDataEnabledForApn(int apnType, int subId, String callingPackage) {
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007085 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Malcolm Chene5ad5792019-04-18 13:51:02 -07007086 mApp, subId, callingPackage, "isDataEnabledForApn")) {
7087 throw new SecurityException("Needs READ_PHONE_STATE for isDataEnabledForApn");
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007088 }
7089
7090 // Now that all security checks passes, perform the operation as ourselves.
7091 final long identity = Binder.clearCallingIdentity();
7092 try {
7093 Phone phone = getPhone(subId);
7094 if (phone == null) return false;
7095
Jack Yu41407ee2019-05-13 16:54:09 -07007096 boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chene5ad5792019-04-18 13:51:02 -07007097 return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
7098 } finally {
7099 Binder.restoreCallingIdentity(identity);
7100 }
7101 }
7102
7103 @Override
Jack Yu41407ee2019-05-13 16:54:09 -07007104 public boolean isApnMetered(@ApnType int apnType, int subId) {
Malcolm Chene5ad5792019-04-18 13:51:02 -07007105 enforceReadPrivilegedPermission("isApnMetered");
7106
7107 // Now that all security checks passes, perform the operation as ourselves.
7108 final long identity = Binder.clearCallingIdentity();
7109 try {
7110 Phone phone = getPhone(subId);
7111 if (phone == null) return true; // By default return true.
7112
Jack Yu41407ee2019-05-13 16:54:09 -07007113 return ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007114 } finally {
7115 Binder.restoreCallingIdentity(identity);
7116 }
7117 }
Brad Ebingera63db5f2019-04-23 16:31:13 -07007118
7119 @Override
7120 public void enqueueSmsPickResult(String callingPackage, IIntegerConsumer pendingSubIdResult) {
7121 SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
7122 (AppOpsManager) mApp.getSystemService(Context.APP_OPS_SERVICE));
7123 if (!permissions.checkCallingCanSendSms(callingPackage, "Sending message")) {
7124 throw new SecurityException("Requires SEND_SMS permission to perform this operation");
7125 }
7126 PickSmsSubscriptionActivity.addPendingResult(pendingSubIdResult);
7127 Intent intent = new Intent();
7128 intent.setClass(mApp, PickSmsSubscriptionActivity.class);
7129 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
7130 // Bring up choose default SMS subscription dialog right now
7131 intent.putExtra(PickSmsSubscriptionActivity.DIALOG_TYPE_KEY,
7132 PickSmsSubscriptionActivity.SMS_PICK_FOR_MESSAGE);
7133 mApp.startActivity(intent);
7134 }
chen xud5ca2d52019-05-28 15:20:57 -07007135
7136 @Override
7137 public String getMmsUAProfUrl(int subId) {
7138 //TODO investigate if this API should require proper permission check in R b/133791609
7139 final long identity = Binder.clearCallingIdentity();
7140 try {
7141 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7142 .getString(com.android.internal.R.string.config_mms_user_agent_profile_url);
7143 } finally {
7144 Binder.restoreCallingIdentity(identity);
7145 }
7146 }
7147
7148 @Override
7149 public String getMmsUserAgent(int subId) {
7150 //TODO investigate if this API should require proper permission check in R b/133791609
7151 final long identity = Binder.clearCallingIdentity();
7152 try {
7153 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7154 .getString(com.android.internal.R.string.config_mms_user_agent);
7155 } finally {
7156 Binder.restoreCallingIdentity(identity);
7157 }
7158 }
Jack Yub07d4972019-05-28 16:12:25 -07007159
7160 @Override
7161 public boolean setDataAllowedDuringVoiceCall(int subId, boolean allow) {
7162 enforceModifyPermission();
7163
7164 // Now that all security checks passes, perform the operation as ourselves.
7165 final long identity = Binder.clearCallingIdentity();
7166 try {
7167 Phone phone = getPhone(subId);
7168 if (phone == null) return false;
7169
7170 return phone.getDataEnabledSettings().setAllowDataDuringVoiceCall(allow);
7171 } finally {
7172 Binder.restoreCallingIdentity(identity);
7173 }
7174 }
7175
7176 @Override
7177 public boolean isDataAllowedInVoiceCall(int subId) {
7178 enforceReadPrivilegedPermission("isDataAllowedInVoiceCall");
7179
7180 // Now that all security checks passes, perform the operation as ourselves.
7181 final long identity = Binder.clearCallingIdentity();
7182 try {
7183 Phone phone = getPhone(subId);
7184 if (phone == null) return false;
7185
7186 return phone.getDataEnabledSettings().isDataAllowedInVoiceCall();
7187 } finally {
7188 Binder.restoreCallingIdentity(identity);
7189 }
7190 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07007191}