blob: b1d3f26093c6a6c5db626f9dbaa9e28d79e3d099 [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 Ebingerdac2f002018-04-03 15:17:52 -070051import android.os.ShellCallback;
Pengquan Meng85728fb2018-03-12 16:31:21 -070052import android.os.SystemProperties;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070053import android.os.UserHandle;
Stuart Scott981d8582015-04-21 14:09:50 -070054import android.os.UserManager;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070055import android.os.WorkSource;
Derek Tan97ebb422014-09-05 16:55:38 -070056import android.preference.PreferenceManager;
Ihab Awadf2177b72013-11-25 13:33:23 -080057import android.provider.Settings;
Amit Mahajan7dbbd822019-03-13 17:33:47 -070058import android.provider.Telephony;
Santos Cordon7a1885b2015-02-03 11:15:19 -080059import android.telecom.PhoneAccount;
Nancy Chen31f9ba12016-01-06 11:42:12 -080060import android.telecom.PhoneAccountHandle;
Andrew Lee9431b832015-03-09 18:46:45 -070061import android.telecom.TelecomManager;
Junda Liu12f7d802015-05-01 12:06:44 -070062import android.telephony.CarrierConfigManager;
Michele Berionne482f8202018-11-27 18:57:59 -080063import android.telephony.CarrierRestrictionRules;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070064import android.telephony.CellInfo;
Nathan Haroldf180aac2018-06-01 18:43:55 -070065import android.telephony.CellInfoGsm;
66import android.telephony.CellInfoWcdma;
Nathan Harold3ff88932018-08-14 10:19:49 -070067import android.telephony.CellLocation;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070068import android.telephony.ClientRequestStats;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -070069import android.telephony.ICellInfoCallback;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -070070import android.telephony.IccOpenLogicalChannelResponse;
Hall Liu1aa510f2017-11-22 17:40:08 -080071import android.telephony.LocationAccessPolicy;
Ta-wei Yen87c49842016-05-13 21:19:52 -070072import android.telephony.ModemActivityInfo;
Jake Hambye994d462014-02-03 13:10:13 -080073import android.telephony.NeighboringCellInfo;
yinxu504e1392017-04-12 16:03:22 -070074import android.telephony.NetworkScanRequest;
Michele4245e952019-02-04 11:36:23 -080075import android.telephony.PhoneCapability;
Hall Liud892bec2018-11-30 14:51:45 -080076import android.telephony.PhoneNumberRange;
Wink Saville5d475dd2014-10-17 15:00:58 -070077import android.telephony.RadioAccessFamily;
Hall Liub2ac8ef2019-02-28 15:56:23 -080078import android.telephony.RadioAccessSpecifier;
Tyler Gunn65d45c22017-06-05 11:22:26 -070079import android.telephony.Rlog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070080import android.telephony.ServiceState;
Nathan Harold46b42aa2017-03-10 19:38:22 -080081import android.telephony.SignalStrength;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080082import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080083import android.telephony.SubscriptionManager;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070084import android.telephony.TelephonyHistogram;
Ta-wei Yenb6929602016-05-24 15:48:27 -070085import android.telephony.TelephonyManager;
Hall Liub2ac8ef2019-02-28 15:56:23 -080086import android.telephony.TelephonyScanManager;
Jordan Liu5aa07002018-12-18 15:44:48 -080087import android.telephony.UiccCardInfo;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +000088import android.telephony.UiccSlotInfo;
Tyler Gunn65d45c22017-06-05 11:22:26 -070089import android.telephony.UssdResponse;
Ta-wei Yenb6929602016-05-24 15:48:27 -070090import android.telephony.VisualVoicemailSmsFilterSettings;
Nathan Harold3ff88932018-08-14 10:19:49 -070091import android.telephony.cdma.CdmaCellLocation;
Jack Yub5d8f642018-11-26 11:20:48 -080092import android.telephony.data.ApnSetting;
Jack Yu41407ee2019-05-13 16:54:09 -070093import android.telephony.data.ApnSetting.ApnType;
Jack Yub5d8f642018-11-26 11:20:48 -080094import android.telephony.emergency.EmergencyNumber;
Nathan Harold3ff88932018-08-14 10:19:49 -070095import android.telephony.gsm.GsmCellLocation;
Brad Ebinger1c8542e2019-01-14 13:43:14 -080096import android.telephony.ims.ProvisioningManager;
Brad Ebinger35c841c2018-10-01 10:40:55 -070097import android.telephony.ims.aidl.IImsCapabilityCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -080098import android.telephony.ims.aidl.IImsConfig;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -070099import android.telephony.ims.aidl.IImsConfigCallback;
Brad Ebinger22bc3e42018-01-16 09:39:35 -0800100import android.telephony.ims.aidl.IImsMmTelFeature;
101import android.telephony.ims.aidl.IImsRcsFeature;
102import android.telephony.ims.aidl.IImsRegistration;
Brad Ebinger35c841c2018-10-01 10:40:55 -0700103import android.telephony.ims.aidl.IImsRegistrationCallback;
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800104import android.telephony.ims.feature.MmTelFeature;
105import android.telephony.ims.stub.ImsConfigImplBase;
Brad Ebinger1f2b5082018-02-08 16:11:32 -0800106import android.telephony.ims.stub.ImsRegistrationImplBase;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700107import android.text.TextUtils;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800108import android.util.ArraySet;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700109import android.util.Log;
Jake Hambye994d462014-02-03 13:10:13 -0800110import android.util.Pair;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800111import android.util.Slog;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800112
Brad Ebinger35c841c2018-10-01 10:40:55 -0700113import com.android.ims.ImsException;
Andrew Lee312e8172014-10-23 17:01:36 -0700114import com.android.ims.ImsManager;
Brad Ebinger34bef922017-11-09 10:27:08 -0800115import com.android.ims.internal.IImsServiceFeatureCallback;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700116import com.android.internal.telephony.CallManager;
Tyler Gunn52dcf772017-04-26 11:30:31 -0700117import com.android.internal.telephony.CallStateException;
pkanwar79ec0542017-07-31 14:10:01 -0700118import com.android.internal.telephony.CarrierInfoManager;
chen xu651eec72018-11-11 19:03:44 -0800119import com.android.internal.telephony.CarrierResolver;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700120import com.android.internal.telephony.CellNetworkScanResult;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700121import com.android.internal.telephony.CommandException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700122import com.android.internal.telephony.DefaultPhoneNotifier;
Nathan Harold48d6fd52019-02-06 19:01:40 -0800123import com.android.internal.telephony.HalVersion;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700124import com.android.internal.telephony.IIntegerConsumer;
Hall Liud892bec2018-11-30 14:51:45 -0800125import com.android.internal.telephony.INumberVerificationCallback;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700126import com.android.internal.telephony.ITelephony;
Jake Hambye994d462014-02-03 13:10:13 -0800127import com.android.internal.telephony.IccCard;
Jack Yu5f7092c2018-04-13 14:05:37 -0700128import com.android.internal.telephony.LocaleTracker;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100129import com.android.internal.telephony.MccTable;
yinxub1bed742017-04-17 11:45:04 -0700130import com.android.internal.telephony.NetworkScanRequestTracker;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700131import com.android.internal.telephony.OperatorInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700132import com.android.internal.telephony.Phone;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700133import com.android.internal.telephony.PhoneConfigurationManager;
Nathan Harolda667c152016-12-14 11:27:20 -0800134import com.android.internal.telephony.PhoneConstantConversions;
Ta-wei Yen87c49842016-05-13 21:19:52 -0700135import com.android.internal.telephony.PhoneConstants;
Wink Saville36469e72014-06-11 15:17:00 -0700136import com.android.internal.telephony.PhoneFactory;
Wink Saville5d475dd2014-10-17 15:00:58 -0700137import com.android.internal.telephony.ProxyController;
Sanket Padawe99ef1e32016-05-18 16:12:33 -0700138import com.android.internal.telephony.RIL;
Svet Ganovb320e182015-04-16 12:30:10 -0700139import com.android.internal.telephony.RILConstants;
Jack Yu5f7092c2018-04-13 14:05:37 -0700140import com.android.internal.telephony.ServiceStateTracker;
Makoto Onukida3bf792018-09-18 16:06:29 -0700141import com.android.internal.telephony.SmsApplication;
142import com.android.internal.telephony.SmsApplication.SmsApplicationData;
Amit Mahajandccb3f12019-05-13 13:48:32 -0700143import com.android.internal.telephony.SmsController;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700144import com.android.internal.telephony.SmsPermissions;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800145import com.android.internal.telephony.SubscriptionController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800146import com.android.internal.telephony.TelephonyPermissions;
Malcolm Chendc8c10e2019-04-10 18:25:07 -0700147import com.android.internal.telephony.dataconnection.ApnSettingUtils;
sqianf4ca7ed2019-01-15 18:32:07 -0800148import com.android.internal.telephony.emergency.EmergencyNumberTracker;
Derek Tan740e1672017-06-27 14:56:27 -0700149import com.android.internal.telephony.euicc.EuiccConnector;
Brad Ebinger9c0eb502019-01-23 15:06:19 -0800150import com.android.internal.telephony.ims.ImsResolver;
Pengquan Meng6c2dc9f2019-02-06 11:12:53 -0800151import com.android.internal.telephony.metrics.TelephonyMetrics;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700152import com.android.internal.telephony.uicc.IccIoResult;
153import com.android.internal.telephony.uicc.IccUtils;
Nathan Haroldb3014052017-01-25 15:57:32 -0800154import com.android.internal.telephony.uicc.SIMRecords;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700155import com.android.internal.telephony.uicc.UiccCard;
Nathan Haroldb3014052017-01-25 15:57:32 -0800156import com.android.internal.telephony.uicc.UiccCardApplication;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700157import com.android.internal.telephony.uicc.UiccController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800158import com.android.internal.telephony.uicc.UiccProfile;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000159import com.android.internal.telephony.uicc.UiccSlot;
fionaxu7ed723d2017-05-30 18:58:54 -0700160import com.android.internal.telephony.util.VoicemailNotificationSettingsUtil;
Jake Hambye994d462014-02-03 13:10:13 -0800161import com.android.internal.util.HexDump;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700162import com.android.phone.settings.PickSmsSubscriptionActivity;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700163import com.android.phone.vvm.PhoneAccountHandleConverter;
Ta-wei Yen527a9c02017-01-06 15:29:25 -0800164import com.android.phone.vvm.RemoteVvmTaskManager;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700165import com.android.phone.vvm.VisualVoicemailSettingsUtil;
Ta-wei Yenc8905312017-03-28 11:14:45 -0700166import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800167
Ta-wei Yenc236d6b2016-06-21 13:33:12 -0700168import java.io.FileDescriptor;
169import java.io.PrintWriter;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700170import java.util.ArrayList;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800171import java.util.Arrays;
Makoto Onukida3bf792018-09-18 16:06:29 -0700172import java.util.Collection;
sqian11b7a0e2018-12-05 18:48:28 -0800173import java.util.HashMap;
sqianf4ca7ed2019-01-15 18:32:07 -0800174import java.util.HashSet;
Jake Hambye994d462014-02-03 13:10:13 -0800175import java.util.List;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100176import java.util.Locale;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800177import java.util.Map;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700178import java.util.NoSuchElementException;
sqianf4ca7ed2019-01-15 18:32:07 -0800179import java.util.Set;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700180
181/**
182 * Implementation of the ITelephony interface.
183 */
Santos Cordon117fee72014-05-16 17:56:12 -0700184public class PhoneInterfaceManager extends ITelephony.Stub {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700185 private static final String LOG_TAG = "PhoneInterfaceManager";
186 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
187 private static final boolean DBG_LOC = false;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800188 private static final boolean DBG_MERGE = false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700189
190 // Message codes used with mMainThreadHandler
191 private static final int CMD_HANDLE_PIN_MMI = 1;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700192 private static final int CMD_TRANSMIT_APDU_LOGICAL_CHANNEL = 7;
193 private static final int EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE = 8;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700194 private static final int CMD_OPEN_CHANNEL = 9;
195 private static final int EVENT_OPEN_CHANNEL_DONE = 10;
196 private static final int CMD_CLOSE_CHANNEL = 11;
197 private static final int EVENT_CLOSE_CHANNEL_DONE = 12;
Jake Hambye994d462014-02-03 13:10:13 -0800198 private static final int CMD_NV_READ_ITEM = 13;
199 private static final int EVENT_NV_READ_ITEM_DONE = 14;
200 private static final int CMD_NV_WRITE_ITEM = 15;
201 private static final int EVENT_NV_WRITE_ITEM_DONE = 16;
202 private static final int CMD_NV_WRITE_CDMA_PRL = 17;
203 private static final int EVENT_NV_WRITE_CDMA_PRL_DONE = 18;
chen xu6dac5ab2018-10-26 17:39:23 -0700204 private static final int CMD_RESET_MODEM_CONFIG = 19;
205 private static final int EVENT_RESET_MODEM_CONFIG_DONE = 20;
Jake Hamby7c27be32014-03-03 13:25:59 -0800206 private static final int CMD_GET_PREFERRED_NETWORK_TYPE = 21;
207 private static final int EVENT_GET_PREFERRED_NETWORK_TYPE_DONE = 22;
208 private static final int CMD_SET_PREFERRED_NETWORK_TYPE = 23;
209 private static final int EVENT_SET_PREFERRED_NETWORK_TYPE_DONE = 24;
Sailesh Nepal35b59452014-03-06 09:26:56 -0800210 private static final int CMD_SEND_ENVELOPE = 25;
211 private static final int EVENT_SEND_ENVELOPE_DONE = 26;
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000212 private static final int CMD_INVOKE_OEM_RIL_REQUEST_RAW = 27;
213 private static final int EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE = 28;
Derek Tan6b088ee2014-09-05 14:15:18 -0700214 private static final int CMD_TRANSMIT_APDU_BASIC_CHANNEL = 29;
215 private static final int EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE = 30;
216 private static final int CMD_EXCHANGE_SIM_IO = 31;
217 private static final int EVENT_EXCHANGE_SIM_IO_DONE = 32;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800218 private static final int CMD_SET_VOICEMAIL_NUMBER = 33;
219 private static final int EVENT_SET_VOICEMAIL_NUMBER_DONE = 34;
Stuart Scott54788802015-03-30 13:18:01 -0700220 private static final int CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC = 35;
221 private static final int EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE = 36;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700222 private static final int CMD_GET_MODEM_ACTIVITY_INFO = 37;
223 private static final int EVENT_GET_MODEM_ACTIVITY_INFO_DONE = 38;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700224 private static final int CMD_PERFORM_NETWORK_SCAN = 39;
225 private static final int EVENT_PERFORM_NETWORK_SCAN_DONE = 40;
226 private static final int CMD_SET_NETWORK_SELECTION_MODE_MANUAL = 41;
227 private static final int EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE = 42;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700228 private static final int CMD_SET_ALLOWED_CARRIERS = 43;
229 private static final int EVENT_SET_ALLOWED_CARRIERS_DONE = 44;
230 private static final int CMD_GET_ALLOWED_CARRIERS = 45;
231 private static final int EVENT_GET_ALLOWED_CARRIERS_DONE = 46;
pkanwar32d516d2016-10-14 19:37:38 -0700232 private static final int CMD_HANDLE_USSD_REQUEST = 47;
Nathan Haroldb3014052017-01-25 15:57:32 -0800233 private static final int CMD_GET_FORBIDDEN_PLMNS = 48;
234 private static final int EVENT_GET_FORBIDDEN_PLMNS_DONE = 49;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000235 private static final int CMD_SWITCH_SLOTS = 50;
236 private static final int EVENT_SWITCH_SLOTS_DONE = 51;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700237 private static final int CMD_GET_NETWORK_SELECTION_MODE = 52;
238 private static final int EVENT_GET_NETWORK_SELECTION_MODE_DONE = 53;
239 private static final int CMD_GET_CDMA_ROAMING_MODE = 54;
240 private static final int EVENT_GET_CDMA_ROAMING_MODE_DONE = 55;
241 private static final int CMD_SET_CDMA_ROAMING_MODE = 56;
242 private static final int EVENT_SET_CDMA_ROAMING_MODE_DONE = 57;
243 private static final int CMD_SET_CDMA_SUBSCRIPTION_MODE = 58;
244 private static final int EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE = 59;
Nathan Harold3ff88932018-08-14 10:19:49 -0700245 private static final int CMD_GET_ALL_CELL_INFO = 60;
246 private static final int EVENT_GET_ALL_CELL_INFO_DONE = 61;
247 private static final int CMD_GET_CELL_LOCATION = 62;
248 private static final int EVENT_GET_CELL_LOCATION_DONE = 63;
chen xu6dac5ab2018-10-26 17:39:23 -0700249 private static final int CMD_MODEM_REBOOT = 64;
250 private static final int EVENT_CMD_MODEM_REBOOT_DONE = 65;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -0700251 private static final int CMD_REQUEST_CELL_INFO_UPDATE = 66;
252 private static final int EVENT_REQUEST_CELL_INFO_UPDATE_DONE = 67;
Malcolm Chen8e4ed912019-01-15 20:22:16 -0800253 private static final int CMD_REQUEST_ENABLE_MODEM = 68;
254 private static final int EVENT_ENABLE_MODEM_DONE = 69;
Nazanin Bakhshif71371d2019-04-29 17:29:44 -0700255 private static final int CMD_GET_MODEM_STATUS = 70;
256 private static final int EVENT_GET_MODEM_STATUS_DONE = 71;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700257
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -0800258 // Parameters of select command.
259 private static final int SELECT_COMMAND = 0xA4;
260 private static final int SELECT_P1 = 0x04;
261 private static final int SELECT_P2 = 0;
262 private static final int SELECT_P3 = 0x10;
263
Pengquan Meng85728fb2018-03-12 16:31:21 -0700264 private static final String DEFAULT_NETWORK_MODE_PROPERTY_NAME = "ro.telephony.default_network";
265 private static final String DEFAULT_DATA_ROAMING_PROPERTY_NAME = "ro.com.android.dataroaming";
266 private static final String DEFAULT_MOBILE_DATA_PROPERTY_NAME = "ro.com.android.mobiledata";
267
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700268 /** The singleton instance. */
269 private static PhoneInterfaceManager sInstance;
270
Wink Saville3ab207e2014-11-20 13:07:20 -0800271 private PhoneGlobals mApp;
Wink Saville3ab207e2014-11-20 13:07:20 -0800272 private CallManager mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700273 private UserManager mUserManager;
Wink Saville3ab207e2014-11-20 13:07:20 -0800274 private AppOpsManager mAppOps;
275 private MainThreadHandler mMainThreadHandler;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800276 private SubscriptionController mSubscriptionController;
Wink Saville3ab207e2014-11-20 13:07:20 -0800277 private SharedPreferences mTelephonySharedPreferences;
Malcolm Chen2c63d402018-08-14 16:00:53 -0700278 private PhoneConfigurationManager mPhoneConfigurationManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700279
Derek Tan97ebb422014-09-05 16:55:38 -0700280 private static final String PREF_CARRIERS_ALPHATAG_PREFIX = "carrier_alphtag_";
281 private static final String PREF_CARRIERS_NUMBER_PREFIX = "carrier_number_";
Jeff Sharkey85190e62014-12-05 09:40:12 -0800282 private static final String PREF_CARRIERS_SUBSCRIBER_PREFIX = "carrier_subscriber_";
Brad Ebinger1c8542e2019-01-14 13:43:14 -0800283 private static final String PREF_PROVISION_IMS_MMTEL_PREFIX = "provision_ims_mmtel_";
Derek Tan89e89d42014-07-08 17:00:10 -0700284
Michelecea4cf22018-12-21 15:00:11 -0800285 // String to store multi SIM allowed
286 private static final String PREF_MULTI_SIM_RESTRICTED = "multisim_restricted";
287
Derek Tan740e1672017-06-27 14:56:27 -0700288 // The AID of ISD-R.
289 private static final String ISDR_AID = "A0000005591010FFFFFFFF8900000100";
290
yinxub1bed742017-04-17 11:45:04 -0700291 private NetworkScanRequestTracker mNetworkScanRequestTracker;
292
David Kelly5e06a7f2018-03-12 14:10:59 +0000293 private static final int TYPE_ALLOCATION_CODE_LENGTH = 8;
294 private static final int MANUFACTURER_CODE_LENGTH = 8;
295
Derek Tan89e89d42014-07-08 17:00:10 -0700296 /**
Shishir Agrawal566b7612013-10-28 14:41:00 -0700297 * A request object to use for transmitting data to an ICC.
298 */
299 private static final class IccAPDUArgument {
300 public int channel, cla, command, p1, p2, p3;
301 public String data;
302
303 public IccAPDUArgument(int channel, int cla, int command,
304 int p1, int p2, int p3, String data) {
305 this.channel = channel;
306 this.cla = cla;
307 this.command = command;
308 this.p1 = p1;
309 this.p2 = p2;
310 this.p3 = p3;
311 this.data = data;
312 }
313 }
314
315 /**
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700316 * A request object to use for transmitting data to an ICC.
317 */
318 private static final class ManualNetworkSelectionArgument {
319 public OperatorInfo operatorInfo;
320 public boolean persistSelection;
321
322 public ManualNetworkSelectionArgument(OperatorInfo operatorInfo, boolean persistSelection) {
323 this.operatorInfo = operatorInfo;
324 this.persistSelection = persistSelection;
325 }
326 }
327
328 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700329 * A request object for use with {@link MainThreadHandler}. Requesters should wait() on the
330 * request after sending. The main thread will notify the request when it is complete.
331 */
332 private static final class MainThreadRequest {
333 /** The argument to use for the request */
334 public Object argument;
335 /** The result of the request that is run on the main thread */
336 public Object result;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800337 // The subscriber id that this request applies to. Defaults to
338 // SubscriptionManager.INVALID_SUBSCRIPTION_ID
339 public Integer subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700340
Nathan Harold92bed182018-10-12 18:16:49 -0700341 // In cases where subId is unavailable, the caller needs to specify the phone.
342 public Phone phone;
343
vagdeviaf9a5b92018-08-15 16:01:53 -0700344 public WorkSource workSource;
345
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700346 public MainThreadRequest(Object argument) {
347 this.argument = argument;
348 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800349
Nathan Harold92bed182018-10-12 18:16:49 -0700350 MainThreadRequest(Object argument, Phone phone, WorkSource workSource) {
351 this.argument = argument;
352 if (phone != null) {
353 this.phone = phone;
354 }
355 this.workSource = workSource;
356 }
357
vagdeviaf9a5b92018-08-15 16:01:53 -0700358 MainThreadRequest(Object argument, Integer subId, WorkSource workSource) {
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800359 this.argument = argument;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800360 if (subId != null) {
361 this.subId = subId;
362 }
vagdeviaf9a5b92018-08-15 16:01:53 -0700363 this.workSource = workSource;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800364 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700365 }
366
Sailesh Nepalcc0375f2013-11-13 09:15:18 -0800367 private static final class IncomingThirdPartyCallArgs {
368 public final ComponentName component;
369 public final String callId;
370 public final String callerDisplayName;
371
372 public IncomingThirdPartyCallArgs(ComponentName component, String callId,
373 String callerDisplayName) {
374 this.component = component;
375 this.callId = callId;
376 this.callerDisplayName = callerDisplayName;
377 }
378 }
379
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700380 /**
381 * A handler that processes messages on the main thread in the phone process. Since many
382 * of the Phone calls are not thread safe this is needed to shuttle the requests from the
383 * inbound binder threads to the main thread in the phone process. The Binder thread
384 * may provide a {@link MainThreadRequest} object in the msg.obj field that they are waiting
385 * on, which will be notified when the operation completes and will contain the result of the
386 * request.
387 *
388 * <p>If a MainThreadRequest object is provided in the msg.obj field,
389 * note that request.result must be set to something non-null for the calling thread to
390 * unblock.
391 */
392 private final class MainThreadHandler extends Handler {
393 @Override
394 public void handleMessage(Message msg) {
395 MainThreadRequest request;
396 Message onCompleted;
397 AsyncResult ar;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800398 UiccCard uiccCard;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700399 IccAPDUArgument iccArgument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800400 final Phone defaultPhone = getDefaultPhone();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700401
402 switch (msg.what) {
Pengquan Menga1bb6272018-09-06 09:59:22 -0700403 case CMD_HANDLE_USSD_REQUEST: {
404 request = (MainThreadRequest) msg.obj;
405 final Phone phone = getPhoneFromRequest(request);
406 Pair<String, ResultReceiver> ussdObject = (Pair) request.argument;
407 String ussdRequest = ussdObject.first;
408 ResultReceiver wrappedCallback = ussdObject.second;
Tyler Gunn65d45c22017-06-05 11:22:26 -0700409
Pengquan Menga1bb6272018-09-06 09:59:22 -0700410 if (!isUssdApiAllowed(request.subId)) {
411 // Carrier does not support use of this API, return failure.
412 Rlog.w(LOG_TAG, "handleUssdRequest: carrier does not support USSD apis.");
413 UssdResponse response = new UssdResponse(ussdRequest, null);
414 Bundle returnData = new Bundle();
415 returnData.putParcelable(TelephonyManager.USSD_RESPONSE, response);
416 wrappedCallback.send(TelephonyManager.USSD_RETURN_FAILURE, returnData);
Tyler Gunn65d45c22017-06-05 11:22:26 -0700417
Pengquan Menga1bb6272018-09-06 09:59:22 -0700418 request.result = true;
419 notifyRequester(request);
420 return;
421 }
Tyler Gunn65d45c22017-06-05 11:22:26 -0700422
Pengquan Menga1bb6272018-09-06 09:59:22 -0700423 try {
424 request.result = phone != null
425 ? phone.handleUssdRequest(ussdRequest, wrappedCallback) : false;
426 } catch (CallStateException cse) {
427 request.result = false;
428 }
429 // Wake up the requesting thread
430 notifyRequester(request);
431 break;
pkanwar32d516d2016-10-14 19:37:38 -0700432 }
433
Yorke Lee716f67e2015-06-17 15:39:16 -0700434 case CMD_HANDLE_PIN_MMI: {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700435 request = (MainThreadRequest) msg.obj;
Yorke Lee716f67e2015-06-17 15:39:16 -0700436 final Phone phone = getPhoneFromRequest(request);
437 request.result = phone != null ?
438 getPhoneFromRequest(request).handlePinMmi((String) request.argument)
439 : false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700440 // Wake up the requesting thread
Pengquan Menga1bb6272018-09-06 09:59:22 -0700441 notifyRequester(request);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700442 break;
Yorke Lee716f67e2015-06-17 15:39:16 -0700443 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700444
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700445 case CMD_TRANSMIT_APDU_LOGICAL_CHANNEL:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700446 request = (MainThreadRequest) msg.obj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700447 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800448 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700449 if (uiccCard == null) {
450 loge("iccTransmitApduLogicalChannel: No UICC");
451 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700452 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700453 } else {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700454 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE,
455 request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700456 uiccCard.iccTransmitApduLogicalChannel(
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700457 iccArgument.channel, iccArgument.cla, iccArgument.command,
458 iccArgument.p1, iccArgument.p2, iccArgument.p3, iccArgument.data,
Shishir Agrawal566b7612013-10-28 14:41:00 -0700459 onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700460 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700461 break;
462
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700463 case EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700464 ar = (AsyncResult) msg.obj;
465 request = (MainThreadRequest) ar.userObj;
466 if (ar.exception == null && ar.result != null) {
467 request.result = ar.result;
468 } else {
469 request.result = new IccIoResult(0x6F, 0, (byte[])null);
470 if (ar.result == null) {
471 loge("iccTransmitApduLogicalChannel: Empty response");
Jake Hambye994d462014-02-03 13:10:13 -0800472 } else if (ar.exception instanceof CommandException) {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700473 loge("iccTransmitApduLogicalChannel: CommandException: " +
Jake Hambye994d462014-02-03 13:10:13 -0800474 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700475 } else {
476 loge("iccTransmitApduLogicalChannel: Unknown exception");
477 }
478 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700479 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700480 break;
481
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700482 case CMD_TRANSMIT_APDU_BASIC_CHANNEL:
483 request = (MainThreadRequest) msg.obj;
484 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800485 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700486 if (uiccCard == null) {
487 loge("iccTransmitApduBasicChannel: No UICC");
488 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700489 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700490 } else {
491 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE,
492 request);
493 uiccCard.iccTransmitApduBasicChannel(
494 iccArgument.cla, iccArgument.command, iccArgument.p1, iccArgument.p2,
495 iccArgument.p3, iccArgument.data, onCompleted);
496 }
497 break;
498
499 case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
500 ar = (AsyncResult) msg.obj;
501 request = (MainThreadRequest) ar.userObj;
502 if (ar.exception == null && ar.result != null) {
503 request.result = ar.result;
504 } else {
505 request.result = new IccIoResult(0x6F, 0, (byte[])null);
506 if (ar.result == null) {
507 loge("iccTransmitApduBasicChannel: Empty response");
508 } else if (ar.exception instanceof CommandException) {
509 loge("iccTransmitApduBasicChannel: CommandException: " +
510 ar.exception);
511 } else {
512 loge("iccTransmitApduBasicChannel: Unknown exception");
513 }
514 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700515 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700516 break;
517
518 case CMD_EXCHANGE_SIM_IO:
519 request = (MainThreadRequest) msg.obj;
520 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800521 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700522 if (uiccCard == null) {
523 loge("iccExchangeSimIO: No UICC");
524 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700525 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700526 } else {
527 onCompleted = obtainMessage(EVENT_EXCHANGE_SIM_IO_DONE,
528 request);
529 uiccCard.iccExchangeSimIO(iccArgument.cla, /* fileID */
530 iccArgument.command, iccArgument.p1, iccArgument.p2, iccArgument.p3,
531 iccArgument.data, onCompleted);
532 }
533 break;
534
535 case EVENT_EXCHANGE_SIM_IO_DONE:
536 ar = (AsyncResult) msg.obj;
537 request = (MainThreadRequest) ar.userObj;
538 if (ar.exception == null && ar.result != null) {
539 request.result = ar.result;
540 } else {
541 request.result = new IccIoResult(0x6f, 0, (byte[])null);
542 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700543 notifyRequester(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700544 break;
545
Derek Tan4d5e5c12014-02-04 11:54:58 -0800546 case CMD_SEND_ENVELOPE:
547 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800548 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700549 if (uiccCard == null) {
550 loge("sendEnvelopeWithStatus: No UICC");
551 request.result = new IccIoResult(0x6F, 0, (byte[])null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700552 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700553 } else {
554 onCompleted = obtainMessage(EVENT_SEND_ENVELOPE_DONE, request);
555 uiccCard.sendEnvelopeWithStatus((String)request.argument, onCompleted);
556 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800557 break;
558
559 case EVENT_SEND_ENVELOPE_DONE:
560 ar = (AsyncResult) msg.obj;
561 request = (MainThreadRequest) ar.userObj;
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700562 if (ar.exception == null && ar.result != null) {
563 request.result = ar.result;
Derek Tan4d5e5c12014-02-04 11:54:58 -0800564 } else {
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700565 request.result = new IccIoResult(0x6F, 0, (byte[])null);
566 if (ar.result == null) {
567 loge("sendEnvelopeWithStatus: Empty response");
568 } else if (ar.exception instanceof CommandException) {
569 loge("sendEnvelopeWithStatus: CommandException: " +
570 ar.exception);
571 } else {
572 loge("sendEnvelopeWithStatus: exception:" + ar.exception);
573 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800574 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700575 notifyRequester(request);
Derek Tan4d5e5c12014-02-04 11:54:58 -0800576 break;
577
Shishir Agrawal566b7612013-10-28 14:41:00 -0700578 case CMD_OPEN_CHANNEL:
579 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800580 uiccCard = getUiccCardFromRequest(request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800581 Pair<String, Integer> openChannelArgs = (Pair<String, Integer>) request.argument;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700582 if (uiccCard == null) {
583 loge("iccOpenLogicalChannel: No UICC");
Shishir Agrawalfc0492a2016-02-17 11:15:33 -0800584 request.result = new IccOpenLogicalChannelResponse(-1,
585 IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE, null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700586 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700587 } else {
588 onCompleted = obtainMessage(EVENT_OPEN_CHANNEL_DONE, request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800589 uiccCard.iccOpenLogicalChannel(openChannelArgs.first,
590 openChannelArgs.second, onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700591 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700592 break;
593
594 case EVENT_OPEN_CHANNEL_DONE:
595 ar = (AsyncResult) msg.obj;
596 request = (MainThreadRequest) ar.userObj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700597 IccOpenLogicalChannelResponse openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700598 if (ar.exception == null && ar.result != null) {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700599 int[] result = (int[]) ar.result;
600 int channelId = result[0];
601 byte[] selectResponse = null;
602 if (result.length > 1) {
603 selectResponse = new byte[result.length - 1];
604 for (int i = 1; i < result.length; ++i) {
605 selectResponse[i - 1] = (byte) result[i];
606 }
607 }
608 openChannelResp = new IccOpenLogicalChannelResponse(channelId,
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700609 IccOpenLogicalChannelResponse.STATUS_NO_ERROR, selectResponse);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700610 } else {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700611 if (ar.result == null) {
612 loge("iccOpenLogicalChannel: Empty response");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700613 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700614 if (ar.exception != null) {
615 loge("iccOpenLogicalChannel: Exception: " + ar.exception);
616 }
617
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700618 int errorCode = IccOpenLogicalChannelResponse.STATUS_UNKNOWN_ERROR;
Junda Liua754ba12015-05-20 01:17:52 -0700619 if (ar.exception instanceof CommandException) {
620 CommandException.Error error =
621 ((CommandException) (ar.exception)).getCommandError();
622 if (error == CommandException.Error.MISSING_RESOURCE) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700623 errorCode = IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
Junda Liua754ba12015-05-20 01:17:52 -0700624 } else if (error == CommandException.Error.NO_SUCH_ELEMENT) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700625 errorCode = IccOpenLogicalChannelResponse.STATUS_NO_SUCH_ELEMENT;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700626 }
627 }
628 openChannelResp = new IccOpenLogicalChannelResponse(
629 IccOpenLogicalChannelResponse.INVALID_CHANNEL, errorCode, null);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700630 }
Shishir Agrawal82c8a462014-07-31 18:13:17 -0700631 request.result = openChannelResp;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700632 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700633 break;
634
635 case CMD_CLOSE_CHANNEL:
636 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800637 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700638 if (uiccCard == null) {
639 loge("iccCloseLogicalChannel: No UICC");
Yoshiaki Naka2e29d822016-09-02 19:27:39 +0900640 request.result = false;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700641 notifyRequester(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700642 } else {
643 onCompleted = obtainMessage(EVENT_CLOSE_CHANNEL_DONE, request);
644 uiccCard.iccCloseLogicalChannel((Integer) request.argument, onCompleted);
645 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700646 break;
647
648 case EVENT_CLOSE_CHANNEL_DONE:
Jake Hambye994d462014-02-03 13:10:13 -0800649 handleNullReturnEvent(msg, "iccCloseLogicalChannel");
650 break;
651
652 case CMD_NV_READ_ITEM:
653 request = (MainThreadRequest) msg.obj;
654 onCompleted = obtainMessage(EVENT_NV_READ_ITEM_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800655 defaultPhone.nvReadItem((Integer) request.argument, onCompleted,
656 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800657 break;
658
659 case EVENT_NV_READ_ITEM_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700660 ar = (AsyncResult) msg.obj;
661 request = (MainThreadRequest) ar.userObj;
Jake Hambye994d462014-02-03 13:10:13 -0800662 if (ar.exception == null && ar.result != null) {
663 request.result = ar.result; // String
Shishir Agrawal566b7612013-10-28 14:41:00 -0700664 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800665 request.result = "";
666 if (ar.result == null) {
667 loge("nvReadItem: Empty response");
668 } else if (ar.exception instanceof CommandException) {
669 loge("nvReadItem: CommandException: " +
670 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700671 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800672 loge("nvReadItem: Unknown exception");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700673 }
674 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700675 notifyRequester(request);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700676 break;
677
Jake Hambye994d462014-02-03 13:10:13 -0800678 case CMD_NV_WRITE_ITEM:
679 request = (MainThreadRequest) msg.obj;
680 onCompleted = obtainMessage(EVENT_NV_WRITE_ITEM_DONE, request);
681 Pair<Integer, String> idValue = (Pair<Integer, String>) request.argument;
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800682 defaultPhone.nvWriteItem(idValue.first, idValue.second, onCompleted,
vagdeviaf9a5b92018-08-15 16:01:53 -0700683 request.workSource);
Jake Hambye994d462014-02-03 13:10:13 -0800684 break;
685
686 case EVENT_NV_WRITE_ITEM_DONE:
687 handleNullReturnEvent(msg, "nvWriteItem");
688 break;
689
690 case CMD_NV_WRITE_CDMA_PRL:
691 request = (MainThreadRequest) msg.obj;
692 onCompleted = obtainMessage(EVENT_NV_WRITE_CDMA_PRL_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800693 defaultPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800694 break;
695
696 case EVENT_NV_WRITE_CDMA_PRL_DONE:
697 handleNullReturnEvent(msg, "nvWriteCdmaPrl");
698 break;
699
chen xu6dac5ab2018-10-26 17:39:23 -0700700 case CMD_RESET_MODEM_CONFIG:
Jake Hambye994d462014-02-03 13:10:13 -0800701 request = (MainThreadRequest) msg.obj;
chen xu6dac5ab2018-10-26 17:39:23 -0700702 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800703 defaultPhone.resetModemConfig(onCompleted);
Jake Hambye994d462014-02-03 13:10:13 -0800704 break;
705
chen xu6dac5ab2018-10-26 17:39:23 -0700706 case EVENT_RESET_MODEM_CONFIG_DONE:
707 handleNullReturnEvent(msg, "resetModemConfig");
Jake Hambye994d462014-02-03 13:10:13 -0800708 break;
709
Jake Hamby7c27be32014-03-03 13:25:59 -0800710 case CMD_GET_PREFERRED_NETWORK_TYPE:
711 request = (MainThreadRequest) msg.obj;
712 onCompleted = obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE_DONE, request);
Stuart Scott54788802015-03-30 13:18:01 -0700713 getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800714 break;
715
716 case EVENT_GET_PREFERRED_NETWORK_TYPE_DONE:
717 ar = (AsyncResult) msg.obj;
718 request = (MainThreadRequest) ar.userObj;
719 if (ar.exception == null && ar.result != null) {
720 request.result = ar.result; // Integer
721 } else {
Sanket Padawecfc2d352016-01-05 19:52:14 -0800722 request.result = null;
Jake Hamby7c27be32014-03-03 13:25:59 -0800723 if (ar.result == null) {
724 loge("getPreferredNetworkType: Empty response");
725 } else if (ar.exception instanceof CommandException) {
726 loge("getPreferredNetworkType: CommandException: " +
727 ar.exception);
728 } else {
729 loge("getPreferredNetworkType: Unknown exception");
730 }
731 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700732 notifyRequester(request);
Jake Hamby7c27be32014-03-03 13:25:59 -0800733 break;
734
735 case CMD_SET_PREFERRED_NETWORK_TYPE:
736 request = (MainThreadRequest) msg.obj;
737 onCompleted = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE_DONE, request);
738 int networkType = (Integer) request.argument;
Stuart Scott54788802015-03-30 13:18:01 -0700739 getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800740 break;
741
742 case EVENT_SET_PREFERRED_NETWORK_TYPE_DONE:
743 handleNullReturnEvent(msg, "setPreferredNetworkType");
744 break;
745
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000746 case CMD_INVOKE_OEM_RIL_REQUEST_RAW:
747 request = (MainThreadRequest)msg.obj;
748 onCompleted = obtainMessage(EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800749 defaultPhone.invokeOemRilRequestRaw((byte[]) request.argument, onCompleted);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000750 break;
751
752 case EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE:
753 ar = (AsyncResult)msg.obj;
754 request = (MainThreadRequest)ar.userObj;
755 request.result = ar;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700756 notifyRequester(request);
Shuo Qian850e4d6a2018-04-25 21:02:08 +0000757 break;
758
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800759 case CMD_SET_VOICEMAIL_NUMBER:
760 request = (MainThreadRequest) msg.obj;
761 onCompleted = obtainMessage(EVENT_SET_VOICEMAIL_NUMBER_DONE, request);
762 Pair<String, String> tagNum = (Pair<String, String>) request.argument;
Stuart Scott584921c2015-01-15 17:10:34 -0800763 getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
764 onCompleted);
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800765 break;
766
767 case EVENT_SET_VOICEMAIL_NUMBER_DONE:
768 handleNullReturnEvent(msg, "setVoicemailNumber");
769 break;
770
Stuart Scott54788802015-03-30 13:18:01 -0700771 case CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC:
772 request = (MainThreadRequest) msg.obj;
773 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE,
774 request);
775 getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
776 break;
777
778 case EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE:
779 handleNullReturnEvent(msg, "setNetworkSelectionModeAutomatic");
780 break;
781
Shishir Agrawal302c8692015-06-19 13:49:39 -0700782 case CMD_PERFORM_NETWORK_SCAN:
783 request = (MainThreadRequest) msg.obj;
784 onCompleted = obtainMessage(EVENT_PERFORM_NETWORK_SCAN_DONE, request);
785 getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
786 break;
787
788 case EVENT_PERFORM_NETWORK_SCAN_DONE:
789 ar = (AsyncResult) msg.obj;
790 request = (MainThreadRequest) ar.userObj;
791 CellNetworkScanResult cellScanResult;
792 if (ar.exception == null && ar.result != null) {
793 cellScanResult = new CellNetworkScanResult(
794 CellNetworkScanResult.STATUS_SUCCESS,
795 (List<OperatorInfo>) ar.result);
796 } else {
797 if (ar.result == null) {
798 loge("getCellNetworkScanResults: Empty response");
799 }
800 if (ar.exception != null) {
801 loge("getCellNetworkScanResults: Exception: " + ar.exception);
802 }
803 int errorCode = CellNetworkScanResult.STATUS_UNKNOWN_ERROR;
804 if (ar.exception instanceof CommandException) {
805 CommandException.Error error =
806 ((CommandException) (ar.exception)).getCommandError();
807 if (error == CommandException.Error.RADIO_NOT_AVAILABLE) {
808 errorCode = CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE;
809 } else if (error == CommandException.Error.GENERIC_FAILURE) {
810 errorCode = CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE;
811 }
812 }
813 cellScanResult = new CellNetworkScanResult(errorCode, null);
814 }
815 request.result = cellScanResult;
Pengquan Menga1bb6272018-09-06 09:59:22 -0700816 notifyRequester(request);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700817 break;
818
819 case CMD_SET_NETWORK_SELECTION_MODE_MANUAL:
820 request = (MainThreadRequest) msg.obj;
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700821 ManualNetworkSelectionArgument selArg =
822 (ManualNetworkSelectionArgument) request.argument;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700823 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE,
824 request);
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700825 getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
826 selArg.persistSelection, onCompleted);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700827 break;
828
829 case EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE:
Pengquan Menge3d01e22018-09-20 15:25:35 -0700830 ar = (AsyncResult) msg.obj;
831 request = (MainThreadRequest) ar.userObj;
832 if (ar.exception == null) {
833 request.result = true;
834 } else {
835 request.result = false;
836 loge("setNetworkSelectionModeManual " + ar.exception);
837 }
838 notifyRequester(request);
839 mApp.onNetworkSelectionChanged(request.subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700840 break;
841
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700842 case CMD_GET_MODEM_ACTIVITY_INFO:
843 request = (MainThreadRequest) msg.obj;
844 onCompleted = obtainMessage(EVENT_GET_MODEM_ACTIVITY_INFO_DONE, request);
James Mattisab947702019-04-03 14:18:34 -0700845 if (defaultPhone != null) {
846 defaultPhone.getModemActivityInfo(onCompleted, request.workSource);
847 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700848 break;
849
850 case EVENT_GET_MODEM_ACTIVITY_INFO_DONE:
851 ar = (AsyncResult) msg.obj;
852 request = (MainThreadRequest) ar.userObj;
853 if (ar.exception == null && ar.result != null) {
854 request.result = ar.result;
855 } else {
856 if (ar.result == null) {
857 loge("queryModemActivityInfo: Empty response");
858 } else if (ar.exception instanceof CommandException) {
859 loge("queryModemActivityInfo: CommandException: " +
860 ar.exception);
861 } else {
862 loge("queryModemActivityInfo: Unknown exception");
863 }
864 }
Amit Mahajand4766222016-01-28 15:28:28 -0800865 // Result cannot be null. Return ModemActivityInfo with all fields set to 0.
866 if (request.result == null) {
867 request.result = new ModemActivityInfo(0, 0, 0, null, 0, 0);
868 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700869 notifyRequester(request);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700870 break;
871
Meng Wang1a7c35a2016-05-05 20:56:15 -0700872 case CMD_SET_ALLOWED_CARRIERS:
873 request = (MainThreadRequest) msg.obj;
Michele Berionne482f8202018-11-27 18:57:59 -0800874 CarrierRestrictionRules argument =
875 (CarrierRestrictionRules) request.argument;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700876 onCompleted = obtainMessage(EVENT_SET_ALLOWED_CARRIERS_DONE, request);
Michele Berionne482f8202018-11-27 18:57:59 -0800877 defaultPhone.setAllowedCarriers(argument, onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700878 break;
879
880 case EVENT_SET_ALLOWED_CARRIERS_DONE:
881 ar = (AsyncResult) msg.obj;
882 request = (MainThreadRequest) ar.userObj;
883 if (ar.exception == null && ar.result != null) {
884 request.result = ar.result;
885 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800886 request.result = TelephonyManager.SET_CARRIER_RESTRICTION_ERROR;
887 if (ar.exception instanceof CommandException) {
888 loge("setAllowedCarriers: CommandException: " + ar.exception);
889 CommandException.Error error =
890 ((CommandException) (ar.exception)).getCommandError();
891 if (error == CommandException.Error.REQUEST_NOT_SUPPORTED) {
892 request.result =
893 TelephonyManager.SET_CARRIER_RESTRICTION_NOT_SUPPORTED;
894 }
Meng Wang1a7c35a2016-05-05 20:56:15 -0700895 } else {
896 loge("setAllowedCarriers: Unknown exception");
897 }
898 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700899 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700900 break;
901
902 case CMD_GET_ALLOWED_CARRIERS:
903 request = (MainThreadRequest) msg.obj;
904 onCompleted = obtainMessage(EVENT_GET_ALLOWED_CARRIERS_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -0800905 defaultPhone.getAllowedCarriers(onCompleted, request.workSource);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700906 break;
907
908 case EVENT_GET_ALLOWED_CARRIERS_DONE:
909 ar = (AsyncResult) msg.obj;
910 request = (MainThreadRequest) ar.userObj;
911 if (ar.exception == null && ar.result != null) {
912 request.result = ar.result;
913 } else {
Michele Berionne482f8202018-11-27 18:57:59 -0800914 request.result = new IllegalStateException(
915 "Failed to get carrier restrictions");
Meng Wang1a7c35a2016-05-05 20:56:15 -0700916 if (ar.result == null) {
917 loge("getAllowedCarriers: Empty response");
918 } else if (ar.exception instanceof CommandException) {
919 loge("getAllowedCarriers: CommandException: " +
920 ar.exception);
921 } else {
922 loge("getAllowedCarriers: Unknown exception");
923 }
924 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700925 notifyRequester(request);
Meng Wang1a7c35a2016-05-05 20:56:15 -0700926 break;
927
Nathan Haroldb3014052017-01-25 15:57:32 -0800928 case EVENT_GET_FORBIDDEN_PLMNS_DONE:
929 ar = (AsyncResult) msg.obj;
930 request = (MainThreadRequest) ar.userObj;
931 if (ar.exception == null && ar.result != null) {
932 request.result = ar.result;
933 } else {
934 request.result = new IllegalArgumentException(
935 "Failed to retrieve Forbidden Plmns");
936 if (ar.result == null) {
937 loge("getForbiddenPlmns: Empty response");
938 } else {
939 loge("getForbiddenPlmns: Unknown exception");
940 }
941 }
Pengquan Menga1bb6272018-09-06 09:59:22 -0700942 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800943 break;
944
945 case CMD_GET_FORBIDDEN_PLMNS:
946 request = (MainThreadRequest) msg.obj;
947 uiccCard = getUiccCardFromRequest(request);
948 if (uiccCard == null) {
949 loge("getForbiddenPlmns() UiccCard is null");
950 request.result = new IllegalArgumentException(
951 "getForbiddenPlmns() UiccCard is null");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700952 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800953 break;
954 }
955 Integer appType = (Integer) request.argument;
956 UiccCardApplication uiccApp = uiccCard.getApplicationByType(appType);
957 if (uiccApp == null) {
958 loge("getForbiddenPlmns() no app with specified type -- "
959 + appType);
960 request.result = new IllegalArgumentException("Failed to get UICC App");
Pengquan Menga1bb6272018-09-06 09:59:22 -0700961 notifyRequester(request);
Nathan Haroldb3014052017-01-25 15:57:32 -0800962 break;
963 } else {
964 if (DBG) logv("getForbiddenPlmns() found app " + uiccApp.getAid()
965 + " specified type -- " + appType);
966 }
967 onCompleted = obtainMessage(EVENT_GET_FORBIDDEN_PLMNS_DONE, request);
968 ((SIMRecords) uiccApp.getIccRecords()).getForbiddenPlmns(
969 onCompleted);
970 break;
971
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000972 case CMD_SWITCH_SLOTS:
973 request = (MainThreadRequest) msg.obj;
974 int[] physicalSlots = (int[]) request.argument;
975 onCompleted = obtainMessage(EVENT_SWITCH_SLOTS_DONE, request);
976 UiccController.getInstance().switchSlots(physicalSlots, onCompleted);
977 break;
978
979 case EVENT_SWITCH_SLOTS_DONE:
980 ar = (AsyncResult) msg.obj;
981 request = (MainThreadRequest) ar.userObj;
982 request.result = (ar.exception == null);
Pengquan Menga1bb6272018-09-06 09:59:22 -0700983 notifyRequester(request);
984 break;
985 case CMD_GET_NETWORK_SELECTION_MODE:
986 request = (MainThreadRequest) msg.obj;
987 onCompleted = obtainMessage(EVENT_GET_NETWORK_SELECTION_MODE_DONE, request);
988 getPhoneFromRequest(request).getNetworkSelectionMode(onCompleted);
989 break;
990
991 case EVENT_GET_NETWORK_SELECTION_MODE_DONE:
992 ar = (AsyncResult) msg.obj;
993 request = (MainThreadRequest) ar.userObj;
994 if (ar.exception != null) {
995 request.result = TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
996 } else {
997 int mode = ((int[]) ar.result)[0];
998 if (mode == 0) {
999 request.result = TelephonyManager.NETWORK_SELECTION_MODE_AUTO;
1000 } else {
1001 request.result = TelephonyManager.NETWORK_SELECTION_MODE_MANUAL;
1002 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001003 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001004 notifyRequester(request);
1005 break;
1006 case CMD_GET_CDMA_ROAMING_MODE:
1007 request = (MainThreadRequest) msg.obj;
1008 onCompleted = obtainMessage(EVENT_GET_CDMA_ROAMING_MODE_DONE, request);
1009 getPhoneFromRequest(request).queryCdmaRoamingPreference(onCompleted);
1010 break;
1011 case EVENT_GET_CDMA_ROAMING_MODE_DONE:
1012 ar = (AsyncResult) msg.obj;
1013 request = (MainThreadRequest) ar.userObj;
1014 if (ar.exception != null) {
1015 request.result = TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT;
1016 } else {
1017 request.result = ((int[]) ar.result)[0];
1018 }
1019 notifyRequester(request);
1020 break;
1021 case CMD_SET_CDMA_ROAMING_MODE:
1022 request = (MainThreadRequest) msg.obj;
1023 onCompleted = obtainMessage(EVENT_SET_CDMA_ROAMING_MODE_DONE, request);
1024 int mode = (int) request.argument;
1025 getPhoneFromRequest(request).setCdmaRoamingPreference(mode, onCompleted);
1026 break;
1027 case EVENT_SET_CDMA_ROAMING_MODE_DONE:
1028 ar = (AsyncResult) msg.obj;
1029 request = (MainThreadRequest) ar.userObj;
1030 request.result = ar.exception == null;
1031 notifyRequester(request);
1032 break;
1033 case CMD_SET_CDMA_SUBSCRIPTION_MODE:
1034 request = (MainThreadRequest) msg.obj;
1035 onCompleted = obtainMessage(EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE, request);
1036 int subscriptionMode = (int) request.argument;
1037 getPhoneFromRequest(request).setCdmaSubscription(subscriptionMode, onCompleted);
1038 break;
1039 case EVENT_SET_CDMA_SUBSCRIPTION_MODE_DONE:
1040 ar = (AsyncResult) msg.obj;
1041 request = (MainThreadRequest) ar.userObj;
1042 request.result = ar.exception == null;
1043 notifyRequester(request);
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00001044 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001045 case CMD_GET_ALL_CELL_INFO:
1046 request = (MainThreadRequest) msg.obj;
Nathan Harold3ff88932018-08-14 10:19:49 -07001047 onCompleted = obtainMessage(EVENT_GET_ALL_CELL_INFO_DONE, request);
Nathan Harold92bed182018-10-12 18:16:49 -07001048 request.phone.requestCellInfoUpdate(request.workSource, onCompleted);
Nathan Harold3ff88932018-08-14 10:19:49 -07001049 break;
Nathan Harold3ff88932018-08-14 10:19:49 -07001050 case EVENT_GET_ALL_CELL_INFO_DONE:
1051 ar = (AsyncResult) msg.obj;
1052 request = (MainThreadRequest) ar.userObj;
Nathan Harold8d0f1742018-10-02 12:14:47 -07001053 // If a timeout occurs, the response will be null
1054 request.result = (ar.exception == null && ar.result != null)
1055 ? ar.result : new ArrayList<CellInfo>();
Nathan Harold3ff88932018-08-14 10:19:49 -07001056 synchronized (request) {
1057 request.notifyAll();
1058 }
1059 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001060 case CMD_REQUEST_CELL_INFO_UPDATE:
1061 request = (MainThreadRequest) msg.obj;
1062 request.phone.requestCellInfoUpdate(request.workSource,
1063 obtainMessage(EVENT_REQUEST_CELL_INFO_UPDATE_DONE, request));
1064 break;
1065 case EVENT_REQUEST_CELL_INFO_UPDATE_DONE:
1066 ar = (AsyncResult) msg.obj;
1067 request = (MainThreadRequest) ar.userObj;
1068 ICellInfoCallback cb = (ICellInfoCallback) request.argument;
1069 try {
1070 if (ar.exception != null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001071 Log.e(LOG_TAG, "Exception retrieving CellInfo=" + ar.exception);
Nathan Harolde82c4b82018-12-18 19:40:37 -08001072 cb.onError(TelephonyManager.CellInfoCallback.ERROR_MODEM_ERROR,
1073 new android.os.ParcelableException(ar.exception));
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001074 } else if (ar.result == null) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001075 Log.w(LOG_TAG, "Timeout Waiting for CellInfo!");
Nathan Harolde82c4b82018-12-18 19:40:37 -08001076 cb.onError(TelephonyManager.CellInfoCallback.ERROR_TIMEOUT, null);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001077 } else {
1078 // use the result as returned
1079 cb.onCellInfo((List<CellInfo>) ar.result);
1080 }
1081 } catch (RemoteException re) {
1082 Log.w(LOG_TAG, "Discarded CellInfo due to Callback RemoteException");
1083 }
1084 break;
1085 case CMD_GET_CELL_LOCATION:
Nathan Harold3ff88932018-08-14 10:19:49 -07001086 request = (MainThreadRequest) msg.obj;
1087 WorkSource ws = (WorkSource) request.argument;
1088 Phone phone = getPhoneFromRequest(request);
1089 phone.getCellLocation(ws, obtainMessage(EVENT_GET_CELL_LOCATION_DONE, request));
1090 break;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001091 case EVENT_GET_CELL_LOCATION_DONE:
Nathan Harold3ff88932018-08-14 10:19:49 -07001092 ar = (AsyncResult) msg.obj;
1093 request = (MainThreadRequest) ar.userObj;
1094 if (ar.exception == null) {
1095 request.result = ar.result;
1096 } else {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001097 phone = getPhoneFromRequest(request);
Nathan Harold3ff88932018-08-14 10:19:49 -07001098 request.result = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA)
1099 ? new CdmaCellLocation() : new GsmCellLocation();
1100 }
1101
1102 synchronized (request) {
1103 request.notifyAll();
1104 }
1105 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001106 case CMD_MODEM_REBOOT:
1107 request = (MainThreadRequest) msg.obj;
1108 onCompleted = obtainMessage(EVENT_RESET_MODEM_CONFIG_DONE, request);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001109 defaultPhone.rebootModem(onCompleted);
chen xu6dac5ab2018-10-26 17:39:23 -07001110 break;
chen xu6dac5ab2018-10-26 17:39:23 -07001111 case EVENT_CMD_MODEM_REBOOT_DONE:
1112 handleNullReturnEvent(msg, "rebootModem");
1113 break;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001114 case CMD_REQUEST_ENABLE_MODEM:
1115 request = (MainThreadRequest) msg.obj;
1116 boolean enable = (boolean) request.argument;
1117 onCompleted = obtainMessage(EVENT_ENABLE_MODEM_DONE, request);
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001118 onCompleted.arg1 = enable ? 1 : 0;
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001119 PhoneConfigurationManager.getInstance()
1120 .enablePhone(request.phone, enable, onCompleted);
1121 break;
1122 case EVENT_ENABLE_MODEM_DONE:
1123 ar = (AsyncResult) msg.obj;
1124 request = (MainThreadRequest) ar.userObj;
1125 request.result = (ar.exception == null);
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001126 int phoneId = request.phone.getPhoneId();
Nazanin Bakhshi33d584b2019-02-27 10:44:32 -08001127 //update the cache as modem status has changed
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07001128 if ((boolean) request.result) {
1129 mPhoneConfigurationManager.addToPhoneStatusCache(phoneId, msg.arg1 == 1);
1130 updateModemStateMetrics();
1131 } else {
1132 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1133 + ar.exception);
1134 }
1135 notifyRequester(request);
1136 break;
1137 case CMD_GET_MODEM_STATUS:
1138 request = (MainThreadRequest) msg.obj;
1139 onCompleted = obtainMessage(EVENT_GET_MODEM_STATUS_DONE, request);
1140 PhoneConfigurationManager.getInstance()
1141 .getPhoneStatusFromModem(request.phone, onCompleted);
1142 break;
1143 case EVENT_GET_MODEM_STATUS_DONE:
1144 ar = (AsyncResult) msg.obj;
1145 request = (MainThreadRequest) ar.userObj;
1146 int id = request.phone.getPhoneId();
1147 if (ar.exception == null && ar.result != null) {
1148 request.result = ar.result;
1149 //update the cache as modem status has changed
1150 mPhoneConfigurationManager.addToPhoneStatusCache(id,
1151 (boolean) request.result);
1152 } else {
1153 // Return true if modem status cannot be retrieved. For most cases,
1154 // modem status is on. And for older version modems, GET_MODEM_STATUS
1155 // and disable modem are not supported. Modem is always on.
1156 // TODO: this should be fixed in R to support a third
1157 // status UNKNOWN b/131631629
1158 request.result = true;
1159 Log.e(LOG_TAG, msg.what + " failure. Not updating modem status."
1160 + ar.exception);
1161 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08001162 notifyRequester(request);
1163 break;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001164 default:
1165 Log.w(LOG_TAG, "MainThreadHandler: unexpected message code: " + msg.what);
1166 break;
1167 }
1168 }
Jake Hambye994d462014-02-03 13:10:13 -08001169
Pengquan Menga1bb6272018-09-06 09:59:22 -07001170 private void notifyRequester(MainThreadRequest request) {
1171 synchronized (request) {
1172 request.notifyAll();
1173 }
1174 }
1175
Jake Hambye994d462014-02-03 13:10:13 -08001176 private void handleNullReturnEvent(Message msg, String command) {
1177 AsyncResult ar = (AsyncResult) msg.obj;
1178 MainThreadRequest request = (MainThreadRequest) ar.userObj;
1179 if (ar.exception == null) {
1180 request.result = true;
1181 } else {
1182 request.result = false;
1183 if (ar.exception instanceof CommandException) {
1184 loge(command + ": CommandException: " + ar.exception);
1185 } else {
1186 loge(command + ": Unknown exception");
1187 }
1188 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07001189 notifyRequester(request);
Jake Hambye994d462014-02-03 13:10:13 -08001190 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001191 }
1192
1193 /**
1194 * Posts the specified command to be executed on the main thread,
1195 * waits for the request to complete, and returns the result.
1196 * @see #sendRequestAsync
1197 */
1198 private Object sendRequest(int command, Object argument) {
Nathan Harold92bed182018-10-12 18:16:49 -07001199 return sendRequest(
1200 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001201 }
1202
1203 /**
1204 * Posts the specified command to be executed on the main thread,
1205 * waits for the request to complete, and returns the result.
1206 * @see #sendRequestAsync
1207 */
1208 private Object sendRequest(int command, Object argument, WorkSource workSource) {
1209 return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID,
Nathan Harold92bed182018-10-12 18:16:49 -07001210 null, workSource);
Wink Saville36469e72014-06-11 15:17:00 -07001211 }
1212
1213 /**
1214 * Posts the specified command to be executed on the main thread,
1215 * waits for the request to complete, and returns the result.
1216 * @see #sendRequestAsync
1217 */
Shishir Agrawal76d5da92014-11-09 16:17:25 -08001218 private Object sendRequest(int command, Object argument, Integer subId) {
Nathan Harold92bed182018-10-12 18:16:49 -07001219 return sendRequest(command, argument, subId, null, null);
vagdeviaf9a5b92018-08-15 16:01:53 -07001220 }
1221
1222 /**
1223 * Posts the specified command to be executed on the main thread,
1224 * waits for the request to complete, and returns the result.
1225 * @see #sendRequestAsync
1226 */
Nathan Harold92bed182018-10-12 18:16:49 -07001227 private Object sendRequest(int command, Object argument, int subId, WorkSource workSource) {
1228 return sendRequest(command, argument, subId, null, workSource);
1229 }
1230
1231 /**
1232 * Posts the specified command to be executed on the main thread,
1233 * waits for the request to complete, and returns the result.
1234 * @see #sendRequestAsync
1235 */
1236 private Object sendRequest(int command, Object argument, Phone phone, WorkSource workSource) {
1237 return sendRequest(
1238 command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID, phone, workSource);
1239 }
1240
1241 /**
1242 * Posts the specified command to be executed on the main thread,
1243 * waits for the request to complete, and returns the result.
1244 * @see #sendRequestAsync
1245 */
1246 private Object sendRequest(
1247 int command, Object argument, Integer subId, Phone phone, WorkSource workSource) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001248 if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
1249 throw new RuntimeException("This method will deadlock if called from the main thread.");
1250 }
1251
Nathan Harold92bed182018-10-12 18:16:49 -07001252 MainThreadRequest request = null;
1253 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && phone != null) {
1254 throw new IllegalArgumentException("subId and phone cannot both be specified!");
1255 } else if (phone != null) {
1256 request = new MainThreadRequest(argument, phone, workSource);
1257 } else {
1258 request = new MainThreadRequest(argument, subId, workSource);
1259 }
1260
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001261 Message msg = mMainThreadHandler.obtainMessage(command, request);
1262 msg.sendToTarget();
1263
1264 // Wait for the request to complete
1265 synchronized (request) {
1266 while (request.result == null) {
1267 try {
1268 request.wait();
1269 } catch (InterruptedException e) {
1270 // Do nothing, go back and wait until the request is complete
1271 }
1272 }
1273 }
1274 return request.result;
1275 }
1276
1277 /**
1278 * Asynchronous ("fire and forget") version of sendRequest():
1279 * Posts the specified command to be executed on the main thread, and
1280 * returns immediately.
1281 * @see #sendRequest
1282 */
1283 private void sendRequestAsync(int command) {
1284 mMainThreadHandler.sendEmptyMessage(command);
1285 }
1286
1287 /**
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001288 * Same as {@link #sendRequestAsync(int)} except it takes an argument.
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001289 * @see {@link #sendRequest(int)}
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001290 */
1291 private void sendRequestAsync(int command, Object argument) {
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07001292 sendRequestAsync(command, argument, null, null);
1293 }
1294
1295 /**
1296 * Same as {@link #sendRequestAsync(int,Object)} except it takes a Phone and WorkSource.
1297 * @see {@link #sendRequest(int,Object)}
1298 */
1299 private void sendRequestAsync(
1300 int command, Object argument, Phone phone, WorkSource workSource) {
1301 MainThreadRequest request = new MainThreadRequest(argument, phone, workSource);
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001302 Message msg = mMainThreadHandler.obtainMessage(command, request);
1303 msg.sendToTarget();
1304 }
1305
1306 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001307 * Initialize the singleton PhoneInterfaceManager instance.
1308 * This is only done once, at startup, from PhoneApp.onCreate().
1309 */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001310 /* package */ static PhoneInterfaceManager init(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001311 synchronized (PhoneInterfaceManager.class) {
1312 if (sInstance == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001313 sInstance = new PhoneInterfaceManager(app);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001314 } else {
1315 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
1316 }
1317 return sInstance;
1318 }
1319 }
1320
1321 /** Private constructor; @see init() */
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001322 private PhoneInterfaceManager(PhoneGlobals app) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001323 mApp = app;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001324 mCM = PhoneGlobals.getInstance().mCM;
Stuart Scott981d8582015-04-21 14:09:50 -07001325 mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001326 mAppOps = (AppOpsManager)app.getSystemService(Context.APP_OPS_SERVICE);
1327 mMainThreadHandler = new MainThreadHandler();
Tobias Thiererb19e1f12018-12-11 17:54:03 +00001328 mSubscriptionController = SubscriptionController.getInstance();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001329 mTelephonySharedPreferences =
1330 PreferenceManager.getDefaultSharedPreferences(mApp);
yinxub1bed742017-04-17 11:45:04 -07001331 mNetworkScanRequestTracker = new NetworkScanRequestTracker();
Malcolm Chen2c63d402018-08-14 16:00:53 -07001332 mPhoneConfigurationManager = PhoneConfigurationManager.getInstance();
Wink Saville3ab207e2014-11-20 13:07:20 -08001333
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001334 publish();
1335 }
1336
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001337 private Phone getDefaultPhone() {
1338 Phone thePhone = getPhone(getDefaultSubscription());
1339 return (thePhone != null) ? thePhone : PhoneFactory.getDefaultPhone();
1340 }
1341
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001342 private void publish() {
1343 if (DBG) log("publish: " + this);
1344
1345 ServiceManager.addService("phone", this);
1346 }
1347
Stuart Scott584921c2015-01-15 17:10:34 -08001348 private Phone getPhoneFromRequest(MainThreadRequest request) {
Jordan Liu4c733742019-02-28 12:03:40 -08001349 if (request.phone != null) {
1350 return request.phone;
1351 } else {
1352 return getPhoneFromSubId(request.subId);
1353 }
1354 }
1355
1356 private Phone getPhoneFromSubId(int subId) {
1357 return (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID)
1358 ? getDefaultPhone() : getPhone(subId);
Stuart Scott584921c2015-01-15 17:10:34 -08001359 }
1360
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001361 private UiccCard getUiccCardFromRequest(MainThreadRequest request) {
1362 Phone phone = getPhoneFromRequest(request);
1363 return phone == null ? null :
1364 UiccController.getInstance().getUiccCard(phone.getPhoneId());
1365 }
1366
Wink Saville36469e72014-06-11 15:17:00 -07001367 // returns phone associated with the subId.
Wink Savilleb564aae2014-10-23 10:18:09 -07001368 private Phone getPhone(int subId) {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001369 return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
Wink Saville36469e72014-06-11 15:17:00 -07001370 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001371
1372 public void dial(String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001373 dialForSubscriber(getPreferredVoiceSubscription(), number);
Wink Saville36469e72014-06-11 15:17:00 -07001374 }
1375
Wink Savilleb564aae2014-10-23 10:18:09 -07001376 public void dialForSubscriber(int subId, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001377 if (DBG) log("dial: " + number);
1378 // No permission check needed here: This is just a wrapper around the
1379 // ACTION_DIAL intent, which is available to any app since it puts up
1380 // the UI before it does anything.
1381
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001382 final long identity = Binder.clearCallingIdentity();
1383 try {
1384 String url = createTelUrl(number);
1385 if (url == null) {
1386 return;
1387 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001388
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001389 // PENDING: should we just silently fail if phone is offhook or ringing?
1390 PhoneConstants.State state = mCM.getState(subId);
1391 if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
1392 Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
1393 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1394 mApp.startActivity(intent);
1395 }
1396 } finally {
1397 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001398 }
1399 }
1400
1401 public void call(String callingPackage, String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001402 callForSubscriber(getPreferredVoiceSubscription(), callingPackage, number);
Wink Saville36469e72014-06-11 15:17:00 -07001403 }
1404
Wink Savilleb564aae2014-10-23 10:18:09 -07001405 public void callForSubscriber(int subId, String callingPackage, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001406 if (DBG) log("call: " + number);
1407
1408 // This is just a wrapper around the ACTION_CALL intent, but we still
1409 // need to do a permission check since we're calling startActivity()
1410 // from the context of the phone app.
1411 enforceCallPermission();
1412
1413 if (mAppOps.noteOp(AppOpsManager.OP_CALL_PHONE, Binder.getCallingUid(), callingPackage)
1414 != AppOpsManager.MODE_ALLOWED) {
1415 return;
1416 }
1417
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001418 final long identity = Binder.clearCallingIdentity();
1419 try {
1420 String url = createTelUrl(number);
1421 if (url == null) {
1422 return;
1423 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001424
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001425 boolean isValid = false;
1426 final List<SubscriptionInfo> slist = getActiveSubscriptionInfoListPrivileged();
1427 if (slist != null) {
1428 for (SubscriptionInfo subInfoRecord : slist) {
1429 if (subInfoRecord.getSubscriptionId() == subId) {
1430 isValid = true;
1431 break;
1432 }
Wink Saville3ab207e2014-11-20 13:07:20 -08001433 }
Wink Saville08874612014-08-31 19:19:58 -07001434 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001435 if (!isValid) {
1436 return;
1437 }
Wink Saville08874612014-08-31 19:19:58 -07001438
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001439 Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
1440 intent.putExtra(SUBSCRIPTION_KEY, subId);
1441 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1442 mApp.startActivity(intent);
1443 } finally {
1444 Binder.restoreCallingIdentity(identity);
1445 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001446 }
1447
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001448 public boolean supplyPin(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001449 return supplyPinForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001450 }
1451
Wink Savilleb564aae2014-10-23 10:18:09 -07001452 public boolean supplyPinForSubscriber(int subId, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001453 int [] resultArray = supplyPinReportResultForSubscriber(subId, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001454 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1455 }
1456
1457 public boolean supplyPuk(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001458 return supplyPukForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001459 }
1460
Wink Savilleb564aae2014-10-23 10:18:09 -07001461 public boolean supplyPukForSubscriber(int subId, String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001462 int [] resultArray = supplyPukReportResultForSubscriber(subId, puk, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001463 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1464 }
1465
1466 /** {@hide} */
1467 public int[] supplyPinReportResult(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001468 return supplyPinReportResultForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001469 }
1470
Wink Savilleb564aae2014-10-23 10:18:09 -07001471 public int[] supplyPinReportResultForSubscriber(int subId, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001472 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001473
1474 final long identity = Binder.clearCallingIdentity();
1475 try {
1476 final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
1477 checkSimPin.start();
1478 return checkSimPin.unlockSim(null, pin);
1479 } finally {
1480 Binder.restoreCallingIdentity(identity);
1481 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001482 }
1483
Wink Saville9de0f752013-10-22 19:04:03 -07001484 /** {@hide} */
1485 public int[] supplyPukReportResult(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001486 return supplyPukReportResultForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001487 }
1488
Wink Savilleb564aae2014-10-23 10:18:09 -07001489 public int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001490 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001491
1492 final long identity = Binder.clearCallingIdentity();
1493 try {
1494 final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
1495 checkSimPuk.start();
1496 return checkSimPuk.unlockSim(puk, pin);
1497 } finally {
1498 Binder.restoreCallingIdentity(identity);
1499 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001500 }
1501
1502 /**
Wink Saville9de0f752013-10-22 19:04:03 -07001503 * Helper thread to turn async call to SimCard#supplyPin into
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001504 * a synchronous one.
1505 */
1506 private static class UnlockSim extends Thread {
1507
1508 private final IccCard mSimCard;
1509
1510 private boolean mDone = false;
Wink Saville9de0f752013-10-22 19:04:03 -07001511 private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1512 private int mRetryCount = -1;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001513
1514 // For replies from SimCard interface
1515 private Handler mHandler;
1516
1517 // For async handler to identify request type
1518 private static final int SUPPLY_PIN_COMPLETE = 100;
1519
1520 public UnlockSim(IccCard simCard) {
1521 mSimCard = simCard;
1522 }
1523
1524 @Override
1525 public void run() {
1526 Looper.prepare();
1527 synchronized (UnlockSim.this) {
1528 mHandler = new Handler() {
1529 @Override
1530 public void handleMessage(Message msg) {
1531 AsyncResult ar = (AsyncResult) msg.obj;
1532 switch (msg.what) {
1533 case SUPPLY_PIN_COMPLETE:
1534 Log.d(LOG_TAG, "SUPPLY_PIN_COMPLETE");
1535 synchronized (UnlockSim.this) {
Wink Saville9de0f752013-10-22 19:04:03 -07001536 mRetryCount = msg.arg1;
1537 if (ar.exception != null) {
1538 if (ar.exception instanceof CommandException &&
1539 ((CommandException)(ar.exception)).getCommandError()
1540 == CommandException.Error.PASSWORD_INCORRECT) {
1541 mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1542 } else {
1543 mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1544 }
1545 } else {
1546 mResult = PhoneConstants.PIN_RESULT_SUCCESS;
1547 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001548 mDone = true;
1549 UnlockSim.this.notifyAll();
1550 }
1551 break;
1552 }
1553 }
1554 };
1555 UnlockSim.this.notifyAll();
1556 }
1557 Looper.loop();
1558 }
1559
1560 /*
1561 * Use PIN or PUK to unlock SIM card
1562 *
1563 * If PUK is null, unlock SIM card with PIN
1564 *
1565 * If PUK is not null, unlock SIM card with PUK and set PIN code
1566 */
Wink Saville9de0f752013-10-22 19:04:03 -07001567 synchronized int[] unlockSim(String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001568
1569 while (mHandler == null) {
1570 try {
1571 wait();
1572 } catch (InterruptedException e) {
1573 Thread.currentThread().interrupt();
1574 }
1575 }
1576 Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
1577
1578 if (puk == null) {
1579 mSimCard.supplyPin(pin, callback);
1580 } else {
1581 mSimCard.supplyPuk(puk, pin, callback);
1582 }
1583
1584 while (!mDone) {
1585 try {
1586 Log.d(LOG_TAG, "wait for done");
1587 wait();
1588 } catch (InterruptedException e) {
1589 // Restore the interrupted status
1590 Thread.currentThread().interrupt();
1591 }
1592 }
1593 Log.d(LOG_TAG, "done");
Wink Saville9de0f752013-10-22 19:04:03 -07001594 int[] resultArray = new int[2];
1595 resultArray[0] = mResult;
1596 resultArray[1] = mRetryCount;
1597 return resultArray;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001598 }
1599 }
1600
1601 public void updateServiceLocation() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001602 updateServiceLocationForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001603
1604 }
1605
Wink Savilleb564aae2014-10-23 10:18:09 -07001606 public void updateServiceLocationForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001607 // No permission check needed here: this call is harmless, and it's
1608 // needed for the ServiceState.requestStateUpdate() call (which is
1609 // already intentionally exposed to 3rd parties.)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001610 final long identity = Binder.clearCallingIdentity();
1611 try {
1612 final Phone phone = getPhone(subId);
1613 if (phone != null) {
1614 phone.updateServiceLocation();
1615 }
1616 } finally {
1617 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001618 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001619 }
1620
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001621 @Override
1622 public boolean isRadioOn(String callingPackage) {
1623 return isRadioOnForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001624 }
1625
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001626 @Override
1627 public boolean isRadioOnForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08001628 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08001629 mApp, subId, callingPackage, "isRadioOnForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001630 return false;
1631 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001632
1633 final long identity = Binder.clearCallingIdentity();
1634 try {
1635 return isRadioOnForSubscriber(subId);
1636 } finally {
1637 Binder.restoreCallingIdentity(identity);
1638 }
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001639 }
1640
1641 private boolean isRadioOnForSubscriber(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001642 final long identity = Binder.clearCallingIdentity();
1643 try {
1644 final Phone phone = getPhone(subId);
1645 if (phone != null) {
1646 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
1647 } else {
1648 return false;
1649 }
1650 } finally {
1651 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001652 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001653 }
1654
1655 public void toggleRadioOnOff() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001656 toggleRadioOnOffForSubscriber(getDefaultSubscription());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001657 }
Wink Saville36469e72014-06-11 15:17:00 -07001658
Wink Savilleb564aae2014-10-23 10:18:09 -07001659 public void toggleRadioOnOffForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001660 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001661
1662 final long identity = Binder.clearCallingIdentity();
1663 try {
1664 final Phone phone = getPhone(subId);
1665 if (phone != null) {
1666 phone.setRadioPower(!isRadioOnForSubscriber(subId));
1667 }
1668 } finally {
1669 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001670 }
Wink Saville36469e72014-06-11 15:17:00 -07001671 }
1672
1673 public boolean setRadio(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001674 return setRadioForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001675 }
1676
Wink Savilleb564aae2014-10-23 10:18:09 -07001677 public boolean setRadioForSubscriber(int subId, boolean turnOn) {
Wink Saville36469e72014-06-11 15:17:00 -07001678 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001679
1680 final long identity = Binder.clearCallingIdentity();
1681 try {
1682 final Phone phone = getPhone(subId);
1683 if (phone == null) {
1684 return false;
1685 }
1686 if ((phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF) != turnOn) {
1687 toggleRadioOnOffForSubscriber(subId);
1688 }
1689 return true;
1690 } finally {
1691 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001692 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001693 }
Wink Saville36469e72014-06-11 15:17:00 -07001694
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001695 public boolean needMobileRadioShutdown() {
1696 /*
1697 * If any of the Radios are available, it will need to be
1698 * shutdown. So return true if any Radio is available.
1699 */
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001700 final long identity = Binder.clearCallingIdentity();
1701 try {
1702 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1703 Phone phone = PhoneFactory.getPhone(i);
1704 if (phone != null && phone.isRadioAvailable()) return true;
1705 }
1706 logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
1707 return false;
1708 } finally {
1709 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001710 }
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001711 }
1712
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001713 @Override
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001714 public void shutdownMobileRadios() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001715 enforceModifyPermission();
1716
1717 final long identity = Binder.clearCallingIdentity();
1718 try {
1719 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1720 logv("Shutting down Phone " + i);
1721 shutdownRadioUsingPhoneId(i);
1722 }
1723 } finally {
1724 Binder.restoreCallingIdentity(identity);
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001725 }
1726 }
1727
1728 private void shutdownRadioUsingPhoneId(int phoneId) {
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001729 Phone phone = PhoneFactory.getPhone(phoneId);
1730 if (phone != null && phone.isRadioAvailable()) {
1731 phone.shutdownRadio();
1732 }
1733 }
1734
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001735 public boolean setRadioPower(boolean turnOn) {
Jack Yub4e16162017-05-15 12:48:40 -07001736 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001737
1738 final long identity = Binder.clearCallingIdentity();
1739 try {
1740 final Phone defaultPhone = PhoneFactory.getDefaultPhone();
1741 if (defaultPhone != null) {
1742 defaultPhone.setRadioPower(turnOn);
1743 return true;
1744 } else {
1745 loge("There's no default phone.");
1746 return false;
1747 }
1748 } finally {
1749 Binder.restoreCallingIdentity(identity);
Wei Liu9ae2a062016-08-08 11:09:34 -07001750 }
Wink Saville36469e72014-06-11 15:17:00 -07001751 }
1752
Wink Savilleb564aae2014-10-23 10:18:09 -07001753 public boolean setRadioPowerForSubscriber(int subId, boolean turnOn) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001754 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001755
1756 final long identity = Binder.clearCallingIdentity();
1757 try {
1758 final Phone phone = getPhone(subId);
1759 if (phone != null) {
1760 phone.setRadioPower(turnOn);
1761 return true;
1762 } else {
1763 return false;
1764 }
1765 } finally {
1766 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001767 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001768 }
1769
Wink Saville36469e72014-06-11 15:17:00 -07001770 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001771 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001772 public boolean enableDataConnectivity() {
1773 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001774
1775 final long identity = Binder.clearCallingIdentity();
1776 try {
1777 int subId = mSubscriptionController.getDefaultDataSubId();
1778 final Phone phone = getPhone(subId);
1779 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001780 phone.getDataEnabledSettings().setUserDataEnabled(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001781 return true;
1782 } else {
1783 return false;
1784 }
1785 } finally {
1786 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001787 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001788 }
1789
Wink Saville36469e72014-06-11 15:17:00 -07001790 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001791 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001792 public boolean disableDataConnectivity() {
1793 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001794
1795 final long identity = Binder.clearCallingIdentity();
1796 try {
1797 int subId = mSubscriptionController.getDefaultDataSubId();
1798 final Phone phone = getPhone(subId);
1799 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08001800 phone.getDataEnabledSettings().setUserDataEnabled(false);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001801 return true;
1802 } else {
1803 return false;
1804 }
1805 } finally {
1806 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001807 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001808 }
1809
Sanket Padawe356d7632015-06-22 14:03:32 -07001810 @Override
Jack Yuacf8a132017-05-01 17:00:48 -07001811 public boolean isDataConnectivityPossible(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001812 final long identity = Binder.clearCallingIdentity();
1813 try {
1814 final Phone phone = getPhone(subId);
1815 if (phone != null) {
Jack Yub5d8f642018-11-26 11:20:48 -08001816 return phone.isDataAllowed(ApnSetting.TYPE_DEFAULT);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001817 } else {
1818 return false;
1819 }
1820 } finally {
1821 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001822 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001823 }
1824
1825 public boolean handlePinMmi(String dialString) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001826 return handlePinMmiForSubscriber(getDefaultSubscription(), dialString);
Wink Saville36469e72014-06-11 15:17:00 -07001827 }
1828
pkanwarae03a6b2016-11-06 20:37:09 -08001829 public void handleUssdRequest(int subId, String ussdRequest, ResultReceiver wrappedCallback) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001830 enforceCallPermission();
1831
1832 final long identity = Binder.clearCallingIdentity();
1833 try {
1834 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1835 return;
1836 }
1837 Pair<String, ResultReceiver> ussdObject = new Pair(ussdRequest, wrappedCallback);
1838 sendRequest(CMD_HANDLE_USSD_REQUEST, ussdObject, subId);
1839 } finally {
1840 Binder.restoreCallingIdentity(identity);
1841 }
pkanwar32d516d2016-10-14 19:37:38 -07001842 };
1843
Wink Savilleb564aae2014-10-23 10:18:09 -07001844 public boolean handlePinMmiForSubscriber(int subId, String dialString) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001845 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001846
1847 final long identity = Binder.clearCallingIdentity();
1848 try {
1849 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1850 return false;
1851 }
1852 return (Boolean) sendRequest(CMD_HANDLE_PIN_MMI, dialString, subId);
1853 } finally {
1854 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001855 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001856 }
1857
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001858 public int getCallState() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001859 return getCallStateForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001860 }
1861
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001862 public int getCallStateForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001863 final long identity = Binder.clearCallingIdentity();
1864 try {
1865 Phone phone = PhoneFactory.getPhone(slotIndex);
1866 return phone == null ? TelephonyManager.CALL_STATE_IDLE :
1867 PhoneConstantConversions.convertCallState(phone.getState());
1868 } finally {
1869 Binder.restoreCallingIdentity(identity);
1870 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001871 }
1872
Sanket Padawe356d7632015-06-22 14:03:32 -07001873 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001874 public int getDataState() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001875 final long identity = Binder.clearCallingIdentity();
1876 try {
1877 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
1878 if (phone != null) {
1879 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
1880 } else {
1881 return PhoneConstantConversions.convertDataState(
1882 PhoneConstants.DataState.DISCONNECTED);
1883 }
1884 } finally {
1885 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001886 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001887 }
1888
Sanket Padawe356d7632015-06-22 14:03:32 -07001889 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001890 public int getDataActivity() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001891 final long identity = Binder.clearCallingIdentity();
1892 try {
1893 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
1894 if (phone != null) {
1895 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
1896 } else {
1897 return TelephonyManager.DATA_ACTIVITY_NONE;
1898 }
1899 } finally {
1900 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001901 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001902 }
1903
1904 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001905 public Bundle getCellLocation(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08001906 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08001907 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08001908
1909 LocationAccessPolicy.LocationPermissionResult locationResult =
1910 LocationAccessPolicy.checkLocationPermission(mApp,
1911 new LocationAccessPolicy.LocationPermissionQuery.Builder()
1912 .setCallingPackage(callingPackage)
1913 .setCallingPid(Binder.getCallingPid())
1914 .setCallingUid(Binder.getCallingUid())
1915 .setMethod("getCellLocation")
1916 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
1917 .build());
1918 switch (locationResult) {
1919 case DENIED_HARD:
1920 throw new SecurityException("Not allowed to access cell location");
1921 case DENIED_SOFT:
1922 return new Bundle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001923 }
1924
Narayan Kamathf04b5a12018-01-09 11:47:15 +00001925 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001926 final long identity = Binder.clearCallingIdentity();
1927 try {
1928 if (DBG_LOC) log("getCellLocation: is active user");
1929 Bundle data = new Bundle();
Nathan Harold3ff88932018-08-14 10:19:49 -07001930 int subId = mSubscriptionController.getDefaultDataSubId();
1931 CellLocation cl = (CellLocation) sendRequest(CMD_GET_CELL_LOCATION, workSource, subId);
1932 cl.fillInNotifierBundle(data);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001933 return data;
1934 } finally {
1935 Binder.restoreCallingIdentity(identity);
1936 }
Svetoslav64fad262015-04-14 14:35:21 -07001937 }
1938
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001939 @Override
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001940 public String getNetworkCountryIsoForPhone(int phoneId) {
1941 // Reporting the correct network country is ambiguous when IWLAN could conflict with
1942 // registered cell info, so return a NULL country instead.
1943 final long identity = Binder.clearCallingIdentity();
1944 try {
Malcolm Chen3732c2b2018-07-18 20:15:24 -07001945 if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
1946 // Get default phone in this case.
1947 phoneId = SubscriptionManager.DEFAULT_PHONE_INDEX;
1948 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001949 final int subId = mSubscriptionController.getSubIdUsingPhoneId(phoneId);
Jack Yu5f7092c2018-04-13 14:05:37 -07001950 // Todo: fix this when we can get the actual cellular network info when the device
1951 // is on IWLAN.
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001952 if (TelephonyManager.NETWORK_TYPE_IWLAN
1953 == getVoiceNetworkTypeForSubscriber(subId, mApp.getPackageName())) {
1954 return "";
1955 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001956 Phone phone = PhoneFactory.getPhone(phoneId);
1957 if (phone != null) {
1958 ServiceStateTracker sst = phone.getServiceStateTracker();
1959 if (sst != null) {
1960 LocaleTracker lt = sst.getLocaleTracker();
1961 if (lt != null) {
1962 return lt.getCurrentCountry();
1963 }
1964 }
1965 }
1966 return "";
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001967 } finally {
1968 Binder.restoreCallingIdentity(identity);
1969 }
Jonathan Basseribf5362b2017-07-19 12:22:35 -07001970 }
1971
1972 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001973 public void enableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001974 enableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001975 }
1976
Sanket Padawe356d7632015-06-22 14:03:32 -07001977 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001978 public void enableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001979 mApp.enforceCallingOrSelfPermission(
1980 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08001981
1982 final long identity = Binder.clearCallingIdentity();
1983 try {
1984 final Phone phone = getPhone(subId);
1985 if (phone != null) {
1986 phone.enableLocationUpdates();
1987 }
1988 } finally {
1989 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07001990 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001991 }
1992
1993 @Override
1994 public void disableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001995 disableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001996 }
1997
Sanket Padawe356d7632015-06-22 14:03:32 -07001998 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001999 public void disableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002000 mApp.enforceCallingOrSelfPermission(
2001 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002002
2003 final long identity = Binder.clearCallingIdentity();
2004 try {
2005 final Phone phone = getPhone(subId);
2006 if (phone != null) {
2007 phone.disableLocationUpdates();
2008 }
2009 } finally {
2010 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002011 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002012 }
2013
Nathan Harold31d7ff32018-10-15 20:20:30 -07002014 /**
2015 * Returns the target SDK version number for a given package name.
2016 *
2017 * @return target SDK if the package is found or INT_MAX.
2018 */
2019 private int getTargetSdk(String packageName) {
2020 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002021 final ApplicationInfo ai = mApp.getPackageManager().getApplicationInfo(
2022 packageName, 0);
Nathan Harold31d7ff32018-10-15 20:20:30 -07002023 if (ai != null) return ai.targetSdkVersion;
2024 } catch (PackageManager.NameNotFoundException unexpected) {
2025 }
2026 return Integer.MAX_VALUE;
2027 }
2028
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002029 @Override
2030 @SuppressWarnings("unchecked")
Nathan Harold31d7ff32018-10-15 20:20:30 -07002031 public List<NeighboringCellInfo> getNeighboringCellInfo(String callingPackage) {
2032 final int targetSdk = getTargetSdk(callingPackage);
Nathan Harolddbea45a2018-08-30 14:35:07 -07002033 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2034 throw new SecurityException(
2035 "getNeighboringCellInfo() is unavailable to callers targeting Q+ SDK levels.");
2036 }
Nathan Haroldb4d55612018-07-20 13:13:08 -07002037
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002038 if (mAppOps.noteOp(AppOpsManager.OP_NEIGHBORING_CELLS, Binder.getCallingUid(),
2039 callingPackage) != AppOpsManager.MODE_ALLOWED) {
2040 return null;
2041 }
Svetoslav64fad262015-04-14 14:35:21 -07002042
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002043 if (DBG_LOC) log("getNeighboringCellInfo: is active user");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002044
Nathan Haroldf180aac2018-06-01 18:43:55 -07002045 List<CellInfo> info = getAllCellInfo(callingPackage);
2046 if (info == null) return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002047
Nathan Haroldf180aac2018-06-01 18:43:55 -07002048 List<NeighboringCellInfo> neighbors = new ArrayList<NeighboringCellInfo>();
2049 for (CellInfo ci : info) {
2050 if (ci instanceof CellInfoGsm) {
2051 neighbors.add(new NeighboringCellInfo((CellInfoGsm) ci));
2052 } else if (ci instanceof CellInfoWcdma) {
2053 neighbors.add(new NeighboringCellInfo((CellInfoWcdma) ci));
2054 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002055 }
Nathan Haroldf180aac2018-06-01 18:43:55 -07002056 return (neighbors.size()) > 0 ? neighbors : null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002057 }
2058
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002059 private List<CellInfo> getCachedCellInfo() {
2060 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2061 for (Phone phone : PhoneFactory.getPhones()) {
2062 List<CellInfo> info = phone.getAllCellInfo();
2063 if (info != null) cellInfos.addAll(info);
2064 }
2065 return cellInfos;
2066 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002067
2068 @Override
Svetoslav64fad262015-04-14 14:35:21 -07002069 public List<CellInfo> getAllCellInfo(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002070 mApp.getSystemService(AppOpsManager.class)
Hall Liu1aa510f2017-11-22 17:40:08 -08002071 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002072
2073 LocationAccessPolicy.LocationPermissionResult locationResult =
2074 LocationAccessPolicy.checkLocationPermission(mApp,
2075 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2076 .setCallingPackage(callingPackage)
2077 .setCallingPid(Binder.getCallingPid())
2078 .setCallingUid(Binder.getCallingUid())
2079 .setMethod("getAllCellInfo")
Nathan Harold5ae50b52019-02-20 15:46:36 -08002080 .setMinSdkVersionForCoarse(Build.VERSION_CODES.BASE)
Hall Liuf19c44f2018-11-27 14:38:17 -08002081 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2082 .build());
2083 switch (locationResult) {
2084 case DENIED_HARD:
2085 throw new SecurityException("Not allowed to access cell info");
2086 case DENIED_SOFT:
2087 return new ArrayList<>();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002088 }
2089
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002090 final int targetSdk = getTargetSdk(callingPackage);
2091 if (targetSdk >= android.os.Build.VERSION_CODES.Q) {
2092 return getCachedCellInfo();
2093 }
2094
Svetoslav Ganov4a9d4482017-06-20 19:53:35 -07002095 if (DBG_LOC) log("getAllCellInfo: is active user");
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002096 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002097 final long identity = Binder.clearCallingIdentity();
2098 try {
2099 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
2100 for (Phone phone : PhoneFactory.getPhones()) {
Nathan Harold3ff88932018-08-14 10:19:49 -07002101 final List<CellInfo> info = (List<CellInfo>) sendRequest(
Nathan Harold92bed182018-10-12 18:16:49 -07002102 CMD_GET_ALL_CELL_INFO, null, phone, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002103 if (info != null) cellInfos.addAll(info);
2104 }
2105 return cellInfos;
2106 } finally {
2107 Binder.restoreCallingIdentity(identity);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002108 }
2109 }
2110
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07002111 @Override
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002112 public void requestCellInfoUpdate(int subId, ICellInfoCallback cb, String callingPackage) {
2113 requestCellInfoUpdateInternal(
2114 subId, cb, callingPackage, getWorkSource(Binder.getCallingUid()));
2115 }
2116
2117 @Override
2118 public void requestCellInfoUpdateWithWorkSource(
2119 int subId, ICellInfoCallback cb, String callingPackage, WorkSource workSource) {
2120 enforceModifyPermission();
2121 requestCellInfoUpdateInternal(subId, cb, callingPackage, workSource);
2122 }
2123
2124 private void requestCellInfoUpdateInternal(
2125 int subId, ICellInfoCallback cb, String callingPackage, WorkSource workSource) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002126 mApp.getSystemService(AppOpsManager.class)
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002127 .checkPackage(Binder.getCallingUid(), callingPackage);
Hall Liuf19c44f2018-11-27 14:38:17 -08002128
2129 LocationAccessPolicy.LocationPermissionResult locationResult =
2130 LocationAccessPolicy.checkLocationPermission(mApp,
2131 new LocationAccessPolicy.LocationPermissionQuery.Builder()
2132 .setCallingPackage(callingPackage)
2133 .setCallingPid(Binder.getCallingPid())
2134 .setCallingUid(Binder.getCallingUid())
2135 .setMethod("requestCellInfoUpdate")
2136 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
2137 .build());
2138 switch (locationResult) {
2139 case DENIED_HARD:
2140 throw new SecurityException("Not allowed to access cell info");
2141 case DENIED_SOFT:
Nathan Haroldb3c5da42019-05-09 10:26:08 -07002142 try {
2143 cb.onCellInfo(new ArrayList<CellInfo>());
2144 } catch (RemoteException re) {
2145 // Drop without consequences
2146 }
Hall Liuf19c44f2018-11-27 14:38:17 -08002147 return;
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002148 }
2149
Nathan Harold32e84c42019-05-09 10:13:47 -07002150
2151 final Phone phone = getPhoneFromSubId(subId);
Nathan Haroldfa8da0f2018-09-27 18:51:29 -07002152 if (phone == null) throw new IllegalArgumentException("Invalid Subscription Id: " + subId);
2153
2154 sendRequestAsync(CMD_REQUEST_CELL_INFO_UPDATE, cb, phone, workSource);
2155 }
2156
2157 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002158 public void setCellInfoListRate(int rateInMillis) {
Jack Yua8d8cb82017-01-16 10:15:34 -08002159 enforceModifyPermission();
Narayan Kamathf04b5a12018-01-09 11:47:15 +00002160 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002161
2162 final long identity = Binder.clearCallingIdentity();
2163 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002164 getDefaultPhone().setCellInfoListRate(rateInMillis, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002165 } finally {
2166 Binder.restoreCallingIdentity(identity);
2167 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002168 }
2169
Shishir Agrawala9f32182016-04-12 12:00:16 -07002170 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002171 public String getImeiForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002172 Phone phone = PhoneFactory.getPhone(slotIndex);
2173 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002174 return null;
2175 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002176 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002177 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
2178 callingPackage, "getImeiForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002179 return null;
2180 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002181
2182 final long identity = Binder.clearCallingIdentity();
2183 try {
2184 return phone.getImei();
2185 } finally {
2186 Binder.restoreCallingIdentity(identity);
2187 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002188 }
2189
2190 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002191 public String getTypeAllocationCodeForSlot(int slotIndex) {
2192 Phone phone = PhoneFactory.getPhone(slotIndex);
2193 String tac = null;
2194 if (phone != null) {
2195 String imei = phone.getImei();
2196 tac = imei == null ? null : imei.substring(0, TYPE_ALLOCATION_CODE_LENGTH);
2197 }
2198 return tac;
2199 }
2200
2201 @Override
Jack Yu2af8d712017-03-15 17:14:14 -07002202 public String getMeidForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002203 Phone phone = PhoneFactory.getPhone(slotIndex);
2204 if (phone == null) {
Jack Yu2af8d712017-03-15 17:14:14 -07002205 return null;
2206 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002207
Jeff Davidson913390f2018-02-23 17:11:49 -08002208 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07002209 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
2210 callingPackage, "getMeidForSlot")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002211 return null;
2212 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002213
2214 final long identity = Binder.clearCallingIdentity();
2215 try {
2216 return phone.getMeid();
2217 } finally {
2218 Binder.restoreCallingIdentity(identity);
2219 }
Jack Yu2af8d712017-03-15 17:14:14 -07002220 }
2221
2222 @Override
David Kelly5e06a7f2018-03-12 14:10:59 +00002223 public String getManufacturerCodeForSlot(int slotIndex) {
2224 Phone phone = PhoneFactory.getPhone(slotIndex);
2225 String manufacturerCode = null;
2226 if (phone != null) {
2227 String meid = phone.getMeid();
2228 manufacturerCode = meid == null ? null : meid.substring(0, MANUFACTURER_CODE_LENGTH);
2229 }
2230 return manufacturerCode;
2231 }
2232
2233 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002234 public String getDeviceSoftwareVersionForSlot(int slotIndex, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08002235 Phone phone = PhoneFactory.getPhone(slotIndex);
2236 if (phone == null) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002237 return null;
2238 }
Jeff Davidson913390f2018-02-23 17:11:49 -08002239 int subId = phone.getSubId();
2240 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2241 mApp, subId, callingPackage, "getDeviceSoftwareVersionForSlot")) {
2242 return null;
2243 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002244
2245 final long identity = Binder.clearCallingIdentity();
2246 try {
2247 return phone.getDeviceSvn();
2248 } finally {
2249 Binder.restoreCallingIdentity(identity);
2250 }
Shishir Agrawala9f32182016-04-12 12:00:16 -07002251 }
2252
fionaxu43304da2017-11-27 22:51:16 -08002253 @Override
2254 public int getSubscriptionCarrierId(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002255 final long identity = Binder.clearCallingIdentity();
2256 try {
2257 final Phone phone = getPhone(subId);
2258 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID : phone.getCarrierId();
2259 } finally {
2260 Binder.restoreCallingIdentity(identity);
2261 }
fionaxu43304da2017-11-27 22:51:16 -08002262 }
2263
2264 @Override
2265 public String getSubscriptionCarrierName(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002266 final long identity = Binder.clearCallingIdentity();
2267 try {
2268 final Phone phone = getPhone(subId);
2269 return phone == null ? null : phone.getCarrierName();
2270 } finally {
2271 Binder.restoreCallingIdentity(identity);
2272 }
fionaxu43304da2017-11-27 22:51:16 -08002273 }
2274
calvinpanffe225e2018-11-01 19:43:06 +08002275 @Override
chen xu0026ca62019-03-06 15:28:50 -08002276 public int getSubscriptionSpecificCarrierId(int subId) {
chen xu25637222018-11-04 17:17:00 -08002277 final long identity = Binder.clearCallingIdentity();
2278 try {
2279 final Phone phone = getPhone(subId);
2280 return phone == null ? TelephonyManager.UNKNOWN_CARRIER_ID
chen xu0026ca62019-03-06 15:28:50 -08002281 : phone.getSpecificCarrierId();
chen xu25637222018-11-04 17:17:00 -08002282 } finally {
2283 Binder.restoreCallingIdentity(identity);
2284 }
2285 }
2286
2287 @Override
chen xu0026ca62019-03-06 15:28:50 -08002288 public String getSubscriptionSpecificCarrierName(int subId) {
chen xu25637222018-11-04 17:17:00 -08002289 final long identity = Binder.clearCallingIdentity();
2290 try {
2291 final Phone phone = getPhone(subId);
chen xu0026ca62019-03-06 15:28:50 -08002292 return phone == null ? null : phone.getSpecificCarrierName();
chen xu25637222018-11-04 17:17:00 -08002293 } finally {
2294 Binder.restoreCallingIdentity(identity);
2295 }
2296 }
2297
chen xu651eec72018-11-11 19:03:44 -08002298 @Override
chen xu864e11c2018-12-06 22:10:03 -08002299 public int getCarrierIdFromMccMnc(int slotIndex, String mccmnc, boolean isSubscriptionMccMnc) {
2300 if (!isSubscriptionMccMnc) {
2301 enforceReadPrivilegedPermission("getCarrierIdFromMccMnc");
2302 }
chen xu651eec72018-11-11 19:03:44 -08002303 final Phone phone = PhoneFactory.getPhone(slotIndex);
2304 if (phone == null) {
2305 return TelephonyManager.UNKNOWN_CARRIER_ID;
2306 }
2307 final long identity = Binder.clearCallingIdentity();
2308 try {
2309 return CarrierResolver.getCarrierIdFromMccMnc(phone.getContext(), mccmnc);
2310 } finally {
2311 Binder.restoreCallingIdentity(identity);
2312 }
2313 }
2314
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002315 //
2316 // Internal helper methods.
2317 //
2318
Sanket Padaweee13a9b2016-03-08 17:30:28 -08002319 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002320 * Make sure the caller has the MODIFY_PHONE_STATE permission.
2321 *
2322 * @throws SecurityException if the caller does not have the required permission
2323 */
2324 private void enforceModifyPermission() {
2325 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
2326 }
2327
2328 /**
2329 * Make sure the caller has the CALL_PHONE permission.
2330 *
2331 * @throws SecurityException if the caller does not have the required permission
2332 */
2333 private void enforceCallPermission() {
2334 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
2335 }
2336
Stuart Scott8eef64f2015-04-08 15:13:54 -07002337 private void enforceConnectivityInternalPermission() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002338 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL,
Stuart Scott8eef64f2015-04-08 15:13:54 -07002339 "ConnectivityService");
2340 }
2341
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002342 private String createTelUrl(String number) {
2343 if (TextUtils.isEmpty(number)) {
2344 return null;
2345 }
2346
Jake Hambye994d462014-02-03 13:10:13 -08002347 return "tel:" + number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002348 }
2349
Ihab Awadf9e92732013-12-05 18:02:52 -08002350 private static void log(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002351 Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
2352 }
2353
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07002354 private static void logv(String msg) {
2355 Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
2356 }
2357
Ihab Awadf9e92732013-12-05 18:02:52 -08002358 private static void loge(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002359 Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
2360 }
2361
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002362 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002363 public int getActivePhoneType() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07002364 return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002365 }
2366
Sanket Padawe356d7632015-06-22 14:03:32 -07002367 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002368 public int getActivePhoneTypeForSlot(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002369 final long identity = Binder.clearCallingIdentity();
2370 try {
2371 final Phone phone = PhoneFactory.getPhone(slotIndex);
2372 if (phone == null) {
2373 return PhoneConstants.PHONE_TYPE_NONE;
2374 } else {
2375 return phone.getPhoneType();
2376 }
2377 } finally {
2378 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002379 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002380 }
2381
2382 /**
2383 * Returns the CDMA ERI icon index to display
2384 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002385 @Override
2386 public int getCdmaEriIconIndex(String callingPackage) {
2387 return getCdmaEriIconIndexForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002388 }
2389
Sanket Padawe356d7632015-06-22 14:03:32 -07002390 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002391 public int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002392 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002393 mApp, subId, callingPackage, "getCdmaEriIconIndexForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002394 return -1;
2395 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002396
2397 final long identity = Binder.clearCallingIdentity();
2398 try {
2399 final Phone phone = getPhone(subId);
2400 if (phone != null) {
2401 return phone.getCdmaEriIconIndex();
2402 } else {
2403 return -1;
2404 }
2405 } finally {
2406 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002407 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002408 }
2409
2410 /**
2411 * Returns the CDMA ERI icon mode,
2412 * 0 - ON
2413 * 1 - FLASHING
2414 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002415 @Override
2416 public int getCdmaEriIconMode(String callingPackage) {
2417 return getCdmaEriIconModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002418 }
2419
Sanket Padawe356d7632015-06-22 14:03:32 -07002420 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002421 public int getCdmaEriIconModeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002422 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002423 mApp, subId, callingPackage, "getCdmaEriIconModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002424 return -1;
2425 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002426
2427 final long identity = Binder.clearCallingIdentity();
2428 try {
2429 final Phone phone = getPhone(subId);
2430 if (phone != null) {
2431 return phone.getCdmaEriIconMode();
2432 } else {
2433 return -1;
2434 }
2435 } finally {
2436 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002437 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002438 }
2439
2440 /**
2441 * Returns the CDMA ERI text,
2442 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002443 @Override
2444 public String getCdmaEriText(String callingPackage) {
2445 return getCdmaEriTextForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002446 }
2447
Sanket Padawe356d7632015-06-22 14:03:32 -07002448 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002449 public String getCdmaEriTextForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002450 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002451 mApp, subId, callingPackage, "getCdmaEriIconTextForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002452 return null;
2453 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002454
2455 final long identity = Binder.clearCallingIdentity();
2456 try {
2457 final Phone phone = getPhone(subId);
2458 if (phone != null) {
2459 return phone.getCdmaEriText();
2460 } else {
2461 return null;
2462 }
2463 } finally {
2464 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002465 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002466 }
2467
2468 /**
Junda Liuca05d5d2014-08-14 22:36:34 -07002469 * Returns the CDMA MDN.
2470 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002471 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002472 public String getCdmaMdn(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002473 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2474 mApp, subId, "getCdmaMdn");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002475
2476 final long identity = Binder.clearCallingIdentity();
2477 try {
2478 final Phone phone = getPhone(subId);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002479 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002480 return phone.getLine1Number();
2481 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002482 loge("getCdmaMdn: no phone found. Invalid subId: " + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002483 return null;
2484 }
2485 } finally {
2486 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002487 }
2488 }
2489
2490 /**
2491 * Returns the CDMA MIN.
2492 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002493 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002494 public String getCdmaMin(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002495 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2496 mApp, subId, "getCdmaMin");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002497
2498 final long identity = Binder.clearCallingIdentity();
2499 try {
2500 final Phone phone = getPhone(subId);
2501 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2502 return phone.getCdmaMin();
2503 } else {
2504 return null;
2505 }
2506 } finally {
2507 Binder.restoreCallingIdentity(identity);
Junda Liuca05d5d2014-08-14 22:36:34 -07002508 }
2509 }
2510
Hall Liud892bec2018-11-30 14:51:45 -08002511 @Override
2512 public void requestNumberVerification(PhoneNumberRange range, long timeoutMillis,
2513 INumberVerificationCallback callback, String callingPackage) {
2514 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
2515 != PERMISSION_GRANTED) {
2516 throw new SecurityException("Caller must hold the MODIFY_PHONE_STATE permission");
2517 }
2518 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2519
2520 String authorizedPackage = NumberVerificationManager.getAuthorizedPackage(mApp);
2521 if (!TextUtils.equals(callingPackage, authorizedPackage)) {
2522 throw new SecurityException("Calling package must be configured in the device config");
2523 }
2524
2525 if (range == null) {
2526 throw new NullPointerException("Range must be non-null");
2527 }
2528
2529 timeoutMillis = Math.min(timeoutMillis,
Hall Liubd069e32019-02-28 18:56:30 -08002530 TelephonyManager.getMaxNumberVerificationTimeoutMillis());
Hall Liud892bec2018-11-30 14:51:45 -08002531
2532 NumberVerificationManager.getInstance().requestVerification(range, callback, timeoutMillis);
2533 }
2534
Junda Liuca05d5d2014-08-14 22:36:34 -07002535 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002536 * Returns true if CDMA provisioning needs to run.
2537 */
2538 public boolean needsOtaServiceProvisioning() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002539 final long identity = Binder.clearCallingIdentity();
2540 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002541 return getDefaultPhone().needsOtaServiceProvisioning();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002542 } finally {
2543 Binder.restoreCallingIdentity(identity);
2544 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002545 }
2546
2547 /**
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002548 * Sets the voice mail number of a given subId.
2549 */
2550 @Override
2551 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002552 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setVoiceMailNumber");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002553
2554 final long identity = Binder.clearCallingIdentity();
2555 try {
2556 Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
2557 new Pair<String, String>(alphaTag, number), new Integer(subId));
2558 return success;
2559 } finally {
2560 Binder.restoreCallingIdentity(identity);
2561 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002562 }
2563
Ta-wei Yen87c49842016-05-13 21:19:52 -07002564 @Override
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002565 public Bundle getVisualVoicemailSettings(String callingPackage, int subId) {
2566 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002567 String systemDialer = TelecomManager.from(mApp).getSystemDialerPackage();
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002568 if (!TextUtils.equals(callingPackage, systemDialer)) {
2569 throw new SecurityException("caller must be system dialer");
2570 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002571
2572 final long identity = Binder.clearCallingIdentity();
2573 try {
2574 PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
2575 if (phoneAccountHandle == null) {
2576 return null;
2577 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002578 return VisualVoicemailSettingsUtil.dump(mApp, phoneAccountHandle);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002579 } finally {
2580 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002581 }
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002582 }
2583
2584 @Override
Ta-wei Yen409ac562017-03-06 16:00:44 -08002585 public String getVisualVoicemailPackageName(String callingPackage, int subId) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002586 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jeff Davidson7e17e312018-02-13 18:17:36 -08002587 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08002588 mApp, subId, callingPackage, "getVisualVoicemailPackageName")) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002589 return null;
2590 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002591
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002592 final long identity = Binder.clearCallingIdentity();
2593 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002594 return RemoteVvmTaskManager.getRemotePackage(mApp, subId).getPackageName();
Jeff Davidsona8e4e242018-03-15 17:16:18 -07002595 } finally {
2596 Binder.restoreCallingIdentity(identity);
2597 }
Ta-wei Yendca928f2017-01-10 16:17:08 -08002598 }
2599
2600 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002601 public void enableVisualVoicemailSmsFilter(String callingPackage, int subId,
2602 VisualVoicemailSmsFilterSettings settings) {
2603 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002604
2605 final long identity = Binder.clearCallingIdentity();
2606 try {
2607 VisualVoicemailSmsFilterConfig.enableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002608 mApp, callingPackage, subId, settings);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002609 } finally {
2610 Binder.restoreCallingIdentity(identity);
2611 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002612 }
2613
2614 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002615 public void disableVisualVoicemailSmsFilter(String callingPackage, int subId) {
2616 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002617
2618 final long identity = Binder.clearCallingIdentity();
2619 try {
2620 VisualVoicemailSmsFilterConfig.disableVisualVoicemailSmsFilter(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002621 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002622 } finally {
2623 Binder.restoreCallingIdentity(identity);
2624 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002625 }
2626
2627 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002628 public VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(
2629 String callingPackage, int subId) {
2630 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002631
2632 final long identity = Binder.clearCallingIdentity();
2633 try {
2634 return VisualVoicemailSmsFilterConfig.getVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002635 mApp, callingPackage, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002636 } finally {
2637 Binder.restoreCallingIdentity(identity);
2638 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002639 }
2640
2641 @Override
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002642 public VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002643 enforceReadPrivilegedPermission("getActiveVisualVoicemailSmsFilterSettings");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002644
2645 final long identity = Binder.clearCallingIdentity();
2646 try {
2647 return VisualVoicemailSmsFilterConfig.getActiveVisualVoicemailSmsFilterSettings(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002648 mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002649 } finally {
2650 Binder.restoreCallingIdentity(identity);
2651 }
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002652 }
2653
2654 @Override
2655 public void sendVisualVoicemailSmsForSubscriber(String callingPackage, int subId,
2656 String number, int port, String text, PendingIntent sentIntent) {
2657 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen527a9c02017-01-06 15:29:25 -08002658 enforceVisualVoicemailPackage(callingPackage, subId);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002659 enforceSendSmsPermission();
Amit Mahajandccb3f12019-05-13 13:48:32 -07002660 SmsController smsController = PhoneFactory.getSmsController();
2661 smsController.sendVisualVoicemailSmsForSubscriber(callingPackage, subId, number, port, text,
2662 sentIntent);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002663 }
Amit Mahajandccb3f12019-05-13 13:48:32 -07002664
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002665 /**
fionaxu0152e512016-11-14 13:36:14 -08002666 * Sets the voice activation state of a given subId.
2667 */
2668 @Override
2669 public void setVoiceActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002670 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2671 mApp, subId, "setVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002672
2673 final long identity = Binder.clearCallingIdentity();
2674 try {
2675 final Phone phone = getPhone(subId);
2676 if (phone != null) {
2677 phone.setVoiceActivationState(activationState);
2678 } else {
2679 loge("setVoiceActivationState fails with invalid subId: " + subId);
2680 }
2681 } finally {
2682 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002683 }
2684 }
2685
2686 /**
2687 * Sets the data activation state of a given subId.
2688 */
2689 @Override
2690 public void setDataActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002691 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2692 mApp, subId, "setDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002693
2694 final long identity = Binder.clearCallingIdentity();
2695 try {
2696 final Phone phone = getPhone(subId);
2697 if (phone != null) {
2698 phone.setDataActivationState(activationState);
2699 } else {
2700 loge("setVoiceActivationState fails with invalid subId: " + subId);
2701 }
2702 } finally {
2703 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002704 }
2705 }
2706
2707 /**
2708 * Returns the voice activation state of a given subId.
2709 */
2710 @Override
2711 public int getVoiceActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002712 enforceReadPrivilegedPermission("getVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002713
fionaxu0152e512016-11-14 13:36:14 -08002714 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002715 final long identity = Binder.clearCallingIdentity();
2716 try {
2717 if (phone != null) {
2718 return phone.getVoiceActivationState();
2719 } else {
2720 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2721 }
2722 } finally {
2723 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002724 }
2725 }
2726
2727 /**
2728 * Returns the data activation state of a given subId.
2729 */
2730 @Override
2731 public int getDataActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002732 enforceReadPrivilegedPermission("getDataActivationState");
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.getDataActivationState();
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 /**
Wink Saville36469e72014-06-11 15:17:00 -07002748 * Returns the unread count of voicemails for a subId
2749 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002750 @Override
Brad Ebingerf7664ba2018-11-29 12:43:38 -08002751 public int getVoiceMessageCountForSubscriber(int subId, String callingPackage) {
2752 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2753 mApp, subId, callingPackage, "getVoiceMessageCountForSubscriber")) {
2754 return 0;
2755 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002756 final long identity = Binder.clearCallingIdentity();
2757 try {
2758 final Phone phone = getPhone(subId);
2759 if (phone != null) {
2760 return phone.getVoiceMessageCount();
2761 } else {
2762 return 0;
2763 }
2764 } finally {
2765 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002766 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002767 }
2768
2769 /**
pkanwar8a4dcfb2017-01-19 13:43:16 -08002770 * returns true, if the device is in a state where both voice and data
2771 * are supported simultaneously. This can change based on location or network condition.
2772 */
2773 @Override
2774 public boolean isConcurrentVoiceAndDataAllowed(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002775 final long identity = Binder.clearCallingIdentity();
2776 try {
2777 final Phone phone = getPhone(subId);
2778 return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
2779 } finally {
2780 Binder.restoreCallingIdentity(identity);
2781 }
pkanwar8a4dcfb2017-01-19 13:43:16 -08002782 }
2783
2784 /**
fionaxu235cc5e2017-03-06 22:25:57 -08002785 * Send the dialer code if called from the current default dialer or the caller has
2786 * carrier privilege.
2787 * @param inputCode The dialer code to send
2788 */
2789 @Override
2790 public void sendDialerSpecialCode(String callingPackage, String inputCode) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002791 final Phone defaultPhone = getDefaultPhone();
fionaxu235cc5e2017-03-06 22:25:57 -08002792 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002793 String defaultDialer = TelecomManager.from(defaultPhone.getContext())
2794 .getDefaultDialerPackage();
fionaxu235cc5e2017-03-06 22:25:57 -08002795 if (!TextUtils.equals(callingPackage, defaultDialer)) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002796 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
2797 getDefaultSubscription(), "sendDialerSpecialCode");
fionaxu235cc5e2017-03-06 22:25:57 -08002798 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002799
2800 final long identity = Binder.clearCallingIdentity();
2801 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002802 defaultPhone.sendDialerSpecialCode(inputCode);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002803 } finally {
2804 Binder.restoreCallingIdentity(identity);
2805 }
fionaxu235cc5e2017-03-06 22:25:57 -08002806 }
2807
2808 /**
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002809 * Returns the data network type.
2810 * Legacy call, permission-free.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002811 *
2812 * @Deprecated to be removed Q3 2013 use {@link #getDataNetworkType}.
2813 */
2814 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002815 public int getNetworkType() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002816 final long identity = Binder.clearCallingIdentity();
2817 try {
2818 final Phone phone = getPhone(getDefaultSubscription());
2819 if (phone != null) {
2820 return phone.getServiceState().getDataNetworkType();
2821 } else {
2822 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2823 }
2824 } finally {
2825 Binder.restoreCallingIdentity(identity);
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002826 }
Wink Saville36469e72014-06-11 15:17:00 -07002827 }
2828
Pengquan Menga1bb6272018-09-06 09:59:22 -07002829 @Override
2830 public int getNetworkSelectionMode(int subId) {
Pengquan Menge92a50d2018-09-21 15:54:48 -07002831 if (!isActiveSubscription(subId)) {
2832 return TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
2833 }
2834
Pengquan Menga1bb6272018-09-06 09:59:22 -07002835 return (int) sendRequest(CMD_GET_NETWORK_SELECTION_MODE, null /* argument */, subId);
2836 }
2837
Brad Ebinger35c841c2018-10-01 10:40:55 -07002838 @Override
Brad Ebingerb2b65522019-03-15 13:48:47 -07002839 public boolean isInEmergencySmsMode() {
2840 enforceReadPrivilegedPermission("isInEmergencySmsMode");
2841 final long identity = Binder.clearCallingIdentity();
2842 try {
2843 for (Phone phone : PhoneFactory.getPhones()) {
2844 if (phone.isInEmergencySmsMode()) {
2845 return true;
2846 }
2847 }
2848 } finally {
2849 Binder.restoreCallingIdentity(identity);
2850 }
2851 return false;
2852 }
2853
2854 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002855 public void registerImsRegistrationCallback(int subId, IImsRegistrationCallback c)
2856 throws RemoteException {
2857 enforceReadPrivilegedPermission("registerImsRegistrationCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002858 final long token = Binder.clearCallingIdentity();
2859 try {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002860 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002861 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002862 .addRegistrationCallbackForSubscription(c, subId);
2863 } finally {
2864 Binder.restoreCallingIdentity(token);
2865 }
2866 }
2867
2868 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002869 public void unregisterImsRegistrationCallback(int subId, IImsRegistrationCallback c) {
2870 enforceReadPrivilegedPermission("unregisterImsRegistrationCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002871 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2872 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2873 }
2874 Binder.withCleanCallingIdentity(() -> {
2875 try {
2876 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002877 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002878 .removeRegistrationCallbackForSubscription(c, subId);
2879 } catch (IllegalArgumentException e) {
2880 Log.i(LOG_TAG, "unregisterImsRegistrationCallback: " + subId
2881 + "is inactive, ignoring unregister.");
2882 // If the subscription is no longer active, just return, since the callback
2883 // will already have been removed internally.
2884 }
2885 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002886 }
2887
2888 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002889 public void registerMmTelCapabilityCallback(int subId, IImsCapabilityCallback c)
2890 throws RemoteException {
2891 enforceReadPrivilegedPermission("registerMmTelCapabilityCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002892 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2893 final long token = Binder.clearCallingIdentity();
2894 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002895 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002896 .addCapabilitiesCallbackForSubscription(c, subId);
2897 } finally {
2898 Binder.restoreCallingIdentity(token);
2899 }
2900 }
2901
2902 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002903 public void unregisterMmTelCapabilityCallback(int subId, IImsCapabilityCallback c) {
2904 enforceReadPrivilegedPermission("unregisterMmTelCapabilityCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002905
2906 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2907 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2908 }
2909 Binder.withCleanCallingIdentity(() -> {
2910 try {
2911 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002912 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002913 .removeCapabilitiesCallbackForSubscription(c, subId);
2914 } catch (IllegalArgumentException e) {
2915 Log.i(LOG_TAG, "unregisterMmTelCapabilityCallback: " + subId
2916 + "is inactive, ignoring unregister.");
2917 // If the subscription is no longer active, just return, since the callback
2918 // will already have been removed internally.
2919 }
2920 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002921 }
2922
2923 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002924 public boolean isCapable(int subId, int capability, int regTech) {
2925 enforceReadPrivilegedPermission("isCapable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002926 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2927 final long token = Binder.clearCallingIdentity();
2928 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002929 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002930 getSlotIndexOrException(subId)).queryMmTelCapability(capability, regTech);
2931 } catch (ImsException e) {
2932 Log.w(LOG_TAG, "IMS isCapable - service unavailable: " + e.getMessage());
2933 return false;
Brad Ebinger6b5ac222019-02-04 14:36:52 -08002934 } catch (IllegalArgumentException e) {
2935 Log.i(LOG_TAG, "isCapable: " + subId + " is inactive, returning false.");
2936 return false;
Brad Ebinger35c841c2018-10-01 10:40:55 -07002937 } finally {
2938 Binder.restoreCallingIdentity(token);
2939 }
2940 }
2941
2942 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002943 public boolean isAvailable(int subId, int capability, int regTech) {
2944 enforceReadPrivilegedPermission("isAvailable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002945 final long token = Binder.clearCallingIdentity();
2946 try {
2947 Phone phone = getPhone(subId);
2948 if (phone == null) return false;
2949 return phone.isImsCapabilityAvailable(capability, regTech);
2950 } finally {
2951 Binder.restoreCallingIdentity(token);
2952 }
2953 }
2954
2955 @Override
2956 public boolean isAdvancedCallingSettingEnabled(int subId) {
2957 enforceReadPrivilegedPermission("enforceReadPrivilegedPermission");
2958 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2959 final long token = Binder.clearCallingIdentity();
2960 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002961 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002962 getSlotIndexOrException(subId)).isEnhanced4gLteModeSettingEnabledByUser();
2963 } finally {
2964 Binder.restoreCallingIdentity(token);
2965 }
2966 }
2967
2968 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08002969 public void setAdvancedCallingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002970 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08002971 "setAdvancedCallingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002972 final long identity = Binder.clearCallingIdentity();
2973 try {
2974 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002975 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002976 getSlotIndexOrException(subId)).setEnhanced4gLteModeSetting(isEnabled);
2977 } finally {
2978 Binder.restoreCallingIdentity(identity);
2979 }
2980 }
2981
2982 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002983 public boolean isVtSettingEnabled(int subId) {
2984 enforceReadPrivilegedPermission("isVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002985 final long identity = Binder.clearCallingIdentity();
2986 try {
2987 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002988 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002989 getSlotIndexOrException(subId)).isVtEnabledByUser();
2990 } finally {
2991 Binder.restoreCallingIdentity(identity);
2992 }
2993 }
2994
2995 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08002996 public void setVtSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002997 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08002998 "setVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002999 final long identity = Binder.clearCallingIdentity();
3000 try {
3001 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003002 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setVtSetting(isEnabled);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003003 } finally {
3004 Binder.restoreCallingIdentity(identity);
3005 }
3006 }
3007
3008 @Override
3009 public boolean isVoWiFiSettingEnabled(int subId) {
3010 enforceReadPrivilegedPermission("isVoWiFiSettingEnabled");
3011 final long identity = Binder.clearCallingIdentity();
3012 try {
3013 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003014 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003015 getSlotIndexOrException(subId)).isWfcEnabledByUser();
3016 } finally {
3017 Binder.restoreCallingIdentity(identity);
3018 }
3019 }
3020
3021 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003022 public void setVoWiFiSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003023 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003024 "setVoWiFiSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003025 final long identity = Binder.clearCallingIdentity();
3026 try {
3027 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003028 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setWfcSetting(isEnabled);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003029 } finally {
3030 Binder.restoreCallingIdentity(identity);
3031 }
3032 }
3033
3034 @Override
3035 public boolean isVoWiFiRoamingSettingEnabled(int subId) {
3036 enforceReadPrivilegedPermission("isVoWiFiRoamingSettingEnabled");
3037 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 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003041 getSlotIndexOrException(subId)).isWfcRoamingEnabledByUser();
3042 } finally {
3043 Binder.restoreCallingIdentity(identity);
3044 }
3045 }
3046
3047 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003048 public void setVoWiFiRoamingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003049 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003050 "setVoWiFiRoamingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003051 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 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003055 getSlotIndexOrException(subId)).setWfcRoamingSetting(isEnabled);
3056 } finally {
3057 Binder.restoreCallingIdentity(identity);
3058 }
3059 }
3060
3061 @Override
3062 public void setVoWiFiNonPersistent(int subId, boolean isCapable, int mode) {
3063 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3064 "setVoWiFiNonPersistent");
3065 final long identity = Binder.clearCallingIdentity();
3066 try {
3067 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003068 ImsManager.getInstance(mApp,
Brad Ebinger2d29c012019-05-07 18:33:46 -07003069 getSlotIndexOrException(subId)).setWfcNonPersistent(isCapable, mode);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003070 } finally {
3071 Binder.restoreCallingIdentity(identity);
3072 }
3073 }
3074
3075 @Override
3076 public int getVoWiFiModeSetting(int subId) {
3077 enforceReadPrivilegedPermission("getVoWiFiModeSetting");
3078 final long identity = Binder.clearCallingIdentity();
3079 try {
3080 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003081 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003082 getSlotIndexOrException(subId)).getWfcMode(false /*isRoaming*/);
3083 } finally {
3084 Binder.restoreCallingIdentity(identity);
3085 }
3086 }
3087
3088 @Override
3089 public void setVoWiFiModeSetting(int subId, int mode) {
3090 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3091 "setVoWiFiModeSetting");
3092 final long identity = Binder.clearCallingIdentity();
3093 try {
3094 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003095 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003096 getSlotIndexOrException(subId)).setWfcMode(mode, false /*isRoaming*/);
3097 } finally {
3098 Binder.restoreCallingIdentity(identity);
3099 }
3100 }
3101
3102 @Override
3103 public int getVoWiFiRoamingModeSetting(int subId) {
3104 enforceReadPrivilegedPermission("getVoWiFiRoamingModeSetting");
3105 final long identity = Binder.clearCallingIdentity();
3106 try {
3107 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003108 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003109 getSlotIndexOrException(subId)).getWfcMode(true /*isRoaming*/);
3110 } finally {
3111 Binder.restoreCallingIdentity(identity);
3112 }
3113 }
3114
3115 @Override
3116 public void setVoWiFiRoamingModeSetting(int subId, int mode) {
3117 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3118 "setVoWiFiRoamingModeSetting");
3119 final long identity = Binder.clearCallingIdentity();
3120 try {
3121 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003122 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003123 getSlotIndexOrException(subId)).setWfcMode(mode, true /*isRoaming*/);
3124 } finally {
3125 Binder.restoreCallingIdentity(identity);
3126 }
3127 }
3128
3129 @Override
3130 public void setRttCapabilitySetting(int subId, boolean isEnabled) {
3131 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3132 "setRttCapabilityEnabled");
3133 final long identity = Binder.clearCallingIdentity();
3134 try {
3135 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003136 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003137 getSlotIndexOrException(subId)).setRttEnabled(isEnabled);
3138 } finally {
3139 Binder.restoreCallingIdentity(identity);
3140 }
3141 }
3142
3143 @Override
3144 public boolean isTtyOverVolteEnabled(int subId) {
3145 enforceReadPrivilegedPermission("isTtyOverVolteEnabled");
3146 final long identity = Binder.clearCallingIdentity();
3147 try {
3148 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003149 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003150 getSlotIndexOrException(subId)).isTtyOnVoLteCapable();
3151 } finally {
3152 Binder.restoreCallingIdentity(identity);
3153 }
3154 }
3155
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003156 @Override
3157 public void registerImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3158 enforceReadPrivilegedPermission("registerImsProvisioningChangedCallback");
3159 final long identity = Binder.clearCallingIdentity();
3160 try {
3161 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003162 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003163 .addProvisioningCallbackForSubscription(callback, subId);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003164 } finally {
3165 Binder.restoreCallingIdentity(identity);
3166 }
3167 }
3168
3169 @Override
3170 public void unregisterImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3171 enforceReadPrivilegedPermission("unregisterImsProvisioningChangedCallback");
3172 final long identity = Binder.clearCallingIdentity();
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003173 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3174 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3175 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003176 try {
3177 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003178 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003179 .removeProvisioningCallbackForSubscription(callback, subId);
3180 } catch (IllegalArgumentException e) {
3181 Log.i(LOG_TAG, "unregisterImsProvisioningChangedCallback: " + subId
3182 + "is inactive, ignoring unregister.");
3183 // If the subscription is no longer active, just return, since the callback will already
3184 // have been removed internally.
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003185 } finally {
3186 Binder.restoreCallingIdentity(identity);
3187 }
3188 }
3189
3190 @Override
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003191 public void setImsProvisioningStatusForCapability(int subId, int capability, int tech,
3192 boolean isProvisioned) {
3193 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3194 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3195 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3196 }
3197 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3198 "setProvisioningStatusForCapability");
3199 final long identity = Binder.clearCallingIdentity();
3200 try {
3201 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3202 Phone phone = getPhone(subId);
3203 if (phone == null) {
3204 loge("setImsProvisioningStatusForCapability: phone instance null for subid "
3205 + subId);
3206 return;
3207 }
3208 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3209 return;
3210 }
3211
3212 // this capability requires provisioning, route to the correct API.
3213 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3214 switch (capability) {
3215 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3216 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3217 ims.setVolteProvisioned(isProvisioned);
3218 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3219 ims.setWfcProvisioned(isProvisioned);
3220 }
3221 break;
3222 }
3223 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3224 // There is currently no difference in VT provisioning type.
3225 ims.setVtProvisioned(isProvisioned);
3226 break;
3227 }
3228 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3229 // There is no "deprecated" UT provisioning mechanism through ImsConfig, so
3230 // change the capability of the feature instead if needed.
3231 if (isMmTelCapabilityProvisionedInCache(subId, capability, tech)
3232 == isProvisioned) {
3233 // No change in provisioning.
3234 return;
3235 }
3236 cacheMmTelCapabilityProvisioning(subId, capability, tech, isProvisioned);
3237 try {
3238 ims.changeMmTelCapability(capability, tech, isProvisioned);
3239 } catch (ImsException e) {
3240 loge("setImsProvisioningStatusForCapability: couldn't change UT capability"
3241 + ", Exception" + e.getMessage());
3242 }
3243 break;
3244 }
3245 default: {
3246 throw new IllegalArgumentException("Tried to set provisioning for capability '"
3247 + capability + "', which does not require provisioning.");
3248 }
3249 }
3250
3251 } finally {
3252 Binder.restoreCallingIdentity(identity);
3253 }
3254 }
3255
3256 @Override
3257 public boolean getImsProvisioningStatusForCapability(int subId, int capability, int tech) {
3258 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3259 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3260 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3261 }
3262 enforceReadPrivilegedPermission("getProvisioningStatusForCapability");
3263 final long identity = Binder.clearCallingIdentity();
3264 try {
3265 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3266 Phone phone = getPhone(subId);
3267 if (phone == null) {
3268 loge("getImsProvisioningStatusForCapability: phone instance null for subid "
3269 + subId);
3270 // We will fail with "true" as the provisioning status because this is the default
3271 // if we do not require provisioning.
3272 return true;
3273 }
3274
3275 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3276 return true;
3277 }
3278
3279 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3280 switch (capability) {
3281 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3282 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3283 return ims.isVolteProvisionedOnDevice();
3284 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3285 return ims.isWfcProvisionedOnDevice();
3286 }
3287 // This should never happen, since we are checking tech above to make sure it
3288 // is either LTE or IWLAN.
3289 throw new IllegalArgumentException("Invalid radio technology for voice "
3290 + "capability.");
3291 }
3292 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3293 // There is currently no difference in VT provisioning type.
3294 return ims.isVtProvisionedOnDevice();
3295 }
3296 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3297 // There is no "deprecated" UT provisioning mechanism, so get from shared prefs.
3298 return isMmTelCapabilityProvisionedInCache(subId, capability, tech);
3299 }
3300 default: {
3301 throw new IllegalArgumentException("Tried to get provisioning for capability '"
3302 + capability + "', which does not require provisioning.");
3303 }
3304 }
3305
3306 } finally {
3307 Binder.restoreCallingIdentity(identity);
3308 }
3309 }
3310
3311 @Override
3312 public boolean isMmTelCapabilityProvisionedInCache(int subId, int capability, int tech) {
3313 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3314 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3315 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3316 }
3317 enforceReadPrivilegedPermission("isMmTelCapabilityProvisionedInCache");
3318 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3319 return (provisionedBits & capability) > 0;
3320 }
3321
3322 @Override
3323 public void cacheMmTelCapabilityProvisioning(int subId, int capability, int tech,
3324 boolean isProvisioned) {
3325 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3326 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3327 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3328 }
3329 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3330 "setProvisioningStatusForCapability");
3331 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3332 // If the current provisioning status for capability already matches isProvisioned,
3333 // do nothing.
3334 if (((provisionedBits & capability) > 0) == isProvisioned) {
3335 return;
3336 }
3337 if (isProvisioned) {
3338 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits | capability));
3339 } else {
3340 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits & ~capability));
3341 }
3342 }
3343
3344 /**
3345 * @return the bitfield containing the MmTel provisioning for the provided subscription and
3346 * technology. The bitfield should mirror the bitfield defined by
3347 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}.
3348 */
3349 private int getMmTelCapabilityProvisioningBitfield(int subId, int tech) {
3350 String key = getMmTelProvisioningKey(subId, tech);
3351 // Default is no capabilities are provisioned.
3352 return mTelephonySharedPreferences.getInt(key, 0 /*default*/);
3353 }
3354
3355 /**
3356 * Sets the MmTel capability provisioning bitfield (defined by
3357 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}) for the subscription and
3358 * technology specified.
3359 *
3360 * Note: This is a synchronous command and should not be called on UI thread.
3361 */
3362 private void setMmTelCapabilityProvisioningBitfield(int subId, int tech, int newField) {
3363 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
3364 String key = getMmTelProvisioningKey(subId, tech);
3365 editor.putInt(key, newField);
3366 editor.commit();
3367 }
3368
3369 private static String getMmTelProvisioningKey(int subId, int tech) {
3370 // resulting key is provision_ims_mmtel_{subId}_{tech}
3371 return PREF_PROVISION_IMS_MMTEL_PREFIX + subId + "_" + tech;
3372 }
3373
3374 /**
3375 * Query CarrierConfig to see if the specified capability requires provisioning for the
3376 * carrier associated with the subscription id.
3377 */
3378 private boolean doesImsCapabilityRequireProvisioning(Context context, int subId,
3379 int capability) {
3380 CarrierConfigManager configManager = new CarrierConfigManager(context);
3381 PersistableBundle c = configManager.getConfigForSubId(subId);
3382 boolean requireUtProvisioning = c.getBoolean(
3383 // By default, this config is true (even if there is no SIM). We also check to make
3384 // sure the subscription needs provisioning here, so we do not need to check for
3385 // the no-SIM case, where we would normally shortcut this to false.
3386 CarrierConfigManager.KEY_CARRIER_SUPPORTS_SS_OVER_UT_BOOL, true)
3387 && c.getBoolean(CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL,
3388 false);
3389 boolean requireVoiceVtProvisioning = c.getBoolean(
3390 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, false);
3391
3392 // First check to make sure that the capability requires provisioning.
3393 switch (capability) {
3394 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE:
3395 // intentional fallthrough
3396 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3397 if (requireVoiceVtProvisioning) {
3398 // Voice and Video requires provisioning
3399 return true;
3400 }
3401 break;
3402 }
3403 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3404 if (requireUtProvisioning) {
3405 // UT requires provisioning
3406 return true;
3407 }
3408 break;
3409 }
3410 }
3411 return false;
3412 }
3413
3414 @Override
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003415 public int getImsProvisioningInt(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003416 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3417 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3418 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003419 enforceReadPrivilegedPermission("getImsProvisioningInt");
3420 final long identity = Binder.clearCallingIdentity();
3421 try {
3422 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003423 int slotId = getSlotIndex(subId);
3424 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3425 Log.w(LOG_TAG, "getImsProvisioningInt: called with an inactive subscription '"
3426 + subId + "' for key:" + key);
3427 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
3428 }
3429 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigInt(key);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003430 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003431 Log.w(LOG_TAG, "getImsProvisioningInt: ImsService is not available for subscription '"
3432 + subId + "' for key:" + key);
3433 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003434 } finally {
3435 Binder.restoreCallingIdentity(identity);
3436 }
3437 }
3438
3439 @Override
3440 public String getImsProvisioningString(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003441 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3442 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3443 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003444 enforceReadPrivilegedPermission("getImsProvisioningString");
3445 final long identity = Binder.clearCallingIdentity();
3446 try {
3447 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003448 int slotId = getSlotIndex(subId);
3449 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3450 Log.w(LOG_TAG, "getImsProvisioningString: called for an inactive subscription id '"
3451 + subId + "' for key:" + key);
3452 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_GENERIC;
3453 }
3454 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigString(key);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003455 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003456 Log.w(LOG_TAG, "getImsProvisioningString: ImsService is not available for sub '"
3457 + subId + "' for key:" + key);
3458 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_NOT_READY;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003459 } finally {
3460 Binder.restoreCallingIdentity(identity);
3461 }
3462 }
3463
3464 @Override
3465 public int setImsProvisioningInt(int subId, int key, int value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003466 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3467 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3468 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003469 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3470 "setImsProvisioningInt");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003471 final long identity = Binder.clearCallingIdentity();
3472 try {
3473 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003474 int slotId = getSlotIndex(subId);
3475 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3476 Log.w(LOG_TAG, "setImsProvisioningInt: called with an inactive subscription id '"
3477 + subId + "' for key:" + key);
3478 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3479 }
3480 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003481 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003482 Log.w(LOG_TAG, "setImsProvisioningInt: ImsService unavailable for sub '" + subId
3483 + "' for key:" + key);
3484 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003485 } finally {
3486 Binder.restoreCallingIdentity(identity);
3487 }
3488 }
3489
3490 @Override
3491 public int setImsProvisioningString(int subId, int key, String value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003492 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3493 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3494 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003495 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3496 "setImsProvisioningString");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003497 final long identity = Binder.clearCallingIdentity();
3498 try {
3499 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003500 int slotId = getSlotIndex(subId);
3501 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3502 Log.w(LOG_TAG, "setImsProvisioningString: called with an inactive subscription id '"
3503 + subId + "' for key:" + key);
3504 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3505 }
3506 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003507 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003508 Log.w(LOG_TAG, "setImsProvisioningString: ImsService unavailable for sub '" + subId
3509 + "' for key:" + key);
3510 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003511 } finally {
3512 Binder.restoreCallingIdentity(identity);
3513 }
3514 }
3515
Brad Ebinger35c841c2018-10-01 10:40:55 -07003516 private int getSlotIndexOrException(int subId) throws IllegalArgumentException {
3517 int slotId = SubscriptionManager.getSlotIndex(subId);
3518 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
Brad Ebinger6b5ac222019-02-04 14:36:52 -08003519 throw new IllegalArgumentException("Invalid Subscription Id, subId=" + subId);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003520 }
3521 return slotId;
3522 }
3523
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003524 private int getSlotIndex(int subId) {
3525 int slotId = SubscriptionManager.getSlotIndex(subId);
3526 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
3527 return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
3528 }
3529 return slotId;
3530 }
3531
Wink Saville36469e72014-06-11 15:17:00 -07003532 /**
3533 * Returns the network type for a subId
3534 */
3535 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003536 public int getNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003537 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003538 mApp, subId, callingPackage, "getNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003539 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3540 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003541
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003542 final long identity = Binder.clearCallingIdentity();
3543 try {
3544 final Phone phone = getPhone(subId);
3545 if (phone != null) {
3546 return phone.getServiceState().getDataNetworkType();
3547 } else {
3548 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3549 }
3550 } finally {
3551 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003552 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003553 }
3554
3555 /**
3556 * Returns the data network type
3557 */
3558 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003559 public int getDataNetworkType(String callingPackage) {
3560 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003561 }
3562
3563 /**
3564 * Returns the data network type for a subId
3565 */
3566 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003567 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003568 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003569 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003570 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3571 }
3572
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003573 final long identity = Binder.clearCallingIdentity();
3574 try {
3575 final Phone phone = getPhone(subId);
3576 if (phone != null) {
3577 return phone.getServiceState().getDataNetworkType();
3578 } else {
3579 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3580 }
3581 } finally {
3582 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003583 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003584 }
3585
3586 /**
Wink Saville36469e72014-06-11 15:17:00 -07003587 * Returns the Voice network type for a subId
3588 */
3589 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003590 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003591 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003592 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003593 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3594 }
3595
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003596 final long identity = Binder.clearCallingIdentity();
3597 try {
3598 final Phone phone = getPhone(subId);
3599 if (phone != null) {
3600 return phone.getServiceState().getVoiceNetworkType();
3601 } else {
3602 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3603 }
3604 } finally {
3605 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003606 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003607 }
3608
3609 /**
3610 * @return true if a ICC card is present
3611 */
3612 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07003613 // FIXME Make changes to pass defaultSimId of type int
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003614 return hasIccCardUsingSlotIndex(mSubscriptionController.getSlotIndex(
3615 getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07003616 }
3617
3618 /**
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003619 * @return true if a ICC card is present for a slotIndex
Wink Saville36469e72014-06-11 15:17:00 -07003620 */
Sanket Padawe356d7632015-06-22 14:03:32 -07003621 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003622 public boolean hasIccCardUsingSlotIndex(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003623 final long identity = Binder.clearCallingIdentity();
3624 try {
3625 final Phone phone = PhoneFactory.getPhone(slotIndex);
3626 if (phone != null) {
3627 return phone.getIccCard().hasIccCard();
3628 } else {
3629 return false;
3630 }
3631 } finally {
3632 Binder.restoreCallingIdentity(identity);
Amit Mahajana6fc2a82015-01-06 11:53:51 -08003633 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003634 }
3635
3636 /**
3637 * Return if the current radio is LTE on CDMA. This
3638 * is a tri-state return value as for a period of time
3639 * the mode may be unknown.
3640 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003641 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003642 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08003643 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003644 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003645 @Override
3646 public int getLteOnCdmaMode(String callingPackage) {
3647 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003648 }
3649
Sanket Padawe356d7632015-06-22 14:03:32 -07003650 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003651 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003652 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003653 mApp, subId, callingPackage, "getLteOnCdmaModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003654 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3655 }
3656
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003657 final long identity = Binder.clearCallingIdentity();
3658 try {
3659 final Phone phone = getPhone(subId);
3660 if (phone == null) {
3661 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3662 } else {
3663 return phone.getLteOnCdmaMode();
3664 }
3665 } finally {
3666 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003667 }
Wink Saville36469e72014-06-11 15:17:00 -07003668 }
3669
Wink Saville36469e72014-06-11 15:17:00 -07003670 /**
3671 * {@hide}
3672 * Returns Default subId, 0 in the case of single standby.
3673 */
Wink Savilleb564aae2014-10-23 10:18:09 -07003674 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003675 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07003676 }
3677
Shishir Agrawala9f32182016-04-12 12:00:16 -07003678 private int getSlotForDefaultSubscription() {
3679 return mSubscriptionController.getPhoneId(getDefaultSubscription());
3680 }
3681
Wink Savilleb564aae2014-10-23 10:18:09 -07003682 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003683 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003684 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003685
Pengquan Menge92a50d2018-09-21 15:54:48 -07003686 private boolean isActiveSubscription(int subId) {
3687 return mSubscriptionController.isActiveSubId(subId);
3688 }
3689
Ihab Awadf2177b72013-11-25 13:33:23 -08003690 /**
3691 * @see android.telephony.TelephonyManager.WifiCallingChoices
3692 */
3693 public int getWhenToMakeWifiCalls() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003694 final long identity = Binder.clearCallingIdentity();
3695 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003696 return Settings.System.getInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003697 Settings.System.WHEN_TO_MAKE_WIFI_CALLS,
3698 getWhenToMakeWifiCallsDefaultPreference());
3699 } finally {
3700 Binder.restoreCallingIdentity(identity);
3701 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003702 }
3703
3704 /**
3705 * @see android.telephony.TelephonyManager.WifiCallingChoices
3706 */
3707 public void setWhenToMakeWifiCalls(int preference) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003708 final long identity = Binder.clearCallingIdentity();
3709 try {
3710 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003711 Settings.System.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003712 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
3713 } finally {
3714 Binder.restoreCallingIdentity(identity);
3715 }
Ihab Awadf9e92732013-12-05 18:02:52 -08003716 }
3717
Sailesh Nepald1e68152013-12-12 19:08:02 -08003718 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07003719 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08003720 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08003721 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08003722
Jordan Liu4c733742019-02-28 12:03:40 -08003723 private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
3724 int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
3725 if (phoneId == -1) {
3726 throw new IllegalArgumentException("Given slot index: " + slotIndex
3727 + " does not correspond to an active phone");
3728 }
3729 return PhoneFactory.getPhone(phoneId);
3730 }
3731
Shishir Agrawal566b7612013-10-28 14:41:00 -07003732 @Override
Derek Tan740e1672017-06-27 14:56:27 -07003733 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(
3734 int subId, String callingPackage, String aid, int p2) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003735 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3736 mApp, subId, "iccOpenLogicalChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003737 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003738 if (DBG) {
3739 log("iccOpenLogicalChannel: subId=" + subId + " aid=" + aid + " p2=" + p2);
3740 }
3741 return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
3742 p2);
3743 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003744
Jordan Liu4c733742019-02-28 12:03:40 -08003745
3746 @Override
3747 public IccOpenLogicalChannelResponse iccOpenLogicalChannelBySlot(
3748 int slotIndex, String callingPackage, String aid, int p2) {
3749 enforceModifyPermission();
3750 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3751 if (DBG) {
3752 log("iccOpenLogicalChannelBySlot: slot=" + slotIndex + " aid=" + aid + " p2=" + p2);
3753 }
3754 return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3755 callingPackage, aid, p2);
3756 }
3757
3758 private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
3759 String callingPackage, String aid, int p2) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003760 final long identity = Binder.clearCallingIdentity();
3761 try {
3762 if (TextUtils.equals(ISDR_AID, aid)) {
3763 // Only allows LPA to open logical channel to ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003764 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3765 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003766 if (bestComponent == null
3767 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3768 loge("The calling package is not allowed to access ISD-R.");
3769 throw new SecurityException(
3770 "The calling package is not allowed to access ISD-R.");
3771 }
Derek Tan740e1672017-06-27 14:56:27 -07003772 }
Derek Tan740e1672017-06-27 14:56:27 -07003773
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003774 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse) sendRequest(
Jordan Liu4c733742019-02-28 12:03:40 -08003775 CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
3776 null /* workSource */);
3777 if (DBG) log("iccOpenLogicalChannelWithPermission: " + response);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003778 return response;
3779 } finally {
3780 Binder.restoreCallingIdentity(identity);
3781 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003782 }
3783
3784 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003785 public boolean iccCloseLogicalChannel(int subId, int channel) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003786 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3787 mApp, subId, "iccCloseLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003788 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
3789 return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
3790 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003791
Jordan Liu4c733742019-02-28 12:03:40 -08003792 @Override
3793 public boolean iccCloseLogicalChannelBySlot(int slotIndex, int channel) {
3794 enforceModifyPermission();
3795 if (DBG) log("iccCloseLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel);
3796 return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3797 channel);
3798 }
3799
3800 private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003801 final long identity = Binder.clearCallingIdentity();
3802 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003803 if (channel < 0) {
3804 return false;
3805 }
Jordan Liu4c733742019-02-28 12:03:40 -08003806 Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
3807 null /* workSource */);
3808 if (DBG) log("iccCloseLogicalChannelWithPermission: " + success);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003809 return success;
3810 } finally {
3811 Binder.restoreCallingIdentity(identity);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003812 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003813 }
3814
3815 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003816 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07003817 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003818 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3819 mApp, subId, "iccTransmitApduLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003820 if (DBG) {
3821 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel
3822 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3823 + p3 + " data=" + data);
3824 }
3825 return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
3826 command, p1, p2, p3, data);
3827 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003828
Jordan Liu4c733742019-02-28 12:03:40 -08003829 @Override
3830 public String iccTransmitApduLogicalChannelBySlot(int slotIndex, int channel, int cla,
3831 int command, int p1, int p2, int p3, String data) {
3832 enforceModifyPermission();
3833 if (DBG) {
3834 log("iccTransmitApduLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel
3835 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3836 + p3 + " data=" + data);
3837 }
3838 return iccTransmitApduLogicalChannelWithPermission(
3839 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
3840 data);
3841 }
3842
3843 private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
3844 int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003845 final long identity = Binder.clearCallingIdentity();
3846 try {
Hall Liu4fd771b2019-05-02 09:16:29 -07003847 if (channel <= 0) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003848 return "";
3849 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003850
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003851 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003852 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
3853 null /* workSource */);
3854 if (DBG) log("iccTransmitApduLogicalChannelWithPermission: " + response);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003855
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003856 // Append the returned status code to the end of the response payload.
3857 String s = Integer.toHexString(
3858 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3859 if (response.payload != null) {
3860 s = IccUtils.bytesToHexString(response.payload) + s;
3861 }
3862 return s;
3863 } finally {
3864 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003865 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003866 }
Jake Hambye994d462014-02-03 13:10:13 -08003867
Evan Charltonc66da362014-05-16 14:06:40 -07003868 @Override
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003869 public String iccTransmitApduBasicChannel(int subId, String callingPackage, int cla,
3870 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003871 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3872 mApp, subId, "iccTransmitApduBasicChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003873 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003874 if (DBG) {
3875 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd="
3876 + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
3877 }
3878 return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
3879 cla, command, p1, p2, p3, data);
3880 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003881
Jordan Liu4c733742019-02-28 12:03:40 -08003882 @Override
3883 public String iccTransmitApduBasicChannelBySlot(int slotIndex, String callingPackage, int cla,
3884 int command, int p1, int p2, int p3, String data) {
3885 enforceModifyPermission();
3886 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3887 if (DBG) {
3888 log("iccTransmitApduBasicChannelBySlot: slotIndex=" + slotIndex + " cla=" + cla
3889 + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3
3890 + " data=" + data);
3891 }
3892
3893 return iccTransmitApduBasicChannelWithPermission(
3894 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
3895 p2, p3, data);
3896 }
3897
3898 // open APDU basic channel assuming the caller has sufficient permissions
3899 private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
3900 int cla, int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003901 final long identity = Binder.clearCallingIdentity();
3902 try {
3903 if (command == SELECT_COMMAND && p1 == SELECT_P1 && p2 == SELECT_P2 && p3 == SELECT_P3
3904 && TextUtils.equals(ISDR_AID, data)) {
3905 // Only allows LPA to select ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003906 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3907 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003908 if (bestComponent == null
3909 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3910 loge("The calling package is not allowed to select ISD-R.");
3911 throw new SecurityException(
3912 "The calling package is not allowed to select ISD-R.");
3913 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003914 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003915
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003916 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003917 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
3918 null /* workSource */);
3919 if (DBG) log("iccTransmitApduBasicChannelWithPermission: " + response);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003920
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003921 // Append the returned status code to the end of the response payload.
3922 String s = Integer.toHexString(
3923 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3924 if (response.payload != null) {
3925 s = IccUtils.bytesToHexString(response.payload) + s;
3926 }
3927 return s;
3928 } finally {
3929 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003930 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003931 }
3932
3933 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003934 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003935 String filePath) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003936 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3937 mApp, subId, "iccExchangeSimIO");
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003938
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003939 final long identity = Binder.clearCallingIdentity();
3940 try {
3941 if (DBG) {
3942 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " "
3943 + p1 + " " + p2 + " " + p3 + ":" + filePath);
3944 }
3945
3946 IccIoResult response =
3947 (IccIoResult) sendRequest(CMD_EXCHANGE_SIM_IO,
3948 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
3949 subId);
3950
3951 if (DBG) {
3952 log("Exchange SIM_IO [R]" + response);
3953 }
3954
3955 byte[] result = null;
3956 int length = 2;
3957 if (response.payload != null) {
3958 length = 2 + response.payload.length;
3959 result = new byte[length];
3960 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
3961 } else {
3962 result = new byte[length];
3963 }
3964
3965 result[length - 1] = (byte) response.sw2;
3966 result[length - 2] = (byte) response.sw1;
3967 return result;
3968 } finally {
3969 Binder.restoreCallingIdentity(identity);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003970 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003971 }
3972
Nathan Haroldb3014052017-01-25 15:57:32 -08003973 /**
3974 * Get the forbidden PLMN List from the given app type (ex APPTYPE_USIM)
3975 * on a particular subscription
3976 */
sqianb6e41952018-03-12 14:54:01 -07003977 public String[] getForbiddenPlmns(int subId, int appType, String callingPackage) {
3978 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3979 mApp, subId, callingPackage, "getForbiddenPlmns")) {
3980 return null;
3981 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003982
3983 final long identity = Binder.clearCallingIdentity();
3984 try {
3985 if (appType != TelephonyManager.APPTYPE_USIM
3986 && appType != TelephonyManager.APPTYPE_SIM) {
3987 loge("getForbiddenPlmnList(): App Type must be USIM or SIM");
3988 return null;
3989 }
3990 Object response = sendRequest(
3991 CMD_GET_FORBIDDEN_PLMNS, new Integer(appType), subId);
3992 if (response instanceof String[]) {
3993 return (String[]) response;
3994 }
3995 // Response is an Exception of some kind,
3996 // which is signalled to the user as a NULL retval
Nathan Haroldb3014052017-01-25 15:57:32 -08003997 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003998 } finally {
3999 Binder.restoreCallingIdentity(identity);
Nathan Haroldb3014052017-01-25 15:57:32 -08004000 }
Nathan Haroldb3014052017-01-25 15:57:32 -08004001 }
4002
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004003 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004004 public String sendEnvelopeWithStatus(int subId, String content) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004005 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4006 mApp, subId, "sendEnvelopeWithStatus");
Evan Charltonc66da362014-05-16 14:06:40 -07004007
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004008 final long identity = Binder.clearCallingIdentity();
4009 try {
4010 IccIoResult response = (IccIoResult) sendRequest(CMD_SEND_ENVELOPE, content, subId);
4011 if (response.payload == null) {
4012 return "";
4013 }
Evan Charltonc66da362014-05-16 14:06:40 -07004014
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004015 // Append the returned status code to the end of the response payload.
4016 String s = Integer.toHexString(
4017 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4018 s = IccUtils.bytesToHexString(response.payload) + s;
4019 return s;
4020 } finally {
4021 Binder.restoreCallingIdentity(identity);
4022 }
Evan Charltonc66da362014-05-16 14:06:40 -07004023 }
4024
Jake Hambye994d462014-02-03 13:10:13 -08004025 /**
4026 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4027 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4028 *
4029 * @param itemID the ID of the item to read
4030 * @return the NV item as a String, or null on error.
4031 */
4032 @Override
4033 public String nvReadItem(int itemID) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004034 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004035 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4036 mApp, getDefaultSubscription(), "nvReadItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004037
4038 final long identity = Binder.clearCallingIdentity();
4039 try {
4040 if (DBG) log("nvReadItem: item " + itemID);
vagdeviaf9a5b92018-08-15 16:01:53 -07004041 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004042 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
4043 return value;
4044 } finally {
4045 Binder.restoreCallingIdentity(identity);
4046 }
Jake Hambye994d462014-02-03 13:10:13 -08004047 }
4048
4049 /**
4050 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4051 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4052 *
4053 * @param itemID the ID of the item to read
4054 * @param itemValue the value to write, as a String
4055 * @return true on success; false on any failure
4056 */
4057 @Override
4058 public boolean nvWriteItem(int itemID, String itemValue) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004059 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004060 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4061 mApp, getDefaultSubscription(), "nvWriteItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004062
4063 final long identity = Binder.clearCallingIdentity();
4064 try {
4065 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
4066 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
vagdeviaf9a5b92018-08-15 16:01:53 -07004067 new Pair<Integer, String>(itemID, itemValue), workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004068 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
4069 return success;
4070 } finally {
4071 Binder.restoreCallingIdentity(identity);
4072 }
Jake Hambye994d462014-02-03 13:10:13 -08004073 }
4074
4075 /**
4076 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
4077 * Used for device configuration by some CDMA operators.
4078 *
4079 * @param preferredRoamingList byte array containing the new PRL
4080 * @return true on success; false on any failure
4081 */
4082 @Override
4083 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004084 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4085 mApp, getDefaultSubscription(), "nvWriteCdmaPrl");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004086
4087 final long identity = Binder.clearCallingIdentity();
4088 try {
4089 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
4090 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
4091 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
4092 return success;
4093 } finally {
4094 Binder.restoreCallingIdentity(identity);
4095 }
Jake Hambye994d462014-02-03 13:10:13 -08004096 }
4097
4098 /**
chen xu6dac5ab2018-10-26 17:39:23 -07004099 * Rollback modem configurations to factory default except some config which are in whitelist.
Jake Hambye994d462014-02-03 13:10:13 -08004100 * Used for device configuration by some CDMA operators.
4101 *
chen xu6dac5ab2018-10-26 17:39:23 -07004102 * @param slotIndex - device slot.
4103 *
Jake Hambye994d462014-02-03 13:10:13 -08004104 * @return true on success; false on any failure
4105 */
4106 @Override
chen xu6dac5ab2018-10-26 17:39:23 -07004107 public boolean resetModemConfig(int slotIndex) {
4108 Phone phone = PhoneFactory.getPhone(slotIndex);
4109 if (phone != null) {
4110 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4111 mApp, phone.getSubId(), "resetModemConfig");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004112
chen xu6dac5ab2018-10-26 17:39:23 -07004113 final long identity = Binder.clearCallingIdentity();
4114 try {
4115 Boolean success = (Boolean) sendRequest(CMD_RESET_MODEM_CONFIG, null);
4116 if (DBG) log("resetModemConfig:" + ' ' + (success ? "ok" : "fail"));
4117 return success;
4118 } finally {
4119 Binder.restoreCallingIdentity(identity);
4120 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004121 }
chen xu6dac5ab2018-10-26 17:39:23 -07004122 return false;
4123 }
4124
4125 /**
4126 * Generate a radio modem reset. Used for device configuration by some CDMA operators.
4127 *
4128 * @param slotIndex - device slot.
4129 *
4130 * @return true on success; false on any failure
4131 */
4132 @Override
4133 public boolean rebootModem(int slotIndex) {
4134 Phone phone = PhoneFactory.getPhone(slotIndex);
4135 if (phone != null) {
4136 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4137 mApp, phone.getSubId(), "rebootModem");
4138
4139 final long identity = Binder.clearCallingIdentity();
4140 try {
4141 Boolean success = (Boolean) sendRequest(CMD_MODEM_REBOOT, null);
4142 if (DBG) log("rebootModem:" + ' ' + (success ? "ok" : "fail"));
4143 return success;
4144 } finally {
4145 Binder.restoreCallingIdentity(identity);
4146 }
4147 }
4148 return false;
Jake Hambye994d462014-02-03 13:10:13 -08004149 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004150
Svet Ganovb320e182015-04-16 12:30:10 -07004151 public String[] getPcscfAddress(String apnType, String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004152 final Phone defaultPhone = getDefaultPhone();
Jeff Davidson7e17e312018-02-13 18:17:36 -08004153 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004154 mApp, defaultPhone.getSubId(), callingPackage, "getPcscfAddress")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004155 return new String[0];
4156 }
4157
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004158 final long identity = Binder.clearCallingIdentity();
4159 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004160 return defaultPhone.getPcscfAddress(apnType);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004161 } finally {
4162 Binder.restoreCallingIdentity(identity);
4163 }
Wink Saville36469e72014-06-11 15:17:00 -07004164 }
4165
Brad Ebinger51f743a2017-01-23 13:50:20 -08004166 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004167 * Enables IMS for the framework. This will trigger IMS registration and ImsFeature capability
4168 * status updates, if not already enabled.
Brad Ebinger51f743a2017-01-23 13:50:20 -08004169 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004170 public void enableIms(int slotId) {
Brad Ebinger51f743a2017-01-23 13:50:20 -08004171 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004172
4173 final long identity = Binder.clearCallingIdentity();
4174 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004175 ImsResolver resolver = PhoneFactory.getImsResolver();
4176 if (resolver == null) {
4177 // may happen if the device does not support IMS.
4178 return;
4179 }
4180 resolver.enableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004181 } finally {
4182 Binder.restoreCallingIdentity(identity);
4183 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004184 }
4185
4186 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004187 * Disables IMS for the framework. This will trigger IMS de-registration and trigger ImsFeature
4188 * status updates to disabled.
Brad Ebinger34bef922017-11-09 10:27:08 -08004189 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004190 public void disableIms(int slotId) {
4191 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004192
4193 final long identity = Binder.clearCallingIdentity();
4194 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004195 ImsResolver resolver = PhoneFactory.getImsResolver();
4196 if (resolver == null) {
4197 // may happen if the device does not support IMS.
4198 return;
4199 }
4200 resolver.disableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004201 } finally {
4202 Binder.restoreCallingIdentity(identity);
4203 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004204 }
4205
4206 /**
4207 * Returns the {@link IImsMmTelFeature} that corresponds to the given slot Id for the MMTel
4208 * feature or {@link null} if the service is not available. If the feature is available, the
4209 * {@link IImsServiceFeatureCallback} callback is registered as a listener for feature updates.
4210 */
4211 public IImsMmTelFeature getMmTelFeatureAndListen(int slotId,
Brad Ebinger34bef922017-11-09 10:27:08 -08004212 IImsServiceFeatureCallback callback) {
4213 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004214
4215 final long identity = Binder.clearCallingIdentity();
4216 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004217 ImsResolver resolver = PhoneFactory.getImsResolver();
4218 if (resolver == null) {
4219 // may happen if the device does not support IMS.
4220 return null;
4221 }
4222 return resolver.getMmTelFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004223 } finally {
4224 Binder.restoreCallingIdentity(identity);
4225 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004226 }
4227
4228 /**
4229 * Returns the {@link IImsRcsFeature} that corresponds to the given slot Id for the RCS
4230 * feature during emergency calling or {@link null} if the service is not available. If the
4231 * feature is available, the {@link IImsServiceFeatureCallback} callback is registered as a
4232 * listener for feature updates.
4233 */
4234 public IImsRcsFeature getRcsFeatureAndListen(int slotId, IImsServiceFeatureCallback callback) {
4235 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004236
4237 final long identity = Binder.clearCallingIdentity();
4238 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004239 ImsResolver resolver = PhoneFactory.getImsResolver();
4240 if (resolver == null) {
4241 // may happen if the device does not support IMS.
4242 return null;
4243 }
4244 return resolver.getRcsFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004245 } finally {
4246 Binder.restoreCallingIdentity(identity);
4247 }
Brad Ebinger51f743a2017-01-23 13:50:20 -08004248 }
4249
Brad Ebinger5f64b052017-12-14 14:26:15 -08004250 /**
4251 * Returns the {@link IImsRegistration} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004252 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger5f64b052017-12-14 14:26:15 -08004253 */
4254 public IImsRegistration getImsRegistration(int slotId, int feature) throws RemoteException {
4255 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004256
4257 final long identity = Binder.clearCallingIdentity();
4258 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004259 ImsResolver resolver = PhoneFactory.getImsResolver();
4260 if (resolver == null) {
4261 // may happen if the device does not support IMS.
4262 return null;
4263 }
4264 return resolver.getImsRegistration(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004265 } finally {
4266 Binder.restoreCallingIdentity(identity);
4267 }
Brad Ebinger5f64b052017-12-14 14:26:15 -08004268 }
4269
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004270 /**
4271 * Returns the {@link IImsConfig} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004272 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004273 */
4274 public IImsConfig getImsConfig(int slotId, int feature) throws RemoteException {
4275 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004276
4277 final long identity = Binder.clearCallingIdentity();
4278 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004279 ImsResolver resolver = PhoneFactory.getImsResolver();
4280 if (resolver == null) {
4281 // may happen if the device does not support IMS.
4282 return null;
4283 }
4284 return resolver.getImsConfig(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004285 } finally {
4286 Binder.restoreCallingIdentity(identity);
4287 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004288 }
4289
Brad Ebinger884c07b2018-02-15 16:17:40 -08004290 /**
Brad Ebingerdac2f002018-04-03 15:17:52 -07004291 * Sets the ImsService Package Name that Telephony will bind to.
4292 *
4293 * @param slotId the slot ID that the ImsService should bind for.
4294 * @param isCarrierImsService true if the ImsService is the carrier override, false if the
4295 * ImsService is the device default ImsService.
4296 * @param packageName The package name of the application that contains the ImsService to bind
4297 * to.
4298 * @return true if setting the ImsService to bind to succeeded, false if it did not.
4299 * @hide
4300 */
4301 public boolean setImsService(int slotId, boolean isCarrierImsService, String packageName) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004302 int[] subIds = SubscriptionManager.getSubId(slotId);
4303 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4304 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4305 "setImsService");
4306
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004307 final long identity = Binder.clearCallingIdentity();
4308 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004309 ImsResolver resolver = PhoneFactory.getImsResolver();
4310 if (resolver == null) {
4311 // may happen if the device does not support IMS.
4312 return false;
4313 }
4314 return resolver.overrideImsServiceConfiguration(slotId, isCarrierImsService,
4315 packageName);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004316 } finally {
4317 Binder.restoreCallingIdentity(identity);
4318 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004319 }
4320
4321 /**
4322 * Return the ImsService configuration.
4323 *
4324 * @param slotId The slot that the ImsService is associated with.
4325 * @param isCarrierImsService true, if the ImsService is a carrier override, false if it is
4326 * the device default.
4327 * @return the package name of the ImsService configuration.
4328 */
4329 public String getImsService(int slotId, boolean isCarrierImsService) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004330 int[] subIds = SubscriptionManager.getSubId(slotId);
4331 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4332 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4333 "getImsService");
4334
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004335 final long identity = Binder.clearCallingIdentity();
4336 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004337 ImsResolver resolver = PhoneFactory.getImsResolver();
4338 if (resolver == null) {
4339 // may happen if the device does not support IMS.
4340 return "";
4341 }
4342 return resolver.getImsServiceConfiguration(slotId, isCarrierImsService);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004343 } finally {
4344 Binder.restoreCallingIdentity(identity);
4345 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004346 }
4347
Wink Saville36469e72014-06-11 15:17:00 -07004348 public void setImsRegistrationState(boolean registered) {
4349 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004350
4351 final long identity = Binder.clearCallingIdentity();
4352 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004353 getDefaultPhone().setImsRegistrationState(registered);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004354 } finally {
4355 Binder.restoreCallingIdentity(identity);
4356 }
Wink Saville36469e72014-06-11 15:17:00 -07004357 }
4358
4359 /**
Stuart Scott54788802015-03-30 13:18:01 -07004360 * Set the network selection mode to automatic.
4361 *
4362 */
4363 @Override
4364 public void setNetworkSelectionModeAutomatic(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004365 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4366 mApp, subId, "setNetworkSelectionModeAutomatic");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004367
Pengquan Menge92a50d2018-09-21 15:54:48 -07004368 if (!isActiveSubscription(subId)) {
4369 return;
4370 }
4371
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004372 final long identity = Binder.clearCallingIdentity();
4373 try {
4374 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
4375 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
4376 } finally {
4377 Binder.restoreCallingIdentity(identity);
4378 }
Stuart Scott54788802015-03-30 13:18:01 -07004379 }
4380
Pengquan Mengea84e042018-09-20 14:57:26 -07004381 /**
4382 * Ask the radio to connect to the input network and change selection mode to manual.
4383 *
4384 * @param subId the id of the subscription.
4385 * @param operatorInfo the operator information, included the PLMN, long name and short name of
4386 * the operator to attach to.
4387 * @param persistSelection whether the selection will persist until reboot. If true, only allows
4388 * attaching to the selected PLMN until reboot; otherwise, attach to the chosen PLMN and resume
4389 * normal network selection next time.
4390 * @return {@code true} on success; {@code true} on any failure.
Shishir Agrawal302c8692015-06-19 13:49:39 -07004391 */
4392 @Override
Pengquan Mengea84e042018-09-20 14:57:26 -07004393 public boolean setNetworkSelectionModeManual(
4394 int subId, OperatorInfo operatorInfo, boolean persistSelection) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004395 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4396 mApp, subId, "setNetworkSelectionModeManual");
Pengquan Menge92a50d2018-09-21 15:54:48 -07004397
4398 if (!isActiveSubscription(subId)) {
4399 return false;
4400 }
4401
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004402 final long identity = Binder.clearCallingIdentity();
4403 try {
Pengquan Mengea84e042018-09-20 14:57:26 -07004404 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operatorInfo,
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004405 persistSelection);
Pengquan Mengea84e042018-09-20 14:57:26 -07004406 if (DBG) {
4407 log("setNetworkSelectionModeManual: subId: " + subId
4408 + " operator: " + operatorInfo);
4409 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004410 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
4411 } finally {
4412 Binder.restoreCallingIdentity(identity);
4413 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004414 }
4415
4416 /**
4417 * Scans for available networks.
4418 */
4419 @Override
Hall Liuf19c44f2018-11-27 14:38:17 -08004420 public CellNetworkScanResult getCellNetworkScanResults(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004421 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4422 mApp, subId, "getCellNetworkScanResults");
Hall Liuf19c44f2018-11-27 14:38:17 -08004423 LocationAccessPolicy.LocationPermissionResult locationResult =
4424 LocationAccessPolicy.checkLocationPermission(mApp,
4425 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4426 .setCallingPackage(callingPackage)
4427 .setCallingPid(Binder.getCallingPid())
4428 .setCallingUid(Binder.getCallingUid())
4429 .setMethod("getCellNetworkScanResults")
4430 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4431 .build());
4432 switch (locationResult) {
4433 case DENIED_HARD:
4434 throw new SecurityException("Not allowed to access scan results -- location");
4435 case DENIED_SOFT:
4436 return null;
4437 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004438
Pengquan Menga1bb6272018-09-06 09:59:22 -07004439 long identity = Binder.clearCallingIdentity();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004440 try {
4441 if (DBG) log("getCellNetworkScanResults: subId " + subId);
Pengquan Menga1bb6272018-09-06 09:59:22 -07004442 return (CellNetworkScanResult) sendRequest(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004443 CMD_PERFORM_NETWORK_SCAN, null, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004444 } finally {
4445 Binder.restoreCallingIdentity(identity);
4446 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004447 }
4448
4449 /**
yinxub1bed742017-04-17 11:45:04 -07004450 * Starts a new network scan and returns the id of this scan.
yinxu504e1392017-04-12 16:03:22 -07004451 *
yinxub1bed742017-04-17 11:45:04 -07004452 * @param subId id of the subscription
4453 * @param request contains the radio access networks with bands/channels to scan
4454 * @param messenger callback messenger for scan results or errors
4455 * @param binder for the purpose of auto clean when the user thread crashes
yinxu504e1392017-04-12 16:03:22 -07004456 * @return the id of the requested scan which can be used to stop the scan.
4457 */
4458 @Override
4459 public int requestNetworkScan(int subId, NetworkScanRequest request, Messenger messenger,
Hall Liuf19c44f2018-11-27 14:38:17 -08004460 IBinder binder, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004461 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4462 mApp, subId, "requestNetworkScan");
Hall Liuf19c44f2018-11-27 14:38:17 -08004463 LocationAccessPolicy.LocationPermissionResult locationResult =
4464 LocationAccessPolicy.checkLocationPermission(mApp,
4465 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4466 .setCallingPackage(callingPackage)
4467 .setCallingPid(Binder.getCallingPid())
4468 .setCallingUid(Binder.getCallingUid())
4469 .setMethod("requestNetworkScan")
4470 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4471 .build());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004472 if (locationResult != LocationAccessPolicy.LocationPermissionResult.ALLOWED) {
4473 SecurityException e = checkNetworkRequestForSanitizedLocationAccess(request);
4474 if (e != null) {
4475 if (locationResult == LocationAccessPolicy.LocationPermissionResult.DENIED_HARD) {
4476 throw e;
4477 } else {
Hall Liu0e5abaf2019-04-04 01:25:30 -07004478 loge(e.getMessage());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004479 return TelephonyScanManager.INVALID_SCAN_ID;
4480 }
4481 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004482 }
Hall Liu912dfd32019-04-25 14:02:26 -07004483 int callingUid = Binder.getCallingUid();
4484 int callingPid = Binder.getCallingPid();
Ying Xu94a46582019-04-18 17:14:56 -07004485 final long identity = Binder.clearCallingIdentity();
4486 try {
4487 return mNetworkScanRequestTracker.startNetworkScan(
4488 request, messenger, binder, getPhone(subId),
Hall Liu912dfd32019-04-25 14:02:26 -07004489 callingUid, callingPid, callingPackage);
Ying Xu94a46582019-04-18 17:14:56 -07004490 } finally {
4491 Binder.restoreCallingIdentity(identity);
4492 }
yinxu504e1392017-04-12 16:03:22 -07004493 }
4494
Hall Liub2ac8ef2019-02-28 15:56:23 -08004495 private SecurityException checkNetworkRequestForSanitizedLocationAccess(
4496 NetworkScanRequest request) {
4497 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.NETWORK_SCAN)
4498 != PERMISSION_GRANTED) {
4499 return new SecurityException("permission.NETWORK_SCAN is needed for network scans"
4500 + " without location access.");
4501 }
4502
4503 if (request.getSpecifiers() != null && request.getSpecifiers().length > 0) {
4504 for (RadioAccessSpecifier ras : request.getSpecifiers()) {
Hall Liub2ac8ef2019-02-28 15:56:23 -08004505 if (ras.getChannels() != null && ras.getChannels().length > 0) {
4506 return new SecurityException("Specific channels must not be"
4507 + " scanned without location access.");
4508 }
4509 }
4510 }
4511
Hall Liub2ac8ef2019-02-28 15:56:23 -08004512 return null;
4513 }
4514
yinxu504e1392017-04-12 16:03:22 -07004515 /**
4516 * Stops an existing network scan with the given scanId.
yinxub1bed742017-04-17 11:45:04 -07004517 *
4518 * @param subId id of the subscription
4519 * @param scanId id of the scan that needs to be stopped
yinxu504e1392017-04-12 16:03:22 -07004520 */
4521 @Override
4522 public void stopNetworkScan(int subId, int scanId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004523 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4524 mApp, subId, "stopNetworkScan");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004525
Hall Liu912dfd32019-04-25 14:02:26 -07004526 int callingUid = Binder.getCallingUid();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004527 final long identity = Binder.clearCallingIdentity();
4528 try {
Hall Liu912dfd32019-04-25 14:02:26 -07004529 mNetworkScanRequestTracker.stopNetworkScan(scanId, callingUid);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004530 } finally {
4531 Binder.restoreCallingIdentity(identity);
4532 }
yinxu504e1392017-04-12 16:03:22 -07004533 }
4534
4535 /**
Junda Liu84d15a22014-07-02 11:21:04 -07004536 * Get the calculated preferred network type.
4537 * Used for debugging incorrect network type.
4538 *
4539 * @return the preferred network type, defined in RILConstants.java.
4540 */
4541 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004542 public int getCalculatedPreferredNetworkType(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004543 final Phone defaultPhone = getDefaultPhone();
4544 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
4545 callingPackage, "getCalculatedPreferredNetworkType")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004546 return RILConstants.PREFERRED_NETWORK_MODE;
4547 }
4548
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004549 final long identity = Binder.clearCallingIdentity();
4550 try {
4551 // FIXME: need to get SubId from somewhere.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004552 return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004553 } finally {
4554 Binder.restoreCallingIdentity(identity);
4555 }
Junda Liu84d15a22014-07-02 11:21:04 -07004556 }
4557
4558 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08004559 * Get the preferred network type.
4560 * Used for device configuration by some CDMA operators.
4561 *
4562 * @return the preferred network type, defined in RILConstants.java.
4563 */
4564 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004565 public int getPreferredNetworkType(int subId) {
Pengquan Menga4009cb2018-12-20 11:00:24 -08004566 TelephonyPermissions
4567 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
4568 mApp, subId, "getPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004569
4570 final long identity = Binder.clearCallingIdentity();
4571 try {
4572 if (DBG) log("getPreferredNetworkType");
4573 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
4574 int networkType = (result != null ? result[0] : -1);
4575 if (DBG) log("getPreferredNetworkType: " + networkType);
4576 return networkType;
4577 } finally {
4578 Binder.restoreCallingIdentity(identity);
4579 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004580 }
4581
4582 /**
4583 * Set the preferred network type.
4584 * Used for device configuration by some CDMA operators.
4585 *
4586 * @param networkType the preferred network type, defined in RILConstants.java.
4587 * @return true on success; false on any failure.
4588 */
4589 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004590 public boolean setPreferredNetworkType(int subId, int networkType) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004591 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4592 mApp, subId, "setPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004593
4594 final long identity = Binder.clearCallingIdentity();
4595 try {
4596 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
4597 Boolean success = (Boolean) sendRequest(
4598 CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
4599 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
4600 if (success) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004601 Settings.Global.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004602 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
4603 }
4604 return success;
4605 } finally {
4606 Binder.restoreCallingIdentity(identity);
Junda Liu80bc0d12014-07-14 16:36:44 -07004607 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004608 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004609
4610 /**
Miaoa84611c2019-03-15 09:21:10 +08004611 * Check whether DUN APN is required for tethering with subId.
Junda Liu475951f2014-11-07 16:45:03 -08004612 *
Miaoa84611c2019-03-15 09:21:10 +08004613 * @param subId the id of the subscription to require tethering.
Amit Mahajanfe58cdf2017-07-11 12:01:53 -07004614 * @return {@code true} if DUN APN is required for tethering.
Junda Liu475951f2014-11-07 16:45:03 -08004615 * @hide
4616 */
4617 @Override
Miaoa84611c2019-03-15 09:21:10 +08004618 public boolean getTetherApnRequiredForSubscriber(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004619 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004620 final long identity = Binder.clearCallingIdentity();
Miaoa84611c2019-03-15 09:21:10 +08004621 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004622 try {
Miaoa84611c2019-03-15 09:21:10 +08004623 if (phone != null) {
4624 return phone.hasMatchedTetherApnSetting();
4625 } else {
4626 return false;
4627 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004628 } finally {
4629 Binder.restoreCallingIdentity(identity);
Junda Liu475951f2014-11-07 16:45:03 -08004630 }
Junda Liu475951f2014-11-07 16:45:03 -08004631 }
4632
4633 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07004634 * Set mobile data enabled
4635 * Used by the user through settings etc to turn on/off mobile data
4636 *
4637 * @param enable {@code true} turn turn data on, else {@code false}
4638 */
4639 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004640 public void setUserDataEnabled(int subId, boolean enable) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004641 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4642 mApp, subId, "setUserDataEnabled");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004643
4644 final long identity = Binder.clearCallingIdentity();
4645 try {
4646 int phoneId = mSubscriptionController.getPhoneId(subId);
4647 if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4648 Phone phone = PhoneFactory.getPhone(phoneId);
4649 if (phone != null) {
4650 if (DBG) log("setUserDataEnabled: subId=" + subId + " enable=" + enable);
Jack Yud79fba22018-12-13 11:51:28 -08004651 phone.getDataEnabledSettings().setUserDataEnabled(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004652 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004653 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004654 }
4655 } finally {
4656 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004657 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004658 }
4659
4660 /**
Malcolm Chen964682d2017-11-28 16:20:07 -08004661 * Get the user enabled state of Mobile Data.
4662 *
4663 * TODO: remove and use isUserDataEnabled.
4664 * This can't be removed now because some vendor codes
4665 * calls through ITelephony directly while they should
4666 * use TelephonyManager.
4667 *
4668 * @return true on enabled
4669 */
4670 @Override
4671 public boolean getDataEnabled(int subId) {
4672 return isUserDataEnabled(subId);
4673 }
4674
4675 /**
4676 * Get whether mobile data is enabled per user setting.
4677 *
4678 * There are other factors deciding whether mobile data is actually enabled, but they are
4679 * not considered here. See {@link #isDataEnabled(int)} for more details.
Robert Greenwalt646120a2014-05-23 11:54:03 -07004680 *
Jeff Davidsona1920712016-11-18 17:05:56 -08004681 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
Robert Greenwalted86e582014-05-21 20:03:20 -07004682 *
4683 * @return {@code true} if data is enabled else {@code false}
4684 */
4685 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004686 public boolean isUserDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07004687 try {
4688 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4689 null);
4690 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004691 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4692 mApp, subId, "isUserDataEnabled");
Robert Greenwalt646120a2014-05-23 11:54:03 -07004693 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004694
4695 final long identity = Binder.clearCallingIdentity();
4696 try {
4697 int phoneId = mSubscriptionController.getPhoneId(subId);
4698 if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4699 Phone phone = PhoneFactory.getPhone(phoneId);
4700 if (phone != null) {
4701 boolean retVal = phone.isUserDataEnabled();
4702 if (DBG) log("isUserDataEnabled: subId=" + subId + " retVal=" + retVal);
4703 return retVal;
4704 } else {
4705 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
4706 return false;
4707 }
4708 } finally {
4709 Binder.restoreCallingIdentity(identity);
Malcolm Chen964682d2017-11-28 16:20:07 -08004710 }
4711 }
4712
4713 /**
4714 * Get whether mobile data is enabled.
4715 *
4716 * Comparable to {@link #isUserDataEnabled(int)}, this considers all factors deciding
4717 * whether mobile data is actually enabled.
4718 *
4719 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
4720 *
4721 * @return {@code true} if data is enabled else {@code false}
4722 */
4723 @Override
4724 public boolean isDataEnabled(int subId) {
4725 try {
4726 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4727 null);
4728 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004729 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4730 mApp, subId, "isDataEnabled");
Malcolm Chen964682d2017-11-28 16:20:07 -08004731 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004732
4733 final long identity = Binder.clearCallingIdentity();
4734 try {
4735 int phoneId = mSubscriptionController.getPhoneId(subId);
4736 if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4737 Phone phone = PhoneFactory.getPhone(phoneId);
4738 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08004739 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004740 if (DBG) log("isDataEnabled: subId=" + subId + " retVal=" + retVal);
4741 return retVal;
4742 } else {
4743 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
4744 return false;
4745 }
4746 } finally {
4747 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004748 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004749 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004750
4751 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004752 public int getCarrierPrivilegeStatus(int subId) {
4753 final Phone phone = getPhone(subId);
4754 if (phone == null) {
4755 loge("getCarrierPrivilegeStatus: Invalid subId");
4756 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4757 }
4758 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004759 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08004760 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004761 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4762 }
4763 return card.getCarrierPrivilegeStatusForCurrentTransaction(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004764 phone.getContext().getPackageManager());
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004765 }
Junda Liu29340342014-07-10 15:23:27 -07004766
4767 @Override
Jeff Davidson7e17e312018-02-13 18:17:36 -08004768 public int getCarrierPrivilegeStatusForUid(int subId, int uid) {
4769 final Phone phone = getPhone(subId);
4770 if (phone == null) {
4771 loge("getCarrierPrivilegeStatus: Invalid subId");
4772 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4773 }
4774 UiccProfile profile =
4775 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
4776 if (profile == null) {
4777 loge("getCarrierPrivilegeStatus: No UICC");
4778 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4779 }
4780 return profile.getCarrierPrivilegeStatusForUid(phone.getContext().getPackageManager(), uid);
4781 }
4782
4783 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07004784 public int checkCarrierPrivilegesForPackage(int subId, String pkgName) {
4785 if (TextUtils.isEmpty(pkgName)) {
Junda Liu317d70b2016-03-08 09:33:53 -08004786 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
chen xuf7e9fe82019-05-09 19:31:02 -07004787 }
4788
4789 int phoneId = SubscriptionManager.getPhoneId(subId);
4790 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004791 if (card == null) {
chen xuf7e9fe82019-05-09 19:31:02 -07004792 loge("checkCarrierPrivilegesForPackage: No UICC on subId " + subId);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004793 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4794 }
chen xuf7e9fe82019-05-09 19:31:02 -07004795
4796 return card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004797 }
4798
4799 @Override
4800 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08004801 if (TextUtils.isEmpty(pkgName))
4802 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07004803 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4804 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4805 UiccCard card = UiccController.getInstance().getUiccCard(i);
4806 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07004807 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07004808 continue;
4809 }
4810
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004811 result = card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004812 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
4813 break;
4814 }
4815 }
4816
4817 return result;
Junda Liu29340342014-07-10 15:23:27 -07004818 }
Derek Tan89e89d42014-07-08 17:00:10 -07004819
4820 @Override
Junda Liue64de782015-04-16 17:19:16 -07004821 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
4822 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
4823 loge("phoneId " + phoneId + " is not valid.");
4824 return null;
4825 }
4826 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004827 if (card == null) {
Diego Pontorieroaf74c862014-08-28 11:51:16 -07004828 loge("getCarrierPackageNamesForIntent: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004829 return null ;
4830 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004831 return card.getCarrierPackageNamesForIntent(mApp.getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004832 }
4833
Amith Yamasani6e118872016-02-19 12:53:51 -08004834 @Override
chen xuf7e9fe82019-05-09 19:31:02 -07004835 public List<String> getPackagesWithCarrierPrivileges(int phoneId) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004836 PackageManager pm = mApp.getPackageManager();
Amith Yamasani6e118872016-02-19 12:53:51 -08004837 List<String> privilegedPackages = new ArrayList<>();
4838 List<PackageInfo> packages = null;
chen xuf7e9fe82019-05-09 19:31:02 -07004839 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
4840 // has UICC in that slot.
4841 if (card != null) {
Amith Yamasani6e118872016-02-19 12:53:51 -08004842 if (card.hasCarrierPrivilegeRules()) {
4843 if (packages == null) {
4844 // Only check packages in user 0 for now
4845 packages = pm.getInstalledPackagesAsUser(
4846 PackageManager.MATCH_DISABLED_COMPONENTS
chen xuf7e9fe82019-05-09 19:31:02 -07004847 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
4848 | PackageManager.GET_SIGNATURES, UserHandle.USER_SYSTEM);
Amith Yamasani6e118872016-02-19 12:53:51 -08004849 }
4850 for (int p = packages.size() - 1; p >= 0; p--) {
4851 PackageInfo pkgInfo = packages.get(p);
4852 if (pkgInfo != null && pkgInfo.packageName != null
4853 && card.getCarrierPrivilegeStatus(pkgInfo)
chen xuf7e9fe82019-05-09 19:31:02 -07004854 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Amith Yamasani6e118872016-02-19 12:53:51 -08004855 privilegedPackages.add(pkgInfo.packageName);
4856 }
4857 }
4858 }
4859 }
4860 return privilegedPackages;
4861 }
4862
chen xuf7e9fe82019-05-09 19:31:02 -07004863 @Override
4864 public List<String> getPackagesWithCarrierPrivilegesForAllPhones() {
4865 List<String> privilegedPackages = new ArrayList<>();
4866 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4867 privilegedPackages.addAll(getPackagesWithCarrierPrivileges(i));
4868 }
4869 return privilegedPackages;
4870 }
4871
Wink Savilleb564aae2014-10-23 10:18:09 -07004872 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07004873 final Phone phone = getPhone(subId);
4874 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07004875 if (card == null) {
4876 loge("getIccId: No UICC");
4877 return null;
4878 }
4879 String iccId = card.getIccId();
4880 if (TextUtils.isEmpty(iccId)) {
4881 loge("getIccId: ICC ID is null or empty.");
4882 return null;
4883 }
4884 return iccId;
4885 }
4886
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004887 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08004888 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
4889 String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004890 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
4891 subId, "setLine1NumberForDisplayForSubscriber");
Derek Tan97ebb422014-09-05 16:55:38 -07004892
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004893 final long identity = Binder.clearCallingIdentity();
4894 try {
4895 final String iccId = getIccId(subId);
4896 final Phone phone = getPhone(subId);
4897 if (phone == null) {
4898 return false;
4899 }
4900 final String subscriberId = phone.getSubscriberId();
4901
4902 if (DBG_MERGE) {
4903 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
4904 + subscriberId + " to " + number);
4905 }
4906
4907 if (TextUtils.isEmpty(iccId)) {
4908 return false;
4909 }
4910
4911 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
4912
4913 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
4914 if (alphaTag == null) {
4915 editor.remove(alphaTagPrefKey);
4916 } else {
4917 editor.putString(alphaTagPrefKey, alphaTag);
4918 }
4919
4920 // Record both the line number and IMSI for this ICCID, since we need to
4921 // track all merged IMSIs based on line number
4922 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4923 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
4924 if (number == null) {
4925 editor.remove(numberPrefKey);
4926 editor.remove(subscriberPrefKey);
4927 } else {
4928 editor.putString(numberPrefKey, number);
4929 editor.putString(subscriberPrefKey, subscriberId);
4930 }
4931
4932 editor.commit();
4933 return true;
4934 } finally {
4935 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07004936 }
Derek Tan7226c842014-07-02 17:42:23 -07004937 }
4938
4939 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004940 public String getLine1NumberForDisplay(int subId, String callingPackage) {
Makoto Onukifee69342015-06-29 14:44:50 -07004941 // This is open to apps with WRITE_SMS.
Jeff Davidson7e17e312018-02-13 18:17:36 -08004942 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
Jeff Davidson913390f2018-02-23 17:11:49 -08004943 mApp, subId, callingPackage, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08004944 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07004945 return null;
4946 }
Derek Tan97ebb422014-09-05 16:55:38 -07004947
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004948 final long identity = Binder.clearCallingIdentity();
4949 try {
4950 String iccId = getIccId(subId);
4951 if (iccId != null) {
4952 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4953 if (DBG_MERGE) {
4954 log("getLine1NumberForDisplay returning "
4955 + mTelephonySharedPreferences.getString(numberPrefKey, null));
4956 }
4957 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Amit Mahajan9cf11512015-11-09 11:40:48 -08004958 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004959 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
4960 return null;
4961 } finally {
4962 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07004963 }
Derek Tan7226c842014-07-02 17:42:23 -07004964 }
4965
4966 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004967 public String getLine1AlphaTagForDisplay(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004968 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08004969 mApp, subId, callingPackage, "getLine1AlphaTagForDisplay")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004970 return null;
4971 }
Derek Tan97ebb422014-09-05 16:55:38 -07004972
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004973 final long identity = Binder.clearCallingIdentity();
4974 try {
4975 String iccId = getIccId(subId);
4976 if (iccId != null) {
4977 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
4978 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
4979 }
4980 return null;
4981 } finally {
4982 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07004983 }
Derek Tan7226c842014-07-02 17:42:23 -07004984 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07004985
4986 @Override
Jordan Liub49b04b2019-05-06 14:45:15 -07004987 public String[] getMergedSubscriberIds(int subId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08004988 // This API isn't public, so no need to provide a valid subscription ID - we're not worried
4989 // about carrier-privileged callers not having access.
Jeff Davidson7e17e312018-02-13 18:17:36 -08004990 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08004991 mApp, SubscriptionManager.INVALID_SUBSCRIPTION_ID, callingPackage,
4992 "getMergedSubscriberIds")) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07004993 return null;
4994 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08004995
Jordan Liub49b04b2019-05-06 14:45:15 -07004996 // Clear calling identity, when calling TelephonyManager, because callerUid must be
4997 // the process, where TelephonyManager was instantiated.
4998 // Otherwise AppOps check will fail.
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07004999 final long identity = Binder.clearCallingIdentity();
5000 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005001 final Context context = mApp;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005002 final TelephonyManager tele = TelephonyManager.from(context);
5003 final SubscriptionManager sub = SubscriptionManager.from(context);
5004
5005 // Figure out what subscribers are currently active
5006 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005007
Jordan Liub49b04b2019-05-06 14:45:15 -07005008 // Only consider subs which match the current subId
5009 // This logic can be simplified. See b/131189269 for progress.
5010 if (isActiveSubscription(subId)) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005011 activeSubscriberIds.add(tele.getSubscriberId(subId));
5012 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005013
5014 // First pass, find a number override for an active subscriber
5015 String mergeNumber = null;
5016 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
5017 for (String key : prefs.keySet()) {
5018 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
5019 final String subscriberId = (String) prefs.get(key);
5020 if (activeSubscriberIds.contains(subscriberId)) {
5021 final String iccId = key.substring(
5022 PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
5023 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5024 mergeNumber = (String) prefs.get(numberKey);
5025 if (DBG_MERGE) {
5026 Slog.d(LOG_TAG, "Found line number " + mergeNumber
5027 + " for active subscriber " + subscriberId);
5028 }
5029 if (!TextUtils.isEmpty(mergeNumber)) {
5030 break;
5031 }
5032 }
5033 }
5034 }
5035
5036 // Shortcut when no active merged subscribers
5037 if (TextUtils.isEmpty(mergeNumber)) {
5038 return null;
5039 }
5040
5041 // Second pass, find all subscribers under that line override
5042 final ArraySet<String> result = new ArraySet<>();
5043 for (String key : prefs.keySet()) {
5044 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
5045 final String number = (String) prefs.get(key);
5046 if (mergeNumber.equals(number)) {
5047 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
5048 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
5049 final String subscriberId = (String) prefs.get(subscriberKey);
5050 if (!TextUtils.isEmpty(subscriberId)) {
5051 result.add(subscriberId);
5052 }
5053 }
5054 }
5055 }
5056
5057 final String[] resultArray = result.toArray(new String[result.size()]);
5058 Arrays.sort(resultArray);
5059 if (DBG_MERGE) {
5060 Slog.d(LOG_TAG,
5061 "Found subscribers " + Arrays.toString(resultArray) + " after merge");
5062 }
5063 return resultArray;
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005064 } finally {
5065 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08005066 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005067 }
5068
5069 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005070 public boolean setOperatorBrandOverride(int subId, String brand) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005071 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
5072 subId, "setOperatorBrandOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005073
5074 final long identity = Binder.clearCallingIdentity();
5075 try {
5076 final Phone phone = getPhone(subId);
5077 return phone == null ? false : phone.setOperatorBrandOverride(brand);
5078 } finally {
5079 Binder.restoreCallingIdentity(identity);
5080 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005081 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05005082
5083 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005084 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005085 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
5086 List<String> cdmaNonRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005087 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setRoamingOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005088
5089 final long identity = Binder.clearCallingIdentity();
5090 try {
5091 final Phone phone = getPhone(subId);
5092 if (phone == null) {
5093 return false;
5094 }
5095 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
5096 cdmaNonRoamingList);
5097 } finally {
5098 Binder.restoreCallingIdentity(identity);
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005099 }
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005100 }
5101
5102 @Override
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005103 @Deprecated
5104 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
5105 enforceModifyPermission();
5106
5107 int returnValue = 0;
5108 try {
vagdeviaf9a5b92018-08-15 16:01:53 -07005109 AsyncResult result = (AsyncResult) sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005110 if(result.exception == null) {
5111 if (result.result != null) {
5112 byte[] responseData = (byte[])(result.result);
5113 if(responseData.length > oemResp.length) {
5114 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
5115 responseData.length + "bytes. Buffer Size is " +
5116 oemResp.length + "bytes.");
5117 }
5118 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
5119 returnValue = responseData.length;
5120 }
5121 } else {
5122 CommandException ex = (CommandException) result.exception;
5123 returnValue = ex.getCommandError().ordinal();
5124 if(returnValue > 0) returnValue *= -1;
5125 }
5126 } catch (RuntimeException e) {
5127 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
5128 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
5129 if(returnValue > 0) returnValue *= -1;
5130 }
5131
5132 return returnValue;
5133 }
5134
5135 @Override
Wink Saville5d475dd2014-10-17 15:00:58 -07005136 public void setRadioCapability(RadioAccessFamily[] rafs) {
5137 try {
5138 ProxyController.getInstance().setRadioCapability(rafs);
5139 } catch (RuntimeException e) {
5140 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
5141 }
5142 }
5143
5144 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07005145 public int getRadioAccessFamily(int phoneId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005146 Phone phone = PhoneFactory.getPhone(phoneId);
chen xub97461a2018-10-26 14:17:57 -07005147 int raf = RadioAccessFamily.RAF_UNKNOWN;
Jeff Davidson913390f2018-02-23 17:11:49 -08005148 if (phone == null) {
chen xub97461a2018-10-26 14:17:57 -07005149 return raf;
Jeff Davidson913390f2018-02-23 17:11:49 -08005150 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005151 final long identity = Binder.clearCallingIdentity();
5152 try {
chen xub97461a2018-10-26 14:17:57 -07005153 TelephonyPermissions
5154 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5155 mApp, phone.getSubId(), "getRadioAccessFamily");
5156 raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005157 } finally {
5158 Binder.restoreCallingIdentity(identity);
5159 }
chen xub97461a2018-10-26 14:17:57 -07005160 return raf;
Wink Saville5d475dd2014-10-17 15:00:58 -07005161 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005162
5163 @Override
5164 public void enableVideoCalling(boolean enable) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005165 final Phone defaultPhone = getDefaultPhone();
Andrew Leedf14ead2014-10-17 14:22:52 -07005166 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005167
5168 final long identity = Binder.clearCallingIdentity();
5169 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005170 ImsManager.getInstance(defaultPhone.getContext(),
5171 defaultPhone.getPhoneId()).setVtSetting(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005172 } finally {
5173 Binder.restoreCallingIdentity(identity);
5174 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005175 }
5176
5177 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005178 public boolean isVideoCallingEnabled(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005179 final Phone defaultPhone = getDefaultPhone();
Amit Mahajan578e53d2018-03-20 16:18:38 +00005180 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005181 mApp, defaultPhone.getSubId(), callingPackage, "isVideoCallingEnabled")) {
Amit Mahajan578e53d2018-03-20 16:18:38 +00005182 return false;
5183 }
Svet Ganovb320e182015-04-16 12:30:10 -07005184
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005185 final long identity = Binder.clearCallingIdentity();
5186 try {
5187 // Check the user preference and the system-level IMS setting. Even if the user has
5188 // enabled video calling, if IMS is disabled we aren't able to support video calling.
5189 // In the long run, we may instead need to check if there exists a connection service
5190 // which can support video calling.
5191 ImsManager imsManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005192 ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005193 return imsManager.isVtEnabledByPlatform()
5194 && imsManager.isEnhanced4gLteModeSettingEnabledByUser()
5195 && imsManager.isVtEnabledByUser();
5196 } finally {
5197 Binder.restoreCallingIdentity(identity);
5198 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005199 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06005200
Andrew Leea1239f22015-03-02 17:44:07 -08005201 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005202 public boolean canChangeDtmfToneLength(int subId, String callingPackage) {
5203 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5204 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5205 return false;
5206 }
5207
5208 final long identity = Binder.clearCallingIdentity();
5209 try {
5210 CarrierConfigManager configManager =
5211 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005212 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005213 .getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
5214 } finally {
5215 Binder.restoreCallingIdentity(identity);
5216 }
Andrew Leea1239f22015-03-02 17:44:07 -08005217 }
5218
5219 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005220 public boolean isWorldPhone(int subId, String callingPackage) {
5221 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5222 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5223 return false;
5224 }
5225
5226 final long identity = Binder.clearCallingIdentity();
5227 try {
5228 CarrierConfigManager configManager =
5229 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005230 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005231 .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
5232 } finally {
5233 Binder.restoreCallingIdentity(identity);
5234 }
Andrew Leea1239f22015-03-02 17:44:07 -08005235 }
5236
Andrew Lee9431b832015-03-09 18:46:45 -07005237 @Override
5238 public boolean isTtyModeSupported() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005239 TelecomManager telecomManager = TelecomManager.from(mApp);
Wooki Wu1f82f7a2016-02-15 15:59:58 +08005240 return telecomManager.isTtySupported();
Andrew Lee9431b832015-03-09 18:46:45 -07005241 }
5242
5243 @Override
5244 public boolean isHearingAidCompatibilitySupported() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005245 final long identity = Binder.clearCallingIdentity();
5246 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005247 return mApp.getResources().getBoolean(R.bool.hac_enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005248 } finally {
5249 Binder.restoreCallingIdentity(identity);
5250 }
Andrew Lee9431b832015-03-09 18:46:45 -07005251 }
5252
Hall Liuf6668912018-10-31 17:05:23 -07005253 /**
5254 * Determines whether the device currently supports RTT (Real-time text). Based both on carrier
5255 * support for the feature and device firmware support.
5256 *
5257 * @return {@code true} if the device and carrier both support RTT, {@code false} otherwise.
5258 */
5259 @Override
5260 public boolean isRttSupported(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005261 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005262 final Phone phone = getPhone(subscriptionId);
5263 if (phone == null) {
5264 loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
5265 return false;
5266 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005267 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005268 boolean isCarrierSupported = mApp.getCarrierConfigForSubId(subscriptionId).getBoolean(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005269 CarrierConfigManager.KEY_RTT_SUPPORTED_BOOL);
5270 boolean isDeviceSupported =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005271 phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005272 return isCarrierSupported && isDeviceSupported;
5273 } finally {
5274 Binder.restoreCallingIdentity(identity);
5275 }
Hall Liu98187582018-01-22 19:15:32 -08005276 }
5277
Hall Liuf6668912018-10-31 17:05:23 -07005278 /**
5279 * Determines whether the user has turned on RTT. Only returns true if the device and carrier
5280 * both also support RTT.
5281 */
5282 public boolean isRttEnabled(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005283 final long identity = Binder.clearCallingIdentity();
5284 try {
Hall Liuf6668912018-10-31 17:05:23 -07005285 return isRttSupported(subscriptionId) && Settings.Secure.getInt(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005286 mApp.getContentResolver(), Settings.Secure.RTT_CALLING_MODE, 0) != 0;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005287 } finally {
5288 Binder.restoreCallingIdentity(identity);
5289 }
Hall Liu3ad5f012018-04-06 16:23:39 -07005290 }
5291
Sanket Padawe7310cc72015-01-14 09:53:20 -08005292 /**
5293 * Returns the unique device ID of phone, for example, the IMEI for
5294 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
5295 *
5296 * <p>Requires Permission:
5297 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
5298 */
5299 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005300 public String getDeviceId(String callingPackage) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005301 final Phone phone = PhoneFactory.getPhone(0);
Jeff Davidson913390f2018-02-23 17:11:49 -08005302 if (phone == null) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005303 return null;
5304 }
Jeff Davidson913390f2018-02-23 17:11:49 -08005305 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07005306 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
5307 callingPackage, "getDeviceId")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005308 return null;
5309 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005310
5311 final long identity = Binder.clearCallingIdentity();
5312 try {
5313 return phone.getDeviceId();
5314 } finally {
5315 Binder.restoreCallingIdentity(identity);
5316 }
Sanket Padawe7310cc72015-01-14 09:53:20 -08005317 }
5318
Ping Sunc67b7c22016-03-02 19:16:45 +08005319 /**
5320 * {@hide}
5321 * Returns the IMS Registration Status on a particular subid
5322 *
5323 * @param subId
5324 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005325 public boolean isImsRegistered(int subId) {
Ping Sunc67b7c22016-03-02 19:16:45 +08005326 Phone phone = getPhone(subId);
5327 if (phone != null) {
5328 return phone.isImsRegistered();
5329 } else {
5330 return false;
5331 }
5332 }
5333
Santos Cordon7a1885b2015-02-03 11:15:19 -08005334 @Override
5335 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005336 final long identity = Binder.clearCallingIdentity();
5337 try {
5338 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
5339 } finally {
5340 Binder.restoreCallingIdentity(identity);
5341 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08005342 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07005343
Tyler Gunnf70ed162019-04-03 15:28:53 -07005344 @Override
5345 public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
5346 final long identity = Binder.clearCallingIdentity();
5347 try {
5348 Phone phone = getPhone(subscriptionId);
5349 if (phone == null) {
5350 return null;
5351 }
5352 return PhoneUtils.makePstnPhoneAccountHandle(phone);
5353 } finally {
5354 Binder.restoreCallingIdentity(identity);
5355 }
5356 }
5357
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005358 /**
5359 * @return the VoWiFi calling availability.
Nathan Haroldc55097a2015-03-11 18:14:50 -07005360 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005361 public boolean isWifiCallingAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005362 final long identity = Binder.clearCallingIdentity();
5363 try {
5364 Phone phone = getPhone(subId);
5365 if (phone != null) {
5366 return phone.isWifiCallingEnabled();
5367 } else {
5368 return false;
5369 }
5370 } finally {
5371 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005372 }
Nathan Haroldc55097a2015-03-11 18:14:50 -07005373 }
5374
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005375 /**
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005376 * @return the VT calling availability.
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005377 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005378 public boolean isVideoTelephonyAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005379 final long identity = Binder.clearCallingIdentity();
5380 try {
5381 Phone phone = getPhone(subId);
5382 if (phone != null) {
5383 return phone.isVideoEnabled();
5384 } else {
5385 return false;
5386 }
5387 } finally {
5388 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005389 }
5390 }
5391
5392 /**
5393 * @return the IMS registration technology for the MMTEL feature. Valid return values are
5394 * defined in {@link ImsRegistrationImplBase}.
5395 */
5396 public @ImsRegistrationImplBase.ImsRegistrationTech int getImsRegTechnologyForMmTel(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005397 final long identity = Binder.clearCallingIdentity();
5398 try {
5399 Phone phone = getPhone(subId);
5400 if (phone != null) {
5401 return phone.getImsRegistrationTech();
5402 } else {
5403 return ImsRegistrationImplBase.REGISTRATION_TECH_NONE;
5404 }
5405 } finally {
5406 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005407 }
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005408 }
5409
Stuart Scott8eef64f2015-04-08 15:13:54 -07005410 @Override
5411 public void factoryReset(int subId) {
5412 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07005413 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
5414 return;
5415 }
5416
Svet Ganovcc087f82015-05-12 20:35:54 -07005417 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005418
Svet Ganovcc087f82015-05-12 20:35:54 -07005419 try {
Stuart Scott981d8582015-04-21 14:09:50 -07005420 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
5421 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Pengquan Meng85728fb2018-03-12 16:31:21 -07005422 setUserDataEnabled(subId, getDefaultDataEnabled());
Svet Ganovcc087f82015-05-12 20:35:54 -07005423 setNetworkSelectionModeAutomatic(subId);
Pengquan Meng85728fb2018-03-12 16:31:21 -07005424 setPreferredNetworkType(subId, getDefaultNetworkType(subId));
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005425 setDataRoamingEnabled(subId, getDefaultDataRoamingEnabled(subId));
5426 CarrierInfoManager.deleteAllCarrierKeysForImsiEncryption(mApp);
Svet Ganovcc087f82015-05-12 20:35:54 -07005427 }
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005428 // There has been issues when Sms raw table somehow stores orphan
5429 // fragments. They lead to garbled message when new fragments come
5430 // in and combined with those stale ones. In case this happens again,
5431 // user can reset all network settings which will clean up this table.
5432 cleanUpSmsRawTable(getDefaultPhone().getContext());
Svet Ganovcc087f82015-05-12 20:35:54 -07005433 } finally {
5434 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07005435 }
5436 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005437
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005438 private void cleanUpSmsRawTable(Context context) {
5439 ContentResolver resolver = context.getContentResolver();
5440 Uri uri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw/permanentDelete");
5441 resolver.delete(uri, null, null);
5442 }
5443
Narayan Kamath1c496c22015-04-16 14:40:19 +01005444 @Override
chen xu5d3637b2019-01-21 23:31:38 -08005445 public String getSimLocaleForSubscriber(int subId) {
5446 enforceReadPrivilegedPermission("getSimLocaleForSubscriber, subId: " + subId);
5447 final Phone phone = getPhone(subId);
5448 if (phone == null) {
5449 log("getSimLocaleForSubscriber, invalid subId");
chen xu2bb91e42019-01-24 14:35:54 -08005450 return null;
chen xu5d3637b2019-01-21 23:31:38 -08005451 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005452 final long identity = Binder.clearCallingIdentity();
5453 try {
chen xu5d3637b2019-01-21 23:31:38 -08005454 final SubscriptionInfo info = mSubscriptionController.getActiveSubscriptionInfo(subId,
5455 phone.getContext().getOpPackageName());
chen xu6291c472019-02-04 12:55:53 -08005456 if (info == null) {
5457 log("getSimLocaleForSubscriber, inactive subId: " + subId);
5458 return null;
5459 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005460 // Try and fetch the locale from the carrier properties or from the SIM language
5461 // preferences (EF-PL and EF-LI)...
5462 final int mcc = info.getMcc();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005463 String simLanguage = null;
chen xu5d3637b2019-01-21 23:31:38 -08005464 final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
5465 if (localeFromDefaultSim != null) {
5466 if (!localeFromDefaultSim.getCountry().isEmpty()) {
5467 if (DBG) log("Using locale from subId: " + subId + " locale: "
5468 + localeFromDefaultSim);
5469 return localeFromDefaultSim.toLanguageTag();
5470 } else {
5471 simLanguage = localeFromDefaultSim.getLanguage();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005472 }
5473 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005474
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005475 // The SIM language preferences only store a language (e.g. fr = French), not an
5476 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
5477 // the SIM and carrier preferences does not include a country we add the country
5478 // determined from the SIM MCC to provide an exact locale.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005479 final Locale mccLocale = MccTable.getLocaleFromMcc(mApp, mcc, simLanguage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005480 if (mccLocale != null) {
chen xu5d3637b2019-01-21 23:31:38 -08005481 if (DBG) log("No locale from SIM, using mcc locale:" + mccLocale);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005482 return mccLocale.toLanguageTag();
5483 }
5484
5485 if (DBG) log("No locale found - returning null");
5486 return null;
5487 } finally {
5488 Binder.restoreCallingIdentity(identity);
5489 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005490 }
5491
5492 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005493 return mSubscriptionController.getAllSubInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005494 }
5495
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005496 /**
5497 * NOTE: this method assumes permission checks are done and caller identity has been cleared.
5498 */
5499 private List<SubscriptionInfo> getActiveSubscriptionInfoListPrivileged() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005500 return mSubscriptionController.getActiveSubscriptionInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005501 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005502
Chenjie Yu1ba97252018-01-11 18:16:20 -08005503 private final ModemActivityInfo mLastModemActivityInfo =
5504 new ModemActivityInfo(0, 0, 0, new int[0], 0, 0);
5505
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005506 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07005507 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
5508 * representing the state of the modem.
5509 *
Chenjie Yu1ba97252018-01-11 18:16:20 -08005510 * NOTE: The underlying implementation clears the modem state, so there should only ever be one
5511 * caller to it. Everyone should call this class to get cumulative data.
Adam Lesinski903a54c2016-04-11 14:49:52 -07005512 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005513 */
5514 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07005515 public void requestModemActivityInfo(ResultReceiver result) {
5516 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005517 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005518
5519 final long identity = Binder.clearCallingIdentity();
5520 try {
5521 ModemActivityInfo ret = null;
5522 synchronized (mLastModemActivityInfo) {
5523 ModemActivityInfo info = (ModemActivityInfo) sendRequest(
5524 CMD_GET_MODEM_ACTIVITY_INFO,
vagdeviaf9a5b92018-08-15 16:01:53 -07005525 null, workSource);
Siddharth Rayb8114062018-06-17 15:02:38 -07005526 if (isModemActivityInfoValid(info)) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005527 int[] mergedTxTimeMs = new int[ModemActivityInfo.TX_POWER_LEVELS];
5528 for (int i = 0; i < mergedTxTimeMs.length; i++) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005529 mergedTxTimeMs[i] = info.getTxTimeMillis()[i]
5530 + mLastModemActivityInfo.getTxTimeMillis()[i];
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005531 }
5532 mLastModemActivityInfo.setTimestamp(info.getTimestamp());
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005533 mLastModemActivityInfo.setSleepTimeMillis(info.getSleepTimeMillis()
5534 + mLastModemActivityInfo.getSleepTimeMillis());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005535 mLastModemActivityInfo.setIdleTimeMillis(
5536 info.getIdleTimeMillis() + mLastModemActivityInfo.getIdleTimeMillis());
5537 mLastModemActivityInfo.setTxTimeMillis(mergedTxTimeMs);
5538 mLastModemActivityInfo.setRxTimeMillis(
5539 info.getRxTimeMillis() + mLastModemActivityInfo.getRxTimeMillis());
5540 mLastModemActivityInfo.setEnergyUsed(
5541 info.getEnergyUsed() + mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005542 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005543 ret = new ModemActivityInfo(mLastModemActivityInfo.getTimestamp(),
5544 mLastModemActivityInfo.getSleepTimeMillis(),
5545 mLastModemActivityInfo.getIdleTimeMillis(),
5546 mLastModemActivityInfo.getTxTimeMillis(),
5547 mLastModemActivityInfo.getRxTimeMillis(),
5548 mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005549 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005550 Bundle bundle = new Bundle();
5551 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, ret);
5552 result.send(0, bundle);
5553 } finally {
5554 Binder.restoreCallingIdentity(identity);
Chenjie Yu1ba97252018-01-11 18:16:20 -08005555 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005556 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005557
Siddharth Rayb8114062018-06-17 15:02:38 -07005558 // Checks that ModemActivityInfo is valid. Sleep time, Idle time, Rx time and Tx time should be
5559 // less than total activity duration.
5560 private boolean isModemActivityInfoValid(ModemActivityInfo info) {
5561 if (info == null) {
5562 return false;
5563 }
5564 int activityDurationMs =
5565 (int) (info.getTimestamp() - mLastModemActivityInfo.getTimestamp());
5566 int totalTxTimeMs = 0;
5567 for (int i = 0; i < info.getTxTimeMillis().length; i++) {
5568 totalTxTimeMs += info.getTxTimeMillis()[i];
5569 }
5570 return (info.isValid()
5571 && (info.getSleepTimeMillis() <= activityDurationMs)
5572 && (info.getIdleTimeMillis() <= activityDurationMs)
5573 && (info.getRxTimeMillis() <= activityDurationMs)
5574 && (totalTxTimeMs <= activityDurationMs));
5575 }
5576
Jack Yu85bd38a2015-11-09 11:34:32 -08005577 /**
5578 * {@hide}
5579 * Returns the service state information on specified subscription.
5580 */
5581 @Override
5582 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005583 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005584 mApp, subId, callingPackage, "getServiceStateForSubscriber")) {
Jack Yu85bd38a2015-11-09 11:34:32 -08005585 return null;
5586 }
5587
Hall Liuf19c44f2018-11-27 14:38:17 -08005588 LocationAccessPolicy.LocationPermissionResult fineLocationResult =
5589 LocationAccessPolicy.checkLocationPermission(mApp,
5590 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5591 .setCallingPackage(callingPackage)
5592 .setCallingPid(Binder.getCallingPid())
5593 .setCallingUid(Binder.getCallingUid())
5594 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005595 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005596 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
5597 .build());
5598
5599 LocationAccessPolicy.LocationPermissionResult coarseLocationResult =
5600 LocationAccessPolicy.checkLocationPermission(mApp,
5601 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5602 .setCallingPackage(callingPackage)
5603 .setCallingPid(Binder.getCallingPid())
5604 .setCallingUid(Binder.getCallingUid())
5605 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005606 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005607 .setMinSdkVersionForCoarse(Build.VERSION_CODES.Q)
5608 .build());
5609 // We don't care about hard or soft here -- all we need to know is how much info to scrub.
5610 boolean hasFinePermission =
5611 fineLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5612 boolean hasCoarsePermission =
5613 coarseLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5614
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005615 final long identity = Binder.clearCallingIdentity();
5616 try {
5617 final Phone phone = getPhone(subId);
5618 if (phone == null) {
5619 return null;
5620 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005621
Hall Liuf19c44f2018-11-27 14:38:17 -08005622 ServiceState ss = phone.getServiceState();
5623
5624 // Scrub out the location info in ServiceState depending on what level of access
5625 // the caller has.
5626 if (hasFinePermission) return ss;
5627 if (hasCoarsePermission) return ss.sanitizeLocationInfo(false);
5628 return ss.sanitizeLocationInfo(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005629 } finally {
5630 Binder.restoreCallingIdentity(identity);
5631 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005632 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005633
5634 /**
5635 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
5636 *
5637 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5638 * voicemail ringtone.
5639 * @return The URI for the ringtone to play when receiving a voicemail from a specific
5640 * PhoneAccount.
5641 */
5642 @Override
5643 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005644 final long identity = Binder.clearCallingIdentity();
5645 try {
5646 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5647 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005648 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005649 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005650
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005651 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
5652 } finally {
5653 Binder.restoreCallingIdentity(identity);
5654 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005655 }
5656
5657 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005658 * Sets the per-account voicemail ringtone.
5659 *
5660 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5661 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5662 *
5663 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5664 * voicemail ringtone.
5665 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific
5666 * PhoneAccount.
5667 */
5668 @Override
5669 public void setVoicemailRingtoneUri(String callingPackage,
5670 PhoneAccountHandle phoneAccountHandle, Uri uri) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005671 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005672 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5673 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005674 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005675 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5676 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5677 "setVoicemailRingtoneUri");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005678 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005679
5680 final long identity = Binder.clearCallingIdentity();
5681 try {
5682 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5683 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005684 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005685 }
5686 VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
5687 } finally {
5688 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005689 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005690 }
5691
5692 /**
Nancy Chen31f9ba12016-01-06 11:42:12 -08005693 * Returns whether vibration is set for voicemail notification in Phone settings.
5694 *
5695 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5696 * voicemail vibration setting.
5697 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
5698 */
5699 @Override
5700 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005701 final long identity = Binder.clearCallingIdentity();
5702 try {
5703 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5704 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005705 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005706 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005707
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005708 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
5709 } finally {
5710 Binder.restoreCallingIdentity(identity);
5711 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005712 }
5713
Youhan Wange64578a2016-05-02 15:32:42 -07005714 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005715 * Sets the per-account voicemail vibration.
5716 *
5717 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5718 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5719 *
5720 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5721 * voicemail vibration setting.
5722 * @param enabled Whether to enable or disable vibration for voicemail notifications from a
5723 * specific PhoneAccount.
5724 */
5725 @Override
5726 public void setVoicemailVibrationEnabled(String callingPackage,
5727 PhoneAccountHandle phoneAccountHandle, boolean enabled) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005728 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005729 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5730 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005731 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005732 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5733 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5734 "setVoicemailVibrationEnabled");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005735 }
5736
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005737 final long identity = Binder.clearCallingIdentity();
5738 try {
5739 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5740 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005741 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005742 }
5743 VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
5744 } finally {
5745 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005746 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005747 }
5748
5749 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005750 * Make sure either called from same process as self (phone) or IPC caller has read privilege.
5751 *
5752 * @throws SecurityException if the caller does not have the required permission
5753 */
Brad Ebinger35c841c2018-10-01 10:40:55 -07005754 private void enforceReadPrivilegedPermission(String message) {
Youhan Wange64578a2016-05-02 15:32:42 -07005755 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
Brad Ebinger35c841c2018-10-01 10:40:55 -07005756 message);
Youhan Wange64578a2016-05-02 15:32:42 -07005757 }
5758
5759 /**
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005760 * Make sure either called from same process as self (phone) or IPC caller has send SMS
5761 * permission.
5762 *
5763 * @throws SecurityException if the caller does not have the required permission
5764 */
5765 private void enforceSendSmsPermission() {
5766 mApp.enforceCallingOrSelfPermission(permission.SEND_SMS, null);
5767 }
5768
5769 /**
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005770 * Make sure called from the package in charge of visual voicemail.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005771 *
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005772 * @throws SecurityException if the caller is not the visual voicemail package.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005773 */
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005774 private void enforceVisualVoicemailPackage(String callingPackage, int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005775 final long identity = Binder.clearCallingIdentity();
5776 try {
5777 ComponentName componentName =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005778 RemoteVvmTaskManager.getRemotePackage(mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005779 if (componentName == null) {
5780 throw new SecurityException(
5781 "Caller not current active visual voicemail package[null]");
5782 }
5783 String vvmPackage = componentName.getPackageName();
5784 if (!callingPackage.equals(vvmPackage)) {
5785 throw new SecurityException("Caller not current active visual voicemail package["
5786 + vvmPackage + "]");
5787 }
5788 } finally {
5789 Binder.restoreCallingIdentity(identity);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005790 }
5791 }
5792
5793 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005794 * Return the application ID for the app type.
5795 *
5796 * @param subId the subscription ID that this request applies to.
5797 * @param appType the uicc app type.
5798 * @return Application ID for specificied app type, or null if no uicc.
5799 */
5800 @Override
5801 public String getAidForAppType(int subId, int appType) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005802 enforceReadPrivilegedPermission("getAidForAppType");
Youhan Wange64578a2016-05-02 15:32:42 -07005803 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005804
5805 final long identity = Binder.clearCallingIdentity();
Youhan Wange64578a2016-05-02 15:32:42 -07005806 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005807 if (phone == null) {
5808 return null;
5809 }
5810 String aid = null;
5811 try {
5812 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
5813 .getApplicationByType(appType).getAid();
5814 } catch (Exception e) {
5815 Log.e(LOG_TAG, "Not getting aid. Exception ex=" + e);
5816 }
5817 return aid;
5818 } finally {
5819 Binder.restoreCallingIdentity(identity);
Youhan Wange64578a2016-05-02 15:32:42 -07005820 }
Youhan Wange64578a2016-05-02 15:32:42 -07005821 }
5822
Youhan Wang4001d252016-05-11 10:29:41 -07005823 /**
5824 * Return the Electronic Serial Number.
5825 *
5826 * @param subId the subscription ID that this request applies to.
5827 * @return ESN or null if error.
5828 */
5829 @Override
5830 public String getEsn(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005831 enforceReadPrivilegedPermission("getEsn");
Youhan Wang4001d252016-05-11 10:29:41 -07005832 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005833
5834 final long identity = Binder.clearCallingIdentity();
Youhan Wang4001d252016-05-11 10:29:41 -07005835 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005836 if (phone == null) {
5837 return null;
5838 }
5839 String esn = null;
5840 try {
5841 esn = phone.getEsn();
5842 } catch (Exception e) {
5843 Log.e(LOG_TAG, "Not getting ESN. Exception ex=" + e);
5844 }
5845 return esn;
5846 } finally {
5847 Binder.restoreCallingIdentity(identity);
Youhan Wang4001d252016-05-11 10:29:41 -07005848 }
Youhan Wang4001d252016-05-11 10:29:41 -07005849 }
5850
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005851 /**
Youhan Wang66ad5d72016-07-18 17:56:58 -07005852 * Return the Preferred Roaming List Version.
5853 *
5854 * @param subId the subscription ID that this request applies to.
5855 * @return PRLVersion or null if error.
5856 */
5857 @Override
5858 public String getCdmaPrlVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005859 enforceReadPrivilegedPermission("getCdmaPrlVersion");
Youhan Wang66ad5d72016-07-18 17:56:58 -07005860 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005861
5862 final long identity = Binder.clearCallingIdentity();
Youhan Wang66ad5d72016-07-18 17:56:58 -07005863 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005864 if (phone == null) {
5865 return null;
5866 }
5867 String cdmaPrlVersion = null;
5868 try {
5869 cdmaPrlVersion = phone.getCdmaPrlVersion();
5870 } catch (Exception e) {
5871 Log.e(LOG_TAG, "Not getting PRLVersion", e);
5872 }
5873 return cdmaPrlVersion;
5874 } finally {
5875 Binder.restoreCallingIdentity(identity);
Youhan Wang66ad5d72016-07-18 17:56:58 -07005876 }
Youhan Wang66ad5d72016-07-18 17:56:58 -07005877 }
5878
5879 /**
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005880 * Get snapshot of Telephony histograms
5881 * @return List of Telephony histograms
5882 * @hide
5883 */
5884 @Override
5885 public List<TelephonyHistogram> getTelephonyHistograms() {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005886 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5887 mApp, getDefaultSubscription(), "getTelephonyHistograms");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005888
5889 final long identity = Binder.clearCallingIdentity();
5890 try {
5891 return RIL.getTelephonyRILTimingHistograms();
5892 } finally {
5893 Binder.restoreCallingIdentity(identity);
5894 }
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005895 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005896
5897 /**
5898 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005899 * Set the allowed carrier list and the excluded carrier list, indicating the priority between
5900 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005901 * Require system privileges. In the future we may add this to carrier APIs.
5902 *
Michele Berionne482f8202018-11-27 18:57:59 -08005903 * @return Integer with the result of the operation, as defined in {@link TelephonyManager}.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005904 */
5905 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005906 @TelephonyManager.SetCarrierRestrictionResult
5907 public int setAllowedCarriers(CarrierRestrictionRules carrierRestrictionRules) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07005908 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005909 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005910
Michele Berionne482f8202018-11-27 18:57:59 -08005911 if (carrierRestrictionRules == null) {
5912 throw new NullPointerException("carrier restriction cannot be null");
Meng Wang9b7c4e92017-02-17 11:41:27 -08005913 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005914
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005915 final long identity = Binder.clearCallingIdentity();
5916 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005917 return (int) sendRequest(CMD_SET_ALLOWED_CARRIERS, carrierRestrictionRules,
vagdeviaf9a5b92018-08-15 16:01:53 -07005918 workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005919 } finally {
5920 Binder.restoreCallingIdentity(identity);
5921 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005922 }
5923
5924 /**
5925 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005926 * Get the allowed carrier list and the excluded carrier list, including the priority between
5927 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005928 * Require system privileges. In the future we may add this to carrier APIs.
5929 *
Michele Berionne482f8202018-11-27 18:57:59 -08005930 * @return {@link android.telephony.CarrierRestrictionRules}
Meng Wang1a7c35a2016-05-05 20:56:15 -07005931 */
5932 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005933 public CarrierRestrictionRules getAllowedCarriers() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005934 enforceReadPrivilegedPermission("getAllowedCarriers");
vagdeviaf9a5b92018-08-15 16:01:53 -07005935 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005936
5937 final long identity = Binder.clearCallingIdentity();
5938 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005939 Object response = sendRequest(CMD_GET_ALLOWED_CARRIERS, null, workSource);
5940 if (response instanceof CarrierRestrictionRules) {
5941 return (CarrierRestrictionRules) response;
5942 }
5943 // Response is an Exception of some kind,
5944 // which is signalled to the user as a NULL retval
5945 return null;
5946 } catch (Exception e) {
5947 Log.e(LOG_TAG, "getAllowedCarriers. Exception ex=" + e);
5948 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005949 } finally {
5950 Binder.restoreCallingIdentity(identity);
5951 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005952 }
5953
fionaxu59545b42016-05-25 15:53:37 -07005954 /**
5955 * Action set from carrier signalling broadcast receivers to enable/disable metered apns
5956 * @param subId the subscription ID that this action applies to.
5957 * @param enabled control enable or disable metered apns.
5958 * {@hide}
5959 */
5960 @Override
5961 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) {
5962 enforceModifyPermission();
5963 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005964
5965 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07005966 if (phone == null) {
5967 loge("carrierAction: SetMeteredApnsEnabled fails with invalid subId: " + subId);
5968 return;
5969 }
5970 try {
5971 phone.carrierActionSetMeteredApnsEnabled(enabled);
5972 } catch (Exception e) {
5973 Log.e(LOG_TAG, "carrierAction: SetMeteredApnsEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005974 } finally {
5975 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07005976 }
5977 }
5978
5979 /**
5980 * Action set from carrier signalling broadcast receivers to enable/disable radio
5981 * @param subId the subscription ID that this action applies to.
5982 * @param enabled control enable or disable radio.
5983 * {@hide}
5984 */
5985 @Override
5986 public void carrierActionSetRadioEnabled(int subId, boolean enabled) {
5987 enforceModifyPermission();
5988 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005989
5990 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07005991 if (phone == null) {
5992 loge("carrierAction: SetRadioEnabled fails with invalid sibId: " + subId);
5993 return;
5994 }
5995 try {
5996 phone.carrierActionSetRadioEnabled(enabled);
5997 } catch (Exception e) {
5998 Log.e(LOG_TAG, "carrierAction: SetRadioEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005999 } finally {
6000 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006001 }
6002 }
6003
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006004 /**
fionaxu8da9cb12017-05-23 15:02:46 -07006005 * Action set from carrier signalling broadcast receivers to start/stop reporting the default
6006 * network status based on which carrier apps could apply actions accordingly,
6007 * enable/disable default url handler for example.
6008 *
6009 * @param subId the subscription ID that this action applies to.
6010 * @param report control start/stop reporting the default network status.
6011 * {@hide}
6012 */
6013 @Override
6014 public void carrierActionReportDefaultNetworkStatus(int subId, boolean report) {
6015 enforceModifyPermission();
6016 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006017
6018 final long identity = Binder.clearCallingIdentity();
fionaxu8da9cb12017-05-23 15:02:46 -07006019 if (phone == null) {
6020 loge("carrierAction: ReportDefaultNetworkStatus fails with invalid sibId: " + subId);
6021 return;
6022 }
6023 try {
6024 phone.carrierActionReportDefaultNetworkStatus(report);
6025 } catch (Exception e) {
6026 Log.e(LOG_TAG, "carrierAction: ReportDefaultNetworkStatus fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006027 } finally {
6028 Binder.restoreCallingIdentity(identity);
fionaxu8da9cb12017-05-23 15:02:46 -07006029 }
6030 }
6031
6032 /**
fionaxud9622282017-07-17 17:51:30 -07006033 * Action set from carrier signalling broadcast receivers to reset all carrier actions
6034 * @param subId the subscription ID that this action applies to.
6035 * {@hide}
6036 */
6037 @Override
6038 public void carrierActionResetAll(int subId) {
6039 enforceModifyPermission();
6040 final Phone phone = getPhone(subId);
6041 if (phone == null) {
6042 loge("carrierAction: ResetAll fails with invalid sibId: " + subId);
6043 return;
6044 }
6045 try {
6046 phone.carrierActionResetAll();
6047 } catch (Exception e) {
6048 Log.e(LOG_TAG, "carrierAction: ResetAll fails. Exception ex=" + e);
6049 }
6050 }
6051
6052 /**
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006053 * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
6054 * bug report is being generated.
6055 */
6056 @Override
Ta-wei Yen99282e02016-06-21 18:19:35 -07006057 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006058 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
6059 != PackageManager.PERMISSION_GRANTED) {
dcashman22b950d2016-06-27 11:39:02 -07006060 writer.println("Permission Denial: can't dump Phone from pid="
6061 + Binder.getCallingPid()
6062 + ", uid=" + Binder.getCallingUid()
6063 + "without permission "
6064 + android.Manifest.permission.DUMP);
6065 return;
6066 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006067 DumpsysHandler.dump(mApp, fd, writer, args);
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006068 }
Jack Yueb89b242016-06-22 13:27:47 -07006069
Brad Ebingerdac2f002018-04-03 15:17:52 -07006070 @Override
6071 public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
6072 String[] args, ShellCallback callback, ResultReceiver resultReceiver)
6073 throws RemoteException {
6074 (new TelephonyShellCommand(this)).exec(this, in, out, err, args, callback, resultReceiver);
6075 }
6076
Jack Yueb89b242016-06-22 13:27:47 -07006077 /**
Jack Yu84291ec2017-05-26 16:07:50 -07006078 * Get aggregated video call data usage since boot.
6079 *
6080 * @param perUidStats True if requesting data usage per uid, otherwise overall usage.
6081 * @return Snapshot of video call data usage
Jack Yueb89b242016-06-22 13:27:47 -07006082 * {@hide}
6083 */
6084 @Override
Jack Yu84291ec2017-05-26 16:07:50 -07006085 public NetworkStats getVtDataUsage(int subId, boolean perUidStats) {
Jack Yueb89b242016-06-22 13:27:47 -07006086 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_NETWORK_USAGE_HISTORY,
6087 null);
6088
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006089 final long identity = Binder.clearCallingIdentity();
6090 try {
6091 // NetworkStatsService keeps tracking the active network interface and identity. It
6092 // records the delta with the corresponding network identity.
6093 // We just return the total video call data usage snapshot since boot.
6094 Phone phone = getPhone(subId);
6095 if (phone != null) {
6096 return phone.getVtDataUsage(perUidStats);
6097 }
6098 return null;
6099 } finally {
6100 Binder.restoreCallingIdentity(identity);
Jack Yueb89b242016-06-22 13:27:47 -07006101 }
Jack Yueb89b242016-06-22 13:27:47 -07006102 }
Jack Yu75ab2952016-07-08 14:29:33 -07006103
6104 /**
6105 * Policy control of data connection. Usually used when data limit is passed.
6106 * @param enabled True if enabling the data, otherwise disabling.
6107 * @param subId Subscription index
6108 * {@hide}
6109 */
6110 @Override
6111 public void setPolicyDataEnabled(boolean enabled, int subId) {
6112 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006113
6114 final long identity = Binder.clearCallingIdentity();
6115 try {
6116 Phone phone = getPhone(subId);
6117 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08006118 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006119 }
6120 } finally {
6121 Binder.restoreCallingIdentity(identity);
Jack Yu75ab2952016-07-08 14:29:33 -07006122 }
6123 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006124
6125 /**
6126 * Get Client request stats
6127 * @return List of Client Request Stats
6128 * @hide
6129 */
6130 @Override
6131 public List<ClientRequestStats> getClientRequestStats(String callingPackage, int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006132 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08006133 mApp, subId, callingPackage, "getClientRequestStats")) {
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006134 return null;
6135 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006136 Phone phone = getPhone(subId);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006137
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006138 final long identity = Binder.clearCallingIdentity();
6139 try {
6140 if (phone != null) {
6141 return phone.getClientRequestStats();
6142 }
6143
6144 return null;
6145 } finally {
6146 Binder.restoreCallingIdentity(identity);
6147 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006148 }
6149
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006150 private WorkSource getWorkSource(int uid) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006151 String packageName = mApp.getPackageManager().getNameForUid(uid);
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006152 return new WorkSource(uid, packageName);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006153 }
Jack Yueb4124c2017-02-16 15:32:43 -08006154
6155 /**
Grace Chen70990072017-03-24 17:21:30 -07006156 * Set SIM card power state.
Jack Yueb4124c2017-02-16 15:32:43 -08006157 *
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006158 * @param slotIndex SIM slot id.
Grace Chen70990072017-03-24 17:21:30 -07006159 * @param state State of SIM (power down, power up, pass through)
6160 * - {@link android.telephony.TelephonyManager#CARD_POWER_DOWN}
6161 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP}
6162 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP_PASS_THROUGH}
Jack Yueb4124c2017-02-16 15:32:43 -08006163 *
6164 **/
6165 @Override
Grace Chen70990072017-03-24 17:21:30 -07006166 public void setSimPowerStateForSlot(int slotIndex, int state) {
Jack Yueb4124c2017-02-16 15:32:43 -08006167 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006168 Phone phone = PhoneFactory.getPhone(slotIndex);
6169
vagdeviaf9a5b92018-08-15 16:01:53 -07006170 WorkSource workSource = getWorkSource(Binder.getCallingUid());
6171
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006172 final long identity = Binder.clearCallingIdentity();
6173 try {
6174 if (phone != null) {
vagdeviaf9a5b92018-08-15 16:01:53 -07006175 phone.setSimPowerState(state, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006176 }
6177 } finally {
6178 Binder.restoreCallingIdentity(identity);
Jack Yueb4124c2017-02-16 15:32:43 -08006179 }
6180 }
Shuo Qiandd210312017-04-12 22:11:33 +00006181
Tyler Gunn65d45c22017-06-05 11:22:26 -07006182 private boolean isUssdApiAllowed(int subId) {
6183 CarrierConfigManager configManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006184 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Tyler Gunn65d45c22017-06-05 11:22:26 -07006185 if (configManager == null) {
6186 return false;
6187 }
6188 PersistableBundle pb = configManager.getConfigForSubId(subId);
6189 if (pb == null) {
6190 return false;
6191 }
6192 return pb.getBoolean(
6193 CarrierConfigManager.KEY_ALLOW_USSD_REQUESTS_VIA_TELEPHONY_MANAGER_BOOL);
6194 }
6195
Shuo Qiandd210312017-04-12 22:11:33 +00006196 /**
6197 * Check if phone is in emergency callback mode
6198 * @return true if phone is in emergency callback mode
6199 * @param subId sub id
6200 */
goneil9c5f4872017-12-05 14:07:56 -08006201 @Override
Shuo Qiandd210312017-04-12 22:11:33 +00006202 public boolean getEmergencyCallbackMode(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006203 enforceReadPrivilegedPermission("getEmergencyCallbackMode");
Shuo Qiandd210312017-04-12 22:11:33 +00006204 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006205
6206 final long identity = Binder.clearCallingIdentity();
6207 try {
6208 if (phone != null) {
6209 return phone.isInEcm();
6210 } else {
6211 return false;
6212 }
6213 } finally {
6214 Binder.restoreCallingIdentity(identity);
Shuo Qiandd210312017-04-12 22:11:33 +00006215 }
6216 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006217
6218 /**
6219 * Get the current signal strength information for the given subscription.
6220 * Because this information is not updated when the device is in a low power state
6221 * it should not be relied-upon to be current.
6222 * @param subId Subscription index
6223 * @return the most recent cached signal strength info from the modem
6224 */
6225 @Override
6226 public SignalStrength getSignalStrength(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006227 final long identity = Binder.clearCallingIdentity();
6228 try {
6229 Phone p = getPhone(subId);
6230 if (p == null) {
6231 return null;
6232 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006233
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006234 return p.getSignalStrength();
6235 } finally {
6236 Binder.restoreCallingIdentity(identity);
6237 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006238 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006239
Pengquan Meng77b7f132018-08-22 14:49:57 -07006240 /**
Chen Xuf792fd62018-10-17 17:54:36 +00006241 * Get the current modem radio state for the given slot.
6242 * @param slotIndex slot index.
6243 * @param callingPackage the name of the package making the call.
6244 * @return the current radio power state from the modem
6245 */
6246 @Override
6247 public int getRadioPowerState(int slotIndex, String callingPackage) {
6248 Phone phone = PhoneFactory.getPhone(slotIndex);
6249 if (phone != null) {
6250 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6251 mApp, phone.getSubId(), callingPackage, "getRadioPowerState")) {
6252 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6253 }
6254
6255 final long identity = Binder.clearCallingIdentity();
6256 try {
6257 return phone.getRadioPowerState();
6258 } finally {
6259 Binder.restoreCallingIdentity(identity);
6260 }
6261 }
6262 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6263 }
6264
6265 /**
Pengquan Meng77b7f132018-08-22 14:49:57 -07006266 * Checks if data roaming is enabled on the subscription with id {@code subId}.
6267 *
6268 * <p>Requires one of the following permissions:
6269 * {@link android.Manifest.permission#ACCESS_NETWORK_STATE},
6270 * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
6271 * privileges.
6272 *
6273 * @param subId subscription id
6274 * @return {@code true} if data roaming is enabled on this subscription, otherwise return
6275 * {@code false}.
6276 */
6277 @Override
6278 public boolean isDataRoamingEnabled(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006279 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
6280 null /* message */);
6281
Pengquan Menga1bb6272018-09-06 09:59:22 -07006282 boolean isEnabled = false;
6283 final long identity = Binder.clearCallingIdentity();
Pengquan Meng77b7f132018-08-22 14:49:57 -07006284 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006285 Phone phone = getPhone(subId);
6286 isEnabled = phone != null ? phone.getDataRoamingEnabled() : false;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006287 } catch (Exception e) {
6288 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6289 mApp, subId, "isDataRoamingEnabled");
Pengquan Menga1bb6272018-09-06 09:59:22 -07006290 } finally {
6291 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006292 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006293 return isEnabled;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006294 }
6295
6296
6297 /**
6298 * Enables/Disables the data roaming on the subscription with id {@code subId}.
6299 *
6300 * <p> Requires permission:
6301 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
6302 * privileges.
6303 *
6304 * @param subId subscription id
6305 * @param isEnabled {@code true} means enable, {@code false} means disable.
6306 */
6307 @Override
6308 public void setDataRoamingEnabled(int subId, boolean isEnabled) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006309 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6310 mApp, subId, "setDataRoamingEnabled");
6311
Pengquan Menga1bb6272018-09-06 09:59:22 -07006312 final long identity = Binder.clearCallingIdentity();
6313 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006314 Phone phone = getPhone(subId);
6315 if (phone != null) {
6316 phone.setDataRoamingEnabled(isEnabled);
6317 }
6318 } finally {
6319 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006320 }
6321 }
6322
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006323 @Override
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006324 public boolean isManualNetworkSelectionAllowed(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006325 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6326 mApp, subId, "isManualNetworkSelectionAllowed");
6327
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006328 boolean isAllowed = true;
6329 final long identity = Binder.clearCallingIdentity();
6330 try {
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006331 Phone phone = getPhone(subId);
6332 if (phone != null) {
6333 isAllowed = phone.isCspPlmnEnabled();
6334 }
6335 } finally {
6336 Binder.restoreCallingIdentity(identity);
6337 }
6338 return isAllowed;
6339 }
6340
6341 @Override
Jordan Liu75f43ea2019-01-17 16:56:37 -08006342 public List<UiccCardInfo> getUiccCardsInfo(String callingPackage) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006343 boolean hasReadPermission = false;
Jordan Liuc65bc952019-02-12 17:54:02 -08006344 try {
6345 enforceReadPrivilegedPermission("getUiccCardsInfo");
Jordan Liu1e142fc2019-04-22 15:10:43 -07006346 hasReadPermission = true;
Jordan Liuc65bc952019-02-12 17:54:02 -08006347 } catch (SecurityException e) {
6348 // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
6349 // has carrier privileges on an active UICC
6350 if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
6351 != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006352 throw new SecurityException("Caller does not have permission.");
Jordan Liuc65bc952019-02-12 17:54:02 -08006353 }
Jordan Liu75f43ea2019-01-17 16:56:37 -08006354 }
Jordan Liu5aa07002018-12-18 15:44:48 -08006355
6356 final long identity = Binder.clearCallingIdentity();
6357 try {
Jordan Liu75f43ea2019-01-17 16:56:37 -08006358 UiccController uiccController = UiccController.getInstance();
6359 ArrayList<UiccCardInfo> cardInfos = uiccController.getAllUiccCardInfos();
Jordan Liu1e142fc2019-04-22 15:10:43 -07006360 if (hasReadPermission) {
6361 return cardInfos;
Jordan Liu75f43ea2019-01-17 16:56:37 -08006362 }
Jordan Liu1e142fc2019-04-22 15:10:43 -07006363
6364 // Remove private info if the caller doesn't have access
6365 ArrayList<UiccCardInfo> filteredInfos = new ArrayList<>();
6366 for (UiccCardInfo cardInfo : cardInfos) {
6367 // For an inactive eUICC, the UiccCard will be null even though the UiccCardInfo
6368 // is available
6369 UiccCard card = uiccController.getUiccCardForSlot(cardInfo.getSlotIndex());
6370 if (card == null || card.getUiccProfile() == null) {
6371 // assume no access if the card or profile is unavailable
6372 filteredInfos.add(cardInfo.getUnprivileged());
6373 continue;
6374 }
6375 UiccProfile profile = card.getUiccProfile();
6376 if (profile.getCarrierPrivilegeStatus(mApp.getPackageManager(), callingPackage)
6377 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
6378 filteredInfos.add(cardInfo);
6379 } else {
6380 filteredInfos.add(cardInfo.getUnprivileged());
6381 }
6382 }
6383 return filteredInfos;
Jordan Liu5aa07002018-12-18 15:44:48 -08006384 } finally {
6385 Binder.restoreCallingIdentity(identity);
6386 }
6387 }
6388
6389 @Override
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006390 public UiccSlotInfo[] getUiccSlotsInfo() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006391 enforceReadPrivilegedPermission("getUiccSlotsInfo");
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006392
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006393 final long identity = Binder.clearCallingIdentity();
6394 try {
6395 UiccSlot[] slots = UiccController.getInstance().getUiccSlots();
6396 if (slots == null) {
6397 Rlog.i(LOG_TAG, "slots is null.");
6398 return null;
6399 }
6400
6401 UiccSlotInfo[] infos = new UiccSlotInfo[slots.length];
6402 for (int i = 0; i < slots.length; i++) {
6403 UiccSlot slot = slots[i];
6404 if (slot == null) {
6405 continue;
6406 }
6407
Jordan Liu7be7e652019-05-06 18:55:02 +00006408 String cardId;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006409 UiccCard card = slot.getUiccCard();
6410 if (card != null) {
6411 cardId = card.getCardId();
Jordan Liu7be7e652019-05-06 18:55:02 +00006412 } else {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006413 cardId = slot.getIccId();
6414 }
6415
6416 int cardState = 0;
6417 switch (slot.getCardState()) {
6418 case CARDSTATE_ABSENT:
6419 cardState = UiccSlotInfo.CARD_STATE_INFO_ABSENT;
6420 break;
6421 case CARDSTATE_PRESENT:
6422 cardState = UiccSlotInfo.CARD_STATE_INFO_PRESENT;
6423 break;
6424 case CARDSTATE_ERROR:
6425 cardState = UiccSlotInfo.CARD_STATE_INFO_ERROR;
6426 break;
6427 case CARDSTATE_RESTRICTED:
6428 cardState = UiccSlotInfo.CARD_STATE_INFO_RESTRICTED;
6429 break;
6430 default:
6431 break;
6432
6433 }
6434
6435 infos[i] = new UiccSlotInfo(
6436 slot.isActive(),
6437 slot.isEuicc(),
6438 cardId,
6439 cardState,
6440 slot.getPhoneId(),
Jordan Liua2619582019-02-14 12:56:40 -08006441 slot.isExtendedApduSupported(),
6442 slot.isRemovable());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006443 }
6444 return infos;
6445 } finally {
6446 Binder.restoreCallingIdentity(identity);
Holly Jiuyu Sun1d957c52018-04-04 13:52:42 -07006447 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006448 }
6449
6450 @Override
6451 public boolean switchSlots(int[] physicalSlots) {
6452 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006453
6454 final long identity = Binder.clearCallingIdentity();
6455 try {
6456 return (Boolean) sendRequest(CMD_SWITCH_SLOTS, physicalSlots);
6457 } finally {
6458 Binder.restoreCallingIdentity(identity);
6459 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006460 }
Jack Yu4c988042018-02-27 15:30:01 -08006461
6462 @Override
Jordan Liu7de49fa2018-12-06 14:48:49 -08006463 public int getCardIdForDefaultEuicc(int subId, String callingPackage) {
Jordan Liu7de49fa2018-12-06 14:48:49 -08006464 final long identity = Binder.clearCallingIdentity();
6465 try {
6466 return UiccController.getInstance().getCardIdForDefaultEuicc();
6467 } finally {
6468 Binder.restoreCallingIdentity(identity);
6469 }
6470 }
6471
6472 @Override
Jack Yu4c988042018-02-27 15:30:01 -08006473 public void setRadioIndicationUpdateMode(int subId, int filters, int mode) {
6474 enforceModifyPermission();
6475 final Phone phone = getPhone(subId);
6476 if (phone == null) {
6477 loge("setRadioIndicationUpdateMode fails with invalid subId: " + subId);
6478 return;
6479 }
6480
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006481 final long identity = Binder.clearCallingIdentity();
6482 try {
6483 phone.setRadioIndicationUpdateMode(filters, mode);
6484 } finally {
6485 Binder.restoreCallingIdentity(identity);
6486 }
Jack Yu4c988042018-02-27 15:30:01 -08006487 }
Pengquan Meng85728fb2018-03-12 16:31:21 -07006488
6489 /**
goneil47ffb6e2018-04-06 15:40:58 -07006490 * A test API to reload the UICC profile.
6491 *
6492 * <p>Requires that the calling app has permission
6493 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6494 * @hide
6495 */
6496 @Override
6497 public void refreshUiccProfile(int subId) {
6498 enforceModifyPermission();
6499
6500 final long identity = Binder.clearCallingIdentity();
6501 try {
6502 Phone phone = getPhone(subId);
6503 if (phone == null) {
6504 return;
6505 }
6506 UiccCard uiccCard = phone.getUiccCard();
6507 if (uiccCard == null) {
6508 return;
6509 }
6510 UiccProfile uiccProfile = uiccCard.getUiccProfile();
6511 if (uiccProfile == null) {
6512 return;
6513 }
6514 uiccProfile.refresh();
6515 } finally {
6516 Binder.restoreCallingIdentity(identity);
6517 }
6518 }
6519
6520 /**
Pengquan Meng85728fb2018-03-12 16:31:21 -07006521 * Returns false if the mobile data is disabled by default, otherwise return true.
6522 */
6523 private boolean getDefaultDataEnabled() {
6524 return "true".equalsIgnoreCase(
6525 SystemProperties.get(DEFAULT_MOBILE_DATA_PROPERTY_NAME, "true"));
6526 }
6527
6528 /**
6529 * Returns true if the data roaming is enabled by default, i.e the system property
6530 * of {@link #DEFAULT_DATA_ROAMING_PROPERTY_NAME} is true or the config of
6531 * {@link CarrierConfigManager#KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL} is true.
6532 */
6533 private boolean getDefaultDataRoamingEnabled(int subId) {
6534 final CarrierConfigManager configMgr = (CarrierConfigManager)
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006535 mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Pengquan Meng85728fb2018-03-12 16:31:21 -07006536 boolean isDataRoamingEnabled = "true".equalsIgnoreCase(
6537 SystemProperties.get(DEFAULT_DATA_ROAMING_PROPERTY_NAME, "false"));
6538 isDataRoamingEnabled |= configMgr.getConfigForSubId(subId).getBoolean(
6539 CarrierConfigManager.KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL);
6540 return isDataRoamingEnabled;
6541 }
6542
6543 /**
6544 * Returns the default network type for the given {@code subId}, if the default network type is
6545 * not set, return {@link Phone#PREFERRED_NT_MODE}.
6546 */
6547 private int getDefaultNetworkType(int subId) {
6548 return Integer.parseInt(
6549 TelephonyManager.getTelephonyProperty(
6550 mSubscriptionController.getPhoneId(subId),
6551 DEFAULT_NETWORK_MODE_PROPERTY_NAME,
6552 String.valueOf(Phone.PREFERRED_NT_MODE)));
6553 }
fionaxua13278b2018-03-21 00:08:13 -07006554
6555 @Override
6556 public void setCarrierTestOverride(int subId, String mccmnc, String imsi, String iccid, String
chen xueaba88a2019-03-15 13:15:10 -07006557 gid1, String gid2, String plmn, String spn, String carrierPrivilegeRules, String apn) {
fionaxua13278b2018-03-21 00:08:13 -07006558 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006559
6560 final long identity = Binder.clearCallingIdentity();
6561 try {
6562 final Phone phone = getPhone(subId);
6563 if (phone == null) {
6564 loge("setCarrierTestOverride fails with invalid subId: " + subId);
6565 return;
6566 }
chen xueaba88a2019-03-15 13:15:10 -07006567 phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
6568 carrierPrivilegeRules, apn);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006569 } finally {
6570 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006571 }
fionaxua13278b2018-03-21 00:08:13 -07006572 }
6573
6574 @Override
6575 public int getCarrierIdListVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006576 enforceReadPrivilegedPermission("getCarrierIdListVersion");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006577
6578 final long identity = Binder.clearCallingIdentity();
6579 try {
6580 final Phone phone = getPhone(subId);
6581 if (phone == null) {
6582 loge("getCarrierIdListVersion fails with invalid subId: " + subId);
6583 return TelephonyManager.UNKNOWN_CARRIER_ID_LIST_VERSION;
6584 }
6585 return phone.getCarrierIdListVersion();
6586 } finally {
6587 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006588 }
fionaxua13278b2018-03-21 00:08:13 -07006589 }
Malcolm Chen2c63d402018-08-14 16:00:53 -07006590
6591 @Override
6592 public int getNumberOfModemsWithSimultaneousDataConnections(int subId, String callingPackage) {
6593 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6594 mApp, subId, callingPackage, "getNumberOfModemsWithSimultaneousDataConnections")) {
6595 return -1;
6596 }
6597
6598 final long identity = Binder.clearCallingIdentity();
6599 try {
6600 return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
6601 } finally {
6602 Binder.restoreCallingIdentity(identity);
6603 }
6604 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006605
6606 @Override
6607 public int getCdmaRoamingMode(int subId) {
6608 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6609 mApp, subId, "getCdmaRoamingMode");
6610
6611 final long identity = Binder.clearCallingIdentity();
6612 try {
6613 return (int) sendRequest(CMD_GET_CDMA_ROAMING_MODE, null /* argument */, subId);
6614 } finally {
6615 Binder.restoreCallingIdentity(identity);
6616 }
6617 }
6618
6619 @Override
6620 public boolean setCdmaRoamingMode(int subId, int mode) {
6621 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6622 mApp, subId, "setCdmaRoamingMode");
6623
6624 final long identity = Binder.clearCallingIdentity();
6625 try {
6626 return (boolean) sendRequest(CMD_SET_CDMA_ROAMING_MODE, mode, subId);
6627 } finally {
6628 Binder.restoreCallingIdentity(identity);
6629 }
6630 }
6631
6632 @Override
6633 public boolean setCdmaSubscriptionMode(int subId, int mode) {
6634 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6635 mApp, subId, "setCdmaSubscriptionMode");
6636
6637 final long identity = Binder.clearCallingIdentity();
6638 try {
6639 return (boolean) sendRequest(CMD_SET_CDMA_SUBSCRIPTION_MODE, mode, subId);
6640 } finally {
6641 Binder.restoreCallingIdentity(identity);
6642 }
6643 }
Makoto Onukida3bf792018-09-18 16:06:29 -07006644
6645 private void ensureUserRunning(int userId) {
6646 if (!mUserManager.isUserRunning(userId)) {
6647 throw new IllegalStateException("User " + userId + " does not exist or not running");
6648 }
6649 }
6650
6651 /**
6652 * Returns a list of SMS apps on a given user.
6653 *
6654 * Only the shell user (UID 2000 or 0) can call it.
6655 * Target user must be running.
6656 */
6657 @Override
6658 public String[] getSmsApps(int userId) {
6659 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getSmsApps");
6660 ensureUserRunning(userId);
6661
6662 final Collection<SmsApplicationData> apps =
6663 SmsApplication.getApplicationCollectionAsUser(mApp, userId);
6664
6665 String[] ret = new String[apps.size()];
6666 int i = 0;
6667 for (SmsApplicationData app : apps) {
6668 ret[i++] = app.mPackageName;
6669 }
6670 return ret;
6671 }
6672
6673 /**
6674 * Returns the default SMS app package name on a given user.
6675 *
6676 * Only the shell user (UID 2000 or 0) can call it.
6677 * Target user must be running.
6678 */
6679 @Override
6680 public String getDefaultSmsApp(int userId) {
6681 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getDefaultSmsApp");
6682 ensureUserRunning(userId);
6683
6684 final ComponentName cn = SmsApplication.getDefaultSmsApplicationAsUser(mApp,
6685 /* updateIfNeeded= */ true, userId);
6686 return cn == null ? null : cn.getPackageName();
6687 }
6688
6689 /**
6690 * Set a package as the default SMS app on a given user.
6691 *
6692 * Only the shell user (UID 2000 or 0) can call it.
6693 * Target user must be running.
6694 */
6695 @Override
6696 public void setDefaultSmsApp(int userId, String packageName) {
6697 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "setDefaultSmsApp");
6698 ensureUserRunning(userId);
6699
6700 boolean found = false;
6701 for (String pkg : getSmsApps(userId)) {
6702 if (TextUtils.equals(packageName, pkg)) {
6703 found = true;
6704 break;
6705 }
6706 }
6707 if (!found) {
6708 throw new IllegalArgumentException("Package " + packageName + " is not an SMS app");
6709 }
6710
6711 SmsApplication.setDefaultApplicationAsUser(packageName, mApp, userId);
6712 }
sqianc5eccab2018-10-19 18:46:41 -07006713
6714 @Override
sqian8c685422019-02-22 15:55:18 -08006715 public Map<Integer, List<EmergencyNumber>> getEmergencyNumberList(
sqianc5eccab2018-10-19 18:46:41 -07006716 String callingPackage) {
sqian11b7a0e2018-12-05 18:48:28 -08006717 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
sqian8c685422019-02-22 15:55:18 -08006718 mApp, getDefaultSubscription(), callingPackage, "getEmergencyNumberList")) {
sqian11b7a0e2018-12-05 18:48:28 -08006719 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6720 }
6721 final long identity = Binder.clearCallingIdentity();
6722 try {
sqian854d44b2018-12-12 16:48:18 -08006723 Map<Integer, List<EmergencyNumber>> emergencyNumberListInternal = new HashMap<>();
6724 for (Phone phone: PhoneFactory.getPhones()) {
6725 if (phone.getEmergencyNumberTracker() != null
6726 && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
6727 emergencyNumberListInternal.put(
6728 phone.getSubId(),
6729 phone.getEmergencyNumberTracker().getEmergencyNumberList());
6730 }
sqian11b7a0e2018-12-05 18:48:28 -08006731 }
sqian854d44b2018-12-12 16:48:18 -08006732 return emergencyNumberListInternal;
sqian11b7a0e2018-12-05 18:48:28 -08006733 } finally {
6734 Binder.restoreCallingIdentity(identity);
6735 }
sqianc5eccab2018-10-19 18:46:41 -07006736 }
6737
6738 @Override
sqian8c685422019-02-22 15:55:18 -08006739 public boolean isEmergencyNumber(String number, boolean exactMatch) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006740 final Phone defaultPhone = getDefaultPhone();
sqian11b7a0e2018-12-05 18:48:28 -08006741 if (!exactMatch) {
6742 TelephonyPermissions
6743 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
sqian8c685422019-02-22 15:55:18 -08006744 mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
sqian11b7a0e2018-12-05 18:48:28 -08006745 }
6746 final long identity = Binder.clearCallingIdentity();
6747 try {
sqian854d44b2018-12-12 16:48:18 -08006748 for (Phone phone: PhoneFactory.getPhones()) {
6749 if (phone.getEmergencyNumberTracker() != null
6750 && phone.getEmergencyNumberTracker() != null) {
6751 if (phone.getEmergencyNumberTracker().isEmergencyNumber(
6752 number, exactMatch)) {
6753 return true;
sqian11b7a0e2018-12-05 18:48:28 -08006754 }
6755 }
sqian11b7a0e2018-12-05 18:48:28 -08006756 }
6757 return false;
6758 } finally {
6759 Binder.restoreCallingIdentity(identity);
6760 }
6761 }
6762
sqianf4ca7ed2019-01-15 18:32:07 -08006763 /**
6764 * Update emergency number list for test mode.
6765 */
6766 @Override
6767 public void updateEmergencyNumberListTestMode(int action, EmergencyNumber num) {
6768 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6769 "updateEmergencyNumberListTestMode");
6770
6771 final long identity = Binder.clearCallingIdentity();
6772 try {
6773 for (Phone phone: PhoneFactory.getPhones()) {
6774 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6775 if (tracker != null) {
6776 tracker.executeEmergencyNumberTestModeCommand(action, num);
6777 }
6778 }
6779 } finally {
6780 Binder.restoreCallingIdentity(identity);
6781 }
6782 }
6783
6784 /**
6785 * Get the full emergency number list for test mode.
6786 */
6787 @Override
6788 public List<String> getEmergencyNumberListTestMode() {
6789 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6790 "getEmergencyNumberListTestMode");
6791
6792 final long identity = Binder.clearCallingIdentity();
6793 try {
6794 Set<String> emergencyNumbers = new HashSet<>();
6795 for (Phone phone: PhoneFactory.getPhones()) {
6796 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6797 if (tracker != null) {
6798 for (EmergencyNumber num : tracker.getEmergencyNumberList()) {
6799 emergencyNumbers.add(num.getNumber());
6800 }
6801 }
6802 }
6803 return new ArrayList<>(emergencyNumbers);
6804 } finally {
6805 Binder.restoreCallingIdentity(identity);
6806 }
6807 }
6808
chen xud6b45bd2018-10-30 22:27:10 -07006809 @Override
6810 public List<String> getCertsFromCarrierPrivilegeAccessRules(int subId) {
6811 enforceReadPrivilegedPermission("getCertsFromCarrierPrivilegeAccessRules");
6812 Phone phone = getPhone(subId);
6813 if (phone == null) {
6814 return null;
6815 }
6816 final long identity = Binder.clearCallingIdentity();
6817 try {
6818 UiccProfile profile = UiccController.getInstance()
6819 .getUiccProfileForPhone(phone.getPhoneId());
6820 if (profile != null) {
6821 return profile.getCertsFromCarrierPrivilegeAccessRules();
6822 }
6823 } finally {
6824 Binder.restoreCallingIdentity(identity);
6825 }
6826 return null;
6827 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08006828
6829 /**
6830 * Enable or disable a modem stack.
6831 */
6832 @Override
6833 public boolean enableModemForSlot(int slotIndex, boolean enable) {
6834 enforceModifyPermission();
6835
6836 final long identity = Binder.clearCallingIdentity();
6837 try {
6838 Phone phone = PhoneFactory.getPhone(slotIndex);
6839 if (phone == null) {
6840 return false;
6841 } else {
6842 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
6843 }
6844 } finally {
6845 Binder.restoreCallingIdentity(identity);
6846 }
6847 }
Michelecea4cf22018-12-21 15:00:11 -08006848
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006849 /**
6850 * Whether a modem stack is enabled or not.
6851 */
6852 @Override
6853 public boolean isModemEnabledForSlot(int slotIndex, String callingPackage) {
6854 Phone phone = PhoneFactory.getPhone(slotIndex);
6855 if (phone == null) return false;
6856
6857 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6858 mApp, phone.getSubId(), callingPackage, "isModemEnabledForSlot")) {
6859 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6860 }
6861
6862 final long identity = Binder.clearCallingIdentity();
6863 try {
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07006864 try {
6865 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
6866 } catch (NoSuchElementException ex) {
6867 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
6868 }
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006869 } finally {
6870 Binder.restoreCallingIdentity(identity);
6871 }
6872 }
6873
Michelecea4cf22018-12-21 15:00:11 -08006874 @Override
Michele0ea7d782019-03-19 14:58:42 -07006875 public void setMultiSimCarrierRestriction(boolean isMultiSimCarrierRestricted) {
Michelecea4cf22018-12-21 15:00:11 -08006876 enforceModifyPermission();
6877
6878 final long identity = Binder.clearCallingIdentity();
6879 try {
6880 mTelephonySharedPreferences.edit()
Michele0ea7d782019-03-19 14:58:42 -07006881 .putBoolean(PREF_MULTI_SIM_RESTRICTED, isMultiSimCarrierRestricted)
Michelecea4cf22018-12-21 15:00:11 -08006882 .commit();
6883 } finally {
6884 Binder.restoreCallingIdentity(identity);
6885 }
6886 }
6887
6888 @Override
Michele0ea7d782019-03-19 14:58:42 -07006889 @TelephonyManager.IsMultiSimSupportedResult
6890 public int isMultiSimSupported(String callingPackage) {
Michele4245e952019-02-04 11:36:23 -08006891 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
Michele0ea7d782019-03-19 14:58:42 -07006892 getDefaultPhone().getSubId(), callingPackage, "isMultiSimSupported")) {
6893 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele4245e952019-02-04 11:36:23 -08006894 }
Michelecea4cf22018-12-21 15:00:11 -08006895
6896 final long identity = Binder.clearCallingIdentity();
6897 try {
Michele0ea7d782019-03-19 14:58:42 -07006898 return isMultiSimSupportedInternal();
Michelecea4cf22018-12-21 15:00:11 -08006899 } finally {
6900 Binder.restoreCallingIdentity(identity);
6901 }
6902 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006903
Michele0ea7d782019-03-19 14:58:42 -07006904 @TelephonyManager.IsMultiSimSupportedResult
6905 private int isMultiSimSupportedInternal() {
Michele30b57b22019-03-01 12:01:14 -08006906 // If the device has less than 2 SIM cards, indicate that multisim is restricted.
6907 int numPhysicalSlots = UiccController.getInstance().getUiccSlots().length;
6908 if (numPhysicalSlots < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006909 loge("isMultiSimSupportedInternal: requires at least 2 cards");
6910 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006911 }
6912 // Check if the hardware supports multisim functionality. If usage of multisim is not
6913 // supported by the modem, indicate that it is restricted.
6914 PhoneCapability staticCapability =
6915 mPhoneConfigurationManager.getStaticPhoneCapability();
6916 if (staticCapability == null) {
Michele0ea7d782019-03-19 14:58:42 -07006917 loge("isMultiSimSupportedInternal: no static configuration available");
6918 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006919 }
6920 if (staticCapability.logicalModemList.size() < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006921 loge("isMultiSimSupportedInternal: maximum number of modem is < 2");
6922 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006923 }
6924 // Check if support of multiple SIMs is restricted by carrier
6925 if (mTelephonySharedPreferences.getBoolean(PREF_MULTI_SIM_RESTRICTED, false)) {
Michele0ea7d782019-03-19 14:58:42 -07006926 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_CARRIER;
Michele30b57b22019-03-01 12:01:14 -08006927 }
6928
Michele0ea7d782019-03-19 14:58:42 -07006929 return TelephonyManager.MULTISIM_ALLOWED;
Michele30b57b22019-03-01 12:01:14 -08006930 }
6931
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006932 /**
6933 * Switch configs to enable multi-sim or switch back to single-sim
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006934 * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
6935 * permission, but the other way around is possible with either MODIFY_PHONE_STATE
6936 * or carrier privileges
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006937 * @param numOfSims number of active sims we want to switch to
6938 */
6939 @Override
6940 public void switchMultiSimConfig(int numOfSims) {
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006941 if (numOfSims == 1) {
6942 enforceModifyPermission();
6943 } else {
6944 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6945 mApp, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "switchMultiSimConfig");
6946 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006947 final long identity = Binder.clearCallingIdentity();
Michele30b57b22019-03-01 12:01:14 -08006948
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006949 try {
Michele30b57b22019-03-01 12:01:14 -08006950 //only proceed if multi-sim is not restricted
Michele0ea7d782019-03-19 14:58:42 -07006951 if (isMultiSimSupportedInternal() != TelephonyManager.MULTISIM_ALLOWED) {
Michele30b57b22019-03-01 12:01:14 -08006952 loge("switchMultiSimConfig not possible. It is restricted or not supported.");
6953 return;
6954 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006955 mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
6956 } finally {
6957 Binder.restoreCallingIdentity(identity);
6958 }
6959 }
6960
6961 /**
chen xub4baa772019-04-03 10:23:41 -07006962 * Get whether making changes to modem configurations will trigger reboot.
6963 * Return value defaults to true.
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08006964 */
6965 @Override
chen xub4baa772019-04-03 10:23:41 -07006966 public boolean doesSwitchMultiSimConfigTriggerReboot(int subId, String callingPackage) {
6967 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6968 mApp, subId, callingPackage, "doesSwitchMultiSimConfigTriggerReboot")) {
6969 return false;
6970 }
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08006971 final long identity = Binder.clearCallingIdentity();
6972 try {
6973 return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
6974 } finally {
6975 Binder.restoreCallingIdentity(identity);
6976 }
6977 }
6978
Nathan Harold29f5f052019-02-15 13:41:57 -08006979 private void updateModemStateMetrics() {
6980 TelephonyMetrics metrics = TelephonyMetrics.getInstance();
6981 // TODO: check the state for each modem if the api is ready.
6982 metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
6983 }
6984
Pengquan Meng3889a572019-01-23 11:16:29 -08006985 @Override
6986 public int[] getSlotsMapping() {
6987 enforceReadPrivilegedPermission("getSlotsMapping");
6988
6989 final long identity = Binder.clearCallingIdentity();
6990 try {
6991 int phoneCount = TelephonyManager.getDefault().getPhoneCount();
6992 // All logical slots should have a mapping to a physical slot.
6993 int[] logicalSlotsMapping = new int[phoneCount];
6994 UiccSlotInfo[] slotInfos = getUiccSlotsInfo();
6995 for (int i = 0; i < slotInfos.length; i++) {
6996 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
6997 logicalSlotsMapping[slotInfos[i].getLogicalSlotIdx()] = i;
6998 }
6999 }
7000 return logicalSlotsMapping;
7001 } finally {
7002 Binder.restoreCallingIdentity(identity);
7003 }
7004 }
Nathan Harold48d6fd52019-02-06 19:01:40 -08007005
7006 /**
7007 * Get the IRadio HAL Version
7008 */
7009 @Override
7010 public int getRadioHalVersion() {
7011 Phone phone = getDefaultPhone();
7012 if (phone == null) return -1;
7013 HalVersion hv = phone.getHalVersion();
7014 if (hv.equals(HalVersion.UNKNOWN)) return -1;
7015 return hv.major * 100 + hv.minor;
7016 }
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007017
7018 /**
Malcolm Chene5ad5792019-04-18 13:51:02 -07007019 * Return whether data is enabled for certain APN type. This will tell if framework will accept
7020 * corresponding network requests on a subId.
7021 *
7022 * Data is enabled if:
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007023 * 1) user data is turned on, or
Malcolm Chene5ad5792019-04-18 13:51:02 -07007024 * 2) APN is un-metered for this subscription, or
7025 * 3) APN type is whitelisted. E.g. MMS is whitelisted if
7026 * {@link SubscriptionManager#setAlwaysAllowMmsData} is turned on.
7027 *
7028 * @return whether data is allowed for a apn type.
7029 *
7030 * @hide
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007031 */
7032 @Override
Malcolm Chene5ad5792019-04-18 13:51:02 -07007033 public boolean isDataEnabledForApn(int apnType, int subId, String callingPackage) {
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007034 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Malcolm Chene5ad5792019-04-18 13:51:02 -07007035 mApp, subId, callingPackage, "isDataEnabledForApn")) {
7036 throw new SecurityException("Needs READ_PHONE_STATE for isDataEnabledForApn");
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007037 }
7038
7039 // Now that all security checks passes, perform the operation as ourselves.
7040 final long identity = Binder.clearCallingIdentity();
7041 try {
7042 Phone phone = getPhone(subId);
7043 if (phone == null) return false;
7044
Jack Yu41407ee2019-05-13 16:54:09 -07007045 boolean isMetered = ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chene5ad5792019-04-18 13:51:02 -07007046 return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
7047 } finally {
7048 Binder.restoreCallingIdentity(identity);
7049 }
7050 }
7051
7052 @Override
Jack Yu41407ee2019-05-13 16:54:09 -07007053 public boolean isApnMetered(@ApnType int apnType, int subId) {
Malcolm Chene5ad5792019-04-18 13:51:02 -07007054 enforceReadPrivilegedPermission("isApnMetered");
7055
7056 // Now that all security checks passes, perform the operation as ourselves.
7057 final long identity = Binder.clearCallingIdentity();
7058 try {
7059 Phone phone = getPhone(subId);
7060 if (phone == null) return true; // By default return true.
7061
Jack Yu41407ee2019-05-13 16:54:09 -07007062 return ApnSettingUtils.isMeteredApnType(apnType, phone);
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007063 } finally {
7064 Binder.restoreCallingIdentity(identity);
7065 }
7066 }
Brad Ebingera63db5f2019-04-23 16:31:13 -07007067
7068 @Override
7069 public void enqueueSmsPickResult(String callingPackage, IIntegerConsumer pendingSubIdResult) {
7070 SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
7071 (AppOpsManager) mApp.getSystemService(Context.APP_OPS_SERVICE));
7072 if (!permissions.checkCallingCanSendSms(callingPackage, "Sending message")) {
7073 throw new SecurityException("Requires SEND_SMS permission to perform this operation");
7074 }
7075 PickSmsSubscriptionActivity.addPendingResult(pendingSubIdResult);
7076 Intent intent = new Intent();
7077 intent.setClass(mApp, PickSmsSubscriptionActivity.class);
7078 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
7079 // Bring up choose default SMS subscription dialog right now
7080 intent.putExtra(PickSmsSubscriptionActivity.DIALOG_TYPE_KEY,
7081 PickSmsSubscriptionActivity.SMS_PICK_FOR_MESSAGE);
7082 mApp.startActivity(intent);
7083 }
chen xud5ca2d52019-05-28 15:20:57 -07007084
7085 @Override
7086 public String getMmsUAProfUrl(int subId) {
7087 //TODO investigate if this API should require proper permission check in R b/133791609
7088 final long identity = Binder.clearCallingIdentity();
7089 try {
7090 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7091 .getString(com.android.internal.R.string.config_mms_user_agent_profile_url);
7092 } finally {
7093 Binder.restoreCallingIdentity(identity);
7094 }
7095 }
7096
7097 @Override
7098 public String getMmsUserAgent(int subId) {
7099 //TODO investigate if this API should require proper permission check in R b/133791609
7100 final long identity = Binder.clearCallingIdentity();
7101 try {
7102 return SubscriptionManager.getResourcesForSubId(getDefaultPhone().getContext(), subId)
7103 .getString(com.android.internal.R.string.config_mms_user_agent);
7104 } finally {
7105 Binder.restoreCallingIdentity(identity);
7106 }
7107 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07007108}