blob: b5b4bb6e9fde79423b5d82f637dffbe1502b6ad6 [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
Ta-wei Yen87c49842016-05-13 21:19:52 -070019import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
20
Ta-wei Yen30a69c82016-12-27 14:52:32 -080021import android.Manifest.permission;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070022import android.app.ActivityManager;
23import android.app.AppOpsManager;
Ta-wei Yen30a69c82016-12-27 14:52:32 -080024import android.app.PendingIntent;
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -070025import android.content.ComponentName;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070026import android.content.Context;
27import android.content.Intent;
Derek Tan97ebb422014-09-05 16:55:38 -070028import android.content.SharedPreferences;
Amith Yamasani6e118872016-02-19 12:53:51 -080029import android.content.pm.PackageInfo;
Shishir Agrawal60f9c952014-06-23 12:00:43 -070030import android.content.pm.PackageManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070031import android.net.Uri;
32import android.os.AsyncResult;
33import android.os.Binder;
34import android.os.Bundle;
35import android.os.Handler;
36import android.os.Looper;
37import android.os.Message;
38import android.os.Process;
Adam Lesinski903a54c2016-04-11 14:49:52 -070039import android.os.ResultReceiver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070040import android.os.ServiceManager;
41import android.os.UserHandle;
Stuart Scott981d8582015-04-21 14:09:50 -070042import android.os.UserManager;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070043import android.os.WorkSource;
Derek Tan97ebb422014-09-05 16:55:38 -070044import android.preference.PreferenceManager;
Ihab Awadf2177b72013-11-25 13:33:23 -080045import android.provider.Settings;
Meng Wang1a7c35a2016-05-05 20:56:15 -070046import android.service.carrier.CarrierIdentifier;
Santos Cordon7a1885b2015-02-03 11:15:19 -080047import android.telecom.PhoneAccount;
Nancy Chen31f9ba12016-01-06 11:42:12 -080048import android.telecom.PhoneAccountHandle;
Andrew Lee9431b832015-03-09 18:46:45 -070049import android.telecom.TelecomManager;
Junda Liu12f7d802015-05-01 12:06:44 -070050import android.telephony.CarrierConfigManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070051import android.telephony.CellInfo;
Sooraj Sasindran9a909312016-07-18 11:57:25 -070052import android.telephony.ClientRequestStats;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -070053import android.telephony.IccOpenLogicalChannelResponse;
Ta-wei Yen87c49842016-05-13 21:19:52 -070054import android.telephony.ModemActivityInfo;
Jake Hambye994d462014-02-03 13:10:13 -080055import android.telephony.NeighboringCellInfo;
Wink Saville5d475dd2014-10-17 15:00:58 -070056import android.telephony.RadioAccessFamily;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070057import android.telephony.ServiceState;
Ta-wei Yen30a69c82016-12-27 14:52:32 -080058import android.telephony.SmsManager;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080059import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080060import android.telephony.SubscriptionManager;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070061import android.telephony.TelephonyHistogram;
Ta-wei Yenb6929602016-05-24 15:48:27 -070062import android.telephony.TelephonyManager;
63import android.telephony.VisualVoicemailSmsFilterSettings;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070064import android.text.TextUtils;
Jeff Sharkey85190e62014-12-05 09:40:12 -080065import android.util.ArraySet;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070066import android.util.Log;
Jake Hambye994d462014-02-03 13:10:13 -080067import android.util.Pair;
Jeff Sharkey85190e62014-12-05 09:40:12 -080068import android.util.Slog;
Ta-wei Yen30a69c82016-12-27 14:52:32 -080069
Andrew Lee312e8172014-10-23 17:01:36 -070070import com.android.ims.ImsManager;
Brad Ebinger51f743a2017-01-23 13:50:20 -080071import com.android.ims.internal.IImsServiceController;
72import com.android.ims.internal.IImsServiceFeatureListener;
Shishir Agrawal566b7612013-10-28 14:41:00 -070073import com.android.internal.telephony.CallManager;
Tyler Gunn10d19bf2017-04-26 11:30:31 -070074import com.android.internal.telephony.CallStateException;
Shishir Agrawal302c8692015-06-19 13:49:39 -070075import com.android.internal.telephony.CellNetworkScanResult;
Shishir Agrawal566b7612013-10-28 14:41:00 -070076import com.android.internal.telephony.CommandException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070077import com.android.internal.telephony.DefaultPhoneNotifier;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070078import com.android.internal.telephony.ITelephony;
Jake Hambye994d462014-02-03 13:10:13 -080079import com.android.internal.telephony.IccCard;
Narayan Kamath1c496c22015-04-16 14:40:19 +010080import com.android.internal.telephony.MccTable;
Shishir Agrawal302c8692015-06-19 13:49:39 -070081import com.android.internal.telephony.OperatorInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070082import com.android.internal.telephony.Phone;
Nathan Harolda667c152016-12-14 11:27:20 -080083import com.android.internal.telephony.PhoneConstantConversions;
Ta-wei Yen87c49842016-05-13 21:19:52 -070084import com.android.internal.telephony.PhoneConstants;
Wink Saville36469e72014-06-11 15:17:00 -070085import com.android.internal.telephony.PhoneFactory;
Wink Saville5d475dd2014-10-17 15:00:58 -070086import com.android.internal.telephony.ProxyController;
Sanket Padawe99ef1e32016-05-18 16:12:33 -070087import com.android.internal.telephony.RIL;
Svet Ganovb320e182015-04-16 12:30:10 -070088import com.android.internal.telephony.RILConstants;
Wink Savilleac1bdfd2014-11-20 23:04:44 -080089import com.android.internal.telephony.SubscriptionController;
Shishir Agrawal566b7612013-10-28 14:41:00 -070090import com.android.internal.telephony.uicc.IccIoResult;
91import com.android.internal.telephony.uicc.IccUtils;
Nathan Haroldb3014052017-01-25 15:57:32 -080092import com.android.internal.telephony.uicc.SIMRecords;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -070093import com.android.internal.telephony.uicc.UiccCard;
Nathan Haroldb3014052017-01-25 15:57:32 -080094import com.android.internal.telephony.uicc.UiccCardApplication;
Shishir Agrawal566b7612013-10-28 14:41:00 -070095import com.android.internal.telephony.uicc.UiccController;
fionaxu7ed723d2017-05-30 18:58:54 -070096import com.android.internal.telephony.util.VoicemailNotificationSettingsUtil;
Jake Hambye994d462014-02-03 13:10:13 -080097import com.android.internal.util.HexDump;
Ta-wei Yenc9df0432017-04-17 17:09:07 -070098import com.android.phone.vvm.PhoneAccountHandleConverter;
Ta-wei Yen527a9c02017-01-06 15:29:25 -080099import com.android.phone.vvm.RemoteVvmTaskManager;
Ta-wei Yenc9df0432017-04-17 17:09:07 -0700100import com.android.phone.vvm.VisualVoicemailSettingsUtil;
Ta-wei Yenc8905312017-03-28 11:14:45 -0700101import com.android.phone.vvm.VisualVoicemailSmsFilterConfig;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800102
Ta-wei Yenc236d6b2016-06-21 13:33:12 -0700103import java.io.FileDescriptor;
104import java.io.PrintWriter;
Ta-wei Yen30a69c82016-12-27 14:52:32 -0800105import java.nio.charset.StandardCharsets;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700106import java.util.ArrayList;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800107import java.util.Arrays;
Jake Hambye994d462014-02-03 13:10:13 -0800108import java.util.List;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100109import java.util.Locale;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800110import java.util.Map;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700111
112/**
113 * Implementation of the ITelephony interface.
114 */
Santos Cordon117fee72014-05-16 17:56:12 -0700115public class PhoneInterfaceManager extends ITelephony.Stub {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700116 private static final String LOG_TAG = "PhoneInterfaceManager";
117 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
118 private static final boolean DBG_LOC = false;
Jeff Sharkey85190e62014-12-05 09:40:12 -0800119 private static final boolean DBG_MERGE = false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700120
121 // Message codes used with mMainThreadHandler
122 private static final int CMD_HANDLE_PIN_MMI = 1;
123 private static final int CMD_HANDLE_NEIGHBORING_CELL = 2;
124 private static final int EVENT_NEIGHBORING_CELL_DONE = 3;
125 private static final int CMD_ANSWER_RINGING_CALL = 4;
126 private static final int CMD_END_CALL = 5; // not used yet
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700127 private static final int CMD_TRANSMIT_APDU_LOGICAL_CHANNEL = 7;
128 private static final int EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE = 8;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700129 private static final int CMD_OPEN_CHANNEL = 9;
130 private static final int EVENT_OPEN_CHANNEL_DONE = 10;
131 private static final int CMD_CLOSE_CHANNEL = 11;
132 private static final int EVENT_CLOSE_CHANNEL_DONE = 12;
Jake Hambye994d462014-02-03 13:10:13 -0800133 private static final int CMD_NV_READ_ITEM = 13;
134 private static final int EVENT_NV_READ_ITEM_DONE = 14;
135 private static final int CMD_NV_WRITE_ITEM = 15;
136 private static final int EVENT_NV_WRITE_ITEM_DONE = 16;
137 private static final int CMD_NV_WRITE_CDMA_PRL = 17;
138 private static final int EVENT_NV_WRITE_CDMA_PRL_DONE = 18;
139 private static final int CMD_NV_RESET_CONFIG = 19;
140 private static final int EVENT_NV_RESET_CONFIG_DONE = 20;
Jake Hamby7c27be32014-03-03 13:25:59 -0800141 private static final int CMD_GET_PREFERRED_NETWORK_TYPE = 21;
142 private static final int EVENT_GET_PREFERRED_NETWORK_TYPE_DONE = 22;
143 private static final int CMD_SET_PREFERRED_NETWORK_TYPE = 23;
144 private static final int EVENT_SET_PREFERRED_NETWORK_TYPE_DONE = 24;
Sailesh Nepal35b59452014-03-06 09:26:56 -0800145 private static final int CMD_SEND_ENVELOPE = 25;
146 private static final int EVENT_SEND_ENVELOPE_DONE = 26;
Derek Tan6b088ee2014-09-05 14:15:18 -0700147 private static final int CMD_INVOKE_OEM_RIL_REQUEST_RAW = 27;
148 private static final int EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE = 28;
149 private static final int CMD_TRANSMIT_APDU_BASIC_CHANNEL = 29;
150 private static final int EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE = 30;
151 private static final int CMD_EXCHANGE_SIM_IO = 31;
152 private static final int EVENT_EXCHANGE_SIM_IO_DONE = 32;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800153 private static final int CMD_SET_VOICEMAIL_NUMBER = 33;
154 private static final int EVENT_SET_VOICEMAIL_NUMBER_DONE = 34;
Stuart Scott54788802015-03-30 13:18:01 -0700155 private static final int CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC = 35;
156 private static final int EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE = 36;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700157 private static final int CMD_GET_MODEM_ACTIVITY_INFO = 37;
158 private static final int EVENT_GET_MODEM_ACTIVITY_INFO_DONE = 38;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700159 private static final int CMD_PERFORM_NETWORK_SCAN = 39;
160 private static final int EVENT_PERFORM_NETWORK_SCAN_DONE = 40;
161 private static final int CMD_SET_NETWORK_SELECTION_MODE_MANUAL = 41;
162 private static final int EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE = 42;
Meng Wang1a7c35a2016-05-05 20:56:15 -0700163 private static final int CMD_SET_ALLOWED_CARRIERS = 43;
164 private static final int EVENT_SET_ALLOWED_CARRIERS_DONE = 44;
165 private static final int CMD_GET_ALLOWED_CARRIERS = 45;
166 private static final int EVENT_GET_ALLOWED_CARRIERS_DONE = 46;
pkanwar32d516d2016-10-14 19:37:38 -0700167 private static final int CMD_HANDLE_USSD_REQUEST = 47;
Nathan Haroldb3014052017-01-25 15:57:32 -0800168 private static final int CMD_GET_FORBIDDEN_PLMNS = 48;
169 private static final int EVENT_GET_FORBIDDEN_PLMNS_DONE = 49;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700170
171 /** The singleton instance. */
172 private static PhoneInterfaceManager sInstance;
173
Wink Saville3ab207e2014-11-20 13:07:20 -0800174 private PhoneGlobals mApp;
175 private Phone mPhone;
176 private CallManager mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700177 private UserManager mUserManager;
Wink Saville3ab207e2014-11-20 13:07:20 -0800178 private AppOpsManager mAppOps;
179 private MainThreadHandler mMainThreadHandler;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800180 private SubscriptionController mSubscriptionController;
Wink Saville3ab207e2014-11-20 13:07:20 -0800181 private SharedPreferences mTelephonySharedPreferences;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700182
Derek Tan97ebb422014-09-05 16:55:38 -0700183 private static final String PREF_CARRIERS_ALPHATAG_PREFIX = "carrier_alphtag_";
184 private static final String PREF_CARRIERS_NUMBER_PREFIX = "carrier_number_";
Jeff Sharkey85190e62014-12-05 09:40:12 -0800185 private static final String PREF_CARRIERS_SUBSCRIBER_PREFIX = "carrier_subscriber_";
Derek Tan89e89d42014-07-08 17:00:10 -0700186
187 /**
Shishir Agrawal566b7612013-10-28 14:41:00 -0700188 * A request object to use for transmitting data to an ICC.
189 */
190 private static final class IccAPDUArgument {
191 public int channel, cla, command, p1, p2, p3;
192 public String data;
193
194 public IccAPDUArgument(int channel, int cla, int command,
195 int p1, int p2, int p3, String data) {
196 this.channel = channel;
197 this.cla = cla;
198 this.command = command;
199 this.p1 = p1;
200 this.p2 = p2;
201 this.p3 = p3;
202 this.data = data;
203 }
204 }
205
206 /**
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700207 * A request object to use for transmitting data to an ICC.
208 */
209 private static final class ManualNetworkSelectionArgument {
210 public OperatorInfo operatorInfo;
211 public boolean persistSelection;
212
213 public ManualNetworkSelectionArgument(OperatorInfo operatorInfo, boolean persistSelection) {
214 this.operatorInfo = operatorInfo;
215 this.persistSelection = persistSelection;
216 }
217 }
218
219 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700220 * A request object for use with {@link MainThreadHandler}. Requesters should wait() on the
221 * request after sending. The main thread will notify the request when it is complete.
222 */
223 private static final class MainThreadRequest {
224 /** The argument to use for the request */
225 public Object argument;
226 /** The result of the request that is run on the main thread */
227 public Object result;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800228 // The subscriber id that this request applies to. Defaults to
229 // SubscriptionManager.INVALID_SUBSCRIPTION_ID
230 public Integer subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700231
232 public MainThreadRequest(Object argument) {
233 this.argument = argument;
234 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800235
236 public MainThreadRequest(Object argument, Integer subId) {
237 this.argument = argument;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800238 if (subId != null) {
239 this.subId = subId;
240 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800241 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700242 }
243
Sailesh Nepalcc0375f2013-11-13 09:15:18 -0800244 private static final class IncomingThirdPartyCallArgs {
245 public final ComponentName component;
246 public final String callId;
247 public final String callerDisplayName;
248
249 public IncomingThirdPartyCallArgs(ComponentName component, String callId,
250 String callerDisplayName) {
251 this.component = component;
252 this.callId = callId;
253 this.callerDisplayName = callerDisplayName;
254 }
255 }
256
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700257 /**
258 * A handler that processes messages on the main thread in the phone process. Since many
259 * of the Phone calls are not thread safe this is needed to shuttle the requests from the
260 * inbound binder threads to the main thread in the phone process. The Binder thread
261 * may provide a {@link MainThreadRequest} object in the msg.obj field that they are waiting
262 * on, which will be notified when the operation completes and will contain the result of the
263 * request.
264 *
265 * <p>If a MainThreadRequest object is provided in the msg.obj field,
266 * note that request.result must be set to something non-null for the calling thread to
267 * unblock.
268 */
269 private final class MainThreadHandler extends Handler {
270 @Override
271 public void handleMessage(Message msg) {
272 MainThreadRequest request;
273 Message onCompleted;
274 AsyncResult ar;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800275 UiccCard uiccCard;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700276 IccAPDUArgument iccArgument;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700277
278 switch (msg.what) {
pkanwar32d516d2016-10-14 19:37:38 -0700279 case CMD_HANDLE_USSD_REQUEST: {
280 request = (MainThreadRequest) msg.obj;
281 final Phone phone = getPhoneFromRequest(request);
282 Pair<String, ResultReceiver> ussdObject = (Pair) request.argument;
283 String ussdRequest = ussdObject.first;
284 ResultReceiver wrappedCallback = ussdObject.second;
Tyler Gunn10d19bf2017-04-26 11:30:31 -0700285 try {
286 request.result = phone != null ?
287 phone.handleUssdRequest(ussdRequest, wrappedCallback)
288 : false;
289 } catch (CallStateException cse) {
290 request.result = false;
291 }
pkanwar32d516d2016-10-14 19:37:38 -0700292 // Wake up the requesting thread
293 synchronized (request) {
294 request.notifyAll();
295 }
296 break;
297 }
298
Yorke Lee716f67e2015-06-17 15:39:16 -0700299 case CMD_HANDLE_PIN_MMI: {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700300 request = (MainThreadRequest) msg.obj;
Yorke Lee716f67e2015-06-17 15:39:16 -0700301 final Phone phone = getPhoneFromRequest(request);
302 request.result = phone != null ?
303 getPhoneFromRequest(request).handlePinMmi((String) request.argument)
304 : false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700305 // Wake up the requesting thread
306 synchronized (request) {
307 request.notifyAll();
308 }
309 break;
Yorke Lee716f67e2015-06-17 15:39:16 -0700310 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700311
312 case CMD_HANDLE_NEIGHBORING_CELL:
313 request = (MainThreadRequest) msg.obj;
314 onCompleted = obtainMessage(EVENT_NEIGHBORING_CELL_DONE,
315 request);
Sooraj Sasindran9a909312016-07-18 11:57:25 -0700316 mPhone.getNeighboringCids(onCompleted, (WorkSource)request.argument);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700317 break;
318
319 case EVENT_NEIGHBORING_CELL_DONE:
320 ar = (AsyncResult) msg.obj;
321 request = (MainThreadRequest) ar.userObj;
322 if (ar.exception == null && ar.result != null) {
323 request.result = ar.result;
324 } else {
325 // create an empty list to notify the waiting thread
Jake Hambye994d462014-02-03 13:10:13 -0800326 request.result = new ArrayList<NeighboringCellInfo>(0);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700327 }
328 // Wake up the requesting thread
329 synchronized (request) {
330 request.notifyAll();
331 }
332 break;
333
334 case CMD_ANSWER_RINGING_CALL:
Wink Saville08874612014-08-31 19:19:58 -0700335 request = (MainThreadRequest) msg.obj;
Stuart Scott584921c2015-01-15 17:10:34 -0800336 int answer_subId = request.subId;
Wink Saville08874612014-08-31 19:19:58 -0700337 answerRingingCallInternal(answer_subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700338 break;
339
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700340 case CMD_END_CALL:
341 request = (MainThreadRequest) msg.obj;
Stuart Scott584921c2015-01-15 17:10:34 -0800342 int end_subId = request.subId;
Wink Saville08874612014-08-31 19:19:58 -0700343 final boolean hungUp;
Anthony Leeae4e36d2015-05-21 07:17:46 -0700344 Phone phone = getPhone(end_subId);
345 if (phone == null) {
346 if (DBG) log("CMD_END_CALL: no phone for id: " + end_subId);
347 break;
348 }
349 int phoneType = phone.getPhoneType();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700350 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
351 // CDMA: If the user presses the Power button we treat it as
352 // ending the complete call session
Wink Saville08874612014-08-31 19:19:58 -0700353 hungUp = PhoneUtils.hangupRingingAndActive(getPhone(end_subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700354 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
355 // GSM: End the call as per the Phone state
356 hungUp = PhoneUtils.hangup(mCM);
357 } else {
358 throw new IllegalStateException("Unexpected phone type: " + phoneType);
359 }
360 if (DBG) log("CMD_END_CALL: " + (hungUp ? "hung up!" : "no call to hang up"));
361 request.result = hungUp;
362 // Wake up the requesting thread
363 synchronized (request) {
364 request.notifyAll();
365 }
366 break;
367
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700368 case CMD_TRANSMIT_APDU_LOGICAL_CHANNEL:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700369 request = (MainThreadRequest) msg.obj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700370 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800371 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700372 if (uiccCard == null) {
373 loge("iccTransmitApduLogicalChannel: No UICC");
374 request.result = new IccIoResult(0x6F, 0, (byte[])null);
375 synchronized (request) {
376 request.notifyAll();
377 }
378 } else {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700379 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE,
380 request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700381 uiccCard.iccTransmitApduLogicalChannel(
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700382 iccArgument.channel, iccArgument.cla, iccArgument.command,
383 iccArgument.p1, iccArgument.p2, iccArgument.p3, iccArgument.data,
Shishir Agrawal566b7612013-10-28 14:41:00 -0700384 onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700385 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700386 break;
387
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700388 case EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700389 ar = (AsyncResult) msg.obj;
390 request = (MainThreadRequest) ar.userObj;
391 if (ar.exception == null && ar.result != null) {
392 request.result = ar.result;
393 } else {
394 request.result = new IccIoResult(0x6F, 0, (byte[])null);
395 if (ar.result == null) {
396 loge("iccTransmitApduLogicalChannel: Empty response");
Jake Hambye994d462014-02-03 13:10:13 -0800397 } else if (ar.exception instanceof CommandException) {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700398 loge("iccTransmitApduLogicalChannel: CommandException: " +
Jake Hambye994d462014-02-03 13:10:13 -0800399 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700400 } else {
401 loge("iccTransmitApduLogicalChannel: Unknown exception");
402 }
403 }
404 synchronized (request) {
405 request.notifyAll();
406 }
407 break;
408
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700409 case CMD_TRANSMIT_APDU_BASIC_CHANNEL:
410 request = (MainThreadRequest) msg.obj;
411 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800412 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700413 if (uiccCard == null) {
414 loge("iccTransmitApduBasicChannel: No UICC");
415 request.result = new IccIoResult(0x6F, 0, (byte[])null);
416 synchronized (request) {
417 request.notifyAll();
418 }
419 } else {
420 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE,
421 request);
422 uiccCard.iccTransmitApduBasicChannel(
423 iccArgument.cla, iccArgument.command, iccArgument.p1, iccArgument.p2,
424 iccArgument.p3, iccArgument.data, onCompleted);
425 }
426 break;
427
428 case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
429 ar = (AsyncResult) msg.obj;
430 request = (MainThreadRequest) ar.userObj;
431 if (ar.exception == null && ar.result != null) {
432 request.result = ar.result;
433 } else {
434 request.result = new IccIoResult(0x6F, 0, (byte[])null);
435 if (ar.result == null) {
436 loge("iccTransmitApduBasicChannel: Empty response");
437 } else if (ar.exception instanceof CommandException) {
438 loge("iccTransmitApduBasicChannel: CommandException: " +
439 ar.exception);
440 } else {
441 loge("iccTransmitApduBasicChannel: Unknown exception");
442 }
443 }
444 synchronized (request) {
445 request.notifyAll();
446 }
447 break;
448
449 case CMD_EXCHANGE_SIM_IO:
450 request = (MainThreadRequest) msg.obj;
451 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800452 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700453 if (uiccCard == null) {
454 loge("iccExchangeSimIO: No UICC");
455 request.result = new IccIoResult(0x6F, 0, (byte[])null);
456 synchronized (request) {
457 request.notifyAll();
458 }
459 } else {
460 onCompleted = obtainMessage(EVENT_EXCHANGE_SIM_IO_DONE,
461 request);
462 uiccCard.iccExchangeSimIO(iccArgument.cla, /* fileID */
463 iccArgument.command, iccArgument.p1, iccArgument.p2, iccArgument.p3,
464 iccArgument.data, onCompleted);
465 }
466 break;
467
468 case EVENT_EXCHANGE_SIM_IO_DONE:
469 ar = (AsyncResult) msg.obj;
470 request = (MainThreadRequest) ar.userObj;
471 if (ar.exception == null && ar.result != null) {
472 request.result = ar.result;
473 } else {
474 request.result = new IccIoResult(0x6f, 0, (byte[])null);
475 }
476 synchronized (request) {
477 request.notifyAll();
478 }
479 break;
480
Derek Tan4d5e5c12014-02-04 11:54:58 -0800481 case CMD_SEND_ENVELOPE:
482 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800483 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700484 if (uiccCard == null) {
485 loge("sendEnvelopeWithStatus: No UICC");
486 request.result = new IccIoResult(0x6F, 0, (byte[])null);
487 synchronized (request) {
488 request.notifyAll();
489 }
490 } else {
491 onCompleted = obtainMessage(EVENT_SEND_ENVELOPE_DONE, request);
492 uiccCard.sendEnvelopeWithStatus((String)request.argument, onCompleted);
493 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800494 break;
495
496 case EVENT_SEND_ENVELOPE_DONE:
497 ar = (AsyncResult) msg.obj;
498 request = (MainThreadRequest) ar.userObj;
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700499 if (ar.exception == null && ar.result != null) {
500 request.result = ar.result;
Derek Tan4d5e5c12014-02-04 11:54:58 -0800501 } else {
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700502 request.result = new IccIoResult(0x6F, 0, (byte[])null);
503 if (ar.result == null) {
504 loge("sendEnvelopeWithStatus: Empty response");
505 } else if (ar.exception instanceof CommandException) {
506 loge("sendEnvelopeWithStatus: CommandException: " +
507 ar.exception);
508 } else {
509 loge("sendEnvelopeWithStatus: exception:" + ar.exception);
510 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800511 }
512 synchronized (request) {
513 request.notifyAll();
514 }
515 break;
516
Shishir Agrawal566b7612013-10-28 14:41:00 -0700517 case CMD_OPEN_CHANNEL:
518 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800519 uiccCard = getUiccCardFromRequest(request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800520 Pair<String, Integer> openChannelArgs = (Pair<String, Integer>) request.argument;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700521 if (uiccCard == null) {
522 loge("iccOpenLogicalChannel: No UICC");
Shishir Agrawalfc0492a2016-02-17 11:15:33 -0800523 request.result = new IccOpenLogicalChannelResponse(-1,
524 IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE, null);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700525 synchronized (request) {
526 request.notifyAll();
527 }
528 } else {
529 onCompleted = obtainMessage(EVENT_OPEN_CHANNEL_DONE, request);
Ajay Nambid7454d32015-12-03 13:50:00 -0800530 uiccCard.iccOpenLogicalChannel(openChannelArgs.first,
531 openChannelArgs.second, onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700532 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700533 break;
534
535 case EVENT_OPEN_CHANNEL_DONE:
536 ar = (AsyncResult) msg.obj;
537 request = (MainThreadRequest) ar.userObj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700538 IccOpenLogicalChannelResponse openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700539 if (ar.exception == null && ar.result != null) {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700540 int[] result = (int[]) ar.result;
541 int channelId = result[0];
542 byte[] selectResponse = null;
543 if (result.length > 1) {
544 selectResponse = new byte[result.length - 1];
545 for (int i = 1; i < result.length; ++i) {
546 selectResponse[i - 1] = (byte) result[i];
547 }
548 }
549 openChannelResp = new IccOpenLogicalChannelResponse(channelId,
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700550 IccOpenLogicalChannelResponse.STATUS_NO_ERROR, selectResponse);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700551 } else {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700552 if (ar.result == null) {
553 loge("iccOpenLogicalChannel: Empty response");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700554 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700555 if (ar.exception != null) {
556 loge("iccOpenLogicalChannel: Exception: " + ar.exception);
557 }
558
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700559 int errorCode = IccOpenLogicalChannelResponse.STATUS_UNKNOWN_ERROR;
Junda Liua754ba12015-05-20 01:17:52 -0700560 if (ar.exception instanceof CommandException) {
561 CommandException.Error error =
562 ((CommandException) (ar.exception)).getCommandError();
563 if (error == CommandException.Error.MISSING_RESOURCE) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700564 errorCode = IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
Junda Liua754ba12015-05-20 01:17:52 -0700565 } else if (error == CommandException.Error.NO_SUCH_ELEMENT) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700566 errorCode = IccOpenLogicalChannelResponse.STATUS_NO_SUCH_ELEMENT;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700567 }
568 }
569 openChannelResp = new IccOpenLogicalChannelResponse(
570 IccOpenLogicalChannelResponse.INVALID_CHANNEL, errorCode, null);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700571 }
Shishir Agrawal82c8a462014-07-31 18:13:17 -0700572 request.result = openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700573 synchronized (request) {
574 request.notifyAll();
575 }
576 break;
577
578 case CMD_CLOSE_CHANNEL:
579 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800580 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700581 if (uiccCard == null) {
582 loge("iccCloseLogicalChannel: No UICC");
583 request.result = new IccIoResult(0x6F, 0, (byte[])null);
584 synchronized (request) {
585 request.notifyAll();
586 }
587 } else {
588 onCompleted = obtainMessage(EVENT_CLOSE_CHANNEL_DONE, request);
589 uiccCard.iccCloseLogicalChannel((Integer) request.argument, onCompleted);
590 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700591 break;
592
593 case EVENT_CLOSE_CHANNEL_DONE:
Jake Hambye994d462014-02-03 13:10:13 -0800594 handleNullReturnEvent(msg, "iccCloseLogicalChannel");
595 break;
596
597 case CMD_NV_READ_ITEM:
598 request = (MainThreadRequest) msg.obj;
599 onCompleted = obtainMessage(EVENT_NV_READ_ITEM_DONE, request);
600 mPhone.nvReadItem((Integer) request.argument, onCompleted);
601 break;
602
603 case EVENT_NV_READ_ITEM_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700604 ar = (AsyncResult) msg.obj;
605 request = (MainThreadRequest) ar.userObj;
Jake Hambye994d462014-02-03 13:10:13 -0800606 if (ar.exception == null && ar.result != null) {
607 request.result = ar.result; // String
Shishir Agrawal566b7612013-10-28 14:41:00 -0700608 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800609 request.result = "";
610 if (ar.result == null) {
611 loge("nvReadItem: Empty response");
612 } else if (ar.exception instanceof CommandException) {
613 loge("nvReadItem: CommandException: " +
614 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700615 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800616 loge("nvReadItem: Unknown exception");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700617 }
618 }
619 synchronized (request) {
620 request.notifyAll();
621 }
622 break;
623
Jake Hambye994d462014-02-03 13:10:13 -0800624 case CMD_NV_WRITE_ITEM:
625 request = (MainThreadRequest) msg.obj;
626 onCompleted = obtainMessage(EVENT_NV_WRITE_ITEM_DONE, request);
627 Pair<Integer, String> idValue = (Pair<Integer, String>) request.argument;
628 mPhone.nvWriteItem(idValue.first, idValue.second, onCompleted);
629 break;
630
631 case EVENT_NV_WRITE_ITEM_DONE:
632 handleNullReturnEvent(msg, "nvWriteItem");
633 break;
634
635 case CMD_NV_WRITE_CDMA_PRL:
636 request = (MainThreadRequest) msg.obj;
637 onCompleted = obtainMessage(EVENT_NV_WRITE_CDMA_PRL_DONE, request);
638 mPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
639 break;
640
641 case EVENT_NV_WRITE_CDMA_PRL_DONE:
642 handleNullReturnEvent(msg, "nvWriteCdmaPrl");
643 break;
644
645 case CMD_NV_RESET_CONFIG:
646 request = (MainThreadRequest) msg.obj;
647 onCompleted = obtainMessage(EVENT_NV_RESET_CONFIG_DONE, request);
648 mPhone.nvResetConfig((Integer) request.argument, onCompleted);
649 break;
650
651 case EVENT_NV_RESET_CONFIG_DONE:
652 handleNullReturnEvent(msg, "nvResetConfig");
653 break;
654
Jake Hamby7c27be32014-03-03 13:25:59 -0800655 case CMD_GET_PREFERRED_NETWORK_TYPE:
656 request = (MainThreadRequest) msg.obj;
657 onCompleted = obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE_DONE, request);
Stuart Scott54788802015-03-30 13:18:01 -0700658 getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800659 break;
660
661 case EVENT_GET_PREFERRED_NETWORK_TYPE_DONE:
662 ar = (AsyncResult) msg.obj;
663 request = (MainThreadRequest) ar.userObj;
664 if (ar.exception == null && ar.result != null) {
665 request.result = ar.result; // Integer
666 } else {
Sanket Padawecfc2d352016-01-05 19:52:14 -0800667 request.result = null;
Jake Hamby7c27be32014-03-03 13:25:59 -0800668 if (ar.result == null) {
669 loge("getPreferredNetworkType: Empty response");
670 } else if (ar.exception instanceof CommandException) {
671 loge("getPreferredNetworkType: CommandException: " +
672 ar.exception);
673 } else {
674 loge("getPreferredNetworkType: Unknown exception");
675 }
676 }
677 synchronized (request) {
678 request.notifyAll();
679 }
680 break;
681
682 case CMD_SET_PREFERRED_NETWORK_TYPE:
683 request = (MainThreadRequest) msg.obj;
684 onCompleted = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE_DONE, request);
685 int networkType = (Integer) request.argument;
Stuart Scott54788802015-03-30 13:18:01 -0700686 getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800687 break;
688
689 case EVENT_SET_PREFERRED_NETWORK_TYPE_DONE:
690 handleNullReturnEvent(msg, "setPreferredNetworkType");
691 break;
692
Steven Liu4bf01bc2014-07-17 11:05:29 -0500693 case CMD_INVOKE_OEM_RIL_REQUEST_RAW:
694 request = (MainThreadRequest)msg.obj;
695 onCompleted = obtainMessage(EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE, request);
696 mPhone.invokeOemRilRequestRaw((byte[])request.argument, onCompleted);
697 break;
698
699 case EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE:
700 ar = (AsyncResult)msg.obj;
701 request = (MainThreadRequest)ar.userObj;
702 request.result = ar;
703 synchronized (request) {
704 request.notifyAll();
705 }
706 break;
707
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800708 case CMD_SET_VOICEMAIL_NUMBER:
709 request = (MainThreadRequest) msg.obj;
710 onCompleted = obtainMessage(EVENT_SET_VOICEMAIL_NUMBER_DONE, request);
711 Pair<String, String> tagNum = (Pair<String, String>) request.argument;
Stuart Scott584921c2015-01-15 17:10:34 -0800712 getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
713 onCompleted);
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800714 break;
715
716 case EVENT_SET_VOICEMAIL_NUMBER_DONE:
717 handleNullReturnEvent(msg, "setVoicemailNumber");
718 break;
719
Stuart Scott54788802015-03-30 13:18:01 -0700720 case CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC:
721 request = (MainThreadRequest) msg.obj;
722 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE,
723 request);
724 getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
725 break;
726
727 case EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE:
728 handleNullReturnEvent(msg, "setNetworkSelectionModeAutomatic");
729 break;
730
Shishir Agrawal302c8692015-06-19 13:49:39 -0700731 case CMD_PERFORM_NETWORK_SCAN:
732 request = (MainThreadRequest) msg.obj;
733 onCompleted = obtainMessage(EVENT_PERFORM_NETWORK_SCAN_DONE, request);
734 getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
735 break;
736
737 case EVENT_PERFORM_NETWORK_SCAN_DONE:
738 ar = (AsyncResult) msg.obj;
739 request = (MainThreadRequest) ar.userObj;
740 CellNetworkScanResult cellScanResult;
741 if (ar.exception == null && ar.result != null) {
742 cellScanResult = new CellNetworkScanResult(
743 CellNetworkScanResult.STATUS_SUCCESS,
744 (List<OperatorInfo>) ar.result);
745 } else {
746 if (ar.result == null) {
747 loge("getCellNetworkScanResults: Empty response");
748 }
749 if (ar.exception != null) {
750 loge("getCellNetworkScanResults: Exception: " + ar.exception);
751 }
752 int errorCode = CellNetworkScanResult.STATUS_UNKNOWN_ERROR;
753 if (ar.exception instanceof CommandException) {
754 CommandException.Error error =
755 ((CommandException) (ar.exception)).getCommandError();
756 if (error == CommandException.Error.RADIO_NOT_AVAILABLE) {
757 errorCode = CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE;
758 } else if (error == CommandException.Error.GENERIC_FAILURE) {
759 errorCode = CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE;
760 }
761 }
762 cellScanResult = new CellNetworkScanResult(errorCode, null);
763 }
764 request.result = cellScanResult;
765 synchronized (request) {
766 request.notifyAll();
767 }
768 break;
769
770 case CMD_SET_NETWORK_SELECTION_MODE_MANUAL:
771 request = (MainThreadRequest) msg.obj;
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700772 ManualNetworkSelectionArgument selArg =
773 (ManualNetworkSelectionArgument) request.argument;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700774 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE,
775 request);
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700776 getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
777 selArg.persistSelection, onCompleted);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700778 break;
779
780 case EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE:
781 handleNullReturnEvent(msg, "setNetworkSelectionModeManual");
782 break;
783
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700784 case CMD_GET_MODEM_ACTIVITY_INFO:
785 request = (MainThreadRequest) msg.obj;
786 onCompleted = obtainMessage(EVENT_GET_MODEM_ACTIVITY_INFO_DONE, request);
Prerepa Viswanadham61a60ad2015-06-08 18:07:51 -0700787 mPhone.getModemActivityInfo(onCompleted);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700788 break;
789
790 case EVENT_GET_MODEM_ACTIVITY_INFO_DONE:
791 ar = (AsyncResult) msg.obj;
792 request = (MainThreadRequest) ar.userObj;
793 if (ar.exception == null && ar.result != null) {
794 request.result = ar.result;
795 } else {
796 if (ar.result == null) {
797 loge("queryModemActivityInfo: Empty response");
798 } else if (ar.exception instanceof CommandException) {
799 loge("queryModemActivityInfo: CommandException: " +
800 ar.exception);
801 } else {
802 loge("queryModemActivityInfo: Unknown exception");
803 }
804 }
Amit Mahajand4766222016-01-28 15:28:28 -0800805 // Result cannot be null. Return ModemActivityInfo with all fields set to 0.
806 if (request.result == null) {
807 request.result = new ModemActivityInfo(0, 0, 0, null, 0, 0);
808 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700809 synchronized (request) {
810 request.notifyAll();
811 }
812 break;
813
Meng Wang1a7c35a2016-05-05 20:56:15 -0700814 case CMD_SET_ALLOWED_CARRIERS:
815 request = (MainThreadRequest) msg.obj;
816 onCompleted = obtainMessage(EVENT_SET_ALLOWED_CARRIERS_DONE, request);
817 mPhone.setAllowedCarriers(
818 (List<CarrierIdentifier>) request.argument,
819 onCompleted);
820 break;
821
822 case EVENT_SET_ALLOWED_CARRIERS_DONE:
823 ar = (AsyncResult) msg.obj;
824 request = (MainThreadRequest) ar.userObj;
825 if (ar.exception == null && ar.result != null) {
826 request.result = ar.result;
827 } else {
828 if (ar.result == null) {
829 loge("setAllowedCarriers: Empty response");
830 } else if (ar.exception instanceof CommandException) {
831 loge("setAllowedCarriers: CommandException: " +
832 ar.exception);
833 } else {
834 loge("setAllowedCarriers: Unknown exception");
835 }
836 }
837 // Result cannot be null. Return -1 on error.
838 if (request.result == null) {
839 request.result = new int[]{-1};
840 }
841 synchronized (request) {
842 request.notifyAll();
843 }
844 break;
845
846 case CMD_GET_ALLOWED_CARRIERS:
847 request = (MainThreadRequest) msg.obj;
848 onCompleted = obtainMessage(EVENT_GET_ALLOWED_CARRIERS_DONE, request);
849 mPhone.getAllowedCarriers(onCompleted);
850 break;
851
852 case EVENT_GET_ALLOWED_CARRIERS_DONE:
853 ar = (AsyncResult) msg.obj;
854 request = (MainThreadRequest) ar.userObj;
855 if (ar.exception == null && ar.result != null) {
856 request.result = ar.result;
857 } else {
858 if (ar.result == null) {
859 loge("getAllowedCarriers: Empty response");
860 } else if (ar.exception instanceof CommandException) {
861 loge("getAllowedCarriers: CommandException: " +
862 ar.exception);
863 } else {
864 loge("getAllowedCarriers: Unknown exception");
865 }
866 }
867 // Result cannot be null. Return empty list of CarrierIdentifier.
868 if (request.result == null) {
869 request.result = new ArrayList<CarrierIdentifier>(0);
870 }
871 synchronized (request) {
872 request.notifyAll();
873 }
874 break;
875
Nathan Haroldb3014052017-01-25 15:57:32 -0800876 case EVENT_GET_FORBIDDEN_PLMNS_DONE:
877 ar = (AsyncResult) msg.obj;
878 request = (MainThreadRequest) ar.userObj;
879 if (ar.exception == null && ar.result != null) {
880 request.result = ar.result;
881 } else {
882 request.result = new IllegalArgumentException(
883 "Failed to retrieve Forbidden Plmns");
884 if (ar.result == null) {
885 loge("getForbiddenPlmns: Empty response");
886 } else {
887 loge("getForbiddenPlmns: Unknown exception");
888 }
889 }
890 synchronized (request) {
891 request.notifyAll();
892 }
893 break;
894
895 case CMD_GET_FORBIDDEN_PLMNS:
896 request = (MainThreadRequest) msg.obj;
897 uiccCard = getUiccCardFromRequest(request);
898 if (uiccCard == null) {
899 loge("getForbiddenPlmns() UiccCard is null");
900 request.result = new IllegalArgumentException(
901 "getForbiddenPlmns() UiccCard is null");
902 synchronized (request) {
903 request.notifyAll();
904 }
905 break;
906 }
907 Integer appType = (Integer) request.argument;
908 UiccCardApplication uiccApp = uiccCard.getApplicationByType(appType);
909 if (uiccApp == null) {
910 loge("getForbiddenPlmns() no app with specified type -- "
911 + appType);
912 request.result = new IllegalArgumentException("Failed to get UICC App");
913 synchronized (request) {
914 request.notifyAll();
915 }
916 break;
917 } else {
918 if (DBG) logv("getForbiddenPlmns() found app " + uiccApp.getAid()
919 + " specified type -- " + appType);
920 }
921 onCompleted = obtainMessage(EVENT_GET_FORBIDDEN_PLMNS_DONE, request);
922 ((SIMRecords) uiccApp.getIccRecords()).getForbiddenPlmns(
923 onCompleted);
924 break;
925
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700926 default:
927 Log.w(LOG_TAG, "MainThreadHandler: unexpected message code: " + msg.what);
928 break;
929 }
930 }
Jake Hambye994d462014-02-03 13:10:13 -0800931
932 private void handleNullReturnEvent(Message msg, String command) {
933 AsyncResult ar = (AsyncResult) msg.obj;
934 MainThreadRequest request = (MainThreadRequest) ar.userObj;
935 if (ar.exception == null) {
936 request.result = true;
937 } else {
938 request.result = false;
939 if (ar.exception instanceof CommandException) {
940 loge(command + ": CommandException: " + ar.exception);
941 } else {
942 loge(command + ": Unknown exception");
943 }
944 }
945 synchronized (request) {
946 request.notifyAll();
947 }
948 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700949 }
950
951 /**
952 * Posts the specified command to be executed on the main thread,
953 * waits for the request to complete, and returns the result.
954 * @see #sendRequestAsync
955 */
956 private Object sendRequest(int command, Object argument) {
Sanket Padawe56e75a32016-02-08 12:18:19 -0800957 return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID);
Wink Saville36469e72014-06-11 15:17:00 -0700958 }
959
960 /**
961 * Posts the specified command to be executed on the main thread,
962 * waits for the request to complete, and returns the result.
963 * @see #sendRequestAsync
964 */
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800965 private Object sendRequest(int command, Object argument, Integer subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700966 if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
967 throw new RuntimeException("This method will deadlock if called from the main thread.");
968 }
969
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800970 MainThreadRequest request = new MainThreadRequest(argument, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700971 Message msg = mMainThreadHandler.obtainMessage(command, request);
972 msg.sendToTarget();
973
974 // Wait for the request to complete
975 synchronized (request) {
976 while (request.result == null) {
977 try {
978 request.wait();
979 } catch (InterruptedException e) {
980 // Do nothing, go back and wait until the request is complete
981 }
982 }
983 }
984 return request.result;
985 }
986
987 /**
988 * Asynchronous ("fire and forget") version of sendRequest():
989 * Posts the specified command to be executed on the main thread, and
990 * returns immediately.
991 * @see #sendRequest
992 */
993 private void sendRequestAsync(int command) {
994 mMainThreadHandler.sendEmptyMessage(command);
995 }
996
997 /**
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -0700998 * Same as {@link #sendRequestAsync(int)} except it takes an argument.
999 * @see {@link #sendRequest(int,Object)}
1000 */
1001 private void sendRequestAsync(int command, Object argument) {
1002 MainThreadRequest request = new MainThreadRequest(argument);
1003 Message msg = mMainThreadHandler.obtainMessage(command, request);
1004 msg.sendToTarget();
1005 }
1006
1007 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001008 * Initialize the singleton PhoneInterfaceManager instance.
1009 * This is only done once, at startup, from PhoneApp.onCreate().
1010 */
Sailesh Nepal194161e2014-07-03 08:57:44 -07001011 /* package */ static PhoneInterfaceManager init(PhoneGlobals app, Phone phone) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001012 synchronized (PhoneInterfaceManager.class) {
1013 if (sInstance == null) {
Sailesh Nepal194161e2014-07-03 08:57:44 -07001014 sInstance = new PhoneInterfaceManager(app, phone);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001015 } else {
1016 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
1017 }
1018 return sInstance;
1019 }
1020 }
1021
1022 /** Private constructor; @see init() */
Sailesh Nepal194161e2014-07-03 08:57:44 -07001023 private PhoneInterfaceManager(PhoneGlobals app, Phone phone) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001024 mApp = app;
1025 mPhone = phone;
1026 mCM = PhoneGlobals.getInstance().mCM;
Stuart Scott981d8582015-04-21 14:09:50 -07001027 mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001028 mAppOps = (AppOpsManager)app.getSystemService(Context.APP_OPS_SERVICE);
1029 mMainThreadHandler = new MainThreadHandler();
Andrew Leedf14ead2014-10-17 14:22:52 -07001030 mTelephonySharedPreferences =
Derek Tan97ebb422014-09-05 16:55:38 -07001031 PreferenceManager.getDefaultSharedPreferences(mPhone.getContext());
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001032 mSubscriptionController = SubscriptionController.getInstance();
Wink Saville3ab207e2014-11-20 13:07:20 -08001033
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001034 publish();
1035 }
1036
1037 private void publish() {
1038 if (DBG) log("publish: " + this);
1039
1040 ServiceManager.addService("phone", this);
1041 }
1042
Stuart Scott584921c2015-01-15 17:10:34 -08001043 private Phone getPhoneFromRequest(MainThreadRequest request) {
Sanket Padawe56e75a32016-02-08 12:18:19 -08001044 return (request.subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID)
1045 ? mPhone : getPhone(request.subId);
Stuart Scott584921c2015-01-15 17:10:34 -08001046 }
1047
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001048 private UiccCard getUiccCardFromRequest(MainThreadRequest request) {
1049 Phone phone = getPhoneFromRequest(request);
1050 return phone == null ? null :
1051 UiccController.getInstance().getUiccCard(phone.getPhoneId());
1052 }
1053
Wink Saville36469e72014-06-11 15:17:00 -07001054 // returns phone associated with the subId.
Wink Savilleb564aae2014-10-23 10:18:09 -07001055 private Phone getPhone(int subId) {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001056 return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
Wink Saville36469e72014-06-11 15:17:00 -07001057 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001058 //
1059 // Implementation of the ITelephony interface.
1060 //
1061
1062 public void dial(String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001063 dialForSubscriber(getPreferredVoiceSubscription(), number);
Wink Saville36469e72014-06-11 15:17:00 -07001064 }
1065
Wink Savilleb564aae2014-10-23 10:18:09 -07001066 public void dialForSubscriber(int subId, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001067 if (DBG) log("dial: " + number);
1068 // No permission check needed here: This is just a wrapper around the
1069 // ACTION_DIAL intent, which is available to any app since it puts up
1070 // the UI before it does anything.
1071
1072 String url = createTelUrl(number);
1073 if (url == null) {
1074 return;
1075 }
1076
1077 // PENDING: should we just silently fail if phone is offhook or ringing?
Wink Saville36469e72014-06-11 15:17:00 -07001078 PhoneConstants.State state = mCM.getState(subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001079 if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
1080 Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
1081 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1082 mApp.startActivity(intent);
1083 }
1084 }
1085
1086 public void call(String callingPackage, String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001087 callForSubscriber(getPreferredVoiceSubscription(), callingPackage, number);
Wink Saville36469e72014-06-11 15:17:00 -07001088 }
1089
Wink Savilleb564aae2014-10-23 10:18:09 -07001090 public void callForSubscriber(int subId, String callingPackage, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001091 if (DBG) log("call: " + number);
1092
1093 // This is just a wrapper around the ACTION_CALL intent, but we still
1094 // need to do a permission check since we're calling startActivity()
1095 // from the context of the phone app.
1096 enforceCallPermission();
1097
1098 if (mAppOps.noteOp(AppOpsManager.OP_CALL_PHONE, Binder.getCallingUid(), callingPackage)
1099 != AppOpsManager.MODE_ALLOWED) {
1100 return;
1101 }
1102
1103 String url = createTelUrl(number);
1104 if (url == null) {
1105 return;
1106 }
1107
Wink Saville08874612014-08-31 19:19:58 -07001108 boolean isValid = false;
Narayan Kamath1c496c22015-04-16 14:40:19 +01001109 final List<SubscriptionInfo> slist = getActiveSubscriptionInfoList();
Wink Saville3ab207e2014-11-20 13:07:20 -08001110 if (slist != null) {
1111 for (SubscriptionInfo subInfoRecord : slist) {
1112 if (subInfoRecord.getSubscriptionId() == subId) {
1113 isValid = true;
1114 break;
1115 }
Wink Saville08874612014-08-31 19:19:58 -07001116 }
1117 }
1118 if (isValid == false) {
1119 return;
1120 }
1121
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001122 Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
Wink Saville36469e72014-06-11 15:17:00 -07001123 intent.putExtra(SUBSCRIPTION_KEY, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001124 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1125 mApp.startActivity(intent);
1126 }
1127
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001128 /**
1129 * End a call based on call state
1130 * @return true is a call was ended
1131 */
1132 public boolean endCall() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001133 return endCallForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001134 }
1135
1136 /**
1137 * End a call based on the call state of the subId
1138 * @return true is a call was ended
1139 */
Wink Savilleb564aae2014-10-23 10:18:09 -07001140 public boolean endCallForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001141 enforceCallPermission();
Stuart Scott584921c2015-01-15 17:10:34 -08001142 return (Boolean) sendRequest(CMD_END_CALL, null, new Integer(subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001143 }
1144
1145 public void answerRingingCall() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001146 answerRingingCallForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001147 }
1148
Wink Savilleb564aae2014-10-23 10:18:09 -07001149 public void answerRingingCallForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001150 if (DBG) log("answerRingingCall...");
1151 // TODO: there should eventually be a separate "ANSWER_PHONE" permission,
1152 // but that can probably wait till the big TelephonyManager API overhaul.
1153 // For now, protect this call with the MODIFY_PHONE_STATE permission.
1154 enforceModifyPermission();
Stuart Scott584921c2015-01-15 17:10:34 -08001155 sendRequest(CMD_ANSWER_RINGING_CALL, null, new Integer(subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001156 }
1157
1158 /**
1159 * Make the actual telephony calls to implement answerRingingCall().
1160 * This should only be called from the main thread of the Phone app.
1161 * @see #answerRingingCall
1162 *
1163 * TODO: it would be nice to return true if we answered the call, or
1164 * false if there wasn't actually a ringing incoming call, or some
1165 * other error occurred. (In other words, pass back the return value
1166 * from PhoneUtils.answerCall() or PhoneUtils.answerAndEndActive().)
1167 * But that would require calling this method via sendRequest() rather
1168 * than sendRequestAsync(), and right now we don't actually *need* that
1169 * return value, so let's just return void for now.
1170 */
Wink Savilleb564aae2014-10-23 10:18:09 -07001171 private void answerRingingCallInternal(int subId) {
Wink Saville08874612014-08-31 19:19:58 -07001172 final boolean hasRingingCall = !getPhone(subId).getRingingCall().isIdle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001173 if (hasRingingCall) {
Wink Saville08874612014-08-31 19:19:58 -07001174 final boolean hasActiveCall = !getPhone(subId).getForegroundCall().isIdle();
1175 final boolean hasHoldingCall = !getPhone(subId).getBackgroundCall().isIdle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001176 if (hasActiveCall && hasHoldingCall) {
1177 // Both lines are in use!
1178 // TODO: provide a flag to let the caller specify what
1179 // policy to use if both lines are in use. (The current
1180 // behavior is hardwired to "answer incoming, end ongoing",
1181 // which is how the CALL button is specced to behave.)
1182 PhoneUtils.answerAndEndActive(mCM, mCM.getFirstActiveRingingCall());
1183 return;
1184 } else {
1185 // answerCall() will automatically hold the current active
1186 // call, if there is one.
1187 PhoneUtils.answerCall(mCM.getFirstActiveRingingCall());
1188 return;
1189 }
1190 } else {
1191 // No call was ringing.
1192 return;
1193 }
1194 }
1195
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001196 /**
Santos Cordon5422a8d2014-09-12 04:20:56 -07001197 * This method is no longer used and can be removed once TelephonyManager stops referring to it.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001198 */
Santos Cordon5422a8d2014-09-12 04:20:56 -07001199 public void silenceRinger() {
1200 Log.e(LOG_TAG, "silenseRinger not supported");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001201 }
1202
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001203 @Override
1204 public boolean isOffhook(String callingPackage) {
1205 return isOffhookForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001206 }
1207
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001208 @Override
1209 public boolean isOffhookForSubscriber(int subId, String callingPackage) {
1210 if (!canReadPhoneState(callingPackage, "isOffhookForSubscriber")) {
1211 return false;
1212 }
1213
Sanket Padawe356d7632015-06-22 14:03:32 -07001214 final Phone phone = getPhone(subId);
1215 if (phone != null) {
1216 return (phone.getState() == PhoneConstants.State.OFFHOOK);
1217 } else {
1218 return false;
1219 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001220 }
1221
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001222 @Override
1223 public boolean isRinging(String callingPackage) {
1224 return (isRingingForSubscriber(getDefaultSubscription(), callingPackage));
Wink Saville36469e72014-06-11 15:17:00 -07001225 }
1226
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001227 @Override
1228 public boolean isRingingForSubscriber(int subId, String callingPackage) {
1229 if (!canReadPhoneState(callingPackage, "isRingingForSubscriber")) {
1230 return false;
1231 }
1232
Sanket Padawe356d7632015-06-22 14:03:32 -07001233 final Phone phone = getPhone(subId);
1234 if (phone != null) {
1235 return (phone.getState() == PhoneConstants.State.RINGING);
1236 } else {
1237 return false;
1238 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001239 }
1240
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001241 @Override
1242 public boolean isIdle(String callingPackage) {
1243 return isIdleForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001244 }
1245
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001246 @Override
1247 public boolean isIdleForSubscriber(int subId, String callingPackage) {
1248 if (!canReadPhoneState(callingPackage, "isIdleForSubscriber")) {
1249 return false;
1250 }
1251
Sanket Padawe356d7632015-06-22 14:03:32 -07001252 final Phone phone = getPhone(subId);
1253 if (phone != null) {
1254 return (phone.getState() == PhoneConstants.State.IDLE);
1255 } else {
1256 return false;
1257 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001258 }
1259
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001260 public boolean supplyPin(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001261 return supplyPinForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001262 }
1263
Wink Savilleb564aae2014-10-23 10:18:09 -07001264 public boolean supplyPinForSubscriber(int subId, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001265 int [] resultArray = supplyPinReportResultForSubscriber(subId, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001266 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1267 }
1268
1269 public boolean supplyPuk(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001270 return supplyPukForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001271 }
1272
Wink Savilleb564aae2014-10-23 10:18:09 -07001273 public boolean supplyPukForSubscriber(int subId, String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001274 int [] resultArray = supplyPukReportResultForSubscriber(subId, puk, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001275 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1276 }
1277
1278 /** {@hide} */
1279 public int[] supplyPinReportResult(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001280 return supplyPinReportResultForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001281 }
1282
Wink Savilleb564aae2014-10-23 10:18:09 -07001283 public int[] supplyPinReportResultForSubscriber(int subId, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001284 enforceModifyPermission();
Wink Saville36469e72014-06-11 15:17:00 -07001285 final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001286 checkSimPin.start();
1287 return checkSimPin.unlockSim(null, pin);
1288 }
1289
Wink Saville9de0f752013-10-22 19:04:03 -07001290 /** {@hide} */
1291 public int[] supplyPukReportResult(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001292 return supplyPukReportResultForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001293 }
1294
Wink Savilleb564aae2014-10-23 10:18:09 -07001295 public int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001296 enforceModifyPermission();
Wink Saville36469e72014-06-11 15:17:00 -07001297 final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001298 checkSimPuk.start();
1299 return checkSimPuk.unlockSim(puk, pin);
1300 }
1301
1302 /**
Wink Saville9de0f752013-10-22 19:04:03 -07001303 * Helper thread to turn async call to SimCard#supplyPin into
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001304 * a synchronous one.
1305 */
1306 private static class UnlockSim extends Thread {
1307
1308 private final IccCard mSimCard;
1309
1310 private boolean mDone = false;
Wink Saville9de0f752013-10-22 19:04:03 -07001311 private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1312 private int mRetryCount = -1;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001313
1314 // For replies from SimCard interface
1315 private Handler mHandler;
1316
1317 // For async handler to identify request type
1318 private static final int SUPPLY_PIN_COMPLETE = 100;
1319
1320 public UnlockSim(IccCard simCard) {
1321 mSimCard = simCard;
1322 }
1323
1324 @Override
1325 public void run() {
1326 Looper.prepare();
1327 synchronized (UnlockSim.this) {
1328 mHandler = new Handler() {
1329 @Override
1330 public void handleMessage(Message msg) {
1331 AsyncResult ar = (AsyncResult) msg.obj;
1332 switch (msg.what) {
1333 case SUPPLY_PIN_COMPLETE:
1334 Log.d(LOG_TAG, "SUPPLY_PIN_COMPLETE");
1335 synchronized (UnlockSim.this) {
Wink Saville9de0f752013-10-22 19:04:03 -07001336 mRetryCount = msg.arg1;
1337 if (ar.exception != null) {
1338 if (ar.exception instanceof CommandException &&
1339 ((CommandException)(ar.exception)).getCommandError()
1340 == CommandException.Error.PASSWORD_INCORRECT) {
1341 mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1342 } else {
1343 mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1344 }
1345 } else {
1346 mResult = PhoneConstants.PIN_RESULT_SUCCESS;
1347 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001348 mDone = true;
1349 UnlockSim.this.notifyAll();
1350 }
1351 break;
1352 }
1353 }
1354 };
1355 UnlockSim.this.notifyAll();
1356 }
1357 Looper.loop();
1358 }
1359
1360 /*
1361 * Use PIN or PUK to unlock SIM card
1362 *
1363 * If PUK is null, unlock SIM card with PIN
1364 *
1365 * If PUK is not null, unlock SIM card with PUK and set PIN code
1366 */
Wink Saville9de0f752013-10-22 19:04:03 -07001367 synchronized int[] unlockSim(String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001368
1369 while (mHandler == null) {
1370 try {
1371 wait();
1372 } catch (InterruptedException e) {
1373 Thread.currentThread().interrupt();
1374 }
1375 }
1376 Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
1377
1378 if (puk == null) {
1379 mSimCard.supplyPin(pin, callback);
1380 } else {
1381 mSimCard.supplyPuk(puk, pin, callback);
1382 }
1383
1384 while (!mDone) {
1385 try {
1386 Log.d(LOG_TAG, "wait for done");
1387 wait();
1388 } catch (InterruptedException e) {
1389 // Restore the interrupted status
1390 Thread.currentThread().interrupt();
1391 }
1392 }
1393 Log.d(LOG_TAG, "done");
Wink Saville9de0f752013-10-22 19:04:03 -07001394 int[] resultArray = new int[2];
1395 resultArray[0] = mResult;
1396 resultArray[1] = mRetryCount;
1397 return resultArray;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001398 }
1399 }
1400
1401 public void updateServiceLocation() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001402 updateServiceLocationForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001403
1404 }
1405
Wink Savilleb564aae2014-10-23 10:18:09 -07001406 public void updateServiceLocationForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001407 // No permission check needed here: this call is harmless, and it's
1408 // needed for the ServiceState.requestStateUpdate() call (which is
1409 // already intentionally exposed to 3rd parties.)
Sanket Padawe356d7632015-06-22 14:03:32 -07001410 final Phone phone = getPhone(subId);
1411 if (phone != null) {
1412 phone.updateServiceLocation();
1413 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001414 }
1415
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001416 @Override
1417 public boolean isRadioOn(String callingPackage) {
1418 return isRadioOnForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001419 }
1420
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001421 @Override
1422 public boolean isRadioOnForSubscriber(int subId, String callingPackage) {
1423 if (!canReadPhoneState(callingPackage, "isRadioOnForSubscriber")) {
1424 return false;
1425 }
1426 return isRadioOnForSubscriber(subId);
1427 }
1428
1429 private boolean isRadioOnForSubscriber(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07001430 final Phone phone = getPhone(subId);
1431 if (phone != null) {
1432 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
1433 } else {
1434 return false;
1435 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001436 }
1437
1438 public void toggleRadioOnOff() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001439 toggleRadioOnOffForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001440
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001441 }
Wink Saville36469e72014-06-11 15:17:00 -07001442
Wink Savilleb564aae2014-10-23 10:18:09 -07001443 public void toggleRadioOnOffForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001444 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001445 final Phone phone = getPhone(subId);
1446 if (phone != null) {
1447 phone.setRadioPower(!isRadioOnForSubscriber(subId));
1448 }
Wink Saville36469e72014-06-11 15:17:00 -07001449 }
1450
1451 public boolean setRadio(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001452 return setRadioForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001453 }
1454
Wink Savilleb564aae2014-10-23 10:18:09 -07001455 public boolean setRadioForSubscriber(int subId, boolean turnOn) {
Wink Saville36469e72014-06-11 15:17:00 -07001456 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001457 final Phone phone = getPhone(subId);
1458 if (phone == null) {
1459 return false;
1460 }
1461 if ((phone.getServiceState().getState() !=
Wink Saville36469e72014-06-11 15:17:00 -07001462 ServiceState.STATE_POWER_OFF) != turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001463 toggleRadioOnOffForSubscriber(subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001464 }
1465 return true;
1466 }
Wink Saville36469e72014-06-11 15:17:00 -07001467
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001468 public boolean needMobileRadioShutdown() {
1469 /*
1470 * If any of the Radios are available, it will need to be
1471 * shutdown. So return true if any Radio is available.
1472 */
1473 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1474 Phone phone = PhoneFactory.getPhone(i);
1475 if (phone != null && phone.isRadioAvailable()) return true;
1476 }
1477 logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
1478 return false;
1479 }
1480
1481 public void shutdownMobileRadios() {
1482 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1483 logv("Shutting down Phone " + i);
1484 shutdownRadioUsingPhoneId(i);
1485 }
1486 }
1487
1488 private void shutdownRadioUsingPhoneId(int phoneId) {
1489 enforceModifyPermission();
1490 Phone phone = PhoneFactory.getPhone(phoneId);
1491 if (phone != null && phone.isRadioAvailable()) {
1492 phone.shutdownRadio();
1493 }
1494 }
1495
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001496 public boolean setRadioPower(boolean turnOn) {
Jack Yub4e16162017-05-15 12:48:40 -07001497 enforceModifyPermission();
Wei Liu9ae2a062016-08-08 11:09:34 -07001498 final Phone defaultPhone = PhoneFactory.getDefaultPhone();
1499 if (defaultPhone != null) {
1500 defaultPhone.setRadioPower(turnOn);
1501 return true;
1502 } else {
1503 loge("There's no default phone.");
1504 return false;
1505 }
Wink Saville36469e72014-06-11 15:17:00 -07001506 }
1507
Wink Savilleb564aae2014-10-23 10:18:09 -07001508 public boolean setRadioPowerForSubscriber(int subId, boolean turnOn) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001509 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001510 final Phone phone = getPhone(subId);
1511 if (phone != null) {
1512 phone.setRadioPower(turnOn);
1513 return true;
1514 } else {
1515 return false;
1516 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001517 }
1518
Wink Saville36469e72014-06-11 15:17:00 -07001519 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001520 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001521 public boolean enableDataConnectivity() {
1522 enforceModifyPermission();
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001523 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001524 final Phone phone = getPhone(subId);
1525 if (phone != null) {
1526 phone.setDataEnabled(true);
1527 return true;
1528 } else {
1529 return false;
1530 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001531 }
1532
Wink Saville36469e72014-06-11 15:17:00 -07001533 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001534 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001535 public boolean disableDataConnectivity() {
1536 enforceModifyPermission();
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001537 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001538 final Phone phone = getPhone(subId);
1539 if (phone != null) {
1540 phone.setDataEnabled(false);
1541 return true;
1542 } else {
1543 return false;
1544 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001545 }
1546
Wink Saville36469e72014-06-11 15:17:00 -07001547 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001548 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001549 public boolean isDataConnectivityPossible() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001550 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001551 final Phone phone = getPhone(subId);
1552 if (phone != null) {
1553 return phone.isDataConnectivityPossible();
1554 } else {
1555 return false;
1556 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001557 }
1558
1559 public boolean handlePinMmi(String dialString) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001560 return handlePinMmiForSubscriber(getDefaultSubscription(), dialString);
Wink Saville36469e72014-06-11 15:17:00 -07001561 }
1562
pkanwarae03a6b2016-11-06 20:37:09 -08001563 public void handleUssdRequest(int subId, String ussdRequest, ResultReceiver wrappedCallback) {
pkanwar32d516d2016-10-14 19:37:38 -07001564 enforceCallPermission();
pkanwar32d516d2016-10-14 19:37:38 -07001565 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1566 return;
1567 }
1568 Pair<String, ResultReceiver> ussdObject = new Pair(ussdRequest, wrappedCallback);
1569 sendRequest(CMD_HANDLE_USSD_REQUEST, ussdObject, subId);
1570 };
1571
1572
Wink Savilleb564aae2014-10-23 10:18:09 -07001573 public boolean handlePinMmiForSubscriber(int subId, String dialString) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001574 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001575 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1576 return false;
1577 }
Wink Saville36469e72014-06-11 15:17:00 -07001578 return (Boolean) sendRequest(CMD_HANDLE_PIN_MMI, dialString, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001579 }
1580
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001581 public int getCallState() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001582 return getCallStateForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001583 }
1584
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001585 public int getCallStateForSlot(int slotIndex) {
1586 Phone phone = PhoneFactory.getPhone(slotIndex);
Shishir Agrawala9f32182016-04-12 12:00:16 -07001587 return phone == null ? TelephonyManager.CALL_STATE_IDLE :
Nathan Harolda667c152016-12-14 11:27:20 -08001588 PhoneConstantConversions.convertCallState(phone.getState());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001589 }
1590
Sanket Padawe356d7632015-06-22 14:03:32 -07001591 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001592 public int getDataState() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001593 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001594 if (phone != null) {
Nathan Harolda667c152016-12-14 11:27:20 -08001595 return PhoneConstantConversions.convertDataState(phone.getDataConnectionState());
Sanket Padawe356d7632015-06-22 14:03:32 -07001596 } else {
Nathan Harolda667c152016-12-14 11:27:20 -08001597 return PhoneConstantConversions.convertDataState(PhoneConstants.DataState.DISCONNECTED);
Sanket Padawe356d7632015-06-22 14:03:32 -07001598 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001599 }
1600
Sanket Padawe356d7632015-06-22 14:03:32 -07001601 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001602 public int getDataActivity() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001603 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001604 if (phone != null) {
1605 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
1606 } else {
1607 return TelephonyManager.DATA_ACTIVITY_NONE;
1608 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001609 }
1610
1611 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001612 public Bundle getCellLocation(String callingPackage) {
1613 enforceFineOrCoarseLocationPermission("getCellLocation");
1614
1615 // OP_COARSE_LOCATION controls both fine and coarse location.
1616 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1617 callingPackage) != AppOpsManager.MODE_ALLOWED) {
Amit Mahajan9acc70d2015-06-02 13:17:33 -07001618 log("getCellLocation: returning null; mode != allowed");
Svetoslav64fad262015-04-14 14:35:21 -07001619 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001620 }
1621
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001622 if (checkIfCallerIsSelfOrForegroundUser() ||
1623 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001624 if (DBG_LOC) log("getCellLocation: is active user");
1625 Bundle data = new Bundle();
Legler Wu2c01cdf2014-12-08 19:00:59 +08001626 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001627 if (phone == null) {
1628 return null;
1629 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001630
1631 WorkSource workSource = getWorkSource(null, Binder.getCallingUid());
1632 phone.getCellLocation(workSource).fillInNotifierBundle(data);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001633 return data;
1634 } else {
Amit Mahajan9acc70d2015-06-02 13:17:33 -07001635 log("getCellLocation: suppress non-active user");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001636 return null;
1637 }
1638 }
1639
Svetoslav64fad262015-04-14 14:35:21 -07001640 private void enforceFineOrCoarseLocationPermission(String message) {
1641 try {
1642 mApp.enforceCallingOrSelfPermission(
1643 android.Manifest.permission.ACCESS_FINE_LOCATION, null);
1644 } catch (SecurityException e) {
1645 // If we have ACCESS_FINE_LOCATION permission, skip the check for ACCESS_COARSE_LOCATION
1646 // A failure should throw the SecurityException from ACCESS_COARSE_LOCATION since this
1647 // is the weaker precondition
1648 mApp.enforceCallingOrSelfPermission(
1649 android.Manifest.permission.ACCESS_COARSE_LOCATION, message);
1650 }
1651 }
1652
1653
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001654 @Override
1655 public void enableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001656 enableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001657 }
1658
Sanket Padawe356d7632015-06-22 14:03:32 -07001659 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001660 public void enableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001661 mApp.enforceCallingOrSelfPermission(
1662 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Sanket Padawe356d7632015-06-22 14:03:32 -07001663 final Phone phone = getPhone(subId);
1664 if (phone != null) {
1665 phone.enableLocationUpdates();
1666 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001667 }
1668
1669 @Override
1670 public void disableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001671 disableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001672 }
1673
Sanket Padawe356d7632015-06-22 14:03:32 -07001674 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001675 public void disableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001676 mApp.enforceCallingOrSelfPermission(
1677 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Sanket Padawe356d7632015-06-22 14:03:32 -07001678 final Phone phone = getPhone(subId);
1679 if (phone != null) {
1680 phone.disableLocationUpdates();
1681 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001682 }
1683
1684 @Override
1685 @SuppressWarnings("unchecked")
1686 public List<NeighboringCellInfo> getNeighboringCellInfo(String callingPackage) {
Svetoslav64fad262015-04-14 14:35:21 -07001687 enforceFineOrCoarseLocationPermission("getNeighboringCellInfo");
1688
1689 // OP_COARSE_LOCATION controls both fine and coarse location.
1690 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1691 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1692 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001693 }
1694
1695 if (mAppOps.noteOp(AppOpsManager.OP_NEIGHBORING_CELLS, Binder.getCallingUid(),
1696 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1697 return null;
1698 }
Svetoslav64fad262015-04-14 14:35:21 -07001699
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001700 if (checkIfCallerIsSelfOrForegroundUser() ||
1701 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001702 if (DBG_LOC) log("getNeighboringCellInfo: is active user");
1703
1704 ArrayList<NeighboringCellInfo> cells = null;
1705
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001706 WorkSource workSource = getWorkSource(null, Binder.getCallingUid());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001707 try {
1708 cells = (ArrayList<NeighboringCellInfo>) sendRequest(
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001709 CMD_HANDLE_NEIGHBORING_CELL, workSource,
Sanket Padawe56e75a32016-02-08 12:18:19 -08001710 SubscriptionManager.INVALID_SUBSCRIPTION_ID);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001711 } catch (RuntimeException e) {
Wink Saville36469e72014-06-11 15:17:00 -07001712 Log.e(LOG_TAG, "getNeighboringCellInfo " + e);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001713 }
1714 return cells;
1715 } else {
1716 if (DBG_LOC) log("getNeighboringCellInfo: suppress non-active user");
1717 return null;
1718 }
1719 }
1720
1721
1722 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001723 public List<CellInfo> getAllCellInfo(String callingPackage) {
1724 enforceFineOrCoarseLocationPermission("getAllCellInfo");
1725
1726 // OP_COARSE_LOCATION controls both fine and coarse location.
1727 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1728 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1729 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001730 }
1731
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001732 if (checkIfCallerIsSelfOrForegroundUser() ||
1733 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001734 if (DBG_LOC) log("getAllCellInfo: is active user");
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001735 WorkSource workSource = getWorkSource(null, Binder.getCallingUid());
Legler Wu2c01cdf2014-12-08 19:00:59 +08001736 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
1737 for (Phone phone : PhoneFactory.getPhones()) {
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001738 final List<CellInfo> info = phone.getAllCellInfo(workSource);
1739 if (info != null) cellInfos.addAll(info);
Legler Wu2c01cdf2014-12-08 19:00:59 +08001740 }
1741 return cellInfos;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001742 } else {
1743 if (DBG_LOC) log("getAllCellInfo: suppress non-active user");
1744 return null;
1745 }
1746 }
1747
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001748 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001749 public void setCellInfoListRate(int rateInMillis) {
Jack Yua8d8cb82017-01-16 10:15:34 -08001750 enforceModifyPermission();
Sooraj Sasindran9a909312016-07-18 11:57:25 -07001751 WorkSource workSource = getWorkSource(null, Binder.getCallingUid());
1752 mPhone.setCellInfoListRate(rateInMillis, workSource);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001753 }
1754
Shishir Agrawala9f32182016-04-12 12:00:16 -07001755 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001756 public String getImeiForSlot(int slotIndex, String callingPackage) {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001757 if (!canReadPhoneState(callingPackage, "getImeiForSlot")) {
1758 return null;
1759 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001760 Phone phone = PhoneFactory.getPhone(slotIndex);
Shishir Agrawala9f32182016-04-12 12:00:16 -07001761 return phone == null ? null : phone.getImei();
1762 }
1763
1764 @Override
Jack Yu2af8d712017-03-15 17:14:14 -07001765 public String getMeidForSlot(int slotIndex, String callingPackage) {
1766 if (!canReadPhoneState(callingPackage, "getMeidForSlot")) {
1767 return null;
1768 }
1769 Phone phone = PhoneFactory.getPhone(slotIndex);
1770 return phone == null ? null : phone.getMeid();
1771 }
1772
1773 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001774 public String getDeviceSoftwareVersionForSlot(int slotIndex, String callingPackage) {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001775 if (!canReadPhoneState(callingPackage, "getDeviceSoftwareVersionForSlot")) {
1776 return null;
1777 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001778 Phone phone = PhoneFactory.getPhone(slotIndex);
Shishir Agrawala9f32182016-04-12 12:00:16 -07001779 return phone == null ? null : phone.getDeviceSvn();
1780 }
1781
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001782 //
1783 // Internal helper methods.
1784 //
1785
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001786 /**
1787 * Returns true if the caller holds INTERACT_ACROSS_USERS_FULL.
1788 */
1789 private boolean checkCallerInteractAcrossUsersFull() {
1790 return mPhone.getContext().checkCallingOrSelfPermission(
1791 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
1792 == PackageManager.PERMISSION_GRANTED;
1793 }
1794
Jake Hambye994d462014-02-03 13:10:13 -08001795 private static boolean checkIfCallerIsSelfOrForegroundUser() {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001796 boolean ok;
1797
1798 boolean self = Binder.getCallingUid() == Process.myUid();
1799 if (!self) {
1800 // Get the caller's user id then clear the calling identity
1801 // which will be restored in the finally clause.
1802 int callingUser = UserHandle.getCallingUserId();
1803 long ident = Binder.clearCallingIdentity();
1804
1805 try {
1806 // With calling identity cleared the current user is the foreground user.
1807 int foregroundUser = ActivityManager.getCurrentUser();
1808 ok = (foregroundUser == callingUser);
1809 if (DBG_LOC) {
1810 log("checkIfCallerIsSelfOrForegoundUser: foregroundUser=" + foregroundUser
1811 + " callingUser=" + callingUser + " ok=" + ok);
1812 }
1813 } catch (Exception ex) {
1814 if (DBG_LOC) loge("checkIfCallerIsSelfOrForegoundUser: Exception ex=" + ex);
1815 ok = false;
1816 } finally {
1817 Binder.restoreCallingIdentity(ident);
1818 }
1819 } else {
1820 if (DBG_LOC) log("checkIfCallerIsSelfOrForegoundUser: is self");
1821 ok = true;
1822 }
1823 if (DBG_LOC) log("checkIfCallerIsSelfOrForegoundUser: ret=" + ok);
1824 return ok;
1825 }
1826
1827 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001828 * Make sure the caller has the MODIFY_PHONE_STATE permission.
1829 *
1830 * @throws SecurityException if the caller does not have the required permission
1831 */
1832 private void enforceModifyPermission() {
1833 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
1834 }
1835
1836 /**
Junda Liua2e36012014-07-09 18:30:01 -07001837 * Make sure either system app or the caller has carrier privilege.
1838 *
1839 * @throws SecurityException if the caller does not have the required permission/privilege
1840 */
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001841 private void enforceModifyPermissionOrCarrierPrivilege(int subId) {
Shishir Agrawalf1ac4c92014-07-14 13:54:28 -07001842 int permission = mApp.checkCallingOrSelfPermission(
1843 android.Manifest.permission.MODIFY_PHONE_STATE);
1844 if (permission == PackageManager.PERMISSION_GRANTED) {
1845 return;
1846 }
1847
1848 log("No modify permission, check carrier privilege next.");
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001849 enforceCarrierPrivilege(subId);
Junda Liua2e36012014-07-09 18:30:01 -07001850 }
1851
1852 /**
1853 * Make sure the caller has carrier privilege.
1854 *
1855 * @throws SecurityException if the caller does not have the required permission
1856 */
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001857 private void enforceCarrierPrivilege(int subId) {
1858 if (getCarrierPrivilegeStatus(subId) !=
1859 TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Shishir Agrawalf1ac4c92014-07-14 13:54:28 -07001860 loge("No Carrier Privilege.");
1861 throw new SecurityException("No Carrier Privilege.");
Junda Liua2e36012014-07-09 18:30:01 -07001862 }
1863 }
1864
1865 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001866 * Make sure the caller has the CALL_PHONE permission.
1867 *
1868 * @throws SecurityException if the caller does not have the required permission
1869 */
1870 private void enforceCallPermission() {
1871 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
1872 }
1873
Stuart Scott8eef64f2015-04-08 15:13:54 -07001874 private void enforceConnectivityInternalPermission() {
1875 mApp.enforceCallingOrSelfPermission(
1876 android.Manifest.permission.CONNECTIVITY_INTERNAL,
1877 "ConnectivityService");
1878 }
1879
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001880 private String createTelUrl(String number) {
1881 if (TextUtils.isEmpty(number)) {
1882 return null;
1883 }
1884
Jake Hambye994d462014-02-03 13:10:13 -08001885 return "tel:" + number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001886 }
1887
Ihab Awadf9e92732013-12-05 18:02:52 -08001888 private static void log(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001889 Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
1890 }
1891
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001892 private static void logv(String msg) {
1893 Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
1894 }
1895
Ihab Awadf9e92732013-12-05 18:02:52 -08001896 private static void loge(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001897 Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
1898 }
1899
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001900 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001901 public int getActivePhoneType() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001902 return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001903 }
1904
Sanket Padawe356d7632015-06-22 14:03:32 -07001905 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07001906 public int getActivePhoneTypeForSlot(int slotIndex) {
1907 final Phone phone = PhoneFactory.getPhone(slotIndex);
Sanket Padawe356d7632015-06-22 14:03:32 -07001908 if (phone == null) {
1909 return PhoneConstants.PHONE_TYPE_NONE;
1910 } else {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001911 return phone.getPhoneType();
Sanket Padawe356d7632015-06-22 14:03:32 -07001912 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001913 }
1914
1915 /**
1916 * Returns the CDMA ERI icon index to display
1917 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001918 @Override
1919 public int getCdmaEriIconIndex(String callingPackage) {
1920 return getCdmaEriIconIndexForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001921 }
1922
Sanket Padawe356d7632015-06-22 14:03:32 -07001923 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001924 public int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage) {
1925 if (!canReadPhoneState(callingPackage, "getCdmaEriIconIndexForSubscriber")) {
1926 return -1;
1927 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001928 final Phone phone = getPhone(subId);
1929 if (phone != null) {
1930 return phone.getCdmaEriIconIndex();
1931 } else {
1932 return -1;
1933 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001934 }
1935
1936 /**
1937 * Returns the CDMA ERI icon mode,
1938 * 0 - ON
1939 * 1 - FLASHING
1940 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001941 @Override
1942 public int getCdmaEriIconMode(String callingPackage) {
1943 return getCdmaEriIconModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001944 }
1945
Sanket Padawe356d7632015-06-22 14:03:32 -07001946 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001947 public int getCdmaEriIconModeForSubscriber(int subId, String callingPackage) {
1948 if (!canReadPhoneState(callingPackage, "getCdmaEriIconModeForSubscriber")) {
1949 return -1;
1950 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001951 final Phone phone = getPhone(subId);
1952 if (phone != null) {
1953 return phone.getCdmaEriIconMode();
1954 } else {
1955 return -1;
1956 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001957 }
1958
1959 /**
1960 * Returns the CDMA ERI text,
1961 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001962 @Override
1963 public String getCdmaEriText(String callingPackage) {
1964 return getCdmaEriTextForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001965 }
1966
Sanket Padawe356d7632015-06-22 14:03:32 -07001967 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001968 public String getCdmaEriTextForSubscriber(int subId, String callingPackage) {
1969 if (!canReadPhoneState(callingPackage, "getCdmaEriIconTextForSubscriber")) {
1970 return null;
1971 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001972 final Phone phone = getPhone(subId);
1973 if (phone != null) {
1974 return phone.getCdmaEriText();
1975 } else {
1976 return null;
1977 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001978 }
1979
1980 /**
Junda Liuca05d5d2014-08-14 22:36:34 -07001981 * Returns the CDMA MDN.
1982 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001983 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001984 public String getCdmaMdn(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001985 enforceModifyPermissionOrCarrierPrivilege(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07001986 final Phone phone = getPhone(subId);
1987 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA && phone != null) {
1988 return phone.getLine1Number();
Junda Liuca05d5d2014-08-14 22:36:34 -07001989 } else {
1990 return null;
1991 }
1992 }
1993
1994 /**
1995 * Returns the CDMA MIN.
1996 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001997 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001998 public String getCdmaMin(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001999 enforceModifyPermissionOrCarrierPrivilege(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07002000 final Phone phone = getPhone(subId);
2001 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
2002 return phone.getCdmaMin();
Junda Liuca05d5d2014-08-14 22:36:34 -07002003 } else {
2004 return null;
2005 }
2006 }
2007
2008 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002009 * Returns true if CDMA provisioning needs to run.
2010 */
2011 public boolean needsOtaServiceProvisioning() {
2012 return mPhone.needsOtaServiceProvisioning();
2013 }
2014
2015 /**
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002016 * Sets the voice mail number of a given subId.
2017 */
2018 @Override
2019 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002020 enforceCarrierPrivilege(subId);
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002021 Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
2022 new Pair<String, String>(alphaTag, number), new Integer(subId));
2023 return success;
2024 }
2025
Ta-wei Yen87c49842016-05-13 21:19:52 -07002026 @Override
Ta-wei Yenc9df0432017-04-17 17:09:07 -07002027 public Bundle getVisualVoicemailSettings(String callingPackage, int subId) {
2028 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2029 String systemDialer = TelecomManager.from(mPhone.getContext()).getSystemDialerPackage();
2030 if (!TextUtils.equals(callingPackage, systemDialer)) {
2031 throw new SecurityException("caller must be system dialer");
2032 }
2033 PhoneAccountHandle phoneAccountHandle = PhoneAccountHandleConverter.fromSubId(subId);
2034 if (phoneAccountHandle == null){
2035 return null;
2036 }
2037 return VisualVoicemailSettingsUtil.dump(mPhone.getContext(), phoneAccountHandle);
2038 }
2039
2040 @Override
Ta-wei Yen409ac562017-03-06 16:00:44 -08002041 public String getVisualVoicemailPackageName(String callingPackage, int subId) {
Ta-wei Yendca928f2017-01-10 16:17:08 -08002042 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2043 if (!canReadPhoneState(callingPackage, "getVisualVoicemailPackageName")) {
2044 return null;
2045 }
Ta-wei Yendca928f2017-01-10 16:17:08 -08002046 return RemoteVvmTaskManager.getRemotePackage(mPhone.getContext(), subId).getPackageName();
2047 }
2048
2049 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002050 public void enableVisualVoicemailSmsFilter(String callingPackage, int subId,
2051 VisualVoicemailSmsFilterSettings settings) {
2052 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002053 VisualVoicemailSmsFilterConfig
Ta-wei Yenb6929602016-05-24 15:48:27 -07002054 .enableVisualVoicemailSmsFilter(mPhone.getContext(), callingPackage, subId,
2055 settings);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002056 }
2057
2058 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002059 public void disableVisualVoicemailSmsFilter(String callingPackage, int subId) {
2060 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002061 VisualVoicemailSmsFilterConfig
Ta-wei Yenb6929602016-05-24 15:48:27 -07002062 .disableVisualVoicemailSmsFilter(mPhone.getContext(), callingPackage, subId);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002063 }
2064
2065 @Override
Ta-wei Yenb6929602016-05-24 15:48:27 -07002066 public VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(
2067 String callingPackage, int subId) {
2068 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002069 return VisualVoicemailSmsFilterConfig
Ta-wei Yenb6929602016-05-24 15:48:27 -07002070 .getVisualVoicemailSmsFilterSettings(mPhone.getContext(), callingPackage, subId);
Ta-wei Yen87c49842016-05-13 21:19:52 -07002071 }
2072
2073 @Override
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002074 public VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId) {
Ta-wei Yenb6929602016-05-24 15:48:27 -07002075 enforceReadPrivilegedPermission();
Ta-wei Yen87c49842016-05-13 21:19:52 -07002076 return VisualVoicemailSmsFilterConfig
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002077 .getActiveVisualVoicemailSmsFilterSettings(mPhone.getContext(), subId);
2078 }
2079
2080 @Override
2081 public void sendVisualVoicemailSmsForSubscriber(String callingPackage, int subId,
2082 String number, int port, String text, PendingIntent sentIntent) {
2083 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
Ta-wei Yen527a9c02017-01-06 15:29:25 -08002084 enforceVisualVoicemailPackage(callingPackage, subId);
Ta-wei Yen30a69c82016-12-27 14:52:32 -08002085 enforceSendSmsPermission();
2086 // Make the calls as the phone process.
2087 final long identity = Binder.clearCallingIdentity();
2088 try {
2089 SmsManager smsManager = SmsManager.getSmsManagerForSubscriptionId(subId);
2090 if (port == 0) {
2091 smsManager.sendTextMessageWithSelfPermissions(number, null, text,
2092 sentIntent, null, false);
2093 } else {
2094 byte[] data = text.getBytes(StandardCharsets.UTF_8);
2095 smsManager.sendDataMessageWithSelfPermissions(number, null,
2096 (short) port, data, sentIntent, null);
2097 }
2098 } finally {
2099 Binder.restoreCallingIdentity(identity);
2100 }
Ta-wei Yen87c49842016-05-13 21:19:52 -07002101 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -08002102 /**
fionaxu0152e512016-11-14 13:36:14 -08002103 * Sets the voice activation state of a given subId.
2104 */
2105 @Override
2106 public void setVoiceActivationState(int subId, int activationState) {
2107 enforceModifyPermissionOrCarrierPrivilege(subId);
2108 final Phone phone = getPhone(subId);
2109 if (phone != null) {
2110 phone.setVoiceActivationState(activationState);
2111 } else {
2112 loge("setVoiceActivationState fails with invalid subId: " + subId);
2113 }
2114 }
2115
2116 /**
2117 * Sets the data activation state of a given subId.
2118 */
2119 @Override
2120 public void setDataActivationState(int subId, int activationState) {
2121 enforceModifyPermissionOrCarrierPrivilege(subId);
2122 final Phone phone = getPhone(subId);
2123 if (phone != null) {
2124 phone.setDataActivationState(activationState);
2125 } else {
2126 loge("setVoiceActivationState fails with invalid subId: " + subId);
2127 }
2128 }
2129
2130 /**
2131 * Returns the voice activation state of a given subId.
2132 */
2133 @Override
2134 public int getVoiceActivationState(int subId, String callingPackage) {
2135 if (!canReadPhoneState(callingPackage, "getVoiceActivationStateForSubscriber")) {
2136 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2137 }
2138 final Phone phone = getPhone(subId);
2139 if (phone != null) {
2140 return phone.getVoiceActivationState();
2141 } else {
2142 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2143 }
2144 }
2145
2146 /**
2147 * Returns the data activation state of a given subId.
2148 */
2149 @Override
2150 public int getDataActivationState(int subId, String callingPackage) {
2151 if (!canReadPhoneState(callingPackage, "getDataActivationStateForSubscriber")) {
2152 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2153 }
2154 final Phone phone = getPhone(subId);
2155 if (phone != null) {
2156 return phone.getDataActivationState();
2157 } else {
2158 return TelephonyManager.SIM_ACTIVATION_STATE_UNKNOWN;
2159 }
2160 }
2161
2162 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002163 * Returns the unread count of voicemails
2164 */
2165 public int getVoiceMessageCount() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07002166 return getVoiceMessageCountForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07002167 }
2168
2169 /**
2170 * Returns the unread count of voicemails for a subId
2171 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002172 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07002173 public int getVoiceMessageCountForSubscriber( int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07002174 final Phone phone = getPhone(subId);
2175 if (phone != null) {
2176 return phone.getVoiceMessageCount();
2177 } else {
2178 return 0;
2179 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002180 }
2181
2182 /**
pkanwar8a4dcfb2017-01-19 13:43:16 -08002183 * returns true, if the device is in a state where both voice and data
2184 * are supported simultaneously. This can change based on location or network condition.
2185 */
2186 @Override
2187 public boolean isConcurrentVoiceAndDataAllowed(int subId) {
2188 final Phone phone = getPhone(subId);
2189 return (phone == null ? false : phone.isConcurrentVoiceAndDataAllowed());
2190 }
2191
2192 /**
fionaxu235cc5e2017-03-06 22:25:57 -08002193 * Send the dialer code if called from the current default dialer or the caller has
2194 * carrier privilege.
2195 * @param inputCode The dialer code to send
2196 */
2197 @Override
2198 public void sendDialerSpecialCode(String callingPackage, String inputCode) {
2199 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
2200 String defaultDialer = TelecomManager.from(mPhone.getContext()).getDefaultDialerPackage();
2201 if (!TextUtils.equals(callingPackage, defaultDialer)) {
2202 enforceCarrierPrivilege(getDefaultSubscription());
2203 }
2204 mPhone.sendDialerSpecialCode(inputCode);
2205 }
2206
2207 /**
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002208 * Returns the data network type.
2209 * Legacy call, permission-free.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002210 *
2211 * @Deprecated to be removed Q3 2013 use {@link #getDataNetworkType}.
2212 */
2213 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002214 public int getNetworkType() {
2215 final Phone phone = getPhone(getDefaultSubscription());
2216 if (phone != null) {
2217 return phone.getServiceState().getDataNetworkType();
2218 } else {
2219 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2220 }
Wink Saville36469e72014-06-11 15:17:00 -07002221 }
2222
2223 /**
2224 * Returns the network type for a subId
2225 */
2226 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002227 public int getNetworkTypeForSubscriber(int subId, String callingPackage) {
2228 if (!canReadPhoneState(callingPackage, "getNetworkTypeForSubscriber")) {
2229 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2230 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002231
Sanket Padawe356d7632015-06-22 14:03:32 -07002232 final Phone phone = getPhone(subId);
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002233 if (phone != null) {
Sanket Padawe356d7632015-06-22 14:03:32 -07002234 return phone.getServiceState().getDataNetworkType();
2235 } else {
2236 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2237 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002238 }
2239
2240 /**
2241 * Returns the data network type
2242 */
2243 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002244 public int getDataNetworkType(String callingPackage) {
2245 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002246 }
2247
2248 /**
2249 * Returns the data network type for a subId
2250 */
2251 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002252 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage) {
2253 if (!canReadPhoneState(callingPackage, "getDataNetworkTypeForSubscriber")) {
2254 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2255 }
2256
Sanket Padawe356d7632015-06-22 14:03:32 -07002257 final Phone phone = getPhone(subId);
2258 if (phone != null) {
2259 return phone.getServiceState().getDataNetworkType();
2260 } else {
2261 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2262 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002263 }
2264
2265 /**
Wink Saville36469e72014-06-11 15:17:00 -07002266 * Returns the Voice network type for a subId
2267 */
2268 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07002269 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage) {
2270 if (!canReadPhoneState(callingPackage, "getDataNetworkTypeForSubscriber")) {
2271 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2272 }
2273
Sanket Padawe356d7632015-06-22 14:03:32 -07002274 final Phone phone = getPhone(subId);
2275 if (phone != null) {
2276 return phone.getServiceState().getVoiceNetworkType();
2277 } else {
2278 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
2279 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002280 }
2281
2282 /**
2283 * @return true if a ICC card is present
2284 */
2285 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07002286 // FIXME Make changes to pass defaultSimId of type int
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002287 return hasIccCardUsingSlotIndex(mSubscriptionController.getSlotIndex(
2288 getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07002289 }
2290
2291 /**
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002292 * @return true if a ICC card is present for a slotIndex
Wink Saville36469e72014-06-11 15:17:00 -07002293 */
Sanket Padawe356d7632015-06-22 14:03:32 -07002294 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002295 public boolean hasIccCardUsingSlotIndex(int slotIndex) {
2296 final Phone phone = PhoneFactory.getPhone(slotIndex);
fionaxu6e6c68b2016-06-23 13:31:32 -07002297 if (phone != null) {
Sanket Padawe356d7632015-06-22 14:03:32 -07002298 return phone.getIccCard().hasIccCard();
Amit Mahajana6fc2a82015-01-06 11:53:51 -08002299 } else {
2300 return false;
2301 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002302 }
2303
2304 /**
2305 * Return if the current radio is LTE on CDMA. This
2306 * is a tri-state return value as for a period of time
2307 * the mode may be unknown.
2308 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002309 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002310 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08002311 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002312 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002313 @Override
2314 public int getLteOnCdmaMode(String callingPackage) {
2315 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07002316 }
2317
Sanket Padawe356d7632015-06-22 14:03:32 -07002318 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002319 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage) {
2320 if (!canReadPhoneState(callingPackage, "getLteOnCdmaModeForSubscriber")) {
2321 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
2322 }
2323
Sanket Padawe356d7632015-06-22 14:03:32 -07002324 final Phone phone = getPhone(subId);
2325 if (phone == null) {
2326 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
2327 } else {
2328 return phone.getLteOnCdmaMode();
2329 }
Wink Saville36469e72014-06-11 15:17:00 -07002330 }
2331
2332 public void setPhone(Phone phone) {
2333 mPhone = phone;
2334 }
2335
2336 /**
2337 * {@hide}
2338 * Returns Default subId, 0 in the case of single standby.
2339 */
Wink Savilleb564aae2014-10-23 10:18:09 -07002340 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08002341 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07002342 }
2343
Shishir Agrawala9f32182016-04-12 12:00:16 -07002344 private int getSlotForDefaultSubscription() {
2345 return mSubscriptionController.getPhoneId(getDefaultSubscription());
2346 }
2347
Wink Savilleb564aae2014-10-23 10:18:09 -07002348 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08002349 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07002350 }
Ihab Awadf2177b72013-11-25 13:33:23 -08002351
2352 /**
2353 * @see android.telephony.TelephonyManager.WifiCallingChoices
2354 */
2355 public int getWhenToMakeWifiCalls() {
Sailesh Nepald1e68152013-12-12 19:08:02 -08002356 return Settings.System.getInt(mPhone.getContext().getContentResolver(),
2357 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, getWhenToMakeWifiCallsDefaultPreference());
Ihab Awadf2177b72013-11-25 13:33:23 -08002358 }
2359
2360 /**
2361 * @see android.telephony.TelephonyManager.WifiCallingChoices
2362 */
2363 public void setWhenToMakeWifiCalls(int preference) {
Sailesh Nepald1e68152013-12-12 19:08:02 -08002364 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
2365 Settings.System.putInt(mPhone.getContext().getContentResolver(),
2366 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
Ihab Awadf9e92732013-12-05 18:02:52 -08002367 }
2368
Sailesh Nepald1e68152013-12-12 19:08:02 -08002369 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07002370 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08002371 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08002372 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08002373
Shishir Agrawal566b7612013-10-28 14:41:00 -07002374 @Override
Ajay Nambid7454d32015-12-03 13:50:00 -08002375 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(int subId, String AID, int p2) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002376 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002377
Ajay Nambid7454d32015-12-03 13:50:00 -08002378 if (DBG) log("iccOpenLogicalChannel: subId=" + subId + " aid=" + AID + " p2=" + p2);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002379 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse)sendRequest(
Ajay Nambid7454d32015-12-03 13:50:00 -08002380 CMD_OPEN_CHANNEL, new Pair<String, Integer>(AID, p2), subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002381 if (DBG) log("iccOpenLogicalChannel: " + response);
2382 return response;
Shishir Agrawal566b7612013-10-28 14:41:00 -07002383 }
2384
2385 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002386 public boolean iccCloseLogicalChannel(int subId, int channel) {
2387 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002388
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002389 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002390 if (channel < 0) {
2391 return false;
2392 }
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002393 Boolean success = (Boolean)sendRequest(CMD_CLOSE_CHANNEL, channel, subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002394 if (DBG) log("iccCloseLogicalChannel: " + success);
2395 return success;
2396 }
2397
2398 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002399 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07002400 int command, int p1, int p2, int p3, String data) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002401 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002402
2403 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002404 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel +
2405 " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 +
Shishir Agrawal566b7612013-10-28 14:41:00 -07002406 " data=" + data);
2407 }
2408
2409 if (channel < 0) {
2410 return "";
2411 }
2412
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002413 IccIoResult response = (IccIoResult)sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002414 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002415 if (DBG) log("iccTransmitApduLogicalChannel: " + response);
2416
Shishir Agrawal566b7612013-10-28 14:41:00 -07002417 // Append the returned status code to the end of the response payload.
2418 String s = Integer.toHexString(
2419 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07002420 if (response.payload != null) {
2421 s = IccUtils.bytesToHexString(response.payload) + s;
2422 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07002423 return s;
2424 }
Jake Hambye994d462014-02-03 13:10:13 -08002425
Evan Charltonc66da362014-05-16 14:06:40 -07002426 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002427 public String iccTransmitApduBasicChannel(int subId, int cla, int command, int p1, int p2,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002428 int p3, String data) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002429 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002430
2431 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002432 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd=" + command
2433 + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002434 }
2435
2436 IccIoResult response = (IccIoResult)sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002437 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002438 if (DBG) log("iccTransmitApduBasicChannel: " + response);
2439
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002440 // Append the returned status code to the end of the response payload.
2441 String s = Integer.toHexString(
2442 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07002443 if (response.payload != null) {
2444 s = IccUtils.bytesToHexString(response.payload) + s;
2445 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002446 return s;
2447 }
2448
2449 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002450 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002451 String filePath) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002452 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002453
2454 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002455 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " " +
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002456 p1 + " " + p2 + " " + p3 + ":" + filePath);
2457 }
2458
2459 IccIoResult response =
2460 (IccIoResult)sendRequest(CMD_EXCHANGE_SIM_IO,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002461 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
2462 subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002463
2464 if (DBG) {
2465 log("Exchange SIM_IO [R]" + response);
2466 }
2467
2468 byte[] result = null;
2469 int length = 2;
2470 if (response.payload != null) {
2471 length = 2 + response.payload.length;
2472 result = new byte[length];
2473 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
2474 } else {
2475 result = new byte[length];
2476 }
2477
2478 result[length - 1] = (byte) response.sw2;
2479 result[length - 2] = (byte) response.sw1;
2480 return result;
2481 }
2482
Nathan Haroldb3014052017-01-25 15:57:32 -08002483 /**
2484 * Get the forbidden PLMN List from the given app type (ex APPTYPE_USIM)
2485 * on a particular subscription
2486 */
2487 public String[] getForbiddenPlmns(int subId, int appType) {
Nathan Harold8c92f382017-04-13 18:19:05 -07002488 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
2489 "Requires READ_PHONE_STATE");
Nathan Haroldb3014052017-01-25 15:57:32 -08002490 if (appType != TelephonyManager.APPTYPE_USIM && appType != TelephonyManager.APPTYPE_SIM) {
2491 loge("getForbiddenPlmnList(): App Type must be USIM or SIM");
2492 return null;
2493 }
2494 Object response = sendRequest(
2495 CMD_GET_FORBIDDEN_PLMNS, new Integer(appType), subId);
2496 if (response instanceof String[]) {
2497 return (String[]) response;
2498 }
2499 // Response is an Exception of some kind, which is signalled to the user as a NULL retval
2500 return null;
2501 }
2502
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002503 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002504 public String sendEnvelopeWithStatus(int subId, String content) {
2505 enforceModifyPermissionOrCarrierPrivilege(subId);
Evan Charltonc66da362014-05-16 14:06:40 -07002506
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002507 IccIoResult response = (IccIoResult)sendRequest(CMD_SEND_ENVELOPE, content, subId);
Evan Charltonc66da362014-05-16 14:06:40 -07002508 if (response.payload == null) {
2509 return "";
2510 }
2511
2512 // Append the returned status code to the end of the response payload.
2513 String s = Integer.toHexString(
2514 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
2515 s = IccUtils.bytesToHexString(response.payload) + s;
2516 return s;
2517 }
2518
Jake Hambye994d462014-02-03 13:10:13 -08002519 /**
2520 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
2521 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
2522 *
2523 * @param itemID the ID of the item to read
2524 * @return the NV item as a String, or null on error.
2525 */
2526 @Override
2527 public String nvReadItem(int itemID) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002528 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002529 if (DBG) log("nvReadItem: item " + itemID);
2530 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID);
2531 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
2532 return value;
2533 }
2534
2535 /**
2536 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
2537 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
2538 *
2539 * @param itemID the ID of the item to read
2540 * @param itemValue the value to write, as a String
2541 * @return true on success; false on any failure
2542 */
2543 @Override
2544 public boolean nvWriteItem(int itemID, String itemValue) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002545 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002546 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
2547 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
2548 new Pair<Integer, String>(itemID, itemValue));
2549 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
2550 return success;
2551 }
2552
2553 /**
2554 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
2555 * Used for device configuration by some CDMA operators.
2556 *
2557 * @param preferredRoamingList byte array containing the new PRL
2558 * @return true on success; false on any failure
2559 */
2560 @Override
2561 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002562 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002563 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
2564 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
2565 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
2566 return success;
2567 }
2568
2569 /**
2570 * Perform the specified type of NV config reset.
2571 * Used for device configuration by some CDMA operators.
2572 *
2573 * @param resetType the type of reset to perform (1 == factory reset; 2 == NV-only reset)
2574 * @return true on success; false on any failure
2575 */
2576 @Override
2577 public boolean nvResetConfig(int resetType) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002578 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002579 if (DBG) log("nvResetConfig: type " + resetType);
2580 Boolean success = (Boolean) sendRequest(CMD_NV_RESET_CONFIG, resetType);
2581 if (DBG) log("nvResetConfig: type " + resetType + ' ' + (success ? "ok" : "fail"));
2582 return success;
2583 }
Jake Hamby7c27be32014-03-03 13:25:59 -08002584
2585 /**
Wink Saville36469e72014-06-11 15:17:00 -07002586 * {@hide}
2587 * Returns Default sim, 0 in the case of single standby.
2588 */
2589 public int getDefaultSim() {
2590 //TODO Need to get it from Telephony Devcontroller
2591 return 0;
2592 }
2593
Svet Ganovb320e182015-04-16 12:30:10 -07002594 public String[] getPcscfAddress(String apnType, String callingPackage) {
2595 if (!canReadPhoneState(callingPackage, "getPcscfAddress")) {
2596 return new String[0];
2597 }
2598
2599
ram87fca6f2014-07-18 18:58:44 +05302600 return mPhone.getPcscfAddress(apnType);
Wink Saville36469e72014-06-11 15:17:00 -07002601 }
2602
Brad Ebinger51f743a2017-01-23 13:50:20 -08002603 /**
2604 * Returns the {@link IImsServiceController} that corresponds to the given slot Id and IMS
2605 * feature or {@link null} if the service is not available. If an ImsServiceController is
2606 * available, the {@link IImsServiceFeatureListener} callback is registered as a listener for
2607 * feature updates.
2608 */
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002609 public IImsServiceController getImsServiceControllerAndListen(int slotIndex, int feature,
Brad Ebinger51f743a2017-01-23 13:50:20 -08002610 IImsServiceFeatureListener callback) {
2611 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07002612 return PhoneFactory.getImsResolver().getImsServiceControllerAndListen(slotIndex, feature,
Brad Ebinger51f743a2017-01-23 13:50:20 -08002613 callback);
2614 }
2615
Wink Saville36469e72014-06-11 15:17:00 -07002616 public void setImsRegistrationState(boolean registered) {
2617 enforceModifyPermission();
2618 mPhone.setImsRegistrationState(registered);
2619 }
2620
2621 /**
Stuart Scott54788802015-03-30 13:18:01 -07002622 * Set the network selection mode to automatic.
2623 *
2624 */
2625 @Override
2626 public void setNetworkSelectionModeAutomatic(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002627 enforceModifyPermissionOrCarrierPrivilege(subId);
Stuart Scott54788802015-03-30 13:18:01 -07002628 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
2629 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
2630 }
2631
2632 /**
Shishir Agrawal302c8692015-06-19 13:49:39 -07002633 * Set the network selection mode to manual with the selected carrier.
2634 */
2635 @Override
Shishir Agrawal77ba3172015-09-10 14:50:19 -07002636 public boolean setNetworkSelectionModeManual(int subId, OperatorInfo operator,
2637 boolean persistSelection) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002638 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002639 if (DBG) log("setNetworkSelectionModeManual: subId:" + subId + " operator:" + operator);
Shishir Agrawal77ba3172015-09-10 14:50:19 -07002640 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operator,
2641 persistSelection);
2642 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002643 }
2644
2645 /**
2646 * Scans for available networks.
2647 */
2648 @Override
2649 public CellNetworkScanResult getCellNetworkScanResults(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002650 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002651 if (DBG) log("getCellNetworkScanResults: subId " + subId);
2652 CellNetworkScanResult result = (CellNetworkScanResult) sendRequest(
2653 CMD_PERFORM_NETWORK_SCAN, null, subId);
2654 return result;
2655 }
2656
2657 /**
Junda Liu84d15a22014-07-02 11:21:04 -07002658 * Get the calculated preferred network type.
2659 * Used for debugging incorrect network type.
2660 *
2661 * @return the preferred network type, defined in RILConstants.java.
2662 */
2663 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002664 public int getCalculatedPreferredNetworkType(String callingPackage) {
2665 if (!canReadPhoneState(callingPackage, "getCalculatedPreferredNetworkType")) {
2666 return RILConstants.PREFERRED_NETWORK_MODE;
2667 }
2668
Amit Mahajan43330e02014-11-18 11:54:45 -08002669 return PhoneFactory.calculatePreferredNetworkType(mPhone.getContext(), 0); // wink FIXME: need to get SubId from somewhere.
Junda Liu84d15a22014-07-02 11:21:04 -07002670 }
2671
2672 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08002673 * Get the preferred network type.
2674 * Used for device configuration by some CDMA operators.
2675 *
2676 * @return the preferred network type, defined in RILConstants.java.
2677 */
2678 @Override
Stuart Scott54788802015-03-30 13:18:01 -07002679 public int getPreferredNetworkType(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002680 enforceModifyPermissionOrCarrierPrivilege(subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002681 if (DBG) log("getPreferredNetworkType");
Stuart Scott54788802015-03-30 13:18:01 -07002682 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002683 int networkType = (result != null ? result[0] : -1);
2684 if (DBG) log("getPreferredNetworkType: " + networkType);
2685 return networkType;
2686 }
2687
2688 /**
2689 * Set the preferred network type.
2690 * Used for device configuration by some CDMA operators.
2691 *
2692 * @param networkType the preferred network type, defined in RILConstants.java.
2693 * @return true on success; false on any failure.
2694 */
2695 @Override
Stuart Scott54788802015-03-30 13:18:01 -07002696 public boolean setPreferredNetworkType(int subId, int networkType) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002697 enforceModifyPermissionOrCarrierPrivilege(subId);
Stuart Scott54788802015-03-30 13:18:01 -07002698 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
2699 Boolean success = (Boolean) sendRequest(CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002700 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
Junda Liu80bc0d12014-07-14 16:36:44 -07002701 if (success) {
2702 Settings.Global.putInt(mPhone.getContext().getContentResolver(),
Stuart Scott54788802015-03-30 13:18:01 -07002703 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
Junda Liu80bc0d12014-07-14 16:36:44 -07002704 }
Jake Hamby7c27be32014-03-03 13:25:59 -08002705 return success;
2706 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002707
2708 /**
Junda Liu475951f2014-11-07 16:45:03 -08002709 * Check TETHER_DUN_REQUIRED and TETHER_DUN_APN settings, net.tethering.noprovisioning
2710 * SystemProperty, and config_tether_apndata to decide whether DUN APN is required for
2711 * tethering.
2712 *
2713 * @return 0: Not required. 1: required. 2: Not set.
2714 * @hide
2715 */
2716 @Override
2717 public int getTetherApnRequired() {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002718 enforceModifyPermission();
Junda Liu475951f2014-11-07 16:45:03 -08002719 int dunRequired = Settings.Global.getInt(mPhone.getContext().getContentResolver(),
2720 Settings.Global.TETHER_DUN_REQUIRED, 2);
2721 // If not set, check net.tethering.noprovisioning, TETHER_DUN_APN setting and
2722 // config_tether_apndata.
2723 if (dunRequired == 2 && mPhone.hasMatchedTetherApnSetting()) {
2724 dunRequired = 1;
2725 }
2726 return dunRequired;
2727 }
2728
2729 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07002730 * Set mobile data enabled
2731 * Used by the user through settings etc to turn on/off mobile data
2732 *
2733 * @param enable {@code true} turn turn data on, else {@code false}
2734 */
2735 @Override
Wink Savillee7353bb2014-12-05 14:21:41 -08002736 public void setDataEnabled(int subId, boolean enable) {
Jeff Davidsona1920712016-11-18 17:05:56 -08002737 enforceModifyPermissionOrCarrierPrivilege(subId);
Wink Savillee7353bb2014-12-05 14:21:41 -08002738 int phoneId = mSubscriptionController.getPhoneId(subId);
Joe Onoratoa601dd22016-02-23 13:03:53 -08002739 if (DBG) log("getDataEnabled: subId=" + subId + " phoneId=" + phoneId);
Wink Savillee7353bb2014-12-05 14:21:41 -08002740 Phone phone = PhoneFactory.getPhone(phoneId);
2741 if (phone != null) {
Joe Onoratoa601dd22016-02-23 13:03:53 -08002742 if (DBG) log("setDataEnabled: subId=" + subId + " enable=" + enable);
Wink Savillee7353bb2014-12-05 14:21:41 -08002743 phone.setDataEnabled(enable);
2744 } else {
2745 loge("setDataEnabled: no phone for subId=" + subId);
2746 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002747 }
2748
2749 /**
Robert Greenwalt646120a2014-05-23 11:54:03 -07002750 * Get whether mobile data is enabled.
2751 *
Jeff Davidsona1920712016-11-18 17:05:56 -08002752 * Accepts either ACCESS_NETWORK_STATE, MODIFY_PHONE_STATE or carrier privileges.
Robert Greenwalted86e582014-05-21 20:03:20 -07002753 *
2754 * @return {@code true} if data is enabled else {@code false}
2755 */
2756 @Override
Wink Savillee7353bb2014-12-05 14:21:41 -08002757 public boolean getDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07002758 try {
2759 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
2760 null);
2761 } catch (Exception e) {
Jeff Davidsona1920712016-11-18 17:05:56 -08002762 enforceModifyPermissionOrCarrierPrivilege(subId);
Robert Greenwalt646120a2014-05-23 11:54:03 -07002763 }
Wink Savillee7353bb2014-12-05 14:21:41 -08002764 int phoneId = mSubscriptionController.getPhoneId(subId);
Joe Onoratoa601dd22016-02-23 13:03:53 -08002765 if (DBG) log("getDataEnabled: subId=" + subId + " phoneId=" + phoneId);
Wink Savillee7353bb2014-12-05 14:21:41 -08002766 Phone phone = PhoneFactory.getPhone(phoneId);
2767 if (phone != null) {
2768 boolean retVal = phone.getDataEnabled();
Joe Onoratoa601dd22016-02-23 13:03:53 -08002769 if (DBG) log("getDataEnabled: subId=" + subId + " retVal=" + retVal);
Wink Savillee7353bb2014-12-05 14:21:41 -08002770 return retVal;
2771 } else {
Joe Onoratoa601dd22016-02-23 13:03:53 -08002772 if (DBG) loge("getDataEnabled: no phone subId=" + subId + " retVal=false");
Wink Savillee7353bb2014-12-05 14:21:41 -08002773 return false;
2774 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002775 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07002776
2777 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002778 public int getCarrierPrivilegeStatus(int subId) {
2779 final Phone phone = getPhone(subId);
2780 if (phone == null) {
2781 loge("getCarrierPrivilegeStatus: Invalid subId");
2782 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
2783 }
2784 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002785 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08002786 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002787 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2788 }
2789 return card.getCarrierPrivilegeStatusForCurrentTransaction(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002790 phone.getContext().getPackageManager());
Shishir Agrawal60f9c952014-06-23 12:00:43 -07002791 }
Junda Liu29340342014-07-10 15:23:27 -07002792
2793 @Override
Zach Johnson50ecba32015-05-19 00:24:21 -07002794 public int checkCarrierPrivilegesForPackage(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08002795 if (TextUtils.isEmpty(pkgName))
2796 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Shishir Agrawal21409252015-01-15 23:33:50 -08002797 UiccCard card = UiccController.getInstance().getUiccCard(mPhone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002798 if (card == null) {
2799 loge("checkCarrierPrivilegesForPackage: No UICC");
2800 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2801 }
Zach Johnson50ecba32015-05-19 00:24:21 -07002802 return card.getCarrierPrivilegeStatus(mPhone.getContext().getPackageManager(), pkgName);
2803 }
2804
2805 @Override
2806 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08002807 if (TextUtils.isEmpty(pkgName))
2808 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07002809 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2810 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2811 UiccCard card = UiccController.getInstance().getUiccCard(i);
2812 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07002813 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07002814 continue;
2815 }
2816
2817 result = card.getCarrierPrivilegeStatus(
2818 mPhone.getContext().getPackageManager(), pkgName);
2819 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
2820 break;
2821 }
2822 }
2823
2824 return result;
Junda Liu29340342014-07-10 15:23:27 -07002825 }
Derek Tan89e89d42014-07-08 17:00:10 -07002826
2827 @Override
Junda Liue64de782015-04-16 17:19:16 -07002828 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
2829 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
2830 loge("phoneId " + phoneId + " is not valid.");
2831 return null;
2832 }
2833 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002834 if (card == null) {
Diego Pontorieroaf74c862014-08-28 11:51:16 -07002835 loge("getCarrierPackageNamesForIntent: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002836 return null ;
2837 }
Diego Pontorieroaf74c862014-08-28 11:51:16 -07002838 return card.getCarrierPackageNamesForIntent(
Svetoslav483aff72015-04-21 14:16:07 -07002839 mPhone.getContext().getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002840 }
2841
Amith Yamasani6e118872016-02-19 12:53:51 -08002842 @Override
2843 public List<String> getPackagesWithCarrierPrivileges() {
2844 PackageManager pm = mPhone.getContext().getPackageManager();
2845 List<String> privilegedPackages = new ArrayList<>();
2846 List<PackageInfo> packages = null;
2847 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2848 UiccCard card = UiccController.getInstance().getUiccCard(i);
2849 if (card == null) {
2850 // No UICC in that slot.
2851 continue;
2852 }
2853 if (card.hasCarrierPrivilegeRules()) {
2854 if (packages == null) {
2855 // Only check packages in user 0 for now
2856 packages = pm.getInstalledPackagesAsUser(
2857 PackageManager.MATCH_DISABLED_COMPONENTS
2858 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
2859 | PackageManager.GET_SIGNATURES, UserHandle.USER_SYSTEM);
2860 }
2861 for (int p = packages.size() - 1; p >= 0; p--) {
2862 PackageInfo pkgInfo = packages.get(p);
2863 if (pkgInfo != null && pkgInfo.packageName != null
2864 && card.getCarrierPrivilegeStatus(pkgInfo)
2865 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
2866 privilegedPackages.add(pkgInfo.packageName);
2867 }
2868 }
2869 }
2870 }
2871 return privilegedPackages;
2872 }
2873
Wink Savilleb564aae2014-10-23 10:18:09 -07002874 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07002875 final Phone phone = getPhone(subId);
2876 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07002877 if (card == null) {
2878 loge("getIccId: No UICC");
2879 return null;
2880 }
2881 String iccId = card.getIccId();
2882 if (TextUtils.isEmpty(iccId)) {
2883 loge("getIccId: ICC ID is null or empty.");
2884 return null;
2885 }
2886 return iccId;
2887 }
2888
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002889 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08002890 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
2891 String number) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002892 enforceCarrierPrivilege(subId);
Derek Tan97ebb422014-09-05 16:55:38 -07002893
Jeff Sharkey85190e62014-12-05 09:40:12 -08002894 final String iccId = getIccId(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07002895 final Phone phone = getPhone(subId);
2896 if (phone == null) {
2897 return false;
2898 }
2899 final String subscriberId = phone.getSubscriberId();
Jeff Sharkey85190e62014-12-05 09:40:12 -08002900
2901 if (DBG_MERGE) {
2902 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
2903 + subscriberId + " to " + number);
2904 }
2905
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002906 if (TextUtils.isEmpty(iccId)) {
2907 return false;
Derek Tan97ebb422014-09-05 16:55:38 -07002908 }
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002909
Jeff Sharkey85190e62014-12-05 09:40:12 -08002910 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
2911
2912 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002913 if (alphaTag == null) {
2914 editor.remove(alphaTagPrefKey);
2915 } else {
2916 editor.putString(alphaTagPrefKey, alphaTag);
2917 }
2918
Jeff Sharkey85190e62014-12-05 09:40:12 -08002919 // Record both the line number and IMSI for this ICCID, since we need to
2920 // track all merged IMSIs based on line number
2921 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
2922 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002923 if (number == null) {
2924 editor.remove(numberPrefKey);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002925 editor.remove(subscriberPrefKey);
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002926 } else {
2927 editor.putString(numberPrefKey, number);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002928 editor.putString(subscriberPrefKey, subscriberId);
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002929 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08002930
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002931 editor.commit();
2932 return true;
Derek Tan7226c842014-07-02 17:42:23 -07002933 }
2934
2935 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002936 public String getLine1NumberForDisplay(int subId, String callingPackage) {
Makoto Onukifee69342015-06-29 14:44:50 -07002937 // This is open to apps with WRITE_SMS.
2938 if (!canReadPhoneNumber(callingPackage, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08002939 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07002940 return null;
2941 }
Derek Tan97ebb422014-09-05 16:55:38 -07002942
2943 String iccId = getIccId(subId);
2944 if (iccId != null) {
2945 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
Amit Mahajan9cf11512015-11-09 11:40:48 -08002946 if (DBG_MERGE) {
2947 log("getLine1NumberForDisplay returning " +
2948 mTelephonySharedPreferences.getString(numberPrefKey, null));
2949 }
Andrew Leedf14ead2014-10-17 14:22:52 -07002950 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Derek Tan7226c842014-07-02 17:42:23 -07002951 }
Amit Mahajan9cf11512015-11-09 11:40:48 -08002952 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
Derek Tan97ebb422014-09-05 16:55:38 -07002953 return null;
Derek Tan7226c842014-07-02 17:42:23 -07002954 }
2955
2956 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002957 public String getLine1AlphaTagForDisplay(int subId, String callingPackage) {
2958 if (!canReadPhoneState(callingPackage, "getLine1AlphaTagForDisplay")) {
2959 return null;
2960 }
Derek Tan97ebb422014-09-05 16:55:38 -07002961
2962 String iccId = getIccId(subId);
2963 if (iccId != null) {
2964 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
Andrew Leedf14ead2014-10-17 14:22:52 -07002965 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
Derek Tan7226c842014-07-02 17:42:23 -07002966 }
Derek Tan97ebb422014-09-05 16:55:38 -07002967 return null;
Derek Tan7226c842014-07-02 17:42:23 -07002968 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07002969
2970 @Override
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07002971 public String[] getMergedSubscriberIds(String callingPackage) {
2972 if (!canReadPhoneState(callingPackage, "getMergedSubscriberIds")) {
2973 return null;
2974 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08002975 final Context context = mPhone.getContext();
2976 final TelephonyManager tele = TelephonyManager.from(context);
2977 final SubscriptionManager sub = SubscriptionManager.from(context);
2978
2979 // Figure out what subscribers are currently active
2980 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07002981 // Clear calling identity, when calling TelephonyManager, because callerUid must be
2982 // the process, where TelephonyManager was instantiated. Otherwise AppOps check will fail.
2983 final long identity = Binder.clearCallingIdentity();
2984 try {
2985 final int[] subIds = sub.getActiveSubscriptionIdList();
2986 for (int subId : subIds) {
2987 activeSubscriberIds.add(tele.getSubscriberId(subId));
2988 }
2989 } finally {
2990 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002991 }
2992
2993 // First pass, find a number override for an active subscriber
2994 String mergeNumber = null;
2995 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
2996 for (String key : prefs.keySet()) {
2997 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
2998 final String subscriberId = (String) prefs.get(key);
2999 if (activeSubscriberIds.contains(subscriberId)) {
3000 final String iccId = key.substring(PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
3001 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
3002 mergeNumber = (String) prefs.get(numberKey);
3003 if (DBG_MERGE) {
3004 Slog.d(LOG_TAG, "Found line number " + mergeNumber
3005 + " for active subscriber " + subscriberId);
3006 }
3007 if (!TextUtils.isEmpty(mergeNumber)) {
3008 break;
3009 }
3010 }
3011 }
3012 }
3013
3014 // Shortcut when no active merged subscribers
3015 if (TextUtils.isEmpty(mergeNumber)) {
3016 return null;
3017 }
3018
3019 // Second pass, find all subscribers under that line override
3020 final ArraySet<String> result = new ArraySet<>();
3021 for (String key : prefs.keySet()) {
3022 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
3023 final String number = (String) prefs.get(key);
3024 if (mergeNumber.equals(number)) {
3025 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
3026 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
3027 final String subscriberId = (String) prefs.get(subscriberKey);
3028 if (!TextUtils.isEmpty(subscriberId)) {
3029 result.add(subscriberId);
3030 }
3031 }
3032 }
3033 }
3034
3035 final String[] resultArray = result.toArray(new String[result.size()]);
3036 Arrays.sort(resultArray);
3037 if (DBG_MERGE) {
3038 Slog.d(LOG_TAG, "Found subscribers " + Arrays.toString(resultArray) + " after merge");
3039 }
3040 return resultArray;
3041 }
3042
3043 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003044 public boolean setOperatorBrandOverride(int subId, String brand) {
3045 enforceCarrierPrivilege(subId);
3046 final Phone phone = getPhone(subId);
3047 return phone == null ? false : phone.setOperatorBrandOverride(brand);
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07003048 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05003049
3050 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003051 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08003052 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
3053 List<String> cdmaNonRoamingList) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08003054 enforceCarrierPrivilege(subId);
3055 final Phone phone = getPhone(subId);
3056 if (phone == null) {
3057 return false;
3058 }
3059 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08003060 cdmaNonRoamingList);
3061 }
3062
3063 @Override
Amit Mahajanf43fe462017-02-23 12:08:31 -08003064 @Deprecated
Steven Liu4bf01bc2014-07-17 11:05:29 -05003065 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
3066 enforceModifyPermission();
3067
3068 int returnValue = 0;
3069 try {
3070 AsyncResult result = (AsyncResult)sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
3071 if(result.exception == null) {
3072 if (result.result != null) {
3073 byte[] responseData = (byte[])(result.result);
3074 if(responseData.length > oemResp.length) {
3075 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
3076 responseData.length + "bytes. Buffer Size is " +
3077 oemResp.length + "bytes.");
3078 }
3079 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
3080 returnValue = responseData.length;
3081 }
3082 } else {
3083 CommandException ex = (CommandException) result.exception;
3084 returnValue = ex.getCommandError().ordinal();
3085 if(returnValue > 0) returnValue *= -1;
3086 }
3087 } catch (RuntimeException e) {
3088 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
3089 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
3090 if(returnValue > 0) returnValue *= -1;
3091 }
3092
3093 return returnValue;
3094 }
Wink Saville5d475dd2014-10-17 15:00:58 -07003095
3096 @Override
3097 public void setRadioCapability(RadioAccessFamily[] rafs) {
3098 try {
3099 ProxyController.getInstance().setRadioCapability(rafs);
3100 } catch (RuntimeException e) {
3101 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
3102 }
3103 }
3104
3105 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07003106 public int getRadioAccessFamily(int phoneId, String callingPackage) {
3107 if (!canReadPhoneState(callingPackage, "getRadioAccessFamily")) {
3108 return RadioAccessFamily.RAF_UNKNOWN;
3109 }
3110
Wink Saville5d475dd2014-10-17 15:00:58 -07003111 return ProxyController.getInstance().getRadioAccessFamily(phoneId);
3112 }
Andrew Leedf14ead2014-10-17 14:22:52 -07003113
3114 @Override
3115 public void enableVideoCalling(boolean enable) {
3116 enforceModifyPermission();
Tyler Gunnfdd69de2015-12-04 21:24:38 -08003117 ImsManager.setVtSetting(mPhone.getContext(), enable);
Andrew Leedf14ead2014-10-17 14:22:52 -07003118 }
3119
3120 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07003121 public boolean isVideoCallingEnabled(String callingPackage) {
3122 if (!canReadPhoneState(callingPackage, "isVideoCallingEnabled")) {
3123 return false;
3124 }
3125
Andrew Lee77527ac2014-10-21 16:57:39 -07003126 // Check the user preference and the system-level IMS setting. Even if the user has
3127 // enabled video calling, if IMS is disabled we aren't able to support video calling.
3128 // In the long run, we may instead need to check if there exists a connection service
3129 // which can support video calling.
Andrew Lee312e8172014-10-23 17:01:36 -07003130 return ImsManager.isVtEnabledByPlatform(mPhone.getContext())
3131 && ImsManager.isEnhanced4gLteModeSettingEnabledByUser(mPhone.getContext())
Tyler Gunnfdd69de2015-12-04 21:24:38 -08003132 && ImsManager.isVtEnabledByUser(mPhone.getContext());
Andrew Leedf14ead2014-10-17 14:22:52 -07003133 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06003134
Andrew Leea1239f22015-03-02 17:44:07 -08003135 @Override
3136 public boolean canChangeDtmfToneLength() {
Jonathan Basseri9504c6b2015-06-04 14:23:32 -07003137 return mApp.getCarrierConfig().getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
Andrew Leea1239f22015-03-02 17:44:07 -08003138 }
3139
3140 @Override
3141 public boolean isWorldPhone() {
Jonathan Basseri9504c6b2015-06-04 14:23:32 -07003142 return mApp.getCarrierConfig().getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
Andrew Leea1239f22015-03-02 17:44:07 -08003143 }
3144
Andrew Lee9431b832015-03-09 18:46:45 -07003145 @Override
3146 public boolean isTtyModeSupported() {
3147 TelecomManager telecomManager = TelecomManager.from(mPhone.getContext());
3148 TelephonyManager telephonyManager =
3149 (TelephonyManager) mPhone.getContext().getSystemService(Context.TELEPHONY_SERVICE);
Wooki Wu1f82f7a2016-02-15 15:59:58 +08003150 return telecomManager.isTtySupported();
Andrew Lee9431b832015-03-09 18:46:45 -07003151 }
3152
3153 @Override
3154 public boolean isHearingAidCompatibilitySupported() {
3155 return mPhone.getContext().getResources().getBoolean(R.bool.hac_enabled);
3156 }
3157
Sanket Padawe7310cc72015-01-14 09:53:20 -08003158 /**
3159 * Returns the unique device ID of phone, for example, the IMEI for
3160 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
3161 *
3162 * <p>Requires Permission:
3163 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
3164 */
3165 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07003166 public String getDeviceId(String callingPackage) {
3167 if (!canReadPhoneState(callingPackage, "getDeviceId")) {
3168 return null;
3169 }
3170
Sanket Padawe7310cc72015-01-14 09:53:20 -08003171 final Phone phone = PhoneFactory.getPhone(0);
3172 if (phone != null) {
3173 return phone.getDeviceId();
3174 } else {
3175 return null;
3176 }
3177 }
3178
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06003179 /*
3180 * {@hide}
3181 * Returns the IMS Registration Status
3182 */
Santos Cordon7a1885b2015-02-03 11:15:19 -08003183 @Override
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06003184 public boolean isImsRegistered() {
3185 return mPhone.isImsRegistered();
3186 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08003187
3188 @Override
3189 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
3190 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
3191 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07003192
Nathan Haroldc55097a2015-03-11 18:14:50 -07003193 /*
3194 * {@hide}
3195 * Returns the IMS Registration Status
3196 */
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07003197 public boolean isWifiCallingAvailable() {
Nathan Haroldc55097a2015-03-11 18:14:50 -07003198 return mPhone.isWifiCallingEnabled();
3199 }
3200
3201 /*
3202 * {@hide}
3203 * Returns the IMS Registration Status
3204 */
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07003205 public boolean isVolteAvailable() {
Nathan Haroldc55097a2015-03-11 18:14:50 -07003206 return mPhone.isVolteEnabled();
3207 }
Svet Ganovb320e182015-04-16 12:30:10 -07003208
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07003209 /*
3210 * {@hide} Returns the IMS Registration Status
3211 */
3212 public boolean isVideoTelephonyAvailable() {
3213 return mPhone.isVideoEnabled();
3214 }
3215
Svet Ganovb320e182015-04-16 12:30:10 -07003216 private boolean canReadPhoneState(String callingPackage, String message) {
Etan Cohen921655c2015-06-24 13:54:50 -07003217 try {
Amit Mahajan83ea23b2015-07-30 16:05:11 -07003218 mApp.enforceCallingOrSelfPermission(
Etan Cohen921655c2015-06-24 13:54:50 -07003219 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, message);
3220
Amit Mahajan83ea23b2015-07-30 16:05:11 -07003221 // SKIP checking for run-time permission since caller or self has PRIVILEDGED permission
Etan Cohen921655c2015-06-24 13:54:50 -07003222 return true;
Amit Mahajan785783f2015-06-29 10:36:50 -07003223 } catch (SecurityException e) {
3224 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
3225 message);
Etan Cohen921655c2015-06-24 13:54:50 -07003226 }
Svet Ganovb320e182015-04-16 12:30:10 -07003227
3228 if (mAppOps.noteOp(AppOpsManager.OP_READ_PHONE_STATE, Binder.getCallingUid(),
3229 callingPackage) != AppOpsManager.MODE_ALLOWED) {
3230 return false;
3231 }
3232
3233 return true;
3234 }
Stuart Scott8eef64f2015-04-08 15:13:54 -07003235
Makoto Onukifee69342015-06-29 14:44:50 -07003236 /**
Amit Mahajanb9b49782015-09-15 18:16:32 -07003237 * Besides READ_PHONE_STATE, WRITE_SMS and READ_SMS also allow apps to get phone numbers.
Makoto Onukifee69342015-06-29 14:44:50 -07003238 */
3239 private boolean canReadPhoneNumber(String callingPackage, String message) {
Makoto Onukie4072d12015-08-03 15:12:23 -07003240 // Default SMS app can always read it.
3241 if (mAppOps.noteOp(AppOpsManager.OP_WRITE_SMS,
3242 Binder.getCallingUid(), callingPackage) == AppOpsManager.MODE_ALLOWED) {
3243 return true;
3244 }
Chad Brubaker7a8fba22016-11-10 11:23:18 -08003245
Makoto Onukie4072d12015-08-03 15:12:23 -07003246 try {
3247 return canReadPhoneState(callingPackage, message);
Amit Mahajanb9b49782015-09-15 18:16:32 -07003248 } catch (SecurityException readPhoneStateSecurityException) {
Makoto Onukie4072d12015-08-03 15:12:23 -07003249 }
Chad Brubaker7a8fba22016-11-10 11:23:18 -08003250 // Can be read with READ_SMS too.
3251 try {
3252 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_SMS, message);
3253 int opCode = mAppOps.permissionToOpCode(android.Manifest.permission.READ_SMS);
3254 if (opCode != AppOpsManager.OP_NONE) {
3255 return mAppOps.noteOp(opCode, Binder.getCallingUid(), callingPackage)
3256 == AppOpsManager.MODE_ALLOWED;
3257 } else {
3258 return true;
3259 }
3260 } catch (SecurityException readSmsSecurityException) {
3261 }
Chad Brubakerf342a982017-03-30 16:27:34 -07003262 // Can be read with READ_PHONE_NUMBERS too.
Chad Brubaker7a8fba22016-11-10 11:23:18 -08003263 try {
Chad Brubakerf342a982017-03-30 16:27:34 -07003264 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_NUMBERS,
Chad Brubaker7a8fba22016-11-10 11:23:18 -08003265 message);
Chad Brubakerf342a982017-03-30 16:27:34 -07003266 int opCode = mAppOps.permissionToOpCode(android.Manifest.permission.READ_PHONE_NUMBERS);
Chad Brubaker7a8fba22016-11-10 11:23:18 -08003267 if (opCode != AppOpsManager.OP_NONE) {
3268 return mAppOps.noteOp(opCode, Binder.getCallingUid(), callingPackage)
3269 == AppOpsManager.MODE_ALLOWED;
3270 } else {
3271 return true;
3272 }
3273 } catch (SecurityException readPhoneNumberSecurityException) {
3274 }
3275
3276 throw new SecurityException(message + ": Neither user " + Binder.getCallingUid() +
3277 " nor current process has" + android.Manifest.permission.READ_PHONE_STATE +
3278 ", " + android.Manifest.permission.READ_SMS + ", or " +
Chad Brubakerf342a982017-03-30 16:27:34 -07003279 android.Manifest.permission.READ_PHONE_NUMBERS);
Makoto Onukifee69342015-06-29 14:44:50 -07003280 }
3281
Stuart Scott8eef64f2015-04-08 15:13:54 -07003282 @Override
3283 public void factoryReset(int subId) {
3284 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07003285 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
3286 return;
3287 }
3288
Svet Ganovcc087f82015-05-12 20:35:54 -07003289 final long identity = Binder.clearCallingIdentity();
3290 try {
Stuart Scott981d8582015-04-21 14:09:50 -07003291 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
3292 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Svet Ganovcc087f82015-05-12 20:35:54 -07003293 // Enable data
3294 setDataEnabled(subId, true);
3295 // Set network selection mode to automatic
3296 setNetworkSelectionModeAutomatic(subId);
3297 // Set preferred mobile network type to the best available
3298 setPreferredNetworkType(subId, Phone.PREFERRED_NT_MODE);
3299 // Turn off roaming
3300 SubscriptionManager.from(mApp).setDataRoaming(0, subId);
3301 }
3302 } finally {
3303 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07003304 }
3305 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01003306
3307 @Override
3308 public String getLocaleFromDefaultSim() {
3309 // We query all subscriptions instead of just the active ones, because
3310 // this might be called early on in the provisioning flow when the
3311 // subscriptions potentially aren't active yet.
3312 final List<SubscriptionInfo> slist = getAllSubscriptionInfoList();
3313 if (slist == null || slist.isEmpty()) {
3314 return null;
3315 }
3316
3317 // This function may be called very early, say, from the setup wizard, at
3318 // which point we won't have a default subscription set. If that's the case
3319 // we just choose the first, which will be valid in "most cases".
3320 final int defaultSubId = getDefaultSubscription();
3321 SubscriptionInfo info = null;
3322 if (defaultSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
3323 info = slist.get(0);
3324 } else {
3325 for (SubscriptionInfo item : slist) {
3326 if (item.getSubscriptionId() == defaultSubId) {
3327 info = item;
3328 break;
3329 }
3330 }
3331
3332 if (info == null) {
3333 return null;
3334 }
3335 }
3336
3337 // Try and fetch the locale from the carrier properties or from the SIM language
3338 // preferences (EF-PL and EF-LI)...
Tony Hill183b2de2015-06-24 14:53:58 +01003339 final int mcc = info.getMcc();
Narayan Kamath1c496c22015-04-16 14:40:19 +01003340 final Phone defaultPhone = getPhone(info.getSubscriptionId());
Narayan Kamath011676f2015-07-29 12:04:08 +01003341 String simLanguage = null;
Narayan Kamath1c496c22015-04-16 14:40:19 +01003342 if (defaultPhone != null) {
3343 final Locale localeFromDefaultSim = defaultPhone.getLocaleFromSimAndCarrierPrefs();
3344 if (localeFromDefaultSim != null) {
Narayan Kamath011676f2015-07-29 12:04:08 +01003345 if (!localeFromDefaultSim.getCountry().isEmpty()) {
Tony Hill183b2de2015-06-24 14:53:58 +01003346 if (DBG) log("Using locale from default SIM:" + localeFromDefaultSim);
3347 return localeFromDefaultSim.toLanguageTag();
Narayan Kamath011676f2015-07-29 12:04:08 +01003348 } else {
3349 simLanguage = localeFromDefaultSim.getLanguage();
Tony Hill183b2de2015-06-24 14:53:58 +01003350 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01003351 }
3352 }
3353
Narayan Kamath011676f2015-07-29 12:04:08 +01003354 // The SIM language preferences only store a language (e.g. fr = French), not an
3355 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
3356 // the SIM and carrier preferences does not include a country we add the country
3357 // determined from the SIM MCC to provide an exact locale.
3358 final Locale mccLocale = MccTable.getLocaleFromMcc(mPhone.getContext(), mcc, simLanguage);
Tony Hill183b2de2015-06-24 14:53:58 +01003359 if (mccLocale != null) {
3360 if (DBG) log("No locale from default SIM, using mcc locale:" + mccLocale);
3361 return mccLocale.toLanguageTag();
Narayan Kamath1c496c22015-04-16 14:40:19 +01003362 }
3363
Tony Hill183b2de2015-06-24 14:53:58 +01003364 if (DBG) log("No locale found - returning null");
Narayan Kamath1c496c22015-04-16 14:40:19 +01003365 return null;
3366 }
3367
3368 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
3369 final long identity = Binder.clearCallingIdentity();
3370 try {
3371 return mSubscriptionController.getAllSubInfoList(
3372 mPhone.getContext().getOpPackageName());
3373 } finally {
3374 Binder.restoreCallingIdentity(identity);
3375 }
3376 }
3377
3378 private List<SubscriptionInfo> getActiveSubscriptionInfoList() {
3379 final long identity = Binder.clearCallingIdentity();
3380 try {
3381 return mSubscriptionController.getActiveSubscriptionInfoList(
3382 mPhone.getContext().getOpPackageName());
3383 } finally {
3384 Binder.restoreCallingIdentity(identity);
3385 }
3386 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07003387
3388 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07003389 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
3390 * representing the state of the modem.
3391 *
3392 * NOTE: This clears the modem state, so there should only every be one caller.
3393 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07003394 */
3395 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07003396 public void requestModemActivityInfo(ResultReceiver result) {
3397 enforceModifyPermission();
3398
3399 ModemActivityInfo info = (ModemActivityInfo) sendRequest(CMD_GET_MODEM_ACTIVITY_INFO, null);
3400 Bundle bundle = new Bundle();
3401 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, info);
3402 result.send(0, bundle);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07003403 }
Jack Yu85bd38a2015-11-09 11:34:32 -08003404
3405 /**
3406 * {@hide}
3407 * Returns the service state information on specified subscription.
3408 */
3409 @Override
3410 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage) {
3411
3412 if (!canReadPhoneState(callingPackage, "getServiceStateForSubscriber")) {
3413 return null;
3414 }
3415
3416 final Phone phone = getPhone(subId);
3417 if (phone == null) {
3418 return null;
3419 }
3420
3421 return phone.getServiceState();
3422 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08003423
3424 /**
3425 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
3426 *
3427 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
3428 * voicemail ringtone.
3429 * @return The URI for the ringtone to play when receiving a voicemail from a specific
3430 * PhoneAccount.
3431 */
3432 @Override
3433 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003434 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
Nancy Chen31f9ba12016-01-06 11:42:12 -08003435 if (phone == null) {
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003436 phone = mPhone;
Nancy Chen31f9ba12016-01-06 11:42:12 -08003437 }
3438
fionaxu7ed723d2017-05-30 18:58:54 -07003439 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone.getContext());
Nancy Chen31f9ba12016-01-06 11:42:12 -08003440 }
3441
3442 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003443 * Sets the per-account voicemail ringtone.
3444 *
3445 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
3446 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
3447 *
3448 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
3449 * voicemail ringtone.
3450 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific
3451 * PhoneAccount.
3452 */
3453 @Override
3454 public void setVoicemailRingtoneUri(String callingPackage,
3455 PhoneAccountHandle phoneAccountHandle, Uri uri) {
3456 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3457 if (!TextUtils.equals(callingPackage,
3458 TelecomManager.from(mPhone.getContext()).getDefaultDialerPackage())) {
3459 enforceModifyPermissionOrCarrierPrivilege(
3460 PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle));
3461 }
3462 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
3463 if (phone == null){
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003464 phone = mPhone;
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003465 }
fionaxu7ed723d2017-05-30 18:58:54 -07003466 VoicemailNotificationSettingsUtil.setRingtoneUri(phone.getContext(), uri);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003467 }
3468
3469 /**
Nancy Chen31f9ba12016-01-06 11:42:12 -08003470 * Returns whether vibration is set for voicemail notification in Phone settings.
3471 *
3472 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
3473 * voicemail vibration setting.
3474 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
3475 */
3476 @Override
3477 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003478 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
Nancy Chen31f9ba12016-01-06 11:42:12 -08003479 if (phone == null) {
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003480 phone = mPhone;
Nancy Chen31f9ba12016-01-06 11:42:12 -08003481 }
3482
fionaxu7ed723d2017-05-30 18:58:54 -07003483 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone.getContext());
Nancy Chen31f9ba12016-01-06 11:42:12 -08003484 }
3485
Youhan Wange64578a2016-05-02 15:32:42 -07003486 /**
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003487 * Sets the per-account voicemail vibration.
3488 *
3489 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or
3490 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
3491 *
3492 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the
3493 * voicemail vibration setting.
3494 * @param enabled Whether to enable or disable vibration for voicemail notifications from a
3495 * specific PhoneAccount.
3496 */
3497 @Override
3498 public void setVoicemailVibrationEnabled(String callingPackage,
3499 PhoneAccountHandle phoneAccountHandle, boolean enabled) {
3500 mAppOps.checkPackage(Binder.getCallingUid(), callingPackage);
3501 if (!TextUtils.equals(callingPackage,
3502 TelecomManager.from(mPhone.getContext()).getDefaultDialerPackage())) {
3503 enforceModifyPermissionOrCarrierPrivilege(
3504 PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle));
3505 }
3506
3507 Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(phoneAccountHandle);
3508 if (phone == null){
Ta-wei Yen00b4ab52017-04-11 13:24:26 -07003509 phone = mPhone;
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003510 }
fionaxu7ed723d2017-05-30 18:58:54 -07003511 VoicemailNotificationSettingsUtil.setVibrationEnabled(phone.getContext(), enabled);
Ta-wei Yenc33877d2017-01-23 18:11:21 -08003512 }
3513
3514 /**
Youhan Wange64578a2016-05-02 15:32:42 -07003515 * Make sure either called from same process as self (phone) or IPC caller has read privilege.
3516 *
3517 * @throws SecurityException if the caller does not have the required permission
3518 */
3519 private void enforceReadPrivilegedPermission() {
3520 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
3521 null);
3522 }
3523
3524 /**
Ta-wei Yen30a69c82016-12-27 14:52:32 -08003525 * Make sure either called from same process as self (phone) or IPC caller has send SMS
3526 * permission.
3527 *
3528 * @throws SecurityException if the caller does not have the required permission
3529 */
3530 private void enforceSendSmsPermission() {
3531 mApp.enforceCallingOrSelfPermission(permission.SEND_SMS, null);
3532 }
3533
3534 /**
Ta-wei Yen527a9c02017-01-06 15:29:25 -08003535 * Make sure called from the package in charge of visual voicemail.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08003536 *
Ta-wei Yen527a9c02017-01-06 15:29:25 -08003537 * @throws SecurityException if the caller is not the visual voicemail package.
Ta-wei Yen30a69c82016-12-27 14:52:32 -08003538 */
Ta-wei Yen527a9c02017-01-06 15:29:25 -08003539 private void enforceVisualVoicemailPackage(String callingPackage, int subId) {
Ta-wei Yen5d81b0c2017-03-03 16:32:26 -08003540 ComponentName componentName =
3541 RemoteVvmTaskManager.getRemotePackage(mPhone.getContext(), subId);
3542 if(componentName == null) {
3543 throw new SecurityException("Caller not current active visual voicemail package[null]");
3544 }
3545 String vvmPackage = componentName.getPackageName();
Ta-wei Yen527a9c02017-01-06 15:29:25 -08003546 if (!callingPackage.equals(vvmPackage)) {
3547 throw new SecurityException("Caller not current active visual voicemail package[" +
3548 vvmPackage + "]");
Ta-wei Yen30a69c82016-12-27 14:52:32 -08003549 }
3550 }
3551
3552 /**
Youhan Wange64578a2016-05-02 15:32:42 -07003553 * Return the application ID for the app type.
3554 *
3555 * @param subId the subscription ID that this request applies to.
3556 * @param appType the uicc app type.
3557 * @return Application ID for specificied app type, or null if no uicc.
3558 */
3559 @Override
3560 public String getAidForAppType(int subId, int appType) {
3561 enforceReadPrivilegedPermission();
3562 Phone phone = getPhone(subId);
3563 if (phone == null) {
3564 return null;
3565 }
3566 String aid = null;
3567 try {
3568 aid = UiccController.getInstance().getUiccCard(phone.getPhoneId())
3569 .getApplicationByType(appType).getAid();
3570 } catch (Exception e) {
3571 Log.e(LOG_TAG, "Not getting aid. Exception ex=" + e);
3572 }
3573 return aid;
3574 }
3575
Youhan Wang4001d252016-05-11 10:29:41 -07003576 /**
3577 * Return the Electronic Serial Number.
3578 *
3579 * @param subId the subscription ID that this request applies to.
3580 * @return ESN or null if error.
3581 */
3582 @Override
3583 public String getEsn(int subId) {
3584 enforceReadPrivilegedPermission();
3585 Phone phone = getPhone(subId);
3586 if (phone == null) {
3587 return null;
3588 }
3589 String esn = null;
3590 try {
3591 esn = phone.getEsn();
3592 } catch (Exception e) {
3593 Log.e(LOG_TAG, "Not getting ESN. Exception ex=" + e);
3594 }
3595 return esn;
3596 }
3597
Sanket Padawe99ef1e32016-05-18 16:12:33 -07003598 /**
Youhan Wang66ad5d72016-07-18 17:56:58 -07003599 * Return the Preferred Roaming List Version.
3600 *
3601 * @param subId the subscription ID that this request applies to.
3602 * @return PRLVersion or null if error.
3603 */
3604 @Override
3605 public String getCdmaPrlVersion(int subId) {
3606 enforceReadPrivilegedPermission();
3607 Phone phone = getPhone(subId);
3608 if (phone == null) {
3609 return null;
3610 }
3611 String cdmaPrlVersion = null;
3612 try {
3613 cdmaPrlVersion = phone.getCdmaPrlVersion();
3614 } catch (Exception e) {
3615 Log.e(LOG_TAG, "Not getting PRLVersion", e);
3616 }
3617 return cdmaPrlVersion;
3618 }
3619
3620 /**
Sanket Padawe99ef1e32016-05-18 16:12:33 -07003621 * Get snapshot of Telephony histograms
3622 * @return List of Telephony histograms
3623 * @hide
3624 */
3625 @Override
3626 public List<TelephonyHistogram> getTelephonyHistograms() {
3627 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
3628 return RIL.getTelephonyRILTimingHistograms();
3629 }
Meng Wang1a7c35a2016-05-05 20:56:15 -07003630
3631 /**
3632 * {@hide}
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003633 * Set the allowed carrier list for slotIndex
Meng Wang1a7c35a2016-05-05 20:56:15 -07003634 * Require system privileges. In the future we may add this to carrier APIs.
3635 *
3636 * @return The number of carriers set successfully, should match length of carriers
3637 */
3638 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003639 public int setAllowedCarriers(int slotIndex, List<CarrierIdentifier> carriers) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07003640 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003641
Meng Wang9b7c4e92017-02-17 11:41:27 -08003642 if (carriers == null) {
3643 throw new NullPointerException("carriers cannot be null");
3644 }
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003645
3646 int subId = SubscriptionManager.getSubId(slotIndex)[0];
Meng Wang1a7c35a2016-05-05 20:56:15 -07003647 int[] retVal = (int[]) sendRequest(CMD_SET_ALLOWED_CARRIERS, carriers, subId);
3648 return retVal[0];
3649 }
3650
3651 /**
3652 * {@hide}
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003653 * Get the allowed carrier list for slotIndex.
Meng Wang1a7c35a2016-05-05 20:56:15 -07003654 * Require system privileges. In the future we may add this to carrier APIs.
3655 *
3656 * @return List of {@link android.service.telephony.CarrierIdentifier}; empty list
3657 * means all carriers are allowed.
3658 */
3659 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003660 public List<CarrierIdentifier> getAllowedCarriers(int slotIndex) {
Meng Wang1a7c35a2016-05-05 20:56:15 -07003661 enforceReadPrivilegedPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003662 int subId = SubscriptionManager.getSubId(slotIndex)[0];
Meng Wang1a7c35a2016-05-05 20:56:15 -07003663 return (List<CarrierIdentifier>) sendRequest(CMD_GET_ALLOWED_CARRIERS, null, subId);
3664 }
3665
fionaxu59545b42016-05-25 15:53:37 -07003666 /**
3667 * Action set from carrier signalling broadcast receivers to enable/disable metered apns
3668 * @param subId the subscription ID that this action applies to.
3669 * @param enabled control enable or disable metered apns.
3670 * {@hide}
3671 */
3672 @Override
3673 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) {
3674 enforceModifyPermission();
3675 final Phone phone = getPhone(subId);
3676 if (phone == null) {
3677 loge("carrierAction: SetMeteredApnsEnabled fails with invalid subId: " + subId);
3678 return;
3679 }
3680 try {
3681 phone.carrierActionSetMeteredApnsEnabled(enabled);
3682 } catch (Exception e) {
3683 Log.e(LOG_TAG, "carrierAction: SetMeteredApnsEnabled fails. Exception ex=" + e);
3684 }
3685 }
3686
3687 /**
3688 * Action set from carrier signalling broadcast receivers to enable/disable radio
3689 * @param subId the subscription ID that this action applies to.
3690 * @param enabled control enable or disable radio.
3691 * {@hide}
3692 */
3693 @Override
3694 public void carrierActionSetRadioEnabled(int subId, boolean enabled) {
3695 enforceModifyPermission();
3696 final Phone phone = getPhone(subId);
3697 if (phone == null) {
3698 loge("carrierAction: SetRadioEnabled fails with invalid sibId: " + subId);
3699 return;
3700 }
3701 try {
3702 phone.carrierActionSetRadioEnabled(enabled);
3703 } catch (Exception e) {
3704 Log.e(LOG_TAG, "carrierAction: SetRadioEnabled fails. Exception ex=" + e);
3705 }
3706 }
3707
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07003708 /**
3709 * Called when "adb shell dumpsys phone" is invoked. Dump is also automatically invoked when a
3710 * bug report is being generated.
3711 */
3712 @Override
Ta-wei Yen99282e02016-06-21 18:19:35 -07003713 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
dcashman22b950d2016-06-27 11:39:02 -07003714 if (mPhone.getContext().checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
3715 != PackageManager.PERMISSION_GRANTED) {
3716 writer.println("Permission Denial: can't dump Phone from pid="
3717 + Binder.getCallingPid()
3718 + ", uid=" + Binder.getCallingUid()
3719 + "without permission "
3720 + android.Manifest.permission.DUMP);
3721 return;
3722 }
Ta-wei Yen99282e02016-06-21 18:19:35 -07003723 DumpsysHandler.dump(mPhone.getContext(), fd, writer, args);
Ta-wei Yenc236d6b2016-06-21 13:33:12 -07003724 }
Jack Yueb89b242016-06-22 13:27:47 -07003725
3726 /**
3727 * Get aggregated video call data usage from all subscriptions since boot.
3728 * @return total data usage in bytes
3729 * {@hide}
3730 */
3731 @Override
3732 public long getVtDataUsage() {
3733 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_NETWORK_USAGE_HISTORY,
3734 null);
3735
3736 // NetworkStatsService keeps tracking the active network interface and identity. It will
3737 // record the delta with the corresponding network identity. What we need to do here is
3738 // returning total video call data usage from all subscriptions since boot.
3739
3740 // TODO: Add sub id support in the future. We'll need it when we support DSDA and
3741 // simultaneous VT calls.
3742 final Phone[] phones = PhoneFactory.getPhones();
3743 long total = 0;
3744 for (Phone phone : phones) {
3745 total += phone.getVtDataUsage();
3746 }
3747 return total;
3748 }
Jack Yu75ab2952016-07-08 14:29:33 -07003749
3750 /**
3751 * Policy control of data connection. Usually used when data limit is passed.
3752 * @param enabled True if enabling the data, otherwise disabling.
3753 * @param subId Subscription index
3754 * {@hide}
3755 */
3756 @Override
3757 public void setPolicyDataEnabled(boolean enabled, int subId) {
3758 enforceModifyPermission();
3759 Phone phone = getPhone(subId);
3760 if (phone != null) {
3761 phone.setPolicyDataEnabled(enabled);
3762 }
3763 }
Sooraj Sasindran9a909312016-07-18 11:57:25 -07003764
3765 /**
3766 * Get Client request stats
3767 * @return List of Client Request Stats
3768 * @hide
3769 */
3770 @Override
3771 public List<ClientRequestStats> getClientRequestStats(String callingPackage, int subId) {
3772 if (!canReadPhoneState(callingPackage, "getClientRequestStats")) {
3773 return null;
3774 }
3775
3776 Phone phone = getPhone(subId);
3777 if (phone != null) {
3778 return phone.getClientRequestStats();
3779 }
3780
3781 return null;
3782 }
3783
3784 private WorkSource getWorkSource(WorkSource workSource, int uid) {
3785 if (workSource != null) {
3786 return workSource;
3787 }
3788
3789 String packageName = mPhone.getContext().getPackageManager().getNameForUid(uid);
3790 workSource = new WorkSource(uid, packageName);
3791 return workSource;
3792 }
Jack Yueb4124c2017-02-16 15:32:43 -08003793
3794 /**
3795 * Set SIM card power state. Request is equivalent to inserting or removing the card.
3796 *
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003797 * @param slotIndex SIM slot id.
Jack Yueb4124c2017-02-16 15:32:43 -08003798 * @param powerUp True if powering up the SIM, otherwise powering down
3799 *
3800 **/
3801 @Override
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003802 public void setSimPowerStateForSlot(int slotIndex, boolean powerUp) {
Jack Yueb4124c2017-02-16 15:32:43 -08003803 enforceModifyPermission();
Sanket Padawe13bac7b2017-03-20 15:04:47 -07003804 Phone phone = PhoneFactory.getPhone(slotIndex);
3805
Jack Yueb4124c2017-02-16 15:32:43 -08003806 if (phone != null) {
3807 phone.setSimPowerState(powerUp);
3808 }
3809 }
Shuo Qiandd210312017-04-12 22:11:33 +00003810
3811 /**
3812 * Check if phone is in emergency callback mode
3813 * @return true if phone is in emergency callback mode
3814 * @param subId sub id
3815 */
3816 public boolean getEmergencyCallbackMode(int subId) {
3817 final Phone phone = getPhone(subId);
3818 if (phone != null) {
3819 return phone.isInEcm();
3820 } else {
3821 return false;
3822 }
3823 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003824}