blob: 2e16dfeb31ebf5a1c8279e3d47f4c2998f778023 [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;
Jack Yu84291ec2017-05-26 16:07:50 -070082import android.telephony.SmsManager;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080083import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080084import android.telephony.SubscriptionManager;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070085import android.telephony.TelephonyHistogram;
Ta-wei Yenb6929602016-05-24 15:48:27 -070086import android.telephony.TelephonyManager;
Hall Liub2ac8ef2019-02-28 15:56:23 -080087import android.telephony.TelephonyScanManager;
Jordan Liu5aa07002018-12-18 15:44:48 -080088import android.telephony.UiccCardInfo;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +000089import android.telephony.UiccSlotInfo;
Tyler Gunn65d45c22017-06-05 11:22:26 -070090import android.telephony.UssdResponse;
Ta-wei Yenb6929602016-05-24 15:48:27 -070091import android.telephony.VisualVoicemailSmsFilterSettings;
Nathan Harold3ff88932018-08-14 10:19:49 -070092import android.telephony.cdma.CdmaCellLocation;
Jack Yub5d8f642018-11-26 11:20:48 -080093import android.telephony.data.ApnSetting;
94import 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;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700143import com.android.internal.telephony.SmsPermissions;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800144import com.android.internal.telephony.SubscriptionController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800145import com.android.internal.telephony.TelephonyPermissions;
Malcolm Chendc8c10e2019-04-10 18:25:07 -0700146import com.android.internal.telephony.dataconnection.ApnSettingUtils;
sqianf4ca7ed2019-01-15 18:32:07 -0800147import com.android.internal.telephony.emergency.EmergencyNumberTracker;
Derek Tan740e1672017-06-27 14:56:27 -0700148import com.android.internal.telephony.euicc.EuiccConnector;
Brad Ebinger9c0eb502019-01-23 15:06:19 -0800149import com.android.internal.telephony.ims.ImsResolver;
Pengquan Meng6c2dc9f2019-02-06 11:12:53 -0800150import com.android.internal.telephony.metrics.TelephonyMetrics;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700151import com.android.internal.telephony.uicc.IccIoResult;
152import com.android.internal.telephony.uicc.IccUtils;
Nathan Haroldb3014052017-01-25 15:57:32 -0800153import com.android.internal.telephony.uicc.SIMRecords;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700154import com.android.internal.telephony.uicc.UiccCard;
Nathan Haroldb3014052017-01-25 15:57:32 -0800155import com.android.internal.telephony.uicc.UiccCardApplication;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700156import com.android.internal.telephony.uicc.UiccController;
Jeff Davidson7e17e312018-02-13 18:17:36 -0800157import com.android.internal.telephony.uicc.UiccProfile;
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +0000158import com.android.internal.telephony.uicc.UiccSlot;
fionaxu7ed723d2017-05-30 18:58:54 -0700159import com.android.internal.telephony.util.VoicemailNotificationSettingsUtil;
Jake Hambye994d462014-02-03 13:10:13 -0800160import com.android.internal.util.HexDump;
Brad Ebingera63db5f2019-04-23 16:31:13 -0700161import com.android.phone.settings.PickSmsSubscriptionActivity;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700162import com.android.phone.vvm.PhoneAccountHandleConverter;
Ta-wei Yen527a9c02017-01-06 15:29:25 -0800163import com.android.phone.vvm.RemoteVvmTaskManager;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700164import com.android.phone.vvm.VisualVoicemailSettingsUtil;
Ta-wei Yenc8905312017-03-28 11:14:45 -0700165import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800166
Ta-wei Yenc236d6b2016-06-21 13:33:12 -0700167import java.io.FileDescriptor;
168import java.io.PrintWriter;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800169import java.nio.charset.StandardCharsets;
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();
2660 // Make the calls as the phone process.
2661 final long identity = Binder.clearCallingIdentity();
2662 try {
2663 SmsManager smsManager = SmsManager.getSmsManagerForSubscriptionId(subId);
2664 if (port == 0) {
2665 smsManager.sendTextMessageWithSelfPermissions(number, null, text,
2666 sentIntent, null, false);
2667 } else {
2668 byte[] data = text.getBytes(StandardCharsets.UTF_8);
2669 smsManager.sendDataMessageWithSelfPermissions(number, null,
2670 (short) port, data, sentIntent, null);
2671 }
2672 } finally {
2673 Binder.restoreCallingIdentity(identity);
2674 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002675 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002676 /**
fionaxu0152e512016-11-14 13:36:14 -08002677 * Sets the voice activation state of a given subId.
2678 */
2679 @Override
2680 public void setVoiceActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002681 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2682 mApp, subId, "setVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002683
2684 final long identity = Binder.clearCallingIdentity();
2685 try {
2686 final Phone phone = getPhone(subId);
2687 if (phone != null) {
2688 phone.setVoiceActivationState(activationState);
2689 } else {
2690 loge("setVoiceActivationState fails with invalid subId: " + subId);
2691 }
2692 } finally {
2693 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002694 }
2695 }
2696
2697 /**
2698 * Sets the data activation state of a given subId.
2699 */
2700 @Override
2701 public void setDataActivationState(int subId, int activationState) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002702 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
2703 mApp, subId, "setDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002704
2705 final long identity = Binder.clearCallingIdentity();
2706 try {
2707 final Phone phone = getPhone(subId);
2708 if (phone != null) {
2709 phone.setDataActivationState(activationState);
2710 } else {
2711 loge("setVoiceActivationState fails with invalid subId: " + subId);
2712 }
2713 } finally {
2714 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002715 }
2716 }
2717
2718 /**
2719 * Returns the voice activation state of a given subId.
2720 */
2721 @Override
2722 public int getVoiceActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002723 enforceReadPrivilegedPermission("getVoiceActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002724
fionaxu0152e512016-11-14 13:36:14 -08002725 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002726 final long identity = Binder.clearCallingIdentity();
2727 try {
2728 if (phone != null) {
2729 return phone.getVoiceActivationState();
2730 } else {
2731 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2732 }
2733 } finally {
2734 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002735 }
2736 }
2737
2738 /**
2739 * Returns the data activation state of a given subId.
2740 */
2741 @Override
2742 public int getDataActivationState(int subId, String callingPackage) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002743 enforceReadPrivilegedPermission("getDataActivationState");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002744
fionaxu0152e512016-11-14 13:36:14 -08002745 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002746 final long identity = Binder.clearCallingIdentity();
2747 try {
2748 if (phone != null) {
2749 return phone.getDataActivationState();
2750 } else {
2751 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2752 }
2753 } finally {
2754 Binder.restoreCallingIdentity(identity);
fionaxu0152e512016-11-14 13:36:14 -08002755 }
2756 }
2757
2758 /**
Wink Saville36469e72014-06-11 15:17:00 -07002759 * Returns the unread count of voicemails for a subId
2760 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002761 @Override
Brad Ebingerf7664ba2018-11-29 12:43:38 -08002762 public int getVoiceMessageCountForSubscriber(int subId, String callingPackage) {
2763 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
2764 mApp, subId, callingPackage, "getVoiceMessageCountForSubscriber")) {
2765 return 0;
2766 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002767 final long identity = Binder.clearCallingIdentity();
2768 try {
2769 final Phone phone = getPhone(subId);
2770 if (phone != null) {
2771 return phone.getVoiceMessageCount();
2772 } else {
2773 return 0;
2774 }
2775 } finally {
2776 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07002777 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002778 }
2779
2780 /**
pkanwar8a4dcfb2017-01-19 13:43:16 -08002781 * returns true, if the device is in a state where both voice and data
2782 * are supported simultaneously. This can change based on location or network condition.
2783 */
2784 @Override
2785 public boolean isConcurrentVoiceAndDataAllowed(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002786 final long identity = Binder.clearCallingIdentity();
2787 try {
2788 final Phone phone = getPhone(subId);
2789 return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
2790 } finally {
2791 Binder.restoreCallingIdentity(identity);
2792 }
pkanwar8a4dcfb2017-01-19 13:43:16 -08002793 }
2794
2795 /**
fionaxu235cc5e2017-03-06 22:25:57 -08002796 * Send the dialer code if called from the current default dialer or the caller has
2797 * carrier privilege.
2798 * @param inputCode The dialer code to send
2799 */
2800 @Override
2801 public void sendDialerSpecialCode(String callingPackage, String inputCode) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002802 final Phone defaultPhone = getDefaultPhone();
fionaxu235cc5e2017-03-06 22:25:57 -08002803 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002804 String defaultDialer = TelecomManager.from(defaultPhone.getContext())
2805 .getDefaultDialerPackage();
fionaxu235cc5e2017-03-06 22:25:57 -08002806 if (!TextUtils.equals(callingPackage, defaultDialer)) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08002807 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
2808 getDefaultSubscription(), "sendDialerSpecialCode");
fionaxu235cc5e2017-03-06 22:25:57 -08002809 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002810
2811 final long identity = Binder.clearCallingIdentity();
2812 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002813 defaultPhone.sendDialerSpecialCode(inputCode);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002814 } finally {
2815 Binder.restoreCallingIdentity(identity);
2816 }
fionaxu235cc5e2017-03-06 22:25:57 -08002817 }
2818
2819 /**
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002820 * Returns the data network type.
2821 * Legacy call, permission-free.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002822 *
2823 * @Deprecated to be removed Q3 2013 use {@link #getDataNetworkType}.
2824 */
2825 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002826 public int getNetworkType() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08002827 final long identity = Binder.clearCallingIdentity();
2828 try {
2829 final Phone phone = getPhone(getDefaultSubscription());
2830 if (phone != null) {
2831 return phone.getServiceState().getDataNetworkType();
2832 } else {
2833 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2834 }
2835 } finally {
2836 Binder.restoreCallingIdentity(identity);
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002837 }
Wink Saville36469e72014-06-11 15:17:00 -07002838 }
2839
Pengquan Menga1bb6272018-09-06 09:59:22 -07002840 @Override
2841 public int getNetworkSelectionMode(int subId) {
Pengquan Menge92a50d2018-09-21 15:54:48 -07002842 if (!isActiveSubscription(subId)) {
2843 return TelephonyManager.NETWORK_SELECTION_MODE_UNKNOWN;
2844 }
2845
Pengquan Menga1bb6272018-09-06 09:59:22 -07002846 return (int) sendRequest(CMD_GET_NETWORK_SELECTION_MODE, null /* argument */, subId);
2847 }
2848
Brad Ebinger35c841c2018-10-01 10:40:55 -07002849 @Override
Brad Ebingerb2b65522019-03-15 13:48:47 -07002850 public boolean isInEmergencySmsMode() {
2851 enforceReadPrivilegedPermission("isInEmergencySmsMode");
2852 final long identity = Binder.clearCallingIdentity();
2853 try {
2854 for (Phone phone : PhoneFactory.getPhones()) {
2855 if (phone.isInEmergencySmsMode()) {
2856 return true;
2857 }
2858 }
2859 } finally {
2860 Binder.restoreCallingIdentity(identity);
2861 }
2862 return false;
2863 }
2864
2865 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002866 public void registerImsRegistrationCallback(int subId, IImsRegistrationCallback c)
2867 throws RemoteException {
2868 enforceReadPrivilegedPermission("registerImsRegistrationCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002869 final long token = Binder.clearCallingIdentity();
2870 try {
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002871 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002872 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002873 .addRegistrationCallbackForSubscription(c, subId);
2874 } finally {
2875 Binder.restoreCallingIdentity(token);
2876 }
2877 }
2878
2879 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002880 public void unregisterImsRegistrationCallback(int subId, IImsRegistrationCallback c) {
2881 enforceReadPrivilegedPermission("unregisterImsRegistrationCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002882 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2883 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2884 }
2885 Binder.withCleanCallingIdentity(() -> {
2886 try {
2887 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002888 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002889 .removeRegistrationCallbackForSubscription(c, subId);
2890 } catch (IllegalArgumentException e) {
2891 Log.i(LOG_TAG, "unregisterImsRegistrationCallback: " + subId
2892 + "is inactive, ignoring unregister.");
2893 // If the subscription is no longer active, just return, since the callback
2894 // will already have been removed internally.
2895 }
2896 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002897 }
2898
2899 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002900 public void registerMmTelCapabilityCallback(int subId, IImsCapabilityCallback c)
2901 throws RemoteException {
2902 enforceReadPrivilegedPermission("registerMmTelCapabilityCallback");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002903 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2904 final long token = Binder.clearCallingIdentity();
2905 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002906 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger35c841c2018-10-01 10:40:55 -07002907 .addCapabilitiesCallbackForSubscription(c, subId);
2908 } finally {
2909 Binder.restoreCallingIdentity(token);
2910 }
2911 }
2912
2913 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002914 public void unregisterMmTelCapabilityCallback(int subId, IImsCapabilityCallback c) {
2915 enforceReadPrivilegedPermission("unregisterMmTelCapabilityCallback");
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002916
2917 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
2918 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
2919 }
2920 Binder.withCleanCallingIdentity(() -> {
2921 try {
2922 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002923 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08002924 .removeCapabilitiesCallbackForSubscription(c, subId);
2925 } catch (IllegalArgumentException e) {
2926 Log.i(LOG_TAG, "unregisterMmTelCapabilityCallback: " + subId
2927 + "is inactive, ignoring unregister.");
2928 // If the subscription is no longer active, just return, since the callback
2929 // will already have been removed internally.
2930 }
2931 });
Brad Ebinger35c841c2018-10-01 10:40:55 -07002932 }
2933
2934 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002935 public boolean isCapable(int subId, int capability, int regTech) {
2936 enforceReadPrivilegedPermission("isCapable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002937 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2938 final long token = Binder.clearCallingIdentity();
2939 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002940 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002941 getSlotIndexOrException(subId)).queryMmTelCapability(capability, regTech);
2942 } catch (ImsException e) {
2943 Log.w(LOG_TAG, "IMS isCapable - service unavailable: " + e.getMessage());
2944 return false;
Brad Ebinger6b5ac222019-02-04 14:36:52 -08002945 } catch (IllegalArgumentException e) {
2946 Log.i(LOG_TAG, "isCapable: " + subId + " is inactive, returning false.");
2947 return false;
Brad Ebinger35c841c2018-10-01 10:40:55 -07002948 } finally {
2949 Binder.restoreCallingIdentity(token);
2950 }
2951 }
2952
2953 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002954 public boolean isAvailable(int subId, int capability, int regTech) {
2955 enforceReadPrivilegedPermission("isAvailable");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002956 final long token = Binder.clearCallingIdentity();
2957 try {
2958 Phone phone = getPhone(subId);
2959 if (phone == null) return false;
2960 return phone.isImsCapabilityAvailable(capability, regTech);
2961 } finally {
2962 Binder.restoreCallingIdentity(token);
2963 }
2964 }
2965
2966 @Override
2967 public boolean isAdvancedCallingSettingEnabled(int subId) {
2968 enforceReadPrivilegedPermission("enforceReadPrivilegedPermission");
2969 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
2970 final long token = Binder.clearCallingIdentity();
2971 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002972 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002973 getSlotIndexOrException(subId)).isEnhanced4gLteModeSettingEnabledByUser();
2974 } finally {
2975 Binder.restoreCallingIdentity(token);
2976 }
2977 }
2978
2979 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08002980 public void setAdvancedCallingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07002981 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08002982 "setAdvancedCallingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002983 final long identity = Binder.clearCallingIdentity();
2984 try {
2985 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002986 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07002987 getSlotIndexOrException(subId)).setEnhanced4gLteModeSetting(isEnabled);
2988 } finally {
2989 Binder.restoreCallingIdentity(identity);
2990 }
2991 }
2992
2993 @Override
Brad Ebinger9878b0b2018-11-08 17:43:22 -08002994 public boolean isVtSettingEnabled(int subId) {
2995 enforceReadPrivilegedPermission("isVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07002996 final long identity = Binder.clearCallingIdentity();
2997 try {
2998 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08002999 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003000 getSlotIndexOrException(subId)).isVtEnabledByUser();
3001 } finally {
3002 Binder.restoreCallingIdentity(identity);
3003 }
3004 }
3005
3006 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003007 public void setVtSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003008 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003009 "setVtSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003010 final long identity = Binder.clearCallingIdentity();
3011 try {
3012 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003013 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setVtSetting(isEnabled);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003014 } finally {
3015 Binder.restoreCallingIdentity(identity);
3016 }
3017 }
3018
3019 @Override
3020 public boolean isVoWiFiSettingEnabled(int subId) {
3021 enforceReadPrivilegedPermission("isVoWiFiSettingEnabled");
3022 final long identity = Binder.clearCallingIdentity();
3023 try {
3024 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003025 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003026 getSlotIndexOrException(subId)).isWfcEnabledByUser();
3027 } finally {
3028 Binder.restoreCallingIdentity(identity);
3029 }
3030 }
3031
3032 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003033 public void setVoWiFiSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003034 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003035 "setVoWiFiSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003036 final long identity = Binder.clearCallingIdentity();
3037 try {
3038 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003039 ImsManager.getInstance(mApp, getSlotIndexOrException(subId)).setWfcSetting(isEnabled);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003040 } finally {
3041 Binder.restoreCallingIdentity(identity);
3042 }
3043 }
3044
3045 @Override
3046 public boolean isVoWiFiRoamingSettingEnabled(int subId) {
3047 enforceReadPrivilegedPermission("isVoWiFiRoamingSettingEnabled");
3048 final long identity = Binder.clearCallingIdentity();
3049 try {
3050 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003051 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003052 getSlotIndexOrException(subId)).isWfcRoamingEnabledByUser();
3053 } finally {
3054 Binder.restoreCallingIdentity(identity);
3055 }
3056 }
3057
3058 @Override
Brad Ebinger1c162042019-02-21 14:49:10 -08003059 public void setVoWiFiRoamingSettingEnabled(int subId, boolean isEnabled) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07003060 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
Brad Ebinger1c162042019-02-21 14:49:10 -08003061 "setVoWiFiRoamingSettingEnabled");
Brad Ebinger35c841c2018-10-01 10:40:55 -07003062 final long identity = Binder.clearCallingIdentity();
3063 try {
3064 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003065 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003066 getSlotIndexOrException(subId)).setWfcRoamingSetting(isEnabled);
3067 } finally {
3068 Binder.restoreCallingIdentity(identity);
3069 }
3070 }
3071
3072 @Override
3073 public void setVoWiFiNonPersistent(int subId, boolean isCapable, int mode) {
3074 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3075 "setVoWiFiNonPersistent");
3076 final long identity = Binder.clearCallingIdentity();
3077 try {
3078 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003079 ImsManager.getInstance(mApp,
Brad Ebinger2d29c012019-05-07 18:33:46 -07003080 getSlotIndexOrException(subId)).setWfcNonPersistent(isCapable, mode);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003081 } finally {
3082 Binder.restoreCallingIdentity(identity);
3083 }
3084 }
3085
3086 @Override
3087 public int getVoWiFiModeSetting(int subId) {
3088 enforceReadPrivilegedPermission("getVoWiFiModeSetting");
3089 final long identity = Binder.clearCallingIdentity();
3090 try {
3091 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003092 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003093 getSlotIndexOrException(subId)).getWfcMode(false /*isRoaming*/);
3094 } finally {
3095 Binder.restoreCallingIdentity(identity);
3096 }
3097 }
3098
3099 @Override
3100 public void setVoWiFiModeSetting(int subId, int mode) {
3101 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3102 "setVoWiFiModeSetting");
3103 final long identity = Binder.clearCallingIdentity();
3104 try {
3105 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003106 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003107 getSlotIndexOrException(subId)).setWfcMode(mode, false /*isRoaming*/);
3108 } finally {
3109 Binder.restoreCallingIdentity(identity);
3110 }
3111 }
3112
3113 @Override
3114 public int getVoWiFiRoamingModeSetting(int subId) {
3115 enforceReadPrivilegedPermission("getVoWiFiRoamingModeSetting");
3116 final long identity = Binder.clearCallingIdentity();
3117 try {
3118 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003119 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003120 getSlotIndexOrException(subId)).getWfcMode(true /*isRoaming*/);
3121 } finally {
3122 Binder.restoreCallingIdentity(identity);
3123 }
3124 }
3125
3126 @Override
3127 public void setVoWiFiRoamingModeSetting(int subId, int mode) {
3128 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3129 "setVoWiFiRoamingModeSetting");
3130 final long identity = Binder.clearCallingIdentity();
3131 try {
3132 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003133 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003134 getSlotIndexOrException(subId)).setWfcMode(mode, true /*isRoaming*/);
3135 } finally {
3136 Binder.restoreCallingIdentity(identity);
3137 }
3138 }
3139
3140 @Override
3141 public void setRttCapabilitySetting(int subId, boolean isEnabled) {
3142 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3143 "setRttCapabilityEnabled");
3144 final long identity = Binder.clearCallingIdentity();
3145 try {
3146 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003147 ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003148 getSlotIndexOrException(subId)).setRttEnabled(isEnabled);
3149 } finally {
3150 Binder.restoreCallingIdentity(identity);
3151 }
3152 }
3153
3154 @Override
3155 public boolean isTtyOverVolteEnabled(int subId) {
3156 enforceReadPrivilegedPermission("isTtyOverVolteEnabled");
3157 final long identity = Binder.clearCallingIdentity();
3158 try {
3159 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003160 return ImsManager.getInstance(mApp,
Brad Ebinger35c841c2018-10-01 10:40:55 -07003161 getSlotIndexOrException(subId)).isTtyOnVoLteCapable();
3162 } finally {
3163 Binder.restoreCallingIdentity(identity);
3164 }
3165 }
3166
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003167 @Override
3168 public void registerImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3169 enforceReadPrivilegedPermission("registerImsProvisioningChangedCallback");
3170 final long identity = Binder.clearCallingIdentity();
3171 try {
3172 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003173 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003174 .addProvisioningCallbackForSubscription(callback, subId);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003175 } finally {
3176 Binder.restoreCallingIdentity(identity);
3177 }
3178 }
3179
3180 @Override
3181 public void unregisterImsProvisioningChangedCallback(int subId, IImsConfigCallback callback) {
3182 enforceReadPrivilegedPermission("unregisterImsProvisioningChangedCallback");
3183 final long identity = Binder.clearCallingIdentity();
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003184 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3185 throw new IllegalArgumentException("Invalid Subscription ID: " + subId);
3186 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003187 try {
3188 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003189 ImsManager.getInstance(mApp, getSlotIndexOrException(subId))
Brad Ebinger4ae57f92019-01-09 16:51:30 -08003190 .removeProvisioningCallbackForSubscription(callback, subId);
3191 } catch (IllegalArgumentException e) {
3192 Log.i(LOG_TAG, "unregisterImsProvisioningChangedCallback: " + subId
3193 + "is inactive, ignoring unregister.");
3194 // If the subscription is no longer active, just return, since the callback will already
3195 // have been removed internally.
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003196 } finally {
3197 Binder.restoreCallingIdentity(identity);
3198 }
3199 }
3200
3201 @Override
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003202 public void setImsProvisioningStatusForCapability(int subId, int capability, int tech,
3203 boolean isProvisioned) {
3204 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3205 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3206 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3207 }
3208 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3209 "setProvisioningStatusForCapability");
3210 final long identity = Binder.clearCallingIdentity();
3211 try {
3212 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3213 Phone phone = getPhone(subId);
3214 if (phone == null) {
3215 loge("setImsProvisioningStatusForCapability: phone instance null for subid "
3216 + subId);
3217 return;
3218 }
3219 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3220 return;
3221 }
3222
3223 // this capability requires provisioning, route to the correct API.
3224 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3225 switch (capability) {
3226 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3227 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3228 ims.setVolteProvisioned(isProvisioned);
3229 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3230 ims.setWfcProvisioned(isProvisioned);
3231 }
3232 break;
3233 }
3234 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3235 // There is currently no difference in VT provisioning type.
3236 ims.setVtProvisioned(isProvisioned);
3237 break;
3238 }
3239 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3240 // There is no "deprecated" UT provisioning mechanism through ImsConfig, so
3241 // change the capability of the feature instead if needed.
3242 if (isMmTelCapabilityProvisionedInCache(subId, capability, tech)
3243 == isProvisioned) {
3244 // No change in provisioning.
3245 return;
3246 }
3247 cacheMmTelCapabilityProvisioning(subId, capability, tech, isProvisioned);
3248 try {
3249 ims.changeMmTelCapability(capability, tech, isProvisioned);
3250 } catch (ImsException e) {
3251 loge("setImsProvisioningStatusForCapability: couldn't change UT capability"
3252 + ", Exception" + e.getMessage());
3253 }
3254 break;
3255 }
3256 default: {
3257 throw new IllegalArgumentException("Tried to set provisioning for capability '"
3258 + capability + "', which does not require provisioning.");
3259 }
3260 }
3261
3262 } finally {
3263 Binder.restoreCallingIdentity(identity);
3264 }
3265 }
3266
3267 @Override
3268 public boolean getImsProvisioningStatusForCapability(int subId, int capability, int tech) {
3269 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3270 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3271 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3272 }
3273 enforceReadPrivilegedPermission("getProvisioningStatusForCapability");
3274 final long identity = Binder.clearCallingIdentity();
3275 try {
3276 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
3277 Phone phone = getPhone(subId);
3278 if (phone == null) {
3279 loge("getImsProvisioningStatusForCapability: phone instance null for subid "
3280 + subId);
3281 // We will fail with "true" as the provisioning status because this is the default
3282 // if we do not require provisioning.
3283 return true;
3284 }
3285
3286 if (!doesImsCapabilityRequireProvisioning(phone.getContext(), subId, capability)) {
3287 return true;
3288 }
3289
3290 ImsManager ims = ImsManager.getInstance(mApp, getSlotIndex(subId));
3291 switch (capability) {
3292 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE: {
3293 if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3294 return ims.isVolteProvisionedOnDevice();
3295 } else if (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN) {
3296 return ims.isWfcProvisionedOnDevice();
3297 }
3298 // This should never happen, since we are checking tech above to make sure it
3299 // is either LTE or IWLAN.
3300 throw new IllegalArgumentException("Invalid radio technology for voice "
3301 + "capability.");
3302 }
3303 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3304 // There is currently no difference in VT provisioning type.
3305 return ims.isVtProvisionedOnDevice();
3306 }
3307 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3308 // There is no "deprecated" UT provisioning mechanism, so get from shared prefs.
3309 return isMmTelCapabilityProvisionedInCache(subId, capability, tech);
3310 }
3311 default: {
3312 throw new IllegalArgumentException("Tried to get provisioning for capability '"
3313 + capability + "', which does not require provisioning.");
3314 }
3315 }
3316
3317 } finally {
3318 Binder.restoreCallingIdentity(identity);
3319 }
3320 }
3321
3322 @Override
3323 public boolean isMmTelCapabilityProvisionedInCache(int subId, int capability, int tech) {
3324 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3325 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3326 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3327 }
3328 enforceReadPrivilegedPermission("isMmTelCapabilityProvisionedInCache");
3329 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3330 return (provisionedBits & capability) > 0;
3331 }
3332
3333 @Override
3334 public void cacheMmTelCapabilityProvisioning(int subId, int capability, int tech,
3335 boolean isProvisioned) {
3336 if (tech != ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN
3337 && tech != ImsRegistrationImplBase.REGISTRATION_TECH_LTE) {
3338 throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
3339 }
3340 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3341 "setProvisioningStatusForCapability");
3342 int provisionedBits = getMmTelCapabilityProvisioningBitfield(subId, tech);
3343 // If the current provisioning status for capability already matches isProvisioned,
3344 // do nothing.
3345 if (((provisionedBits & capability) > 0) == isProvisioned) {
3346 return;
3347 }
3348 if (isProvisioned) {
3349 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits | capability));
3350 } else {
3351 setMmTelCapabilityProvisioningBitfield(subId, tech, (provisionedBits & ~capability));
3352 }
3353 }
3354
3355 /**
3356 * @return the bitfield containing the MmTel provisioning for the provided subscription and
3357 * technology. The bitfield should mirror the bitfield defined by
3358 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}.
3359 */
3360 private int getMmTelCapabilityProvisioningBitfield(int subId, int tech) {
3361 String key = getMmTelProvisioningKey(subId, tech);
3362 // Default is no capabilities are provisioned.
3363 return mTelephonySharedPreferences.getInt(key, 0 /*default*/);
3364 }
3365
3366 /**
3367 * Sets the MmTel capability provisioning bitfield (defined by
3368 * {@link MmTelFeature.MmTelCapabilities.MmTelCapability}) for the subscription and
3369 * technology specified.
3370 *
3371 * Note: This is a synchronous command and should not be called on UI thread.
3372 */
3373 private void setMmTelCapabilityProvisioningBitfield(int subId, int tech, int newField) {
3374 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
3375 String key = getMmTelProvisioningKey(subId, tech);
3376 editor.putInt(key, newField);
3377 editor.commit();
3378 }
3379
3380 private static String getMmTelProvisioningKey(int subId, int tech) {
3381 // resulting key is provision_ims_mmtel_{subId}_{tech}
3382 return PREF_PROVISION_IMS_MMTEL_PREFIX + subId + "_" + tech;
3383 }
3384
3385 /**
3386 * Query CarrierConfig to see if the specified capability requires provisioning for the
3387 * carrier associated with the subscription id.
3388 */
3389 private boolean doesImsCapabilityRequireProvisioning(Context context, int subId,
3390 int capability) {
3391 CarrierConfigManager configManager = new CarrierConfigManager(context);
3392 PersistableBundle c = configManager.getConfigForSubId(subId);
3393 boolean requireUtProvisioning = c.getBoolean(
3394 // By default, this config is true (even if there is no SIM). We also check to make
3395 // sure the subscription needs provisioning here, so we do not need to check for
3396 // the no-SIM case, where we would normally shortcut this to false.
3397 CarrierConfigManager.KEY_CARRIER_SUPPORTS_SS_OVER_UT_BOOL, true)
3398 && c.getBoolean(CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL,
3399 false);
3400 boolean requireVoiceVtProvisioning = c.getBoolean(
3401 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, false);
3402
3403 // First check to make sure that the capability requires provisioning.
3404 switch (capability) {
3405 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE:
3406 // intentional fallthrough
3407 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO: {
3408 if (requireVoiceVtProvisioning) {
3409 // Voice and Video requires provisioning
3410 return true;
3411 }
3412 break;
3413 }
3414 case MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT: {
3415 if (requireUtProvisioning) {
3416 // UT requires provisioning
3417 return true;
3418 }
3419 break;
3420 }
3421 }
3422 return false;
3423 }
3424
3425 @Override
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003426 public int getImsProvisioningInt(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003427 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3428 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3429 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003430 enforceReadPrivilegedPermission("getImsProvisioningInt");
3431 final long identity = Binder.clearCallingIdentity();
3432 try {
3433 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003434 int slotId = getSlotIndex(subId);
3435 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3436 Log.w(LOG_TAG, "getImsProvisioningInt: called with an inactive subscription '"
3437 + subId + "' for key:" + key);
3438 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
3439 }
3440 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigInt(key);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003441 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003442 Log.w(LOG_TAG, "getImsProvisioningInt: ImsService is not available for subscription '"
3443 + subId + "' for key:" + key);
3444 return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003445 } finally {
3446 Binder.restoreCallingIdentity(identity);
3447 }
3448 }
3449
3450 @Override
3451 public String getImsProvisioningString(int subId, int key) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003452 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3453 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3454 }
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003455 enforceReadPrivilegedPermission("getImsProvisioningString");
3456 final long identity = Binder.clearCallingIdentity();
3457 try {
3458 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003459 int slotId = getSlotIndex(subId);
3460 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3461 Log.w(LOG_TAG, "getImsProvisioningString: called for an inactive subscription id '"
3462 + subId + "' for key:" + key);
3463 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_GENERIC;
3464 }
3465 return ImsManager.getInstance(mApp, slotId).getConfigInterface().getConfigString(key);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003466 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003467 Log.w(LOG_TAG, "getImsProvisioningString: ImsService is not available for sub '"
3468 + subId + "' for key:" + key);
3469 return ProvisioningManager.STRING_QUERY_RESULT_ERROR_NOT_READY;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003470 } finally {
3471 Binder.restoreCallingIdentity(identity);
3472 }
3473 }
3474
3475 @Override
3476 public int setImsProvisioningInt(int subId, int key, int value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003477 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3478 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3479 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003480 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3481 "setImsProvisioningInt");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003482 final long identity = Binder.clearCallingIdentity();
3483 try {
3484 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003485 int slotId = getSlotIndex(subId);
3486 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3487 Log.w(LOG_TAG, "setImsProvisioningInt: called with an inactive subscription id '"
3488 + subId + "' for key:" + key);
3489 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3490 }
3491 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003492 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003493 Log.w(LOG_TAG, "setImsProvisioningInt: ImsService unavailable for sub '" + subId
3494 + "' for key:" + key);
3495 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003496 } finally {
3497 Binder.restoreCallingIdentity(identity);
3498 }
3499 }
3500
3501 @Override
3502 public int setImsProvisioningString(int subId, int key, String value) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003503 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
3504 throw new IllegalArgumentException("Invalid Subscription id '" + subId + "'");
3505 }
Brad Ebinger3d0b34e2018-11-15 14:13:12 -08003506 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp, subId,
3507 "setImsProvisioningString");
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003508 final long identity = Binder.clearCallingIdentity();
3509 try {
3510 // TODO: Refactor to remove ImsManager dependence and query through ImsPhone directly.
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003511 int slotId = getSlotIndex(subId);
3512 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX) {
3513 Log.w(LOG_TAG, "setImsProvisioningString: called with an inactive subscription id '"
3514 + subId + "' for key:" + key);
3515 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
3516 }
3517 return ImsManager.getInstance(mApp, slotId).getConfigInterface().setConfig(key, value);
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003518 } catch (ImsException e) {
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003519 Log.w(LOG_TAG, "setImsProvisioningString: ImsService unavailable for sub '" + subId
3520 + "' for key:" + key);
3521 return ImsConfigImplBase.CONFIG_RESULT_FAILED;
Brad Ebingerdf5b4f02018-10-31 11:24:17 -07003522 } finally {
3523 Binder.restoreCallingIdentity(identity);
3524 }
3525 }
3526
Brad Ebinger35c841c2018-10-01 10:40:55 -07003527 private int getSlotIndexOrException(int subId) throws IllegalArgumentException {
3528 int slotId = SubscriptionManager.getSlotIndex(subId);
3529 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
Brad Ebinger6b5ac222019-02-04 14:36:52 -08003530 throw new IllegalArgumentException("Invalid Subscription Id, subId=" + subId);
Brad Ebinger35c841c2018-10-01 10:40:55 -07003531 }
3532 return slotId;
3533 }
3534
Brad Ebinger1c8542e2019-01-14 13:43:14 -08003535 private int getSlotIndex(int subId) {
3536 int slotId = SubscriptionManager.getSlotIndex(subId);
3537 if (!SubscriptionManager.isValidSlotIndex(slotId)) {
3538 return SubscriptionManager.INVALID_SIM_SLOT_INDEX;
3539 }
3540 return slotId;
3541 }
3542
Wink Saville36469e72014-06-11 15:17:00 -07003543 /**
3544 * Returns the network type for a subId
3545 */
3546 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003547 public int getNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003548 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003549 mApp, subId, callingPackage, "getNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003550 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3551 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003552
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003553 final long identity = Binder.clearCallingIdentity();
3554 try {
3555 final Phone phone = getPhone(subId);
3556 if (phone != null) {
3557 return phone.getServiceState().getDataNetworkType();
3558 } else {
3559 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3560 }
3561 } finally {
3562 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003563 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003564 }
3565
3566 /**
3567 * Returns the data network type
3568 */
3569 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003570 public int getDataNetworkType(String callingPackage) {
3571 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003572 }
3573
3574 /**
3575 * Returns the data network type for a subId
3576 */
3577 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003578 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003579 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003580 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003581 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3582 }
3583
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003584 final long identity = Binder.clearCallingIdentity();
3585 try {
3586 final Phone phone = getPhone(subId);
3587 if (phone != null) {
3588 return phone.getServiceState().getDataNetworkType();
3589 } else {
3590 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3591 }
3592 } finally {
3593 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003594 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003595 }
3596
3597 /**
Wink Saville36469e72014-06-11 15:17:00 -07003598 * Returns the Voice network type for a subId
3599 */
3600 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003601 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003602 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003603 mApp, subId, callingPackage, "getDataNetworkTypeForSubscriber")) {
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07003604 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3605 }
3606
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003607 final long identity = Binder.clearCallingIdentity();
3608 try {
3609 final Phone phone = getPhone(subId);
3610 if (phone != null) {
3611 return phone.getServiceState().getVoiceNetworkType();
3612 } else {
3613 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
3614 }
3615 } finally {
3616 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003617 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003618 }
3619
3620 /**
3621 * @return true if a ICC card is present
3622 */
3623 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07003624 // FIXME Make changes to pass defaultSimId of type int
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003625 return hasIccCardUsingSlotIndex(mSubscriptionController.getSlotIndex(
3626 getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07003627 }
3628
3629 /**
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003630 * @return true if a ICC card is present for a slotIndex
Wink Saville36469e72014-06-11 15:17:00 -07003631 */
Sanket Padawe356d7632015-06-22 14:03:32 -07003632 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003633 public boolean hasIccCardUsingSlotIndex(int slotIndex) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003634 final long identity = Binder.clearCallingIdentity();
3635 try {
3636 final Phone phone = PhoneFactory.getPhone(slotIndex);
3637 if (phone != null) {
3638 return phone.getIccCard().hasIccCard();
3639 } else {
3640 return false;
3641 }
3642 } finally {
3643 Binder.restoreCallingIdentity(identity);
Amit Mahajana6fc2a82015-01-06 11:53:51 -08003644 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003645 }
3646
3647 /**
3648 * Return if the current radio is LTE on CDMA. This
3649 * is a tri-state return value as for a period of time
3650 * the mode may be unknown.
3651 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003652 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003653 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08003654 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003655 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003656 @Override
3657 public int getLteOnCdmaMode(String callingPackage) {
3658 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07003659 }
3660
Sanket Padawe356d7632015-06-22 14:03:32 -07003661 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003662 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003663 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08003664 mApp, subId, callingPackage, "getLteOnCdmaModeForSubscriber")) {
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003665 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3666 }
3667
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003668 final long identity = Binder.clearCallingIdentity();
3669 try {
3670 final Phone phone = getPhone(subId);
3671 if (phone == null) {
3672 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
3673 } else {
3674 return phone.getLteOnCdmaMode();
3675 }
3676 } finally {
3677 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07003678 }
Wink Saville36469e72014-06-11 15:17:00 -07003679 }
3680
Wink Saville36469e72014-06-11 15:17:00 -07003681 /**
3682 * {@hide}
3683 * Returns Default subId, 0 in the case of single standby.
3684 */
Wink Savilleb564aae2014-10-23 10:18:09 -07003685 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003686 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07003687 }
3688
Shishir Agrawala9f32182016-04-12 12:00:16 -07003689 private int getSlotForDefaultSubscription() {
3690 return mSubscriptionController.getPhoneId(getDefaultSubscription());
3691 }
3692
Wink Savilleb564aae2014-10-23 10:18:09 -07003693 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08003694 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003695 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003696
Pengquan Menge92a50d2018-09-21 15:54:48 -07003697 private boolean isActiveSubscription(int subId) {
3698 return mSubscriptionController.isActiveSubId(subId);
3699 }
3700
Ihab Awadf2177b72013-11-25 13:33:23 -08003701 /**
3702 * @see android.telephony.TelephonyManager.WifiCallingChoices
3703 */
3704 public int getWhenToMakeWifiCalls() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003705 final long identity = Binder.clearCallingIdentity();
3706 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003707 return Settings.System.getInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003708 Settings.System.WHEN_TO_MAKE_WIFI_CALLS,
3709 getWhenToMakeWifiCallsDefaultPreference());
3710 } finally {
3711 Binder.restoreCallingIdentity(identity);
3712 }
Ihab Awadf2177b72013-11-25 13:33:23 -08003713 }
3714
3715 /**
3716 * @see android.telephony.TelephonyManager.WifiCallingChoices
3717 */
3718 public void setWhenToMakeWifiCalls(int preference) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003719 final long identity = Binder.clearCallingIdentity();
3720 try {
3721 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003722 Settings.System.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003723 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
3724 } finally {
3725 Binder.restoreCallingIdentity(identity);
3726 }
Ihab Awadf9e92732013-12-05 18:02:52 -08003727 }
3728
Sailesh Nepald1e68152013-12-12 19:08:02 -08003729 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07003730 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08003731 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08003732 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08003733
Jordan Liu4c733742019-02-28 12:03:40 -08003734 private Phone getPhoneFromSlotIdOrThrowException(int slotIndex) {
3735 int phoneId = UiccController.getInstance().getPhoneIdFromSlotId(slotIndex);
3736 if (phoneId == -1) {
3737 throw new IllegalArgumentException("Given slot index: " + slotIndex
3738 + " does not correspond to an active phone");
3739 }
3740 return PhoneFactory.getPhone(phoneId);
3741 }
3742
Shishir Agrawal566b7612013-10-28 14:41:00 -07003743 @Override
Derek Tan740e1672017-06-27 14:56:27 -07003744 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(
3745 int subId, String callingPackage, String aid, int p2) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003746 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3747 mApp, subId, "iccOpenLogicalChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003748 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003749 if (DBG) {
3750 log("iccOpenLogicalChannel: subId=" + subId + " aid=" + aid + " p2=" + p2);
3751 }
3752 return iccOpenLogicalChannelWithPermission(getPhoneFromSubId(subId), callingPackage, aid,
3753 p2);
3754 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003755
Jordan Liu4c733742019-02-28 12:03:40 -08003756
3757 @Override
3758 public IccOpenLogicalChannelResponse iccOpenLogicalChannelBySlot(
3759 int slotIndex, String callingPackage, String aid, int p2) {
3760 enforceModifyPermission();
3761 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3762 if (DBG) {
3763 log("iccOpenLogicalChannelBySlot: slot=" + slotIndex + " aid=" + aid + " p2=" + p2);
3764 }
3765 return iccOpenLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3766 callingPackage, aid, p2);
3767 }
3768
3769 private IccOpenLogicalChannelResponse iccOpenLogicalChannelWithPermission(Phone phone,
3770 String callingPackage, String aid, int p2) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003771 final long identity = Binder.clearCallingIdentity();
3772 try {
3773 if (TextUtils.equals(ISDR_AID, aid)) {
3774 // Only allows LPA to open logical channel to ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003775 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3776 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003777 if (bestComponent == null
3778 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3779 loge("The calling package is not allowed to access ISD-R.");
3780 throw new SecurityException(
3781 "The calling package is not allowed to access ISD-R.");
3782 }
Derek Tan740e1672017-06-27 14:56:27 -07003783 }
Derek Tan740e1672017-06-27 14:56:27 -07003784
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003785 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse) sendRequest(
Jordan Liu4c733742019-02-28 12:03:40 -08003786 CMD_OPEN_CHANNEL, new Pair<String, Integer>(aid, p2), phone,
3787 null /* workSource */);
3788 if (DBG) log("iccOpenLogicalChannelWithPermission: " + response);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003789 return response;
3790 } finally {
3791 Binder.restoreCallingIdentity(identity);
3792 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003793 }
3794
3795 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003796 public boolean iccCloseLogicalChannel(int subId, int channel) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003797 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3798 mApp, subId, "iccCloseLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003799 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
3800 return iccCloseLogicalChannelWithPermission(getPhoneFromSubId(subId), channel);
3801 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003802
Jordan Liu4c733742019-02-28 12:03:40 -08003803 @Override
3804 public boolean iccCloseLogicalChannelBySlot(int slotIndex, int channel) {
3805 enforceModifyPermission();
3806 if (DBG) log("iccCloseLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel);
3807 return iccCloseLogicalChannelWithPermission(getPhoneFromSlotIdOrThrowException(slotIndex),
3808 channel);
3809 }
3810
3811 private boolean iccCloseLogicalChannelWithPermission(Phone phone, int channel) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003812 final long identity = Binder.clearCallingIdentity();
3813 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003814 if (channel < 0) {
3815 return false;
3816 }
Jordan Liu4c733742019-02-28 12:03:40 -08003817 Boolean success = (Boolean) sendRequest(CMD_CLOSE_CHANNEL, channel, phone,
3818 null /* workSource */);
3819 if (DBG) log("iccCloseLogicalChannelWithPermission: " + success);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003820 return success;
3821 } finally {
3822 Binder.restoreCallingIdentity(identity);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003823 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003824 }
3825
3826 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003827 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07003828 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003829 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3830 mApp, subId, "iccTransmitApduLogicalChannel");
Jordan Liu4c733742019-02-28 12:03:40 -08003831 if (DBG) {
3832 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel
3833 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3834 + p3 + " data=" + data);
3835 }
3836 return iccTransmitApduLogicalChannelWithPermission(getPhoneFromSubId(subId), channel, cla,
3837 command, p1, p2, p3, data);
3838 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003839
Jordan Liu4c733742019-02-28 12:03:40 -08003840 @Override
3841 public String iccTransmitApduLogicalChannelBySlot(int slotIndex, int channel, int cla,
3842 int command, int p1, int p2, int p3, String data) {
3843 enforceModifyPermission();
3844 if (DBG) {
3845 log("iccTransmitApduLogicalChannelBySlot: slotIndex=" + slotIndex + " chnl=" + channel
3846 + " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3="
3847 + p3 + " data=" + data);
3848 }
3849 return iccTransmitApduLogicalChannelWithPermission(
3850 getPhoneFromSlotIdOrThrowException(slotIndex), channel, cla, command, p1, p2, p3,
3851 data);
3852 }
3853
3854 private String iccTransmitApduLogicalChannelWithPermission(Phone phone, int channel, int cla,
3855 int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003856 final long identity = Binder.clearCallingIdentity();
3857 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003858 if (channel < 0) {
3859 return "";
3860 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003861
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003862 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003863 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), phone,
3864 null /* workSource */);
3865 if (DBG) log("iccTransmitApduLogicalChannelWithPermission: " + response);
Shishir Agrawal566b7612013-10-28 14:41:00 -07003866
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003867 // Append the returned status code to the end of the response payload.
3868 String s = Integer.toHexString(
3869 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3870 if (response.payload != null) {
3871 s = IccUtils.bytesToHexString(response.payload) + s;
3872 }
3873 return s;
3874 } finally {
3875 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003876 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07003877 }
Jake Hambye994d462014-02-03 13:10:13 -08003878
Evan Charltonc66da362014-05-16 14:06:40 -07003879 @Override
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003880 public String iccTransmitApduBasicChannel(int subId, String callingPackage, int cla,
3881 int command, int p1, int p2, int p3, String data) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003882 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3883 mApp, subId, "iccTransmitApduBasicChannel");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003884 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Jordan Liu4c733742019-02-28 12:03:40 -08003885 if (DBG) {
3886 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd="
3887 + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
3888 }
3889 return iccTransmitApduBasicChannelWithPermission(getPhoneFromSubId(subId), callingPackage,
3890 cla, command, p1, p2, p3, data);
3891 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003892
Jordan Liu4c733742019-02-28 12:03:40 -08003893 @Override
3894 public String iccTransmitApduBasicChannelBySlot(int slotIndex, String callingPackage, int cla,
3895 int command, int p1, int p2, int p3, String data) {
3896 enforceModifyPermission();
3897 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3898 if (DBG) {
3899 log("iccTransmitApduBasicChannelBySlot: slotIndex=" + slotIndex + " cla=" + cla
3900 + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3
3901 + " data=" + data);
3902 }
3903
3904 return iccTransmitApduBasicChannelWithPermission(
3905 getPhoneFromSlotIdOrThrowException(slotIndex), callingPackage, cla, command, p1,
3906 p2, p3, data);
3907 }
3908
3909 // open APDU basic channel assuming the caller has sufficient permissions
3910 private String iccTransmitApduBasicChannelWithPermission(Phone phone, String callingPackage,
3911 int cla, int command, int p1, int p2, int p3, String data) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003912 final long identity = Binder.clearCallingIdentity();
3913 try {
3914 if (command == SELECT_COMMAND && p1 == SELECT_P1 && p2 == SELECT_P2 && p3 == SELECT_P3
3915 && TextUtils.equals(ISDR_AID, data)) {
3916 // Only allows LPA to select ISD-R.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08003917 ComponentInfo bestComponent = EuiccConnector.findBestComponent(getDefaultPhone()
3918 .getContext().getPackageManager());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003919 if (bestComponent == null
3920 || !TextUtils.equals(callingPackage, bestComponent.packageName)) {
3921 loge("The calling package is not allowed to select ISD-R.");
3922 throw new SecurityException(
3923 "The calling package is not allowed to select ISD-R.");
3924 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003925 }
Holly Jiuyu Sun1cc2d552018-01-26 15:51:16 -08003926
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003927 IccIoResult response = (IccIoResult) sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Jordan Liu4c733742019-02-28 12:03:40 -08003928 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), phone,
3929 null /* workSource */);
3930 if (DBG) log("iccTransmitApduBasicChannelWithPermission: " + response);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003931
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003932 // Append the returned status code to the end of the response payload.
3933 String s = Integer.toHexString(
3934 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
3935 if (response.payload != null) {
3936 s = IccUtils.bytesToHexString(response.payload) + s;
3937 }
3938 return s;
3939 } finally {
3940 Binder.restoreCallingIdentity(identity);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07003941 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003942 }
3943
3944 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003945 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003946 String filePath) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08003947 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
3948 mApp, subId, "iccExchangeSimIO");
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003949
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003950 final long identity = Binder.clearCallingIdentity();
3951 try {
3952 if (DBG) {
3953 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " "
3954 + p1 + " " + p2 + " " + p3 + ":" + filePath);
3955 }
3956
3957 IccIoResult response =
3958 (IccIoResult) sendRequest(CMD_EXCHANGE_SIM_IO,
3959 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
3960 subId);
3961
3962 if (DBG) {
3963 log("Exchange SIM_IO [R]" + response);
3964 }
3965
3966 byte[] result = null;
3967 int length = 2;
3968 if (response.payload != null) {
3969 length = 2 + response.payload.length;
3970 result = new byte[length];
3971 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
3972 } else {
3973 result = new byte[length];
3974 }
3975
3976 result[length - 1] = (byte) response.sw2;
3977 result[length - 2] = (byte) response.sw1;
3978 return result;
3979 } finally {
3980 Binder.restoreCallingIdentity(identity);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003981 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07003982 }
3983
Nathan Haroldb3014052017-01-25 15:57:32 -08003984 /**
3985 * Get the forbidden PLMN List from the given app type (ex APPTYPE_USIM)
3986 * on a particular subscription
3987 */
sqianb6e41952018-03-12 14:54:01 -07003988 public String[] getForbiddenPlmns(int subId, int appType, String callingPackage) {
3989 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
3990 mApp, subId, callingPackage, "getForbiddenPlmns")) {
3991 return null;
3992 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08003993
3994 final long identity = Binder.clearCallingIdentity();
3995 try {
3996 if (appType != TelephonyManager.APPTYPE_USIM
3997 && appType != TelephonyManager.APPTYPE_SIM) {
3998 loge("getForbiddenPlmnList(): App Type must be USIM or SIM");
3999 return null;
4000 }
4001 Object response = sendRequest(
4002 CMD_GET_FORBIDDEN_PLMNS, new Integer(appType), subId);
4003 if (response instanceof String[]) {
4004 return (String[]) response;
4005 }
4006 // Response is an Exception of some kind,
4007 // which is signalled to the user as a NULL retval
Nathan Haroldb3014052017-01-25 15:57:32 -08004008 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004009 } finally {
4010 Binder.restoreCallingIdentity(identity);
Nathan Haroldb3014052017-01-25 15:57:32 -08004011 }
Nathan Haroldb3014052017-01-25 15:57:32 -08004012 }
4013
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07004014 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004015 public String sendEnvelopeWithStatus(int subId, String content) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004016 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4017 mApp, subId, "sendEnvelopeWithStatus");
Evan Charltonc66da362014-05-16 14:06:40 -07004018
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004019 final long identity = Binder.clearCallingIdentity();
4020 try {
4021 IccIoResult response = (IccIoResult) sendRequest(CMD_SEND_ENVELOPE, content, subId);
4022 if (response.payload == null) {
4023 return "";
4024 }
Evan Charltonc66da362014-05-16 14:06:40 -07004025
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004026 // Append the returned status code to the end of the response payload.
4027 String s = Integer.toHexString(
4028 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
4029 s = IccUtils.bytesToHexString(response.payload) + s;
4030 return s;
4031 } finally {
4032 Binder.restoreCallingIdentity(identity);
4033 }
Evan Charltonc66da362014-05-16 14:06:40 -07004034 }
4035
Jake Hambye994d462014-02-03 13:10:13 -08004036 /**
4037 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4038 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4039 *
4040 * @param itemID the ID of the item to read
4041 * @return the NV item as a String, or null on error.
4042 */
4043 @Override
4044 public String nvReadItem(int itemID) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004045 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004046 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4047 mApp, getDefaultSubscription(), "nvReadItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004048
4049 final long identity = Binder.clearCallingIdentity();
4050 try {
4051 if (DBG) log("nvReadItem: item " + itemID);
vagdeviaf9a5b92018-08-15 16:01:53 -07004052 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004053 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
4054 return value;
4055 } finally {
4056 Binder.restoreCallingIdentity(identity);
4057 }
Jake Hambye994d462014-02-03 13:10:13 -08004058 }
4059
4060 /**
4061 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
4062 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
4063 *
4064 * @param itemID the ID of the item to read
4065 * @param itemValue the value to write, as a String
4066 * @return true on success; false on any failure
4067 */
4068 @Override
4069 public boolean nvWriteItem(int itemID, String itemValue) {
vagdeviaf9a5b92018-08-15 16:01:53 -07004070 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Jeff Davidson7e17e312018-02-13 18:17:36 -08004071 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4072 mApp, getDefaultSubscription(), "nvWriteItem");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004073
4074 final long identity = Binder.clearCallingIdentity();
4075 try {
4076 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
4077 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
vagdeviaf9a5b92018-08-15 16:01:53 -07004078 new Pair<Integer, String>(itemID, itemValue), workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004079 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
4080 return success;
4081 } finally {
4082 Binder.restoreCallingIdentity(identity);
4083 }
Jake Hambye994d462014-02-03 13:10:13 -08004084 }
4085
4086 /**
4087 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
4088 * Used for device configuration by some CDMA operators.
4089 *
4090 * @param preferredRoamingList byte array containing the new PRL
4091 * @return true on success; false on any failure
4092 */
4093 @Override
4094 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004095 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4096 mApp, getDefaultSubscription(), "nvWriteCdmaPrl");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004097
4098 final long identity = Binder.clearCallingIdentity();
4099 try {
4100 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
4101 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
4102 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
4103 return success;
4104 } finally {
4105 Binder.restoreCallingIdentity(identity);
4106 }
Jake Hambye994d462014-02-03 13:10:13 -08004107 }
4108
4109 /**
chen xu6dac5ab2018-10-26 17:39:23 -07004110 * Rollback modem configurations to factory default except some config which are in whitelist.
Jake Hambye994d462014-02-03 13:10:13 -08004111 * Used for device configuration by some CDMA operators.
4112 *
chen xu6dac5ab2018-10-26 17:39:23 -07004113 * @param slotIndex - device slot.
4114 *
Jake Hambye994d462014-02-03 13:10:13 -08004115 * @return true on success; false on any failure
4116 */
4117 @Override
chen xu6dac5ab2018-10-26 17:39:23 -07004118 public boolean resetModemConfig(int slotIndex) {
4119 Phone phone = PhoneFactory.getPhone(slotIndex);
4120 if (phone != null) {
4121 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4122 mApp, phone.getSubId(), "resetModemConfig");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004123
chen xu6dac5ab2018-10-26 17:39:23 -07004124 final long identity = Binder.clearCallingIdentity();
4125 try {
4126 Boolean success = (Boolean) sendRequest(CMD_RESET_MODEM_CONFIG, null);
4127 if (DBG) log("resetModemConfig:" + ' ' + (success ? "ok" : "fail"));
4128 return success;
4129 } finally {
4130 Binder.restoreCallingIdentity(identity);
4131 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004132 }
chen xu6dac5ab2018-10-26 17:39:23 -07004133 return false;
4134 }
4135
4136 /**
4137 * Generate a radio modem reset. Used for device configuration by some CDMA operators.
4138 *
4139 * @param slotIndex - device slot.
4140 *
4141 * @return true on success; false on any failure
4142 */
4143 @Override
4144 public boolean rebootModem(int slotIndex) {
4145 Phone phone = PhoneFactory.getPhone(slotIndex);
4146 if (phone != null) {
4147 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4148 mApp, phone.getSubId(), "rebootModem");
4149
4150 final long identity = Binder.clearCallingIdentity();
4151 try {
4152 Boolean success = (Boolean) sendRequest(CMD_MODEM_REBOOT, null);
4153 if (DBG) log("rebootModem:" + ' ' + (success ? "ok" : "fail"));
4154 return success;
4155 } finally {
4156 Binder.restoreCallingIdentity(identity);
4157 }
4158 }
4159 return false;
Jake Hambye994d462014-02-03 13:10:13 -08004160 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004161
Svet Ganovb320e182015-04-16 12:30:10 -07004162 public String[] getPcscfAddress(String apnType, String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004163 final Phone defaultPhone = getDefaultPhone();
Jeff Davidson7e17e312018-02-13 18:17:36 -08004164 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004165 mApp, defaultPhone.getSubId(), callingPackage, "getPcscfAddress")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004166 return new String[0];
4167 }
4168
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004169 final long identity = Binder.clearCallingIdentity();
4170 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004171 return defaultPhone.getPcscfAddress(apnType);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004172 } finally {
4173 Binder.restoreCallingIdentity(identity);
4174 }
Wink Saville36469e72014-06-11 15:17:00 -07004175 }
4176
Brad Ebinger51f743a2017-01-23 13:50:20 -08004177 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004178 * Enables IMS for the framework. This will trigger IMS registration and ImsFeature capability
4179 * status updates, if not already enabled.
Brad Ebinger51f743a2017-01-23 13:50:20 -08004180 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004181 public void enableIms(int slotId) {
Brad Ebinger51f743a2017-01-23 13:50:20 -08004182 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004183
4184 final long identity = Binder.clearCallingIdentity();
4185 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004186 ImsResolver resolver = PhoneFactory.getImsResolver();
4187 if (resolver == null) {
4188 // may happen if the device does not support IMS.
4189 return;
4190 }
4191 resolver.enableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004192 } finally {
4193 Binder.restoreCallingIdentity(identity);
4194 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004195 }
4196
4197 /**
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004198 * Disables IMS for the framework. This will trigger IMS de-registration and trigger ImsFeature
4199 * status updates to disabled.
Brad Ebinger34bef922017-11-09 10:27:08 -08004200 */
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004201 public void disableIms(int slotId) {
4202 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004203
4204 final long identity = Binder.clearCallingIdentity();
4205 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004206 ImsResolver resolver = PhoneFactory.getImsResolver();
4207 if (resolver == null) {
4208 // may happen if the device does not support IMS.
4209 return;
4210 }
4211 resolver.disableIms(slotId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004212 } finally {
4213 Binder.restoreCallingIdentity(identity);
4214 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004215 }
4216
4217 /**
4218 * Returns the {@link IImsMmTelFeature} that corresponds to the given slot Id for the MMTel
4219 * feature or {@link null} if the service is not available. If the feature is available, the
4220 * {@link IImsServiceFeatureCallback} callback is registered as a listener for feature updates.
4221 */
4222 public IImsMmTelFeature getMmTelFeatureAndListen(int slotId,
Brad Ebinger34bef922017-11-09 10:27:08 -08004223 IImsServiceFeatureCallback callback) {
4224 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004225
4226 final long identity = Binder.clearCallingIdentity();
4227 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004228 ImsResolver resolver = PhoneFactory.getImsResolver();
4229 if (resolver == null) {
4230 // may happen if the device does not support IMS.
4231 return null;
4232 }
4233 return resolver.getMmTelFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004234 } finally {
4235 Binder.restoreCallingIdentity(identity);
4236 }
Brad Ebinger34bef922017-11-09 10:27:08 -08004237 }
4238
4239 /**
4240 * Returns the {@link IImsRcsFeature} that corresponds to the given slot Id for the RCS
4241 * feature during emergency calling or {@link null} if the service is not available. If the
4242 * feature is available, the {@link IImsServiceFeatureCallback} callback is registered as a
4243 * listener for feature updates.
4244 */
4245 public IImsRcsFeature getRcsFeatureAndListen(int slotId, IImsServiceFeatureCallback callback) {
4246 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004247
4248 final long identity = Binder.clearCallingIdentity();
4249 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004250 ImsResolver resolver = PhoneFactory.getImsResolver();
4251 if (resolver == null) {
4252 // may happen if the device does not support IMS.
4253 return null;
4254 }
4255 return resolver.getRcsFeatureAndListen(slotId, callback);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004256 } finally {
4257 Binder.restoreCallingIdentity(identity);
4258 }
Brad Ebinger51f743a2017-01-23 13:50:20 -08004259 }
4260
Brad Ebinger5f64b052017-12-14 14:26:15 -08004261 /**
4262 * Returns the {@link IImsRegistration} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004263 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger5f64b052017-12-14 14:26:15 -08004264 */
4265 public IImsRegistration getImsRegistration(int slotId, int feature) throws RemoteException {
4266 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004267
4268 final long identity = Binder.clearCallingIdentity();
4269 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004270 ImsResolver resolver = PhoneFactory.getImsResolver();
4271 if (resolver == null) {
4272 // may happen if the device does not support IMS.
4273 return null;
4274 }
4275 return resolver.getImsRegistration(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004276 } finally {
4277 Binder.restoreCallingIdentity(identity);
4278 }
Brad Ebinger5f64b052017-12-14 14:26:15 -08004279 }
4280
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004281 /**
4282 * Returns the {@link IImsConfig} structure associated with the slotId and feature
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004283 * specified or null if IMS is not supported on the slot specified.
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004284 */
4285 public IImsConfig getImsConfig(int slotId, int feature) throws RemoteException {
4286 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004287
4288 final long identity = Binder.clearCallingIdentity();
4289 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004290 ImsResolver resolver = PhoneFactory.getImsResolver();
4291 if (resolver == null) {
4292 // may happen if the device does not support IMS.
4293 return null;
4294 }
4295 return resolver.getImsConfig(slotId, feature);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004296 } finally {
4297 Binder.restoreCallingIdentity(identity);
4298 }
Brad Ebinger22bc3e42018-01-16 09:39:35 -08004299 }
4300
Brad Ebinger884c07b2018-02-15 16:17:40 -08004301 /**
Brad Ebingerdac2f002018-04-03 15:17:52 -07004302 * Sets the ImsService Package Name that Telephony will bind to.
4303 *
4304 * @param slotId the slot ID that the ImsService should bind for.
4305 * @param isCarrierImsService true if the ImsService is the carrier override, false if the
4306 * ImsService is the device default ImsService.
4307 * @param packageName The package name of the application that contains the ImsService to bind
4308 * to.
4309 * @return true if setting the ImsService to bind to succeeded, false if it did not.
4310 * @hide
4311 */
4312 public boolean setImsService(int slotId, boolean isCarrierImsService, String packageName) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004313 int[] subIds = SubscriptionManager.getSubId(slotId);
4314 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4315 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4316 "setImsService");
4317
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004318 final long identity = Binder.clearCallingIdentity();
4319 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004320 ImsResolver resolver = PhoneFactory.getImsResolver();
4321 if (resolver == null) {
4322 // may happen if the device does not support IMS.
4323 return false;
4324 }
4325 return resolver.overrideImsServiceConfiguration(slotId, isCarrierImsService,
4326 packageName);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004327 } finally {
4328 Binder.restoreCallingIdentity(identity);
4329 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004330 }
4331
4332 /**
4333 * Return the ImsService configuration.
4334 *
4335 * @param slotId The slot that the ImsService is associated with.
4336 * @param isCarrierImsService true, if the ImsService is a carrier override, false if it is
4337 * the device default.
4338 * @return the package name of the ImsService configuration.
4339 */
4340 public String getImsService(int slotId, boolean isCarrierImsService) {
Brad Ebingerde696de2018-04-06 09:56:40 -07004341 int[] subIds = SubscriptionManager.getSubId(slotId);
4342 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mApp,
4343 (subIds != null ? subIds[0] : SubscriptionManager.INVALID_SUBSCRIPTION_ID),
4344 "getImsService");
4345
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004346 final long identity = Binder.clearCallingIdentity();
4347 try {
Brad Ebinger9c0eb502019-01-23 15:06:19 -08004348 ImsResolver resolver = PhoneFactory.getImsResolver();
4349 if (resolver == null) {
4350 // may happen if the device does not support IMS.
4351 return "";
4352 }
4353 return resolver.getImsServiceConfiguration(slotId, isCarrierImsService);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004354 } finally {
4355 Binder.restoreCallingIdentity(identity);
4356 }
Brad Ebingerdac2f002018-04-03 15:17:52 -07004357 }
4358
Wink Saville36469e72014-06-11 15:17:00 -07004359 public void setImsRegistrationState(boolean registered) {
4360 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004361
4362 final long identity = Binder.clearCallingIdentity();
4363 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004364 getDefaultPhone().setImsRegistrationState(registered);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004365 } finally {
4366 Binder.restoreCallingIdentity(identity);
4367 }
Wink Saville36469e72014-06-11 15:17:00 -07004368 }
4369
4370 /**
Stuart Scott54788802015-03-30 13:18:01 -07004371 * Set the network selection mode to automatic.
4372 *
4373 */
4374 @Override
4375 public void setNetworkSelectionModeAutomatic(int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004376 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4377 mApp, subId, "setNetworkSelectionModeAutomatic");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004378
Pengquan Menge92a50d2018-09-21 15:54:48 -07004379 if (!isActiveSubscription(subId)) {
4380 return;
4381 }
4382
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004383 final long identity = Binder.clearCallingIdentity();
4384 try {
4385 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
4386 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
4387 } finally {
4388 Binder.restoreCallingIdentity(identity);
4389 }
Stuart Scott54788802015-03-30 13:18:01 -07004390 }
4391
Pengquan Mengea84e042018-09-20 14:57:26 -07004392 /**
4393 * Ask the radio to connect to the input network and change selection mode to manual.
4394 *
4395 * @param subId the id of the subscription.
4396 * @param operatorInfo the operator information, included the PLMN, long name and short name of
4397 * the operator to attach to.
4398 * @param persistSelection whether the selection will persist until reboot. If true, only allows
4399 * attaching to the selected PLMN until reboot; otherwise, attach to the chosen PLMN and resume
4400 * normal network selection next time.
4401 * @return {@code true} on success; {@code true} on any failure.
Shishir Agrawal302c8692015-06-19 13:49:39 -07004402 */
4403 @Override
Pengquan Mengea84e042018-09-20 14:57:26 -07004404 public boolean setNetworkSelectionModeManual(
4405 int subId, OperatorInfo operatorInfo, boolean persistSelection) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004406 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4407 mApp, subId, "setNetworkSelectionModeManual");
Pengquan Menge92a50d2018-09-21 15:54:48 -07004408
4409 if (!isActiveSubscription(subId)) {
4410 return false;
4411 }
4412
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004413 final long identity = Binder.clearCallingIdentity();
4414 try {
Pengquan Mengea84e042018-09-20 14:57:26 -07004415 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operatorInfo,
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004416 persistSelection);
Pengquan Mengea84e042018-09-20 14:57:26 -07004417 if (DBG) {
4418 log("setNetworkSelectionModeManual: subId: " + subId
4419 + " operator: " + operatorInfo);
4420 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004421 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
4422 } finally {
4423 Binder.restoreCallingIdentity(identity);
4424 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004425 }
4426
4427 /**
4428 * Scans for available networks.
4429 */
4430 @Override
Hall Liuf19c44f2018-11-27 14:38:17 -08004431 public CellNetworkScanResult getCellNetworkScanResults(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004432 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4433 mApp, subId, "getCellNetworkScanResults");
Hall Liuf19c44f2018-11-27 14:38:17 -08004434 LocationAccessPolicy.LocationPermissionResult locationResult =
4435 LocationAccessPolicy.checkLocationPermission(mApp,
4436 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4437 .setCallingPackage(callingPackage)
4438 .setCallingPid(Binder.getCallingPid())
4439 .setCallingUid(Binder.getCallingUid())
4440 .setMethod("getCellNetworkScanResults")
4441 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4442 .build());
4443 switch (locationResult) {
4444 case DENIED_HARD:
4445 throw new SecurityException("Not allowed to access scan results -- location");
4446 case DENIED_SOFT:
4447 return null;
4448 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004449
Pengquan Menga1bb6272018-09-06 09:59:22 -07004450 long identity = Binder.clearCallingIdentity();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004451 try {
4452 if (DBG) log("getCellNetworkScanResults: subId " + subId);
Pengquan Menga1bb6272018-09-06 09:59:22 -07004453 return (CellNetworkScanResult) sendRequest(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004454 CMD_PERFORM_NETWORK_SCAN, null, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004455 } finally {
4456 Binder.restoreCallingIdentity(identity);
4457 }
Shishir Agrawal302c8692015-06-19 13:49:39 -07004458 }
4459
4460 /**
yinxub1bed742017-04-17 11:45:04 -07004461 * Starts a new network scan and returns the id of this scan.
yinxu504e1392017-04-12 16:03:22 -07004462 *
yinxub1bed742017-04-17 11:45:04 -07004463 * @param subId id of the subscription
4464 * @param request contains the radio access networks with bands/channels to scan
4465 * @param messenger callback messenger for scan results or errors
4466 * @param binder for the purpose of auto clean when the user thread crashes
yinxu504e1392017-04-12 16:03:22 -07004467 * @return the id of the requested scan which can be used to stop the scan.
4468 */
4469 @Override
4470 public int requestNetworkScan(int subId, NetworkScanRequest request, Messenger messenger,
Hall Liuf19c44f2018-11-27 14:38:17 -08004471 IBinder binder, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004472 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4473 mApp, subId, "requestNetworkScan");
Hall Liuf19c44f2018-11-27 14:38:17 -08004474 LocationAccessPolicy.LocationPermissionResult locationResult =
4475 LocationAccessPolicy.checkLocationPermission(mApp,
4476 new LocationAccessPolicy.LocationPermissionQuery.Builder()
4477 .setCallingPackage(callingPackage)
4478 .setCallingPid(Binder.getCallingPid())
4479 .setCallingUid(Binder.getCallingUid())
4480 .setMethod("requestNetworkScan")
4481 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
4482 .build());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004483 if (locationResult != LocationAccessPolicy.LocationPermissionResult.ALLOWED) {
4484 SecurityException e = checkNetworkRequestForSanitizedLocationAccess(request);
4485 if (e != null) {
4486 if (locationResult == LocationAccessPolicy.LocationPermissionResult.DENIED_HARD) {
4487 throw e;
4488 } else {
Hall Liu0e5abaf2019-04-04 01:25:30 -07004489 loge(e.getMessage());
Hall Liub2ac8ef2019-02-28 15:56:23 -08004490 return TelephonyScanManager.INVALID_SCAN_ID;
4491 }
4492 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004493 }
Hall Liu912dfd32019-04-25 14:02:26 -07004494 int callingUid = Binder.getCallingUid();
4495 int callingPid = Binder.getCallingPid();
Ying Xu94a46582019-04-18 17:14:56 -07004496 final long identity = Binder.clearCallingIdentity();
4497 try {
4498 return mNetworkScanRequestTracker.startNetworkScan(
4499 request, messenger, binder, getPhone(subId),
Hall Liu912dfd32019-04-25 14:02:26 -07004500 callingUid, callingPid, callingPackage);
Ying Xu94a46582019-04-18 17:14:56 -07004501 } finally {
4502 Binder.restoreCallingIdentity(identity);
4503 }
yinxu504e1392017-04-12 16:03:22 -07004504 }
4505
Hall Liub2ac8ef2019-02-28 15:56:23 -08004506 private SecurityException checkNetworkRequestForSanitizedLocationAccess(
4507 NetworkScanRequest request) {
4508 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.NETWORK_SCAN)
4509 != PERMISSION_GRANTED) {
4510 return new SecurityException("permission.NETWORK_SCAN is needed for network scans"
4511 + " without location access.");
4512 }
4513
4514 if (request.getSpecifiers() != null && request.getSpecifiers().length > 0) {
4515 for (RadioAccessSpecifier ras : request.getSpecifiers()) {
Hall Liub2ac8ef2019-02-28 15:56:23 -08004516 if (ras.getChannels() != null && ras.getChannels().length > 0) {
4517 return new SecurityException("Specific channels must not be"
4518 + " scanned without location access.");
4519 }
4520 }
4521 }
4522
Hall Liub2ac8ef2019-02-28 15:56:23 -08004523 return null;
4524 }
4525
yinxu504e1392017-04-12 16:03:22 -07004526 /**
4527 * Stops an existing network scan with the given scanId.
yinxub1bed742017-04-17 11:45:04 -07004528 *
4529 * @param subId id of the subscription
4530 * @param scanId id of the scan that needs to be stopped
yinxu504e1392017-04-12 16:03:22 -07004531 */
4532 @Override
4533 public void stopNetworkScan(int subId, int scanId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004534 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4535 mApp, subId, "stopNetworkScan");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004536
Hall Liu912dfd32019-04-25 14:02:26 -07004537 int callingUid = Binder.getCallingUid();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004538 final long identity = Binder.clearCallingIdentity();
4539 try {
Hall Liu912dfd32019-04-25 14:02:26 -07004540 mNetworkScanRequestTracker.stopNetworkScan(scanId, callingUid);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004541 } finally {
4542 Binder.restoreCallingIdentity(identity);
4543 }
yinxu504e1392017-04-12 16:03:22 -07004544 }
4545
4546 /**
Junda Liu84d15a22014-07-02 11:21:04 -07004547 * Get the calculated preferred network type.
4548 * Used for debugging incorrect network type.
4549 *
4550 * @return the preferred network type, defined in RILConstants.java.
4551 */
4552 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004553 public int getCalculatedPreferredNetworkType(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004554 final Phone defaultPhone = getDefaultPhone();
4555 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp, defaultPhone.getSubId(),
4556 callingPackage, "getCalculatedPreferredNetworkType")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004557 return RILConstants.PREFERRED_NETWORK_MODE;
4558 }
4559
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004560 final long identity = Binder.clearCallingIdentity();
4561 try {
4562 // FIXME: need to get SubId from somewhere.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004563 return PhoneFactory.calculatePreferredNetworkType(defaultPhone.getContext(), 0);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004564 } finally {
4565 Binder.restoreCallingIdentity(identity);
4566 }
Junda Liu84d15a22014-07-02 11:21:04 -07004567 }
4568
4569 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08004570 * Get the preferred network type.
4571 * Used for device configuration by some CDMA operators.
4572 *
4573 * @return the preferred network type, defined in RILConstants.java.
4574 */
4575 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004576 public int getPreferredNetworkType(int subId) {
Pengquan Menga4009cb2018-12-20 11:00:24 -08004577 TelephonyPermissions
4578 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
4579 mApp, subId, "getPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004580
4581 final long identity = Binder.clearCallingIdentity();
4582 try {
4583 if (DBG) log("getPreferredNetworkType");
4584 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
4585 int networkType = (result != null ? result[0] : -1);
4586 if (DBG) log("getPreferredNetworkType: " + networkType);
4587 return networkType;
4588 } finally {
4589 Binder.restoreCallingIdentity(identity);
4590 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004591 }
4592
4593 /**
4594 * Set the preferred network type.
4595 * Used for device configuration by some CDMA operators.
4596 *
4597 * @param networkType the preferred network type, defined in RILConstants.java.
4598 * @return true on success; false on any failure.
4599 */
4600 @Override
Stuart Scott54788802015-03-30 13:18:01 -07004601 public boolean setPreferredNetworkType(int subId, int networkType) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004602 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4603 mApp, subId, "setPreferredNetworkType");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004604
4605 final long identity = Binder.clearCallingIdentity();
4606 try {
4607 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
4608 Boolean success = (Boolean) sendRequest(
4609 CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
4610 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
4611 if (success) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004612 Settings.Global.putInt(mApp.getContentResolver(),
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004613 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
4614 }
4615 return success;
4616 } finally {
4617 Binder.restoreCallingIdentity(identity);
Junda Liu80bc0d12014-07-14 16:36:44 -07004618 }
Jake Hamby7c27be32014-03-03 13:25:59 -08004619 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004620
4621 /**
Miaoa84611c2019-03-15 09:21:10 +08004622 * Check whether DUN APN is required for tethering with subId.
Junda Liu475951f2014-11-07 16:45:03 -08004623 *
Miaoa84611c2019-03-15 09:21:10 +08004624 * @param subId the id of the subscription to require tethering.
Amit Mahajanfe58cdf2017-07-11 12:01:53 -07004625 * @return {@code true} if DUN APN is required for tethering.
Junda Liu475951f2014-11-07 16:45:03 -08004626 * @hide
4627 */
4628 @Override
Miaoa84611c2019-03-15 09:21:10 +08004629 public boolean getTetherApnRequiredForSubscriber(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004630 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004631 final long identity = Binder.clearCallingIdentity();
Miaoa84611c2019-03-15 09:21:10 +08004632 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004633 try {
Miaoa84611c2019-03-15 09:21:10 +08004634 if (phone != null) {
4635 return phone.hasMatchedTetherApnSetting();
4636 } else {
4637 return false;
4638 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004639 } finally {
4640 Binder.restoreCallingIdentity(identity);
Junda Liu475951f2014-11-07 16:45:03 -08004641 }
Junda Liu475951f2014-11-07 16:45:03 -08004642 }
4643
4644 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07004645 * Set mobile data enabled
4646 * Used by the user through settings etc to turn on/off mobile data
4647 *
4648 * @param enable {@code true} turn turn data on, else {@code false}
4649 */
4650 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004651 public void setUserDataEnabled(int subId, boolean enable) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004652 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4653 mApp, subId, "setUserDataEnabled");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004654
4655 final long identity = Binder.clearCallingIdentity();
4656 try {
4657 int phoneId = mSubscriptionController.getPhoneId(subId);
4658 if (DBG) log("setUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4659 Phone phone = PhoneFactory.getPhone(phoneId);
4660 if (phone != null) {
4661 if (DBG) log("setUserDataEnabled: subId=" + subId + " enable=" + enable);
Jack Yud79fba22018-12-13 11:51:28 -08004662 phone.getDataEnabledSettings().setUserDataEnabled(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004663 } else {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004664 loge("setUserDataEnabled: no phone found. Invalid subId=" + subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004665 }
4666 } finally {
4667 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004668 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004669 }
4670
4671 /**
Malcolm Chen964682d2017-11-28 16:20:07 -08004672 * Get the user enabled state of Mobile Data.
4673 *
4674 * TODO: remove and use isUserDataEnabled.
4675 * This can't be removed now because some vendor codes
4676 * calls through ITelephony directly while they should
4677 * use TelephonyManager.
4678 *
4679 * @return true on enabled
4680 */
4681 @Override
4682 public boolean getDataEnabled(int subId) {
4683 return isUserDataEnabled(subId);
4684 }
4685
4686 /**
4687 * Get whether mobile data is enabled per user setting.
4688 *
4689 * There are other factors deciding whether mobile data is actually enabled, but they are
4690 * not considered here. See {@link #isDataEnabled(int)} for more details.
Robert Greenwalt646120a2014-05-23 11:54:03 -07004691 *
Jeff Davidsona1920712016-11-18 17:05:56 -08004692 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
Robert Greenwalted86e582014-05-21 20:03:20 -07004693 *
4694 * @return {@code true} if data is enabled else {@code false}
4695 */
4696 @Override
Malcolm Chen964682d2017-11-28 16:20:07 -08004697 public boolean isUserDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07004698 try {
4699 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4700 null);
4701 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004702 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4703 mApp, subId, "isUserDataEnabled");
Robert Greenwalt646120a2014-05-23 11:54:03 -07004704 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004705
4706 final long identity = Binder.clearCallingIdentity();
4707 try {
4708 int phoneId = mSubscriptionController.getPhoneId(subId);
4709 if (DBG) log("isUserDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4710 Phone phone = PhoneFactory.getPhone(phoneId);
4711 if (phone != null) {
4712 boolean retVal = phone.isUserDataEnabled();
4713 if (DBG) log("isUserDataEnabled: subId=" + subId + " retVal=" + retVal);
4714 return retVal;
4715 } else {
4716 if (DBG) loge("isUserDataEnabled: no phone subId=" + subId + " retVal=false");
4717 return false;
4718 }
4719 } finally {
4720 Binder.restoreCallingIdentity(identity);
Malcolm Chen964682d2017-11-28 16:20:07 -08004721 }
4722 }
4723
4724 /**
4725 * Get whether mobile data is enabled.
4726 *
4727 * Comparable to {@link #isUserDataEnabled(int)}, this considers all factors deciding
4728 * whether mobile data is actually enabled.
4729 *
4730 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
4731 *
4732 * @return {@code true} if data is enabled else {@code false}
4733 */
4734 @Override
4735 public boolean isDataEnabled(int subId) {
4736 try {
4737 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
4738 null);
4739 } catch (Exception e) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004740 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
4741 mApp, subId, "isDataEnabled");
Malcolm Chen964682d2017-11-28 16:20:07 -08004742 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004743
4744 final long identity = Binder.clearCallingIdentity();
4745 try {
4746 int phoneId = mSubscriptionController.getPhoneId(subId);
4747 if (DBG) log("isDataEnabled: subId=" + subId + " phoneId=" + phoneId);
4748 Phone phone = PhoneFactory.getPhone(phoneId);
4749 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08004750 boolean retVal = phone.getDataEnabledSettings().isDataEnabled();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004751 if (DBG) log("isDataEnabled: subId=" + subId + " retVal=" + retVal);
4752 return retVal;
4753 } else {
4754 if (DBG) loge("isDataEnabled: no phone subId=" + subId + " retVal=false");
4755 return false;
4756 }
4757 } finally {
4758 Binder.restoreCallingIdentity(identity);
Wink Savillee7353bb2014-12-05 14:21:41 -08004759 }
Robert Greenwalted86e582014-05-21 20:03:20 -07004760 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004761
4762 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004763 public int getCarrierPrivilegeStatus(int subId) {
4764 final Phone phone = getPhone(subId);
4765 if (phone == null) {
4766 loge("getCarrierPrivilegeStatus: Invalid subId");
4767 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4768 }
4769 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004770 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08004771 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004772 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4773 }
4774 return card.getCarrierPrivilegeStatusForCurrentTransaction(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08004775 phone.getContext().getPackageManager());
Shishir Agrawal60f9c952014-06-23 12:00:43 -07004776 }
Junda Liu29340342014-07-10 15:23:27 -07004777
4778 @Override
Jeff Davidson7e17e312018-02-13 18:17:36 -08004779 public int getCarrierPrivilegeStatusForUid(int subId, int uid) {
4780 final Phone phone = getPhone(subId);
4781 if (phone == null) {
4782 loge("getCarrierPrivilegeStatus: Invalid subId");
4783 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
4784 }
4785 UiccProfile profile =
4786 UiccController.getInstance().getUiccProfileForPhone(phone.getPhoneId());
4787 if (profile == null) {
4788 loge("getCarrierPrivilegeStatus: No UICC");
4789 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4790 }
4791 return profile.getCarrierPrivilegeStatusForUid(phone.getContext().getPackageManager(), uid);
4792 }
4793
4794 @Override
Zach Johnson50ecba32015-05-19 00:24:21 -07004795 public int checkCarrierPrivilegesForPackage(String pkgName) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004796 final Phone defaultPhone = getDefaultPhone();
Junda Liu317d70b2016-03-08 09:33:53 -08004797 if (TextUtils.isEmpty(pkgName))
4798 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004799 UiccCard card = UiccController.getInstance().getUiccCard(defaultPhone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07004800 if (card == null) {
4801 loge("checkCarrierPrivilegesForPackage: No UICC");
4802 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4803 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004804 return card.getCarrierPrivilegeStatus(defaultPhone.getContext().getPackageManager(),
4805 pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004806 }
4807
4808 @Override
4809 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08004810 if (TextUtils.isEmpty(pkgName))
4811 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07004812 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
4813 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4814 UiccCard card = UiccController.getInstance().getUiccCard(i);
4815 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07004816 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07004817 continue;
4818 }
4819
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004820 result = card.getCarrierPrivilegeStatus(mApp.getPackageManager(), pkgName);
Zach Johnson50ecba32015-05-19 00:24:21 -07004821 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
4822 break;
4823 }
4824 }
4825
4826 return result;
Junda Liu29340342014-07-10 15:23:27 -07004827 }
Derek Tan89e89d42014-07-08 17:00:10 -07004828
4829 @Override
Junda Liue64de782015-04-16 17:19:16 -07004830 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
4831 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
4832 loge("phoneId " + phoneId + " is not valid.");
4833 return null;
4834 }
4835 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004836 if (card == null) {
Diego Pontorieroaf74c862014-08-28 11:51:16 -07004837 loge("getCarrierPackageNamesForIntent: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004838 return null ;
4839 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004840 return card.getCarrierPackageNamesForIntent(mApp.getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004841 }
4842
Amith Yamasani6e118872016-02-19 12:53:51 -08004843 @Override
4844 public List<String> getPackagesWithCarrierPrivileges() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08004845 PackageManager pm = mApp.getPackageManager();
Amith Yamasani6e118872016-02-19 12:53:51 -08004846 List<String> privilegedPackages = new ArrayList<>();
4847 List<PackageInfo> packages = null;
4848 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
4849 UiccCard card = UiccController.getInstance().getUiccCard(i);
4850 if (card == null) {
4851 // No UICC in that slot.
4852 continue;
4853 }
4854 if (card.hasCarrierPrivilegeRules()) {
4855 if (packages == null) {
4856 // Only check packages in user 0 for now
4857 packages = pm.getInstalledPackagesAsUser(
4858 PackageManager.MATCH_DISABLED_COMPONENTS
4859 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
4860 | PackageManager.GET_SIGNATURES, UserHandle.USER_SYSTEM);
4861 }
4862 for (int p = packages.size() - 1; p >= 0; p--) {
4863 PackageInfo pkgInfo = packages.get(p);
4864 if (pkgInfo != null && pkgInfo.packageName != null
4865 && card.getCarrierPrivilegeStatus(pkgInfo)
4866 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
4867 privilegedPackages.add(pkgInfo.packageName);
4868 }
4869 }
4870 }
4871 }
4872 return privilegedPackages;
4873 }
4874
Wink Savilleb564aae2014-10-23 10:18:09 -07004875 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07004876 final Phone phone = getPhone(subId);
4877 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07004878 if (card == null) {
4879 loge("getIccId: No UICC");
4880 return null;
4881 }
4882 String iccId = card.getIccId();
4883 if (TextUtils.isEmpty(iccId)) {
4884 loge("getIccId: ICC ID is null or empty.");
4885 return null;
4886 }
4887 return iccId;
4888 }
4889
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07004890 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08004891 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
4892 String number) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004893 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
4894 subId, "setLine1NumberForDisplayForSubscriber");
Derek Tan97ebb422014-09-05 16:55:38 -07004895
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004896 final long identity = Binder.clearCallingIdentity();
4897 try {
4898 final String iccId = getIccId(subId);
4899 final Phone phone = getPhone(subId);
4900 if (phone == null) {
4901 return false;
4902 }
4903 final String subscriberId = phone.getSubscriberId();
4904
4905 if (DBG_MERGE) {
4906 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
4907 + subscriberId + " to " + number);
4908 }
4909
4910 if (TextUtils.isEmpty(iccId)) {
4911 return false;
4912 }
4913
4914 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
4915
4916 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
4917 if (alphaTag == null) {
4918 editor.remove(alphaTagPrefKey);
4919 } else {
4920 editor.putString(alphaTagPrefKey, alphaTag);
4921 }
4922
4923 // Record both the line number and IMSI for this ICCID, since we need to
4924 // track all merged IMSIs based on line number
4925 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4926 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
4927 if (number == null) {
4928 editor.remove(numberPrefKey);
4929 editor.remove(subscriberPrefKey);
4930 } else {
4931 editor.putString(numberPrefKey, number);
4932 editor.putString(subscriberPrefKey, subscriberId);
4933 }
4934
4935 editor.commit();
4936 return true;
4937 } finally {
4938 Binder.restoreCallingIdentity(identity);
Sanket Padawe356d7632015-06-22 14:03:32 -07004939 }
Derek Tan7226c842014-07-02 17:42:23 -07004940 }
4941
4942 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004943 public String getLine1NumberForDisplay(int subId, String callingPackage) {
Makoto Onukifee69342015-06-29 14:44:50 -07004944 // This is open to apps with WRITE_SMS.
Jeff Davidson7e17e312018-02-13 18:17:36 -08004945 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneNumber(
Jeff Davidson913390f2018-02-23 17:11:49 -08004946 mApp, subId, callingPackage, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08004947 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07004948 return null;
4949 }
Derek Tan97ebb422014-09-05 16:55:38 -07004950
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004951 final long identity = Binder.clearCallingIdentity();
4952 try {
4953 String iccId = getIccId(subId);
4954 if (iccId != null) {
4955 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
4956 if (DBG_MERGE) {
4957 log("getLine1NumberForDisplay returning "
4958 + mTelephonySharedPreferences.getString(numberPrefKey, null));
4959 }
4960 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Amit Mahajan9cf11512015-11-09 11:40:48 -08004961 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004962 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
4963 return null;
4964 } finally {
4965 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07004966 }
Derek Tan7226c842014-07-02 17:42:23 -07004967 }
4968
4969 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07004970 public String getLine1AlphaTagForDisplay(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08004971 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08004972 mApp, subId, callingPackage, "getLine1AlphaTagForDisplay")) {
Svet Ganovb320e182015-04-16 12:30:10 -07004973 return null;
4974 }
Derek Tan97ebb422014-09-05 16:55:38 -07004975
Malcolm Chenaa4a8532018-02-28 15:00:40 -08004976 final long identity = Binder.clearCallingIdentity();
4977 try {
4978 String iccId = getIccId(subId);
4979 if (iccId != null) {
4980 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
4981 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
4982 }
4983 return null;
4984 } finally {
4985 Binder.restoreCallingIdentity(identity);
Derek Tan7226c842014-07-02 17:42:23 -07004986 }
Derek Tan7226c842014-07-02 17:42:23 -07004987 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07004988
4989 @Override
Jordan Liub49b04b2019-05-06 14:45:15 -07004990 public String[] getMergedSubscriberIds(int subId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08004991 // This API isn't public, so no need to provide a valid subscription ID - we're not worried
4992 // about carrier-privileged callers not having access.
Jeff Davidson7e17e312018-02-13 18:17:36 -08004993 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08004994 mApp, SubscriptionManager.INVALID_SUBSCRIPTION_ID, callingPackage,
4995 "getMergedSubscriberIds")) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07004996 return null;
4997 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08004998
Jordan Liub49b04b2019-05-06 14:45:15 -07004999 // Clear calling identity, when calling TelephonyManager, because callerUid must be
5000 // the process, where TelephonyManager was instantiated.
5001 // Otherwise AppOps check will fail.
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005002 final long identity = Binder.clearCallingIdentity();
5003 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005004 final Context context = mApp;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005005 final TelephonyManager tele = TelephonyManager.from(context);
5006 final SubscriptionManager sub = SubscriptionManager.from(context);
5007
5008 // Figure out what subscribers are currently active
5009 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005010
Jordan Liub49b04b2019-05-06 14:45:15 -07005011 // Only consider subs which match the current subId
5012 // This logic can be simplified. See b/131189269 for progress.
5013 if (isActiveSubscription(subId)) {
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005014 activeSubscriberIds.add(tele.getSubscriberId(subId));
5015 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005016
5017 // First pass, find a number override for an active subscriber
5018 String mergeNumber = null;
5019 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
5020 for (String key : prefs.keySet()) {
5021 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
5022 final String subscriberId = (String) prefs.get(key);
5023 if (activeSubscriberIds.contains(subscriberId)) {
5024 final String iccId = key.substring(
5025 PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
5026 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
5027 mergeNumber = (String) prefs.get(numberKey);
5028 if (DBG_MERGE) {
5029 Slog.d(LOG_TAG, "Found line number " + mergeNumber
5030 + " for active subscriber " + subscriberId);
5031 }
5032 if (!TextUtils.isEmpty(mergeNumber)) {
5033 break;
5034 }
5035 }
5036 }
5037 }
5038
5039 // Shortcut when no active merged subscribers
5040 if (TextUtils.isEmpty(mergeNumber)) {
5041 return null;
5042 }
5043
5044 // Second pass, find all subscribers under that line override
5045 final ArraySet<String> result = new ArraySet<>();
5046 for (String key : prefs.keySet()) {
5047 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
5048 final String number = (String) prefs.get(key);
5049 if (mergeNumber.equals(number)) {
5050 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
5051 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
5052 final String subscriberId = (String) prefs.get(subscriberKey);
5053 if (!TextUtils.isEmpty(subscriberId)) {
5054 result.add(subscriberId);
5055 }
5056 }
5057 }
5058 }
5059
5060 final String[] resultArray = result.toArray(new String[result.size()]);
5061 Arrays.sort(resultArray);
5062 if (DBG_MERGE) {
5063 Slog.d(LOG_TAG,
5064 "Found subscribers " + Arrays.toString(resultArray) + " after merge");
5065 }
5066 return resultArray;
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07005067 } finally {
5068 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08005069 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08005070 }
5071
5072 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005073 public boolean setOperatorBrandOverride(int subId, String brand) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005074 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(
5075 subId, "setOperatorBrandOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005076
5077 final long identity = Binder.clearCallingIdentity();
5078 try {
5079 final Phone phone = getPhone(subId);
5080 return phone == null ? false : phone.setOperatorBrandOverride(brand);
5081 } finally {
5082 Binder.restoreCallingIdentity(identity);
5083 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07005084 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05005085
5086 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005087 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005088 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
5089 List<String> cdmaNonRoamingList) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005090 TelephonyPermissions.enforceCallingOrSelfCarrierPrivilege(subId, "setRoamingOverride");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005091
5092 final long identity = Binder.clearCallingIdentity();
5093 try {
5094 final Phone phone = getPhone(subId);
5095 if (phone == null) {
5096 return false;
5097 }
5098 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
5099 cdmaNonRoamingList);
5100 } finally {
5101 Binder.restoreCallingIdentity(identity);
Shishir Agrawalc04d9752016-02-19 10:41:00 -08005102 }
Shishir Agrawal621a47c2014-12-01 10:25:09 -08005103 }
5104
5105 @Override
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005106 @Deprecated
5107 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
5108 enforceModifyPermission();
5109
5110 int returnValue = 0;
5111 try {
vagdeviaf9a5b92018-08-15 16:01:53 -07005112 AsyncResult result = (AsyncResult) sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
Shuo Qian850e4d6a2018-04-25 21:02:08 +00005113 if(result.exception == null) {
5114 if (result.result != null) {
5115 byte[] responseData = (byte[])(result.result);
5116 if(responseData.length > oemResp.length) {
5117 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
5118 responseData.length + "bytes. Buffer Size is " +
5119 oemResp.length + "bytes.");
5120 }
5121 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
5122 returnValue = responseData.length;
5123 }
5124 } else {
5125 CommandException ex = (CommandException) result.exception;
5126 returnValue = ex.getCommandError().ordinal();
5127 if(returnValue > 0) returnValue *= -1;
5128 }
5129 } catch (RuntimeException e) {
5130 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
5131 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
5132 if(returnValue > 0) returnValue *= -1;
5133 }
5134
5135 return returnValue;
5136 }
5137
5138 @Override
Wink Saville5d475dd2014-10-17 15:00:58 -07005139 public void setRadioCapability(RadioAccessFamily[] rafs) {
5140 try {
5141 ProxyController.getInstance().setRadioCapability(rafs);
5142 } catch (RuntimeException e) {
5143 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
5144 }
5145 }
5146
5147 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07005148 public int getRadioAccessFamily(int phoneId, String callingPackage) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005149 Phone phone = PhoneFactory.getPhone(phoneId);
chen xub97461a2018-10-26 14:17:57 -07005150 int raf = RadioAccessFamily.RAF_UNKNOWN;
Jeff Davidson913390f2018-02-23 17:11:49 -08005151 if (phone == null) {
chen xub97461a2018-10-26 14:17:57 -07005152 return raf;
Jeff Davidson913390f2018-02-23 17:11:49 -08005153 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005154 final long identity = Binder.clearCallingIdentity();
5155 try {
chen xub97461a2018-10-26 14:17:57 -07005156 TelephonyPermissions
5157 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
5158 mApp, phone.getSubId(), "getRadioAccessFamily");
5159 raf = ProxyController.getInstance().getRadioAccessFamily(phoneId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005160 } finally {
5161 Binder.restoreCallingIdentity(identity);
5162 }
chen xub97461a2018-10-26 14:17:57 -07005163 return raf;
Wink Saville5d475dd2014-10-17 15:00:58 -07005164 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005165
5166 @Override
5167 public void enableVideoCalling(boolean enable) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005168 final Phone defaultPhone = getDefaultPhone();
Andrew Leedf14ead2014-10-17 14:22:52 -07005169 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005170
5171 final long identity = Binder.clearCallingIdentity();
5172 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005173 ImsManager.getInstance(defaultPhone.getContext(),
5174 defaultPhone.getPhoneId()).setVtSetting(enable);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005175 } finally {
5176 Binder.restoreCallingIdentity(identity);
5177 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005178 }
5179
5180 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005181 public boolean isVideoCallingEnabled(String callingPackage) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005182 final Phone defaultPhone = getDefaultPhone();
Amit Mahajan578e53d2018-03-20 16:18:38 +00005183 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005184 mApp, defaultPhone.getSubId(), callingPackage, "isVideoCallingEnabled")) {
Amit Mahajan578e53d2018-03-20 16:18:38 +00005185 return false;
5186 }
Svet Ganovb320e182015-04-16 12:30:10 -07005187
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005188 final long identity = Binder.clearCallingIdentity();
5189 try {
5190 // Check the user preference and the system-level IMS setting. Even if the user has
5191 // enabled video calling, if IMS is disabled we aren't able to support video calling.
5192 // In the long run, we may instead need to check if there exists a connection service
5193 // which can support video calling.
5194 ImsManager imsManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005195 ImsManager.getInstance(defaultPhone.getContext(), defaultPhone.getPhoneId());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005196 return imsManager.isVtEnabledByPlatform()
5197 && imsManager.isEnhanced4gLteModeSettingEnabledByUser()
5198 && imsManager.isVtEnabledByUser();
5199 } finally {
5200 Binder.restoreCallingIdentity(identity);
5201 }
Andrew Leedf14ead2014-10-17 14:22:52 -07005202 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06005203
Andrew Leea1239f22015-03-02 17:44:07 -08005204 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005205 public boolean canChangeDtmfToneLength(int subId, String callingPackage) {
5206 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5207 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5208 return false;
5209 }
5210
5211 final long identity = Binder.clearCallingIdentity();
5212 try {
5213 CarrierConfigManager configManager =
5214 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005215 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005216 .getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
5217 } finally {
5218 Binder.restoreCallingIdentity(identity);
5219 }
Andrew Leea1239f22015-03-02 17:44:07 -08005220 }
5221
5222 @Override
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005223 public boolean isWorldPhone(int subId, String callingPackage) {
5224 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
5225 mApp, subId, callingPackage, "isVideoCallingEnabled")) {
5226 return false;
5227 }
5228
5229 final long identity = Binder.clearCallingIdentity();
5230 try {
5231 CarrierConfigManager configManager =
5232 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005233 return configManager.getConfigForSubId(subId)
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005234 .getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
5235 } finally {
5236 Binder.restoreCallingIdentity(identity);
5237 }
Andrew Leea1239f22015-03-02 17:44:07 -08005238 }
5239
Andrew Lee9431b832015-03-09 18:46:45 -07005240 @Override
5241 public boolean isTtyModeSupported() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005242 TelecomManager telecomManager = TelecomManager.from(mApp);
Wooki Wu1f82f7a2016-02-15 15:59:58 +08005243 return telecomManager.isTtySupported();
Andrew Lee9431b832015-03-09 18:46:45 -07005244 }
5245
5246 @Override
5247 public boolean isHearingAidCompatibilitySupported() {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005248 final long identity = Binder.clearCallingIdentity();
5249 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005250 return mApp.getResources().getBoolean(R.bool.hac_enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005251 } finally {
5252 Binder.restoreCallingIdentity(identity);
5253 }
Andrew Lee9431b832015-03-09 18:46:45 -07005254 }
5255
Hall Liuf6668912018-10-31 17:05:23 -07005256 /**
5257 * Determines whether the device currently supports RTT (Real-time text). Based both on carrier
5258 * support for the feature and device firmware support.
5259 *
5260 * @return {@code true} if the device and carrier both support RTT, {@code false} otherwise.
5261 */
5262 @Override
5263 public boolean isRttSupported(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005264 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005265 final Phone phone = getPhone(subscriptionId);
5266 if (phone == null) {
5267 loge("isRttSupported: no Phone found. Invalid subId:" + subscriptionId);
5268 return false;
5269 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005270 try {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005271 boolean isCarrierSupported = mApp.getCarrierConfigForSubId(subscriptionId).getBoolean(
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005272 CarrierConfigManager.KEY_RTT_SUPPORTED_BOOL);
5273 boolean isDeviceSupported =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005274 phone.getContext().getResources().getBoolean(R.bool.config_support_rtt);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005275 return isCarrierSupported && isDeviceSupported;
5276 } finally {
5277 Binder.restoreCallingIdentity(identity);
5278 }
Hall Liu98187582018-01-22 19:15:32 -08005279 }
5280
Hall Liuf6668912018-10-31 17:05:23 -07005281 /**
5282 * Determines whether the user has turned on RTT. Only returns true if the device and carrier
5283 * both also support RTT.
5284 */
5285 public boolean isRttEnabled(int subscriptionId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005286 final long identity = Binder.clearCallingIdentity();
5287 try {
Hall Liuf6668912018-10-31 17:05:23 -07005288 return isRttSupported(subscriptionId) && Settings.Secure.getInt(
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005289 mApp.getContentResolver(), Settings.Secure.RTT_CALLING_MODE, 0) != 0;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005290 } finally {
5291 Binder.restoreCallingIdentity(identity);
5292 }
Hall Liu3ad5f012018-04-06 16:23:39 -07005293 }
5294
Sanket Padawe7310cc72015-01-14 09:53:20 -08005295 /**
5296 * Returns the unique device ID of phone, for example, the IMEI for
5297 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
5298 *
5299 * <p>Requires Permission:
5300 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
5301 */
5302 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07005303 public String getDeviceId(String callingPackage) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005304 final Phone phone = PhoneFactory.getPhone(0);
Jeff Davidson913390f2018-02-23 17:11:49 -08005305 if (phone == null) {
Sanket Padawe7310cc72015-01-14 09:53:20 -08005306 return null;
5307 }
Jeff Davidson913390f2018-02-23 17:11:49 -08005308 int subId = phone.getSubId();
Michael Groover70af6dc2018-10-01 16:23:15 -07005309 if (!TelephonyPermissions.checkCallingOrSelfReadDeviceIdentifiers(mApp, subId,
5310 callingPackage, "getDeviceId")) {
Jeff Davidson913390f2018-02-23 17:11:49 -08005311 return null;
5312 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005313
5314 final long identity = Binder.clearCallingIdentity();
5315 try {
5316 return phone.getDeviceId();
5317 } finally {
5318 Binder.restoreCallingIdentity(identity);
5319 }
Sanket Padawe7310cc72015-01-14 09:53:20 -08005320 }
5321
Ping Sunc67b7c22016-03-02 19:16:45 +08005322 /**
5323 * {@hide}
5324 * Returns the IMS Registration Status on a particular subid
5325 *
5326 * @param subId
5327 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005328 public boolean isImsRegistered(int subId) {
Ping Sunc67b7c22016-03-02 19:16:45 +08005329 Phone phone = getPhone(subId);
5330 if (phone != null) {
5331 return phone.isImsRegistered();
5332 } else {
5333 return false;
5334 }
5335 }
5336
Santos Cordon7a1885b2015-02-03 11:15:19 -08005337 @Override
5338 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005339 final long identity = Binder.clearCallingIdentity();
5340 try {
5341 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
5342 } finally {
5343 Binder.restoreCallingIdentity(identity);
5344 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08005345 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07005346
Tyler Gunnf70ed162019-04-03 15:28:53 -07005347 @Override
5348 public @Nullable PhoneAccountHandle getPhoneAccountHandleForSubscriptionId(int subscriptionId) {
5349 final long identity = Binder.clearCallingIdentity();
5350 try {
5351 Phone phone = getPhone(subscriptionId);
5352 if (phone == null) {
5353 return null;
5354 }
5355 return PhoneUtils.makePstnPhoneAccountHandle(phone);
5356 } finally {
5357 Binder.restoreCallingIdentity(identity);
5358 }
5359 }
5360
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005361 /**
5362 * @return the VoWiFi calling availability.
Nathan Haroldc55097a2015-03-11 18:14:50 -07005363 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005364 public boolean isWifiCallingAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005365 final long identity = Binder.clearCallingIdentity();
5366 try {
5367 Phone phone = getPhone(subId);
5368 if (phone != null) {
5369 return phone.isWifiCallingEnabled();
5370 } else {
5371 return false;
5372 }
5373 } finally {
5374 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005375 }
Nathan Haroldc55097a2015-03-11 18:14:50 -07005376 }
5377
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005378 /**
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005379 * @return the VT calling availability.
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005380 */
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005381 public boolean isVideoTelephonyAvailable(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005382 final long identity = Binder.clearCallingIdentity();
5383 try {
5384 Phone phone = getPhone(subId);
5385 if (phone != null) {
5386 return phone.isVideoEnabled();
5387 } else {
5388 return false;
5389 }
5390 } finally {
5391 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005392 }
5393 }
5394
5395 /**
5396 * @return the IMS registration technology for the MMTEL feature. Valid return values are
5397 * defined in {@link ImsRegistrationImplBase}.
5398 */
5399 public @ImsRegistrationImplBase.ImsRegistrationTech int getImsRegTechnologyForMmTel(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005400 final long identity = Binder.clearCallingIdentity();
5401 try {
5402 Phone phone = getPhone(subId);
5403 if (phone != null) {
5404 return phone.getImsRegistrationTech();
5405 } else {
5406 return ImsRegistrationImplBase.REGISTRATION_TECH_NONE;
5407 }
5408 } finally {
5409 Binder.restoreCallingIdentity(identity);
Brad Ebinger1f2b5082018-02-08 16:11:32 -08005410 }
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07005411 }
5412
Stuart Scott8eef64f2015-04-08 15:13:54 -07005413 @Override
5414 public void factoryReset(int subId) {
5415 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07005416 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
5417 return;
5418 }
5419
Svet Ganovcc087f82015-05-12 20:35:54 -07005420 final long identity = Binder.clearCallingIdentity();
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005421
Svet Ganovcc087f82015-05-12 20:35:54 -07005422 try {
Stuart Scott981d8582015-04-21 14:09:50 -07005423 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
5424 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Pengquan Meng85728fb2018-03-12 16:31:21 -07005425 setUserDataEnabled(subId, getDefaultDataEnabled());
Svet Ganovcc087f82015-05-12 20:35:54 -07005426 setNetworkSelectionModeAutomatic(subId);
Pengquan Meng85728fb2018-03-12 16:31:21 -07005427 setPreferredNetworkType(subId, getDefaultNetworkType(subId));
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005428 setDataRoamingEnabled(subId, getDefaultDataRoamingEnabled(subId));
5429 CarrierInfoManager.deleteAllCarrierKeysForImsiEncryption(mApp);
Svet Ganovcc087f82015-05-12 20:35:54 -07005430 }
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005431 // There has been issues when Sms raw table somehow stores orphan
5432 // fragments. They lead to garbled message when new fragments come
5433 // in and combined with those stale ones. In case this happens again,
5434 // user can reset all network settings which will clean up this table.
5435 cleanUpSmsRawTable(getDefaultPhone().getContext());
Svet Ganovcc087f82015-05-12 20:35:54 -07005436 } finally {
5437 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07005438 }
5439 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005440
Amit Mahajan7dbbd822019-03-13 17:33:47 -07005441 private void cleanUpSmsRawTable(Context context) {
5442 ContentResolver resolver = context.getContentResolver();
5443 Uri uri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw/permanentDelete");
5444 resolver.delete(uri, null, null);
5445 }
5446
Narayan Kamath1c496c22015-04-16 14:40:19 +01005447 @Override
chen xu5d3637b2019-01-21 23:31:38 -08005448 public String getSimLocaleForSubscriber(int subId) {
5449 enforceReadPrivilegedPermission("getSimLocaleForSubscriber, subId: " + subId);
5450 final Phone phone = getPhone(subId);
5451 if (phone == null) {
5452 log("getSimLocaleForSubscriber, invalid subId");
chen xu2bb91e42019-01-24 14:35:54 -08005453 return null;
chen xu5d3637b2019-01-21 23:31:38 -08005454 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005455 final long identity = Binder.clearCallingIdentity();
5456 try {
chen xu5d3637b2019-01-21 23:31:38 -08005457 final SubscriptionInfo info = mSubscriptionController.getActiveSubscriptionInfo(subId,
5458 phone.getContext().getOpPackageName());
chen xu6291c472019-02-04 12:55:53 -08005459 if (info == null) {
5460 log("getSimLocaleForSubscriber, inactive subId: " + subId);
5461 return null;
5462 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005463 // Try and fetch the locale from the carrier properties or from the SIM language
5464 // preferences (EF-PL and EF-LI)...
5465 final int mcc = info.getMcc();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005466 String simLanguage = null;
chen xu5d3637b2019-01-21 23:31:38 -08005467 final Locale localeFromDefaultSim = phone.getLocaleFromSimAndCarrierPrefs();
5468 if (localeFromDefaultSim != null) {
5469 if (!localeFromDefaultSim.getCountry().isEmpty()) {
5470 if (DBG) log("Using locale from subId: " + subId + " locale: "
5471 + localeFromDefaultSim);
5472 return localeFromDefaultSim.toLanguageTag();
5473 } else {
5474 simLanguage = localeFromDefaultSim.getLanguage();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005475 }
5476 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005477
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005478 // The SIM language preferences only store a language (e.g. fr = French), not an
5479 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
5480 // the SIM and carrier preferences does not include a country we add the country
5481 // determined from the SIM MCC to provide an exact locale.
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005482 final Locale mccLocale = MccTable.getLocaleFromMcc(mApp, mcc, simLanguage);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005483 if (mccLocale != null) {
chen xu5d3637b2019-01-21 23:31:38 -08005484 if (DBG) log("No locale from SIM, using mcc locale:" + mccLocale);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005485 return mccLocale.toLanguageTag();
5486 }
5487
5488 if (DBG) log("No locale found - returning null");
5489 return null;
5490 } finally {
5491 Binder.restoreCallingIdentity(identity);
5492 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01005493 }
5494
5495 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005496 return mSubscriptionController.getAllSubInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005497 }
5498
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005499 /**
5500 * NOTE: this method assumes permission checks are done and caller identity has been cleared.
5501 */
5502 private List<SubscriptionInfo> getActiveSubscriptionInfoListPrivileged() {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005503 return mSubscriptionController.getActiveSubscriptionInfoList(mApp.getOpPackageName());
Narayan Kamath1c496c22015-04-16 14:40:19 +01005504 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005505
Chenjie Yu1ba97252018-01-11 18:16:20 -08005506 private final ModemActivityInfo mLastModemActivityInfo =
5507 new ModemActivityInfo(0, 0, 0, new int[0], 0, 0);
5508
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005509 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07005510 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
5511 * representing the state of the modem.
5512 *
Chenjie Yu1ba97252018-01-11 18:16:20 -08005513 * NOTE: The underlying implementation clears the modem state, so there should only ever be one
5514 * caller to it. Everyone should call this class to get cumulative data.
Adam Lesinski903a54c2016-04-11 14:49:52 -07005515 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005516 */
5517 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07005518 public void requestModemActivityInfo(ResultReceiver result) {
5519 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005520 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005521
5522 final long identity = Binder.clearCallingIdentity();
5523 try {
5524 ModemActivityInfo ret = null;
5525 synchronized (mLastModemActivityInfo) {
5526 ModemActivityInfo info = (ModemActivityInfo) sendRequest(
5527 CMD_GET_MODEM_ACTIVITY_INFO,
vagdeviaf9a5b92018-08-15 16:01:53 -07005528 null, workSource);
Siddharth Rayb8114062018-06-17 15:02:38 -07005529 if (isModemActivityInfoValid(info)) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005530 int[] mergedTxTimeMs = new int[ModemActivityInfo.TX_POWER_LEVELS];
5531 for (int i = 0; i < mergedTxTimeMs.length; i++) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005532 mergedTxTimeMs[i] = info.getTxTimeMillis()[i]
5533 + mLastModemActivityInfo.getTxTimeMillis()[i];
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005534 }
5535 mLastModemActivityInfo.setTimestamp(info.getTimestamp());
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005536 mLastModemActivityInfo.setSleepTimeMillis(info.getSleepTimeMillis()
5537 + mLastModemActivityInfo.getSleepTimeMillis());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005538 mLastModemActivityInfo.setIdleTimeMillis(
5539 info.getIdleTimeMillis() + mLastModemActivityInfo.getIdleTimeMillis());
5540 mLastModemActivityInfo.setTxTimeMillis(mergedTxTimeMs);
5541 mLastModemActivityInfo.setRxTimeMillis(
5542 info.getRxTimeMillis() + mLastModemActivityInfo.getRxTimeMillis());
5543 mLastModemActivityInfo.setEnergyUsed(
5544 info.getEnergyUsed() + mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005545 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005546 ret = new ModemActivityInfo(mLastModemActivityInfo.getTimestamp(),
5547 mLastModemActivityInfo.getSleepTimeMillis(),
5548 mLastModemActivityInfo.getIdleTimeMillis(),
5549 mLastModemActivityInfo.getTxTimeMillis(),
5550 mLastModemActivityInfo.getRxTimeMillis(),
5551 mLastModemActivityInfo.getEnergyUsed());
Chenjie Yu1ba97252018-01-11 18:16:20 -08005552 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005553 Bundle bundle = new Bundle();
5554 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, ret);
5555 result.send(0, bundle);
5556 } finally {
5557 Binder.restoreCallingIdentity(identity);
Chenjie Yu1ba97252018-01-11 18:16:20 -08005558 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07005559 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005560
Siddharth Rayb8114062018-06-17 15:02:38 -07005561 // Checks that ModemActivityInfo is valid. Sleep time, Idle time, Rx time and Tx time should be
5562 // less than total activity duration.
5563 private boolean isModemActivityInfoValid(ModemActivityInfo info) {
5564 if (info == null) {
5565 return false;
5566 }
5567 int activityDurationMs =
5568 (int) (info.getTimestamp() - mLastModemActivityInfo.getTimestamp());
5569 int totalTxTimeMs = 0;
5570 for (int i = 0; i < info.getTxTimeMillis().length; i++) {
5571 totalTxTimeMs += info.getTxTimeMillis()[i];
5572 }
5573 return (info.isValid()
5574 && (info.getSleepTimeMillis() <= activityDurationMs)
5575 && (info.getIdleTimeMillis() <= activityDurationMs)
5576 && (info.getRxTimeMillis() <= activityDurationMs)
5577 && (totalTxTimeMs <= activityDurationMs));
5578 }
5579
Jack Yu85bd38a2015-11-09 11:34:32 -08005580 /**
5581 * {@hide}
5582 * Returns the service state information on specified subscription.
5583 */
5584 @Override
5585 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005586 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08005587 mApp, subId, callingPackage, "getServiceStateForSubscriber")) {
Jack Yu85bd38a2015-11-09 11:34:32 -08005588 return null;
5589 }
5590
Hall Liuf19c44f2018-11-27 14:38:17 -08005591 LocationAccessPolicy.LocationPermissionResult fineLocationResult =
5592 LocationAccessPolicy.checkLocationPermission(mApp,
5593 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5594 .setCallingPackage(callingPackage)
5595 .setCallingPid(Binder.getCallingPid())
5596 .setCallingUid(Binder.getCallingUid())
5597 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005598 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005599 .setMinSdkVersionForFine(Build.VERSION_CODES.Q)
5600 .build());
5601
5602 LocationAccessPolicy.LocationPermissionResult coarseLocationResult =
5603 LocationAccessPolicy.checkLocationPermission(mApp,
5604 new LocationAccessPolicy.LocationPermissionQuery.Builder()
5605 .setCallingPackage(callingPackage)
5606 .setCallingPid(Binder.getCallingPid())
5607 .setCallingUid(Binder.getCallingUid())
5608 .setMethod("getServiceStateForSubscriber")
Hall Liuf18a0cf2019-04-17 13:37:11 -07005609 .setLogAsInfo(true)
Hall Liuf19c44f2018-11-27 14:38:17 -08005610 .setMinSdkVersionForCoarse(Build.VERSION_CODES.Q)
5611 .build());
5612 // We don't care about hard or soft here -- all we need to know is how much info to scrub.
5613 boolean hasFinePermission =
5614 fineLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5615 boolean hasCoarsePermission =
5616 coarseLocationResult == LocationAccessPolicy.LocationPermissionResult.ALLOWED;
5617
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005618 final long identity = Binder.clearCallingIdentity();
5619 try {
5620 final Phone phone = getPhone(subId);
5621 if (phone == null) {
5622 return null;
5623 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005624
Hall Liuf19c44f2018-11-27 14:38:17 -08005625 ServiceState ss = phone.getServiceState();
5626
5627 // Scrub out the location info in ServiceState depending on what level of access
5628 // the caller has.
5629 if (hasFinePermission) return ss;
5630 if (hasCoarsePermission) return ss.sanitizeLocationInfo(false);
5631 return ss.sanitizeLocationInfo(true);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005632 } finally {
5633 Binder.restoreCallingIdentity(identity);
5634 }
Jack Yu85bd38a2015-11-09 11:34:32 -08005635 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005636
5637 /**
5638 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
5639 *
5640 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5641 * voicemail ringtone.
5642 * @return The URI for the ringtone to play when receiving a voicemail from a specific
5643 * PhoneAccount.
5644 */
5645 @Override
5646 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005647 final long identity = Binder.clearCallingIdentity();
5648 try {
5649 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5650 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005651 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005652 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005653
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005654 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
5655 } finally {
5656 Binder.restoreCallingIdentity(identity);
5657 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005658 }
5659
5660 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005661 * Sets the per-account voicemail ringtone.
5662 *
5663 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5664 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5665 *
5666 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5667 * voicemail ringtone.
5668 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific
5669 * PhoneAccount.
5670 */
5671 @Override
5672 public void setVoicemailRingtoneUri(String callingPackage,
5673 PhoneAccountHandle phoneAccountHandle, Uri uri) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005674 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005675 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5676 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005677 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005678 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5679 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5680 "setVoicemailRingtoneUri");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005681 }
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005682
5683 final long identity = Binder.clearCallingIdentity();
5684 try {
5685 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5686 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005687 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005688 }
5689 VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
5690 } finally {
5691 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005692 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005693 }
5694
5695 /**
Nancy Chen31f9ba12016-01-06 11:42:12 -08005696 * Returns whether vibration is set for voicemail notification in Phone settings.
5697 *
5698 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
5699 * voicemail vibration setting.
5700 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
5701 */
5702 @Override
5703 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005704 final long identity = Binder.clearCallingIdentity();
5705 try {
5706 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
5707 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005708 phone = getDefaultPhone();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005709 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005710
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005711 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
5712 } finally {
5713 Binder.restoreCallingIdentity(identity);
5714 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08005715 }
5716
Youhan Wange64578a2016-05-02 15:32:42 -07005717 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005718 * Sets the per-account voicemail vibration.
5719 *
5720 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
5721 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
5722 *
5723 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
5724 * voicemail vibration setting.
5725 * @param enabled Whether to enable or disable vibration for voicemail notifications from a
5726 * specific PhoneAccount.
5727 */
5728 @Override
5729 public void setVoicemailVibrationEnabled(String callingPackage,
5730 PhoneAccountHandle phoneAccountHandle, boolean enabled) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005731 final Phone defaultPhone = getDefaultPhone();
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005732 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
5733 if (!TextUtils.equals(callingPackage,
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005734 TelecomManager.from(defaultPhone.getContext()).getDefaultDialerPackage())) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005735 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5736 mApp, PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle),
5737 "setVoicemailVibrationEnabled");
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005738 }
5739
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005740 final long identity = Binder.clearCallingIdentity();
5741 try {
5742 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
5743 if (phone == null) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005744 phone = defaultPhone;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005745 }
5746 VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
5747 } finally {
5748 Binder.restoreCallingIdentity(identity);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005749 }
Ta-wei Yenc33877d2017-01-23 18:11:21 -08005750 }
5751
5752 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005753 * Make sure either called from same process as self (phone) or IPC caller has read privilege.
5754 *
5755 * @throws SecurityException if the caller does not have the required permission
5756 */
Brad Ebinger35c841c2018-10-01 10:40:55 -07005757 private void enforceReadPrivilegedPermission(String message) {
Youhan Wange64578a2016-05-02 15:32:42 -07005758 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
Brad Ebinger35c841c2018-10-01 10:40:55 -07005759 message);
Youhan Wange64578a2016-05-02 15:32:42 -07005760 }
5761
5762 /**
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005763 * Make sure either called from same process as self (phone) or IPC caller has send SMS
5764 * permission.
5765 *
5766 * @throws SecurityException if the caller does not have the required permission
5767 */
5768 private void enforceSendSmsPermission() {
5769 mApp.enforceCallingOrSelfPermission(permission.SEND_SMS, null);
5770 }
5771
5772 /**
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005773 * Make sure called from the package in charge of visual voicemail.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005774 *
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005775 * @throws SecurityException if the caller is not the visual voicemail package.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005776 */
Ta-wei Yen527a9c02017-01-06 15:29:25 -08005777 private void enforceVisualVoicemailPackage(String callingPackage, int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005778 final long identity = Binder.clearCallingIdentity();
5779 try {
5780 ComponentName componentName =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08005781 RemoteVvmTaskManager.getRemotePackage(mApp, subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005782 if (componentName == null) {
5783 throw new SecurityException(
5784 "Caller not current active visual voicemail package[null]");
5785 }
5786 String vvmPackage = componentName.getPackageName();
5787 if (!callingPackage.equals(vvmPackage)) {
5788 throw new SecurityException("Caller not current active visual voicemail package["
5789 + vvmPackage + "]");
5790 }
5791 } finally {
5792 Binder.restoreCallingIdentity(identity);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08005793 }
5794 }
5795
5796 /**
Youhan Wange64578a2016-05-02 15:32:42 -07005797 * Return the application ID for the app type.
5798 *
5799 * @param subId the subscription ID that this request applies to.
5800 * @param appType the uicc app type.
5801 * @return Application ID for specificied app type, or null if no uicc.
5802 */
5803 @Override
5804 public String getAidForAppType(int subId, int appType) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005805 enforceReadPrivilegedPermission("getAidForAppType");
Youhan Wange64578a2016-05-02 15:32:42 -07005806 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005807
5808 final long identity = Binder.clearCallingIdentity();
Youhan Wange64578a2016-05-02 15:32:42 -07005809 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005810 if (phone == null) {
5811 return null;
5812 }
5813 String aid = null;
5814 try {
5815 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
5816 .getApplicationByType(appType).getAid();
5817 } catch (Exception e) {
5818 Log.e(LOG_TAG, "Not getting aid. Exception ex=" + e);
5819 }
5820 return aid;
5821 } finally {
5822 Binder.restoreCallingIdentity(identity);
Youhan Wange64578a2016-05-02 15:32:42 -07005823 }
Youhan Wange64578a2016-05-02 15:32:42 -07005824 }
5825
Youhan Wang4001d252016-05-11 10:29:41 -07005826 /**
5827 * Return the Electronic Serial Number.
5828 *
5829 * @param subId the subscription ID that this request applies to.
5830 * @return ESN or null if error.
5831 */
5832 @Override
5833 public String getEsn(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005834 enforceReadPrivilegedPermission("getEsn");
Youhan Wang4001d252016-05-11 10:29:41 -07005835 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005836
5837 final long identity = Binder.clearCallingIdentity();
Youhan Wang4001d252016-05-11 10:29:41 -07005838 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005839 if (phone == null) {
5840 return null;
5841 }
5842 String esn = null;
5843 try {
5844 esn = phone.getEsn();
5845 } catch (Exception e) {
5846 Log.e(LOG_TAG, "Not getting ESN. Exception ex=" + e);
5847 }
5848 return esn;
5849 } finally {
5850 Binder.restoreCallingIdentity(identity);
Youhan Wang4001d252016-05-11 10:29:41 -07005851 }
Youhan Wang4001d252016-05-11 10:29:41 -07005852 }
5853
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005854 /**
Youhan Wang66ad5d72016-07-18 17:56:58 -07005855 * Return the Preferred Roaming List Version.
5856 *
5857 * @param subId the subscription ID that this request applies to.
5858 * @return PRLVersion or null if error.
5859 */
5860 @Override
5861 public String getCdmaPrlVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005862 enforceReadPrivilegedPermission("getCdmaPrlVersion");
Youhan Wang66ad5d72016-07-18 17:56:58 -07005863 Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005864
5865 final long identity = Binder.clearCallingIdentity();
Youhan Wang66ad5d72016-07-18 17:56:58 -07005866 try {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005867 if (phone == null) {
5868 return null;
5869 }
5870 String cdmaPrlVersion = null;
5871 try {
5872 cdmaPrlVersion = phone.getCdmaPrlVersion();
5873 } catch (Exception e) {
5874 Log.e(LOG_TAG, "Not getting PRLVersion", e);
5875 }
5876 return cdmaPrlVersion;
5877 } finally {
5878 Binder.restoreCallingIdentity(identity);
Youhan Wang66ad5d72016-07-18 17:56:58 -07005879 }
Youhan Wang66ad5d72016-07-18 17:56:58 -07005880 }
5881
5882 /**
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005883 * Get snapshot of Telephony histograms
5884 * @return List of Telephony histograms
5885 * @hide
5886 */
5887 @Override
5888 public List<TelephonyHistogram> getTelephonyHistograms() {
Jeff Davidson7e17e312018-02-13 18:17:36 -08005889 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
5890 mApp, getDefaultSubscription(), "getTelephonyHistograms");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005891
5892 final long identity = Binder.clearCallingIdentity();
5893 try {
5894 return RIL.getTelephonyRILTimingHistograms();
5895 } finally {
5896 Binder.restoreCallingIdentity(identity);
5897 }
Sanket Padawe99ef1e32016-05-18 16:12:33 -07005898 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005899
5900 /**
5901 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005902 * Set the allowed carrier list and the excluded carrier list, indicating the priority between
5903 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005904 * Require system privileges. In the future we may add this to carrier APIs.
5905 *
Michele Berionne482f8202018-11-27 18:57:59 -08005906 * @return Integer with the result of the operation, as defined in {@link TelephonyManager}.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005907 */
5908 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005909 @TelephonyManager.SetCarrierRestrictionResult
5910 public int setAllowedCarriers(CarrierRestrictionRules carrierRestrictionRules) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07005911 enforceModifyPermission();
vagdeviaf9a5b92018-08-15 16:01:53 -07005912 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005913
Michele Berionne482f8202018-11-27 18:57:59 -08005914 if (carrierRestrictionRules == null) {
5915 throw new NullPointerException("carrier restriction cannot be null");
Meng Wang9b7c4e92017-02-17 11:41:27 -08005916 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07005917
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005918 final long identity = Binder.clearCallingIdentity();
5919 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005920 return (int) sendRequest(CMD_SET_ALLOWED_CARRIERS, carrierRestrictionRules,
vagdeviaf9a5b92018-08-15 16:01:53 -07005921 workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005922 } finally {
5923 Binder.restoreCallingIdentity(identity);
5924 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005925 }
5926
5927 /**
5928 * {@hide}
Michele Berionne482f8202018-11-27 18:57:59 -08005929 * Get the allowed carrier list and the excluded carrier list, including the priority between
5930 * the two lists.
Meng Wang1a7c35a2016-05-05 20:56:15 -07005931 * Require system privileges. In the future we may add this to carrier APIs.
5932 *
Michele Berionne482f8202018-11-27 18:57:59 -08005933 * @return {@link android.telephony.CarrierRestrictionRules}
Meng Wang1a7c35a2016-05-05 20:56:15 -07005934 */
5935 @Override
Michele Berionne482f8202018-11-27 18:57:59 -08005936 public CarrierRestrictionRules getAllowedCarriers() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07005937 enforceReadPrivilegedPermission("getAllowedCarriers");
vagdeviaf9a5b92018-08-15 16:01:53 -07005938 WorkSource workSource = getWorkSource(Binder.getCallingUid());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005939
5940 final long identity = Binder.clearCallingIdentity();
5941 try {
Michele Berionne482f8202018-11-27 18:57:59 -08005942 Object response = sendRequest(CMD_GET_ALLOWED_CARRIERS, null, workSource);
5943 if (response instanceof CarrierRestrictionRules) {
5944 return (CarrierRestrictionRules) response;
5945 }
5946 // Response is an Exception of some kind,
5947 // which is signalled to the user as a NULL retval
5948 return null;
5949 } catch (Exception e) {
5950 Log.e(LOG_TAG, "getAllowedCarriers. Exception ex=" + e);
5951 return null;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005952 } finally {
5953 Binder.restoreCallingIdentity(identity);
5954 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07005955 }
5956
fionaxu59545b42016-05-25 15:53:37 -07005957 /**
5958 * Action set from carrier signalling broadcast receivers to enable/disable metered apns
5959 * @param subId the subscription ID that this action applies to.
5960 * @param enabled control enable or disable metered apns.
5961 * {@hide}
5962 */
5963 @Override
5964 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) {
5965 enforceModifyPermission();
5966 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005967
5968 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07005969 if (phone == null) {
5970 loge("carrierAction: SetMeteredApnsEnabled fails with invalid subId: " + subId);
5971 return;
5972 }
5973 try {
5974 phone.carrierActionSetMeteredApnsEnabled(enabled);
5975 } catch (Exception e) {
5976 Log.e(LOG_TAG, "carrierAction: SetMeteredApnsEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005977 } finally {
5978 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07005979 }
5980 }
5981
5982 /**
5983 * Action set from carrier signalling broadcast receivers to enable/disable radio
5984 * @param subId the subscription ID that this action applies to.
5985 * @param enabled control enable or disable radio.
5986 * {@hide}
5987 */
5988 @Override
5989 public void carrierActionSetRadioEnabled(int subId, boolean enabled) {
5990 enforceModifyPermission();
5991 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08005992
5993 final long identity = Binder.clearCallingIdentity();
fionaxu59545b42016-05-25 15:53:37 -07005994 if (phone == null) {
5995 loge("carrierAction: SetRadioEnabled fails with invalid sibId: " + subId);
5996 return;
5997 }
5998 try {
5999 phone.carrierActionSetRadioEnabled(enabled);
6000 } catch (Exception e) {
6001 Log.e(LOG_TAG, "carrierAction: SetRadioEnabled fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006002 } finally {
6003 Binder.restoreCallingIdentity(identity);
fionaxu59545b42016-05-25 15:53:37 -07006004 }
6005 }
6006
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006007 /**
fionaxu8da9cb12017-05-23 15:02:46 -07006008 * Action set from carrier signalling broadcast receivers to start/stop reporting the default
6009 * network status based on which carrier apps could apply actions accordingly,
6010 * enable/disable default url handler for example.
6011 *
6012 * @param subId the subscription ID that this action applies to.
6013 * @param report control start/stop reporting the default network status.
6014 * {@hide}
6015 */
6016 @Override
6017 public void carrierActionReportDefaultNetworkStatus(int subId, boolean report) {
6018 enforceModifyPermission();
6019 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006020
6021 final long identity = Binder.clearCallingIdentity();
fionaxu8da9cb12017-05-23 15:02:46 -07006022 if (phone == null) {
6023 loge("carrierAction: ReportDefaultNetworkStatus fails with invalid sibId: " + subId);
6024 return;
6025 }
6026 try {
6027 phone.carrierActionReportDefaultNetworkStatus(report);
6028 } catch (Exception e) {
6029 Log.e(LOG_TAG, "carrierAction: ReportDefaultNetworkStatus fails. Exception ex=" + e);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006030 } finally {
6031 Binder.restoreCallingIdentity(identity);
fionaxu8da9cb12017-05-23 15:02:46 -07006032 }
6033 }
6034
6035 /**
fionaxud9622282017-07-17 17:51:30 -07006036 * Action set from carrier signalling broadcast receivers to reset all carrier actions
6037 * @param subId the subscription ID that this action applies to.
6038 * {@hide}
6039 */
6040 @Override
6041 public void carrierActionResetAll(int subId) {
6042 enforceModifyPermission();
6043 final Phone phone = getPhone(subId);
6044 if (phone == null) {
6045 loge("carrierAction: ResetAll fails with invalid sibId: " + subId);
6046 return;
6047 }
6048 try {
6049 phone.carrierActionResetAll();
6050 } catch (Exception e) {
6051 Log.e(LOG_TAG, "carrierAction: ResetAll fails. Exception ex=" + e);
6052 }
6053 }
6054
6055 /**
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006056 * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
6057 * bug report is being generated.
6058 */
6059 @Override
Ta-wei Yen99282e02016-06-21 18:19:35 -07006060 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006061 if (mApp.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
6062 != PackageManager.PERMISSION_GRANTED) {
dcashman22b950d2016-06-27 11:39:02 -07006063 writer.println("Permission Denial: can't dump Phone from pid="
6064 + Binder.getCallingPid()
6065 + ", uid=" + Binder.getCallingUid()
6066 + "without permission "
6067 + android.Manifest.permission.DUMP);
6068 return;
6069 }
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006070 DumpsysHandler.dump(mApp, fd, writer, args);
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07006071 }
Jack Yueb89b242016-06-22 13:27:47 -07006072
Brad Ebingerdac2f002018-04-03 15:17:52 -07006073 @Override
6074 public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
6075 String[] args, ShellCallback callback, ResultReceiver resultReceiver)
6076 throws RemoteException {
6077 (new TelephonyShellCommand(this)).exec(this, in, out, err, args, callback, resultReceiver);
6078 }
6079
Jack Yueb89b242016-06-22 13:27:47 -07006080 /**
Jack Yu84291ec2017-05-26 16:07:50 -07006081 * Get aggregated video call data usage since boot.
6082 *
6083 * @param perUidStats True if requesting data usage per uid, otherwise overall usage.
6084 * @return Snapshot of video call data usage
Jack Yueb89b242016-06-22 13:27:47 -07006085 * {@hide}
6086 */
6087 @Override
Jack Yu84291ec2017-05-26 16:07:50 -07006088 public NetworkStats getVtDataUsage(int subId, boolean perUidStats) {
Jack Yueb89b242016-06-22 13:27:47 -07006089 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_NETWORK_USAGE_HISTORY,
6090 null);
6091
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006092 final long identity = Binder.clearCallingIdentity();
6093 try {
6094 // NetworkStatsService keeps tracking the active network interface and identity. It
6095 // records the delta with the corresponding network identity.
6096 // We just return the total video call data usage snapshot since boot.
6097 Phone phone = getPhone(subId);
6098 if (phone != null) {
6099 return phone.getVtDataUsage(perUidStats);
6100 }
6101 return null;
6102 } finally {
6103 Binder.restoreCallingIdentity(identity);
Jack Yueb89b242016-06-22 13:27:47 -07006104 }
Jack Yueb89b242016-06-22 13:27:47 -07006105 }
Jack Yu75ab2952016-07-08 14:29:33 -07006106
6107 /**
6108 * Policy control of data connection. Usually used when data limit is passed.
6109 * @param enabled True if enabling the data, otherwise disabling.
6110 * @param subId Subscription index
6111 * {@hide}
6112 */
6113 @Override
6114 public void setPolicyDataEnabled(boolean enabled, int subId) {
6115 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006116
6117 final long identity = Binder.clearCallingIdentity();
6118 try {
6119 Phone phone = getPhone(subId);
6120 if (phone != null) {
Jack Yud79fba22018-12-13 11:51:28 -08006121 phone.getDataEnabledSettings().setPolicyDataEnabled(enabled);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006122 }
6123 } finally {
6124 Binder.restoreCallingIdentity(identity);
Jack Yu75ab2952016-07-08 14:29:33 -07006125 }
6126 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006127
6128 /**
6129 * Get Client request stats
6130 * @return List of Client Request Stats
6131 * @hide
6132 */
6133 @Override
6134 public List<ClientRequestStats> getClientRequestStats(String callingPackage, int subId) {
Jeff Davidson7e17e312018-02-13 18:17:36 -08006135 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Jeff Davidson913390f2018-02-23 17:11:49 -08006136 mApp, subId, callingPackage, "getClientRequestStats")) {
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006137 return null;
6138 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006139 Phone phone = getPhone(subId);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006140
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006141 final long identity = Binder.clearCallingIdentity();
6142 try {
6143 if (phone != null) {
6144 return phone.getClientRequestStats();
6145 }
6146
6147 return null;
6148 } finally {
6149 Binder.restoreCallingIdentity(identity);
6150 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006151 }
6152
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006153 private WorkSource getWorkSource(int uid) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006154 String packageName = mApp.getPackageManager().getNameForUid(uid);
Narayan Kamathf04b5a12018-01-09 11:47:15 +00006155 return new WorkSource(uid, packageName);
Sooraj Sasindran9a909312016-07-18 11:57:25 -07006156 }
Jack Yueb4124c2017-02-16 15:32:43 -08006157
6158 /**
Grace Chen70990072017-03-24 17:21:30 -07006159 * Set SIM card power state.
Jack Yueb4124c2017-02-16 15:32:43 -08006160 *
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006161 * @param slotIndex SIM slot id.
Grace Chen70990072017-03-24 17:21:30 -07006162 * @param state State of SIM (power down, power up, pass through)
6163 * - {@link android.telephony.TelephonyManager#CARD_POWER_DOWN}
6164 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP}
6165 * - {@link android.telephony.TelephonyManager#CARD_POWER_UP_PASS_THROUGH}
Jack Yueb4124c2017-02-16 15:32:43 -08006166 *
6167 **/
6168 @Override
Grace Chen70990072017-03-24 17:21:30 -07006169 public void setSimPowerStateForSlot(int slotIndex, int state) {
Jack Yueb4124c2017-02-16 15:32:43 -08006170 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07006171 Phone phone = PhoneFactory.getPhone(slotIndex);
6172
vagdeviaf9a5b92018-08-15 16:01:53 -07006173 WorkSource workSource = getWorkSource(Binder.getCallingUid());
6174
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006175 final long identity = Binder.clearCallingIdentity();
6176 try {
6177 if (phone != null) {
vagdeviaf9a5b92018-08-15 16:01:53 -07006178 phone.setSimPowerState(state, workSource);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006179 }
6180 } finally {
6181 Binder.restoreCallingIdentity(identity);
Jack Yueb4124c2017-02-16 15:32:43 -08006182 }
6183 }
Shuo Qiandd210312017-04-12 22:11:33 +00006184
Tyler Gunn65d45c22017-06-05 11:22:26 -07006185 private boolean isUssdApiAllowed(int subId) {
6186 CarrierConfigManager configManager =
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006187 (CarrierConfigManager) mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Tyler Gunn65d45c22017-06-05 11:22:26 -07006188 if (configManager == null) {
6189 return false;
6190 }
6191 PersistableBundle pb = configManager.getConfigForSubId(subId);
6192 if (pb == null) {
6193 return false;
6194 }
6195 return pb.getBoolean(
6196 CarrierConfigManager.KEY_ALLOW_USSD_REQUESTS_VIA_TELEPHONY_MANAGER_BOOL);
6197 }
6198
Shuo Qiandd210312017-04-12 22:11:33 +00006199 /**
6200 * Check if phone is in emergency callback mode
6201 * @return true if phone is in emergency callback mode
6202 * @param subId sub id
6203 */
goneil9c5f4872017-12-05 14:07:56 -08006204 @Override
Shuo Qiandd210312017-04-12 22:11:33 +00006205 public boolean getEmergencyCallbackMode(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006206 enforceReadPrivilegedPermission("getEmergencyCallbackMode");
Shuo Qiandd210312017-04-12 22:11:33 +00006207 final Phone phone = getPhone(subId);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006208
6209 final long identity = Binder.clearCallingIdentity();
6210 try {
6211 if (phone != null) {
6212 return phone.isInEcm();
6213 } else {
6214 return false;
6215 }
6216 } finally {
6217 Binder.restoreCallingIdentity(identity);
Shuo Qiandd210312017-04-12 22:11:33 +00006218 }
6219 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006220
6221 /**
6222 * Get the current signal strength information for the given subscription.
6223 * Because this information is not updated when the device is in a low power state
6224 * it should not be relied-upon to be current.
6225 * @param subId Subscription index
6226 * @return the most recent cached signal strength info from the modem
6227 */
6228 @Override
6229 public SignalStrength getSignalStrength(int subId) {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006230 final long identity = Binder.clearCallingIdentity();
6231 try {
6232 Phone p = getPhone(subId);
6233 if (p == null) {
6234 return null;
6235 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006236
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006237 return p.getSignalStrength();
6238 } finally {
6239 Binder.restoreCallingIdentity(identity);
6240 }
Nathan Harold46b42aa2017-03-10 19:38:22 -08006241 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006242
Pengquan Meng77b7f132018-08-22 14:49:57 -07006243 /**
Chen Xuf792fd62018-10-17 17:54:36 +00006244 * Get the current modem radio state for the given slot.
6245 * @param slotIndex slot index.
6246 * @param callingPackage the name of the package making the call.
6247 * @return the current radio power state from the modem
6248 */
6249 @Override
6250 public int getRadioPowerState(int slotIndex, String callingPackage) {
6251 Phone phone = PhoneFactory.getPhone(slotIndex);
6252 if (phone != null) {
6253 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6254 mApp, phone.getSubId(), callingPackage, "getRadioPowerState")) {
6255 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6256 }
6257
6258 final long identity = Binder.clearCallingIdentity();
6259 try {
6260 return phone.getRadioPowerState();
6261 } finally {
6262 Binder.restoreCallingIdentity(identity);
6263 }
6264 }
6265 return TelephonyManager.RADIO_POWER_UNAVAILABLE;
6266 }
6267
6268 /**
Pengquan Meng77b7f132018-08-22 14:49:57 -07006269 * Checks if data roaming is enabled on the subscription with id {@code subId}.
6270 *
6271 * <p>Requires one of the following permissions:
6272 * {@link android.Manifest.permission#ACCESS_NETWORK_STATE},
6273 * {@link android.Manifest.permission#READ_PHONE_STATE} or that the calling app has carrier
6274 * privileges.
6275 *
6276 * @param subId subscription id
6277 * @return {@code true} if data roaming is enabled on this subscription, otherwise return
6278 * {@code false}.
6279 */
6280 @Override
6281 public boolean isDataRoamingEnabled(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006282 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
6283 null /* message */);
6284
Pengquan Menga1bb6272018-09-06 09:59:22 -07006285 boolean isEnabled = false;
6286 final long identity = Binder.clearCallingIdentity();
Pengquan Meng77b7f132018-08-22 14:49:57 -07006287 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006288 Phone phone = getPhone(subId);
6289 isEnabled = phone != null ? phone.getDataRoamingEnabled() : false;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006290 } catch (Exception e) {
6291 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6292 mApp, subId, "isDataRoamingEnabled");
Pengquan Menga1bb6272018-09-06 09:59:22 -07006293 } finally {
6294 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006295 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006296 return isEnabled;
Pengquan Meng77b7f132018-08-22 14:49:57 -07006297 }
6298
6299
6300 /**
6301 * Enables/Disables the data roaming on the subscription with id {@code subId}.
6302 *
6303 * <p> Requires permission:
6304 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the calling app has carrier
6305 * privileges.
6306 *
6307 * @param subId subscription id
6308 * @param isEnabled {@code true} means enable, {@code false} means disable.
6309 */
6310 @Override
6311 public void setDataRoamingEnabled(int subId, boolean isEnabled) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006312 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6313 mApp, subId, "setDataRoamingEnabled");
6314
Pengquan Menga1bb6272018-09-06 09:59:22 -07006315 final long identity = Binder.clearCallingIdentity();
6316 try {
Pengquan Menga1bb6272018-09-06 09:59:22 -07006317 Phone phone = getPhone(subId);
6318 if (phone != null) {
6319 phone.setDataRoamingEnabled(isEnabled);
6320 }
6321 } finally {
6322 Binder.restoreCallingIdentity(identity);
Pengquan Meng77b7f132018-08-22 14:49:57 -07006323 }
6324 }
6325
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006326 @Override
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006327 public boolean isManualNetworkSelectionAllowed(int subId) {
Pengquan Meng44e66f12019-04-01 10:48:20 -07006328 TelephonyPermissions.enforeceCallingOrSelfReadPhoneStatePermissionOrCarrierPrivilege(
6329 mApp, subId, "isManualNetworkSelectionAllowed");
6330
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006331 boolean isAllowed = true;
6332 final long identity = Binder.clearCallingIdentity();
6333 try {
Pengquan Meng6884a2c2018-10-03 12:19:13 -07006334 Phone phone = getPhone(subId);
6335 if (phone != null) {
6336 isAllowed = phone.isCspPlmnEnabled();
6337 }
6338 } finally {
6339 Binder.restoreCallingIdentity(identity);
6340 }
6341 return isAllowed;
6342 }
6343
6344 @Override
Jordan Liu75f43ea2019-01-17 16:56:37 -08006345 public List<UiccCardInfo> getUiccCardsInfo(String callingPackage) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006346 boolean hasReadPermission = false;
Jordan Liuc65bc952019-02-12 17:54:02 -08006347 try {
6348 enforceReadPrivilegedPermission("getUiccCardsInfo");
Jordan Liu1e142fc2019-04-22 15:10:43 -07006349 hasReadPermission = true;
Jordan Liuc65bc952019-02-12 17:54:02 -08006350 } catch (SecurityException e) {
6351 // even without READ_PRIVILEGED_PHONE_STATE, we allow the call to continue if the caller
6352 // has carrier privileges on an active UICC
6353 if (checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
6354 != TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Jordan Liu1e142fc2019-04-22 15:10:43 -07006355 throw new SecurityException("Caller does not have permission.");
Jordan Liuc65bc952019-02-12 17:54:02 -08006356 }
Jordan Liu75f43ea2019-01-17 16:56:37 -08006357 }
Jordan Liu5aa07002018-12-18 15:44:48 -08006358
6359 final long identity = Binder.clearCallingIdentity();
6360 try {
Jordan Liu75f43ea2019-01-17 16:56:37 -08006361 UiccController uiccController = UiccController.getInstance();
6362 ArrayList<UiccCardInfo> cardInfos = uiccController.getAllUiccCardInfos();
Jordan Liu1e142fc2019-04-22 15:10:43 -07006363 if (hasReadPermission) {
6364 return cardInfos;
Jordan Liu75f43ea2019-01-17 16:56:37 -08006365 }
Jordan Liu1e142fc2019-04-22 15:10:43 -07006366
6367 // Remove private info if the caller doesn't have access
6368 ArrayList<UiccCardInfo> filteredInfos = new ArrayList<>();
6369 for (UiccCardInfo cardInfo : cardInfos) {
6370 // For an inactive eUICC, the UiccCard will be null even though the UiccCardInfo
6371 // is available
6372 UiccCard card = uiccController.getUiccCardForSlot(cardInfo.getSlotIndex());
6373 if (card == null || card.getUiccProfile() == null) {
6374 // assume no access if the card or profile is unavailable
6375 filteredInfos.add(cardInfo.getUnprivileged());
6376 continue;
6377 }
6378 UiccProfile profile = card.getUiccProfile();
6379 if (profile.getCarrierPrivilegeStatus(mApp.getPackageManager(), callingPackage)
6380 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
6381 filteredInfos.add(cardInfo);
6382 } else {
6383 filteredInfos.add(cardInfo.getUnprivileged());
6384 }
6385 }
6386 return filteredInfos;
Jordan Liu5aa07002018-12-18 15:44:48 -08006387 } finally {
6388 Binder.restoreCallingIdentity(identity);
6389 }
6390 }
6391
6392 @Override
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006393 public UiccSlotInfo[] getUiccSlotsInfo() {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006394 enforceReadPrivilegedPermission("getUiccSlotsInfo");
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006395
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006396 final long identity = Binder.clearCallingIdentity();
6397 try {
6398 UiccSlot[] slots = UiccController.getInstance().getUiccSlots();
6399 if (slots == null) {
6400 Rlog.i(LOG_TAG, "slots is null.");
6401 return null;
6402 }
6403
6404 UiccSlotInfo[] infos = new UiccSlotInfo[slots.length];
6405 for (int i = 0; i < slots.length; i++) {
6406 UiccSlot slot = slots[i];
6407 if (slot == null) {
6408 continue;
6409 }
6410
Jordan Liu7be7e652019-05-06 18:55:02 +00006411 String cardId;
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006412 UiccCard card = slot.getUiccCard();
6413 if (card != null) {
6414 cardId = card.getCardId();
Jordan Liu7be7e652019-05-06 18:55:02 +00006415 } else {
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006416 cardId = slot.getIccId();
6417 }
6418
6419 int cardState = 0;
6420 switch (slot.getCardState()) {
6421 case CARDSTATE_ABSENT:
6422 cardState = UiccSlotInfo.CARD_STATE_INFO_ABSENT;
6423 break;
6424 case CARDSTATE_PRESENT:
6425 cardState = UiccSlotInfo.CARD_STATE_INFO_PRESENT;
6426 break;
6427 case CARDSTATE_ERROR:
6428 cardState = UiccSlotInfo.CARD_STATE_INFO_ERROR;
6429 break;
6430 case CARDSTATE_RESTRICTED:
6431 cardState = UiccSlotInfo.CARD_STATE_INFO_RESTRICTED;
6432 break;
6433 default:
6434 break;
6435
6436 }
6437
6438 infos[i] = new UiccSlotInfo(
6439 slot.isActive(),
6440 slot.isEuicc(),
6441 cardId,
6442 cardState,
6443 slot.getPhoneId(),
Jordan Liua2619582019-02-14 12:56:40 -08006444 slot.isExtendedApduSupported(),
6445 slot.isRemovable());
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006446 }
6447 return infos;
6448 } finally {
6449 Binder.restoreCallingIdentity(identity);
Holly Jiuyu Sun1d957c52018-04-04 13:52:42 -07006450 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006451 }
6452
6453 @Override
6454 public boolean switchSlots(int[] physicalSlots) {
6455 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006456
6457 final long identity = Binder.clearCallingIdentity();
6458 try {
6459 return (Boolean) sendRequest(CMD_SWITCH_SLOTS, physicalSlots);
6460 } finally {
6461 Binder.restoreCallingIdentity(identity);
6462 }
Holly Jiuyu Sun01c47ad2018-01-24 17:56:33 +00006463 }
Jack Yu4c988042018-02-27 15:30:01 -08006464
6465 @Override
Jordan Liu7de49fa2018-12-06 14:48:49 -08006466 public int getCardIdForDefaultEuicc(int subId, String callingPackage) {
Jordan Liu7de49fa2018-12-06 14:48:49 -08006467 final long identity = Binder.clearCallingIdentity();
6468 try {
6469 return UiccController.getInstance().getCardIdForDefaultEuicc();
6470 } finally {
6471 Binder.restoreCallingIdentity(identity);
6472 }
6473 }
6474
6475 @Override
Jack Yu4c988042018-02-27 15:30:01 -08006476 public void setRadioIndicationUpdateMode(int subId, int filters, int mode) {
6477 enforceModifyPermission();
6478 final Phone phone = getPhone(subId);
6479 if (phone == null) {
6480 loge("setRadioIndicationUpdateMode fails with invalid subId: " + subId);
6481 return;
6482 }
6483
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006484 final long identity = Binder.clearCallingIdentity();
6485 try {
6486 phone.setRadioIndicationUpdateMode(filters, mode);
6487 } finally {
6488 Binder.restoreCallingIdentity(identity);
6489 }
Jack Yu4c988042018-02-27 15:30:01 -08006490 }
Pengquan Meng85728fb2018-03-12 16:31:21 -07006491
6492 /**
goneil47ffb6e2018-04-06 15:40:58 -07006493 * A test API to reload the UICC profile.
6494 *
6495 * <p>Requires that the calling app has permission
6496 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
6497 * @hide
6498 */
6499 @Override
6500 public void refreshUiccProfile(int subId) {
6501 enforceModifyPermission();
6502
6503 final long identity = Binder.clearCallingIdentity();
6504 try {
6505 Phone phone = getPhone(subId);
6506 if (phone == null) {
6507 return;
6508 }
6509 UiccCard uiccCard = phone.getUiccCard();
6510 if (uiccCard == null) {
6511 return;
6512 }
6513 UiccProfile uiccProfile = uiccCard.getUiccProfile();
6514 if (uiccProfile == null) {
6515 return;
6516 }
6517 uiccProfile.refresh();
6518 } finally {
6519 Binder.restoreCallingIdentity(identity);
6520 }
6521 }
6522
6523 /**
Pengquan Meng85728fb2018-03-12 16:31:21 -07006524 * Returns false if the mobile data is disabled by default, otherwise return true.
6525 */
6526 private boolean getDefaultDataEnabled() {
6527 return "true".equalsIgnoreCase(
6528 SystemProperties.get(DEFAULT_MOBILE_DATA_PROPERTY_NAME, "true"));
6529 }
6530
6531 /**
6532 * Returns true if the data roaming is enabled by default, i.e the system property
6533 * of {@link #DEFAULT_DATA_ROAMING_PROPERTY_NAME} is true or the config of
6534 * {@link CarrierConfigManager#KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL} is true.
6535 */
6536 private boolean getDefaultDataRoamingEnabled(int subId) {
6537 final CarrierConfigManager configMgr = (CarrierConfigManager)
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006538 mApp.getSystemService(Context.CARRIER_CONFIG_SERVICE);
Pengquan Meng85728fb2018-03-12 16:31:21 -07006539 boolean isDataRoamingEnabled = "true".equalsIgnoreCase(
6540 SystemProperties.get(DEFAULT_DATA_ROAMING_PROPERTY_NAME, "false"));
6541 isDataRoamingEnabled |= configMgr.getConfigForSubId(subId).getBoolean(
6542 CarrierConfigManager.KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL);
6543 return isDataRoamingEnabled;
6544 }
6545
6546 /**
6547 * Returns the default network type for the given {@code subId}, if the default network type is
6548 * not set, return {@link Phone#PREFERRED_NT_MODE}.
6549 */
6550 private int getDefaultNetworkType(int subId) {
6551 return Integer.parseInt(
6552 TelephonyManager.getTelephonyProperty(
6553 mSubscriptionController.getPhoneId(subId),
6554 DEFAULT_NETWORK_MODE_PROPERTY_NAME,
6555 String.valueOf(Phone.PREFERRED_NT_MODE)));
6556 }
fionaxua13278b2018-03-21 00:08:13 -07006557
6558 @Override
6559 public void setCarrierTestOverride(int subId, String mccmnc, String imsi, String iccid, String
chen xueaba88a2019-03-15 13:15:10 -07006560 gid1, String gid2, String plmn, String spn, String carrierPrivilegeRules, String apn) {
fionaxua13278b2018-03-21 00:08:13 -07006561 enforceModifyPermission();
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006562
6563 final long identity = Binder.clearCallingIdentity();
6564 try {
6565 final Phone phone = getPhone(subId);
6566 if (phone == null) {
6567 loge("setCarrierTestOverride fails with invalid subId: " + subId);
6568 return;
6569 }
chen xueaba88a2019-03-15 13:15:10 -07006570 phone.setCarrierTestOverride(mccmnc, imsi, iccid, gid1, gid2, plmn, spn,
6571 carrierPrivilegeRules, apn);
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006572 } finally {
6573 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006574 }
fionaxua13278b2018-03-21 00:08:13 -07006575 }
6576
6577 @Override
6578 public int getCarrierIdListVersion(int subId) {
Brad Ebinger35c841c2018-10-01 10:40:55 -07006579 enforceReadPrivilegedPermission("getCarrierIdListVersion");
Malcolm Chenaa4a8532018-02-28 15:00:40 -08006580
6581 final long identity = Binder.clearCallingIdentity();
6582 try {
6583 final Phone phone = getPhone(subId);
6584 if (phone == null) {
6585 loge("getCarrierIdListVersion fails with invalid subId: " + subId);
6586 return TelephonyManager.UNKNOWN_CARRIER_ID_LIST_VERSION;
6587 }
6588 return phone.getCarrierIdListVersion();
6589 } finally {
6590 Binder.restoreCallingIdentity(identity);
fionaxua13278b2018-03-21 00:08:13 -07006591 }
fionaxua13278b2018-03-21 00:08:13 -07006592 }
Malcolm Chen2c63d402018-08-14 16:00:53 -07006593
6594 @Override
6595 public int getNumberOfModemsWithSimultaneousDataConnections(int subId, String callingPackage) {
6596 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6597 mApp, subId, callingPackage, "getNumberOfModemsWithSimultaneousDataConnections")) {
6598 return -1;
6599 }
6600
6601 final long identity = Binder.clearCallingIdentity();
6602 try {
6603 return mPhoneConfigurationManager.getNumberOfModemsWithSimultaneousDataConnections();
6604 } finally {
6605 Binder.restoreCallingIdentity(identity);
6606 }
6607 }
Pengquan Menga1bb6272018-09-06 09:59:22 -07006608
6609 @Override
6610 public int getCdmaRoamingMode(int subId) {
6611 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6612 mApp, subId, "getCdmaRoamingMode");
6613
6614 final long identity = Binder.clearCallingIdentity();
6615 try {
6616 return (int) sendRequest(CMD_GET_CDMA_ROAMING_MODE, null /* argument */, subId);
6617 } finally {
6618 Binder.restoreCallingIdentity(identity);
6619 }
6620 }
6621
6622 @Override
6623 public boolean setCdmaRoamingMode(int subId, int mode) {
6624 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6625 mApp, subId, "setCdmaRoamingMode");
6626
6627 final long identity = Binder.clearCallingIdentity();
6628 try {
6629 return (boolean) sendRequest(CMD_SET_CDMA_ROAMING_MODE, mode, subId);
6630 } finally {
6631 Binder.restoreCallingIdentity(identity);
6632 }
6633 }
6634
6635 @Override
6636 public boolean setCdmaSubscriptionMode(int subId, int mode) {
6637 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6638 mApp, subId, "setCdmaSubscriptionMode");
6639
6640 final long identity = Binder.clearCallingIdentity();
6641 try {
6642 return (boolean) sendRequest(CMD_SET_CDMA_SUBSCRIPTION_MODE, mode, subId);
6643 } finally {
6644 Binder.restoreCallingIdentity(identity);
6645 }
6646 }
Makoto Onukida3bf792018-09-18 16:06:29 -07006647
6648 private void ensureUserRunning(int userId) {
6649 if (!mUserManager.isUserRunning(userId)) {
6650 throw new IllegalStateException("User " + userId + " does not exist or not running");
6651 }
6652 }
6653
6654 /**
6655 * Returns a list of SMS apps on a given user.
6656 *
6657 * Only the shell user (UID 2000 or 0) can call it.
6658 * Target user must be running.
6659 */
6660 @Override
6661 public String[] getSmsApps(int userId) {
6662 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getSmsApps");
6663 ensureUserRunning(userId);
6664
6665 final Collection<SmsApplicationData> apps =
6666 SmsApplication.getApplicationCollectionAsUser(mApp, userId);
6667
6668 String[] ret = new String[apps.size()];
6669 int i = 0;
6670 for (SmsApplicationData app : apps) {
6671 ret[i++] = app.mPackageName;
6672 }
6673 return ret;
6674 }
6675
6676 /**
6677 * Returns the default SMS app package name on a given user.
6678 *
6679 * Only the shell user (UID 2000 or 0) can call it.
6680 * Target user must be running.
6681 */
6682 @Override
6683 public String getDefaultSmsApp(int userId) {
6684 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "getDefaultSmsApp");
6685 ensureUserRunning(userId);
6686
6687 final ComponentName cn = SmsApplication.getDefaultSmsApplicationAsUser(mApp,
6688 /* updateIfNeeded= */ true, userId);
6689 return cn == null ? null : cn.getPackageName();
6690 }
6691
6692 /**
6693 * Set a package as the default SMS app on a given user.
6694 *
6695 * Only the shell user (UID 2000 or 0) can call it.
6696 * Target user must be running.
6697 */
6698 @Override
6699 public void setDefaultSmsApp(int userId, String packageName) {
6700 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(), "setDefaultSmsApp");
6701 ensureUserRunning(userId);
6702
6703 boolean found = false;
6704 for (String pkg : getSmsApps(userId)) {
6705 if (TextUtils.equals(packageName, pkg)) {
6706 found = true;
6707 break;
6708 }
6709 }
6710 if (!found) {
6711 throw new IllegalArgumentException("Package " + packageName + " is not an SMS app");
6712 }
6713
6714 SmsApplication.setDefaultApplicationAsUser(packageName, mApp, userId);
6715 }
sqianc5eccab2018-10-19 18:46:41 -07006716
6717 @Override
sqian8c685422019-02-22 15:55:18 -08006718 public Map<Integer, List<EmergencyNumber>> getEmergencyNumberList(
sqianc5eccab2018-10-19 18:46:41 -07006719 String callingPackage) {
sqian11b7a0e2018-12-05 18:48:28 -08006720 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
sqian8c685422019-02-22 15:55:18 -08006721 mApp, getDefaultSubscription(), callingPackage, "getEmergencyNumberList")) {
sqian11b7a0e2018-12-05 18:48:28 -08006722 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6723 }
6724 final long identity = Binder.clearCallingIdentity();
6725 try {
sqian854d44b2018-12-12 16:48:18 -08006726 Map<Integer, List<EmergencyNumber>> emergencyNumberListInternal = new HashMap<>();
6727 for (Phone phone: PhoneFactory.getPhones()) {
6728 if (phone.getEmergencyNumberTracker() != null
6729 && phone.getEmergencyNumberTracker().getEmergencyNumberList() != null) {
6730 emergencyNumberListInternal.put(
6731 phone.getSubId(),
6732 phone.getEmergencyNumberTracker().getEmergencyNumberList());
6733 }
sqian11b7a0e2018-12-05 18:48:28 -08006734 }
sqian854d44b2018-12-12 16:48:18 -08006735 return emergencyNumberListInternal;
sqian11b7a0e2018-12-05 18:48:28 -08006736 } finally {
6737 Binder.restoreCallingIdentity(identity);
6738 }
sqianc5eccab2018-10-19 18:46:41 -07006739 }
6740
6741 @Override
sqian8c685422019-02-22 15:55:18 -08006742 public boolean isEmergencyNumber(String number, boolean exactMatch) {
Nazanin Bakhshif782e562018-12-11 15:15:39 -08006743 final Phone defaultPhone = getDefaultPhone();
sqian11b7a0e2018-12-05 18:48:28 -08006744 if (!exactMatch) {
6745 TelephonyPermissions
6746 .enforeceCallingOrSelfReadPrivilegedPhoneStatePermissionOrCarrierPrivilege(
sqian8c685422019-02-22 15:55:18 -08006747 mApp, defaultPhone.getSubId(), "isEmergencyNumber(Potential)");
sqian11b7a0e2018-12-05 18:48:28 -08006748 }
6749 final long identity = Binder.clearCallingIdentity();
6750 try {
sqian854d44b2018-12-12 16:48:18 -08006751 for (Phone phone: PhoneFactory.getPhones()) {
6752 if (phone.getEmergencyNumberTracker() != null
6753 && phone.getEmergencyNumberTracker() != null) {
6754 if (phone.getEmergencyNumberTracker().isEmergencyNumber(
6755 number, exactMatch)) {
6756 return true;
sqian11b7a0e2018-12-05 18:48:28 -08006757 }
6758 }
sqian11b7a0e2018-12-05 18:48:28 -08006759 }
6760 return false;
6761 } finally {
6762 Binder.restoreCallingIdentity(identity);
6763 }
6764 }
6765
sqianf4ca7ed2019-01-15 18:32:07 -08006766 /**
6767 * Update emergency number list for test mode.
6768 */
6769 @Override
6770 public void updateEmergencyNumberListTestMode(int action, EmergencyNumber num) {
6771 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6772 "updateEmergencyNumberListTestMode");
6773
6774 final long identity = Binder.clearCallingIdentity();
6775 try {
6776 for (Phone phone: PhoneFactory.getPhones()) {
6777 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6778 if (tracker != null) {
6779 tracker.executeEmergencyNumberTestModeCommand(action, num);
6780 }
6781 }
6782 } finally {
6783 Binder.restoreCallingIdentity(identity);
6784 }
6785 }
6786
6787 /**
6788 * Get the full emergency number list for test mode.
6789 */
6790 @Override
6791 public List<String> getEmergencyNumberListTestMode() {
6792 TelephonyPermissions.enforceShellOnly(Binder.getCallingUid(),
6793 "getEmergencyNumberListTestMode");
6794
6795 final long identity = Binder.clearCallingIdentity();
6796 try {
6797 Set<String> emergencyNumbers = new HashSet<>();
6798 for (Phone phone: PhoneFactory.getPhones()) {
6799 EmergencyNumberTracker tracker = phone.getEmergencyNumberTracker();
6800 if (tracker != null) {
6801 for (EmergencyNumber num : tracker.getEmergencyNumberList()) {
6802 emergencyNumbers.add(num.getNumber());
6803 }
6804 }
6805 }
6806 return new ArrayList<>(emergencyNumbers);
6807 } finally {
6808 Binder.restoreCallingIdentity(identity);
6809 }
6810 }
6811
chen xud6b45bd2018-10-30 22:27:10 -07006812 @Override
6813 public List<String> getCertsFromCarrierPrivilegeAccessRules(int subId) {
6814 enforceReadPrivilegedPermission("getCertsFromCarrierPrivilegeAccessRules");
6815 Phone phone = getPhone(subId);
6816 if (phone == null) {
6817 return null;
6818 }
6819 final long identity = Binder.clearCallingIdentity();
6820 try {
6821 UiccProfile profile = UiccController.getInstance()
6822 .getUiccProfileForPhone(phone.getPhoneId());
6823 if (profile != null) {
6824 return profile.getCertsFromCarrierPrivilegeAccessRules();
6825 }
6826 } finally {
6827 Binder.restoreCallingIdentity(identity);
6828 }
6829 return null;
6830 }
Malcolm Chen8e4ed912019-01-15 20:22:16 -08006831
6832 /**
6833 * Enable or disable a modem stack.
6834 */
6835 @Override
6836 public boolean enableModemForSlot(int slotIndex, boolean enable) {
6837 enforceModifyPermission();
6838
6839 final long identity = Binder.clearCallingIdentity();
6840 try {
6841 Phone phone = PhoneFactory.getPhone(slotIndex);
6842 if (phone == null) {
6843 return false;
6844 } else {
6845 return (Boolean) sendRequest(CMD_REQUEST_ENABLE_MODEM, enable, phone, null);
6846 }
6847 } finally {
6848 Binder.restoreCallingIdentity(identity);
6849 }
6850 }
Michelecea4cf22018-12-21 15:00:11 -08006851
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006852 /**
6853 * Whether a modem stack is enabled or not.
6854 */
6855 @Override
6856 public boolean isModemEnabledForSlot(int slotIndex, String callingPackage) {
6857 Phone phone = PhoneFactory.getPhone(slotIndex);
6858 if (phone == null) return false;
6859
6860 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6861 mApp, phone.getSubId(), callingPackage, "isModemEnabledForSlot")) {
6862 throw new SecurityException("Requires READ_PHONE_STATE permission.");
6863 }
6864
6865 final long identity = Binder.clearCallingIdentity();
6866 try {
Nazanin Bakhshif71371d2019-04-29 17:29:44 -07006867 try {
6868 return mPhoneConfigurationManager.getPhoneStatusFromCache(phone.getPhoneId());
6869 } catch (NoSuchElementException ex) {
6870 return (Boolean) sendRequest(CMD_GET_MODEM_STATUS, null, phone, null);
6871 }
Malcolm Chen4bcd9822019-03-27 18:34:05 -07006872 } finally {
6873 Binder.restoreCallingIdentity(identity);
6874 }
6875 }
6876
Michelecea4cf22018-12-21 15:00:11 -08006877 @Override
Michele0ea7d782019-03-19 14:58:42 -07006878 public void setMultiSimCarrierRestriction(boolean isMultiSimCarrierRestricted) {
Michelecea4cf22018-12-21 15:00:11 -08006879 enforceModifyPermission();
6880
6881 final long identity = Binder.clearCallingIdentity();
6882 try {
6883 mTelephonySharedPreferences.edit()
Michele0ea7d782019-03-19 14:58:42 -07006884 .putBoolean(PREF_MULTI_SIM_RESTRICTED, isMultiSimCarrierRestricted)
Michelecea4cf22018-12-21 15:00:11 -08006885 .commit();
6886 } finally {
6887 Binder.restoreCallingIdentity(identity);
6888 }
6889 }
6890
6891 @Override
Michele0ea7d782019-03-19 14:58:42 -07006892 @TelephonyManager.IsMultiSimSupportedResult
6893 public int isMultiSimSupported(String callingPackage) {
Michele4245e952019-02-04 11:36:23 -08006894 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mApp,
Michele0ea7d782019-03-19 14:58:42 -07006895 getDefaultPhone().getSubId(), callingPackage, "isMultiSimSupported")) {
6896 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele4245e952019-02-04 11:36:23 -08006897 }
Michelecea4cf22018-12-21 15:00:11 -08006898
6899 final long identity = Binder.clearCallingIdentity();
6900 try {
Michele0ea7d782019-03-19 14:58:42 -07006901 return isMultiSimSupportedInternal();
Michelecea4cf22018-12-21 15:00:11 -08006902 } finally {
6903 Binder.restoreCallingIdentity(identity);
6904 }
6905 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006906
Michele0ea7d782019-03-19 14:58:42 -07006907 @TelephonyManager.IsMultiSimSupportedResult
6908 private int isMultiSimSupportedInternal() {
Michele30b57b22019-03-01 12:01:14 -08006909 // If the device has less than 2 SIM cards, indicate that multisim is restricted.
6910 int numPhysicalSlots = UiccController.getInstance().getUiccSlots().length;
6911 if (numPhysicalSlots < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006912 loge("isMultiSimSupportedInternal: requires at least 2 cards");
6913 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006914 }
6915 // Check if the hardware supports multisim functionality. If usage of multisim is not
6916 // supported by the modem, indicate that it is restricted.
6917 PhoneCapability staticCapability =
6918 mPhoneConfigurationManager.getStaticPhoneCapability();
6919 if (staticCapability == null) {
Michele0ea7d782019-03-19 14:58:42 -07006920 loge("isMultiSimSupportedInternal: no static configuration available");
6921 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006922 }
6923 if (staticCapability.logicalModemList.size() < 2) {
Michele0ea7d782019-03-19 14:58:42 -07006924 loge("isMultiSimSupportedInternal: maximum number of modem is < 2");
6925 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_HARDWARE;
Michele30b57b22019-03-01 12:01:14 -08006926 }
6927 // Check if support of multiple SIMs is restricted by carrier
6928 if (mTelephonySharedPreferences.getBoolean(PREF_MULTI_SIM_RESTRICTED, false)) {
Michele0ea7d782019-03-19 14:58:42 -07006929 return TelephonyManager.MULTISIM_NOT_SUPPORTED_BY_CARRIER;
Michele30b57b22019-03-01 12:01:14 -08006930 }
6931
Michele0ea7d782019-03-19 14:58:42 -07006932 return TelephonyManager.MULTISIM_ALLOWED;
Michele30b57b22019-03-01 12:01:14 -08006933 }
6934
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006935 /**
6936 * Switch configs to enable multi-sim or switch back to single-sim
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006937 * Note: Switch from multi-sim to single-sim is only possible with MODIFY_PHONE_STATE
6938 * permission, but the other way around is possible with either MODIFY_PHONE_STATE
6939 * or carrier privileges
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006940 * @param numOfSims number of active sims we want to switch to
6941 */
6942 @Override
6943 public void switchMultiSimConfig(int numOfSims) {
Nazanin Bakhshi17318782019-03-01 11:56:08 -08006944 if (numOfSims == 1) {
6945 enforceModifyPermission();
6946 } else {
6947 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(
6948 mApp, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "switchMultiSimConfig");
6949 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006950 final long identity = Binder.clearCallingIdentity();
Michele30b57b22019-03-01 12:01:14 -08006951
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006952 try {
Michele30b57b22019-03-01 12:01:14 -08006953 //only proceed if multi-sim is not restricted
Michele0ea7d782019-03-19 14:58:42 -07006954 if (isMultiSimSupportedInternal() != TelephonyManager.MULTISIM_ALLOWED) {
Michele30b57b22019-03-01 12:01:14 -08006955 loge("switchMultiSimConfig not possible. It is restricted or not supported.");
6956 return;
6957 }
Nazanin Bakhshi628473f2019-01-29 17:37:52 -08006958 mPhoneConfigurationManager.switchMultiSimConfig(numOfSims);
6959 } finally {
6960 Binder.restoreCallingIdentity(identity);
6961 }
6962 }
6963
6964 /**
chen xub4baa772019-04-03 10:23:41 -07006965 * Get whether making changes to modem configurations will trigger reboot.
6966 * Return value defaults to true.
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08006967 */
6968 @Override
chen xub4baa772019-04-03 10:23:41 -07006969 public boolean doesSwitchMultiSimConfigTriggerReboot(int subId, String callingPackage) {
6970 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
6971 mApp, subId, callingPackage, "doesSwitchMultiSimConfigTriggerReboot")) {
6972 return false;
6973 }
Nazanin Bakhshi5fe5ef22019-01-30 10:52:09 -08006974 final long identity = Binder.clearCallingIdentity();
6975 try {
6976 return mPhoneConfigurationManager.isRebootRequiredForModemConfigChange();
6977 } finally {
6978 Binder.restoreCallingIdentity(identity);
6979 }
6980 }
6981
Nathan Harold29f5f052019-02-15 13:41:57 -08006982 private void updateModemStateMetrics() {
6983 TelephonyMetrics metrics = TelephonyMetrics.getInstance();
6984 // TODO: check the state for each modem if the api is ready.
6985 metrics.updateEnabledModemBitmap((1 << TelephonyManager.from(mApp).getPhoneCount()) - 1);
6986 }
6987
Pengquan Meng3889a572019-01-23 11:16:29 -08006988 @Override
6989 public int[] getSlotsMapping() {
6990 enforceReadPrivilegedPermission("getSlotsMapping");
6991
6992 final long identity = Binder.clearCallingIdentity();
6993 try {
6994 int phoneCount = TelephonyManager.getDefault().getPhoneCount();
6995 // All logical slots should have a mapping to a physical slot.
6996 int[] logicalSlotsMapping = new int[phoneCount];
6997 UiccSlotInfo[] slotInfos = getUiccSlotsInfo();
6998 for (int i = 0; i < slotInfos.length; i++) {
6999 if (SubscriptionManager.isValidPhoneId(slotInfos[i].getLogicalSlotIdx())) {
7000 logicalSlotsMapping[slotInfos[i].getLogicalSlotIdx()] = i;
7001 }
7002 }
7003 return logicalSlotsMapping;
7004 } finally {
7005 Binder.restoreCallingIdentity(identity);
7006 }
7007 }
Nathan Harold48d6fd52019-02-06 19:01:40 -08007008
7009 /**
7010 * Get the IRadio HAL Version
7011 */
7012 @Override
7013 public int getRadioHalVersion() {
7014 Phone phone = getDefaultPhone();
7015 if (phone == null) return -1;
7016 HalVersion hv = phone.getHalVersion();
7017 if (hv.equals(HalVersion.UNKNOWN)) return -1;
7018 return hv.major * 100 + hv.minor;
7019 }
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007020
7021 /**
Malcolm Chene5ad5792019-04-18 13:51:02 -07007022 * Return whether data is enabled for certain APN type. This will tell if framework will accept
7023 * corresponding network requests on a subId.
7024 *
7025 * Data is enabled if:
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007026 * 1) user data is turned on, or
Malcolm Chene5ad5792019-04-18 13:51:02 -07007027 * 2) APN is un-metered for this subscription, or
7028 * 3) APN type is whitelisted. E.g. MMS is whitelisted if
7029 * {@link SubscriptionManager#setAlwaysAllowMmsData} is turned on.
7030 *
7031 * @return whether data is allowed for a apn type.
7032 *
7033 * @hide
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007034 */
7035 @Override
Malcolm Chene5ad5792019-04-18 13:51:02 -07007036 public boolean isDataEnabledForApn(int apnType, int subId, String callingPackage) {
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007037 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
Malcolm Chene5ad5792019-04-18 13:51:02 -07007038 mApp, subId, callingPackage, "isDataEnabledForApn")) {
7039 throw new SecurityException("Needs READ_PHONE_STATE for isDataEnabledForApn");
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007040 }
7041
7042 // Now that all security checks passes, perform the operation as ourselves.
7043 final long identity = Binder.clearCallingIdentity();
7044 try {
7045 Phone phone = getPhone(subId);
7046 if (phone == null) return false;
7047
7048 boolean isMetered = ApnSettingUtils.isMeteredApnType(ApnSetting.getApnTypeString(
Malcolm Chene5ad5792019-04-18 13:51:02 -07007049 apnType), phone);
7050 return !isMetered || phone.getDataEnabledSettings().isDataEnabled(apnType);
7051 } finally {
7052 Binder.restoreCallingIdentity(identity);
7053 }
7054 }
7055
7056 @Override
7057 public boolean isApnMetered(int apnType, int subId) {
7058 enforceReadPrivilegedPermission("isApnMetered");
7059
7060 // Now that all security checks passes, perform the operation as ourselves.
7061 final long identity = Binder.clearCallingIdentity();
7062 try {
7063 Phone phone = getPhone(subId);
7064 if (phone == null) return true; // By default return true.
7065
7066 return ApnSettingUtils.isMeteredApnType(ApnSetting.getApnTypeString(
7067 apnType), phone);
Malcolm Chendc8c10e2019-04-10 18:25:07 -07007068 } finally {
7069 Binder.restoreCallingIdentity(identity);
7070 }
7071 }
Brad Ebingera63db5f2019-04-23 16:31:13 -07007072
7073 @Override
7074 public void enqueueSmsPickResult(String callingPackage, IIntegerConsumer pendingSubIdResult) {
7075 SmsPermissions permissions = new SmsPermissions(getDefaultPhone(), mApp,
7076 (AppOpsManager) mApp.getSystemService(Context.APP_OPS_SERVICE));
7077 if (!permissions.checkCallingCanSendSms(callingPackage, "Sending message")) {
7078 throw new SecurityException("Requires SEND_SMS permission to perform this operation");
7079 }
7080 PickSmsSubscriptionActivity.addPendingResult(pendingSubIdResult);
7081 Intent intent = new Intent();
7082 intent.setClass(mApp, PickSmsSubscriptionActivity.class);
7083 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
7084 // Bring up choose default SMS subscription dialog right now
7085 intent.putExtra(PickSmsSubscriptionActivity.DIALOG_TYPE_KEY,
7086 PickSmsSubscriptionActivity.SMS_PICK_FOR_MESSAGE);
7087 mApp.startActivity(intent);
7088 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07007089}