blob: 7738b77ed6534c3b97987f5bd792e736bf6fe534 [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
19import android.app.ActivityManager;
20import android.app.AppOpsManager;
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -070021import android.content.ComponentName;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070022import android.content.Context;
23import android.content.Intent;
Derek Tan97ebb422014-09-05 16:55:38 -070024import android.content.SharedPreferences;
Amith Yamasani6e118872016-02-19 12:53:51 -080025import android.content.pm.PackageInfo;
Shishir Agrawal60f9c952014-06-23 12:00:43 -070026import android.content.pm.PackageManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070027import android.net.Uri;
28import android.os.AsyncResult;
29import android.os.Binder;
30import android.os.Bundle;
31import android.os.Handler;
32import android.os.Looper;
33import android.os.Message;
34import android.os.Process;
Adam Lesinski903a54c2016-04-11 14:49:52 -070035import android.os.ResultReceiver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070036import android.os.ServiceManager;
37import android.os.UserHandle;
Stuart Scott981d8582015-04-21 14:09:50 -070038import android.os.UserManager;
Derek Tan97ebb422014-09-05 16:55:38 -070039import android.preference.PreferenceManager;
Ihab Awadf2177b72013-11-25 13:33:23 -080040import android.provider.Settings;
Santos Cordon7a1885b2015-02-03 11:15:19 -080041import android.telecom.PhoneAccount;
Nancy Chen31f9ba12016-01-06 11:42:12 -080042import android.telecom.PhoneAccountHandle;
Andrew Lee9431b832015-03-09 18:46:45 -070043import android.telecom.TelecomManager;
Junda Liu12f7d802015-05-01 12:06:44 -070044import android.telephony.CarrierConfigManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070045import android.telephony.CellInfo;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -070046import android.telephony.IccOpenLogicalChannelResponse;
Jake Hambye994d462014-02-03 13:10:13 -080047import android.telephony.NeighboringCellInfo;
Wink Saville5d475dd2014-10-17 15:00:58 -070048import android.telephony.RadioAccessFamily;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070049import android.telephony.ServiceState;
Wink Saville0f3b5fc2014-11-11 08:40:49 -080050import android.telephony.SubscriptionInfo;
Jeff Sharkey85190e62014-12-05 09:40:12 -080051import android.telephony.SubscriptionManager;
Ihab Awadf2177b72013-11-25 13:33:23 -080052import android.telephony.TelephonyManager;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -070053import android.telephony.ModemActivityInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070054import android.text.TextUtils;
Jeff Sharkey85190e62014-12-05 09:40:12 -080055import android.util.ArraySet;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070056import android.util.Log;
Jake Hambye994d462014-02-03 13:10:13 -080057import android.util.Pair;
Jeff Sharkey85190e62014-12-05 09:40:12 -080058import android.util.Slog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070059
Andrew Lee312e8172014-10-23 17:01:36 -070060import com.android.ims.ImsManager;
Shishir Agrawal566b7612013-10-28 14:41:00 -070061import com.android.internal.telephony.CallManager;
Shishir Agrawal302c8692015-06-19 13:49:39 -070062import com.android.internal.telephony.CellNetworkScanResult;
Shishir Agrawal566b7612013-10-28 14:41:00 -070063import com.android.internal.telephony.CommandException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070064import com.android.internal.telephony.DefaultPhoneNotifier;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070065import com.android.internal.telephony.ITelephony;
Jake Hambye994d462014-02-03 13:10:13 -080066import com.android.internal.telephony.IccCard;
Narayan Kamath1c496c22015-04-16 14:40:19 +010067import com.android.internal.telephony.MccTable;
Shishir Agrawal302c8692015-06-19 13:49:39 -070068import com.android.internal.telephony.OperatorInfo;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070069import com.android.internal.telephony.Phone;
Wink Saville36469e72014-06-11 15:17:00 -070070import com.android.internal.telephony.PhoneFactory;
Wink Saville5d475dd2014-10-17 15:00:58 -070071import com.android.internal.telephony.ProxyController;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070072import com.android.internal.telephony.PhoneConstants;
Svet Ganovb320e182015-04-16 12:30:10 -070073import com.android.internal.telephony.RILConstants;
Wink Savilleac1bdfd2014-11-20 23:04:44 -080074import com.android.internal.telephony.SubscriptionController;
Shishir Agrawal566b7612013-10-28 14:41:00 -070075import com.android.internal.telephony.uicc.IccIoResult;
76import com.android.internal.telephony.uicc.IccUtils;
Shishir Agrawaleb8771e2014-07-22 11:24:08 -070077import com.android.internal.telephony.uicc.UiccCard;
Shishir Agrawal566b7612013-10-28 14:41:00 -070078import com.android.internal.telephony.uicc.UiccController;
Jake Hambye994d462014-02-03 13:10:13 -080079import com.android.internal.util.HexDump;
Nancy Chen31f9ba12016-01-06 11:42:12 -080080import com.android.phone.settings.VoicemailNotificationSettingsUtil;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070081
Wink Saville36469e72014-06-11 15:17:00 -070082import static com.android.internal.telephony.PhoneConstants.SUBSCRIPTION_KEY;
83
Santos Cordon7d4ddf62013-07-10 11:58:08 -070084import java.util.ArrayList;
Jeff Sharkey85190e62014-12-05 09:40:12 -080085import java.util.Arrays;
Jake Hambye994d462014-02-03 13:10:13 -080086import java.util.List;
Narayan Kamath1c496c22015-04-16 14:40:19 +010087import java.util.Locale;
Jeff Sharkey85190e62014-12-05 09:40:12 -080088import java.util.Map;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070089
90/**
91 * Implementation of the ITelephony interface.
92 */
Santos Cordon117fee72014-05-16 17:56:12 -070093public class PhoneInterfaceManager extends ITelephony.Stub {
Santos Cordon7d4ddf62013-07-10 11:58:08 -070094 private static final String LOG_TAG = "PhoneInterfaceManager";
95 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
96 private static final boolean DBG_LOC = false;
Jeff Sharkey85190e62014-12-05 09:40:12 -080097 private static final boolean DBG_MERGE = false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070098
99 // Message codes used with mMainThreadHandler
100 private static final int CMD_HANDLE_PIN_MMI = 1;
101 private static final int CMD_HANDLE_NEIGHBORING_CELL = 2;
102 private static final int EVENT_NEIGHBORING_CELL_DONE = 3;
103 private static final int CMD_ANSWER_RINGING_CALL = 4;
104 private static final int CMD_END_CALL = 5; // not used yet
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700105 private static final int CMD_TRANSMIT_APDU_LOGICAL_CHANNEL = 7;
106 private static final int EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE = 8;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700107 private static final int CMD_OPEN_CHANNEL = 9;
108 private static final int EVENT_OPEN_CHANNEL_DONE = 10;
109 private static final int CMD_CLOSE_CHANNEL = 11;
110 private static final int EVENT_CLOSE_CHANNEL_DONE = 12;
Jake Hambye994d462014-02-03 13:10:13 -0800111 private static final int CMD_NV_READ_ITEM = 13;
112 private static final int EVENT_NV_READ_ITEM_DONE = 14;
113 private static final int CMD_NV_WRITE_ITEM = 15;
114 private static final int EVENT_NV_WRITE_ITEM_DONE = 16;
115 private static final int CMD_NV_WRITE_CDMA_PRL = 17;
116 private static final int EVENT_NV_WRITE_CDMA_PRL_DONE = 18;
117 private static final int CMD_NV_RESET_CONFIG = 19;
118 private static final int EVENT_NV_RESET_CONFIG_DONE = 20;
Jake Hamby7c27be32014-03-03 13:25:59 -0800119 private static final int CMD_GET_PREFERRED_NETWORK_TYPE = 21;
120 private static final int EVENT_GET_PREFERRED_NETWORK_TYPE_DONE = 22;
121 private static final int CMD_SET_PREFERRED_NETWORK_TYPE = 23;
122 private static final int EVENT_SET_PREFERRED_NETWORK_TYPE_DONE = 24;
Sailesh Nepal35b59452014-03-06 09:26:56 -0800123 private static final int CMD_SEND_ENVELOPE = 25;
124 private static final int EVENT_SEND_ENVELOPE_DONE = 26;
Derek Tan6b088ee2014-09-05 14:15:18 -0700125 private static final int CMD_INVOKE_OEM_RIL_REQUEST_RAW = 27;
126 private static final int EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE = 28;
127 private static final int CMD_TRANSMIT_APDU_BASIC_CHANNEL = 29;
128 private static final int EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE = 30;
129 private static final int CMD_EXCHANGE_SIM_IO = 31;
130 private static final int EVENT_EXCHANGE_SIM_IO_DONE = 32;
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800131 private static final int CMD_SET_VOICEMAIL_NUMBER = 33;
132 private static final int EVENT_SET_VOICEMAIL_NUMBER_DONE = 34;
Stuart Scott54788802015-03-30 13:18:01 -0700133 private static final int CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC = 35;
134 private static final int EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE = 36;
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700135 private static final int CMD_GET_MODEM_ACTIVITY_INFO = 37;
136 private static final int EVENT_GET_MODEM_ACTIVITY_INFO_DONE = 38;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700137 private static final int CMD_PERFORM_NETWORK_SCAN = 39;
138 private static final int EVENT_PERFORM_NETWORK_SCAN_DONE = 40;
139 private static final int CMD_SET_NETWORK_SELECTION_MODE_MANUAL = 41;
140 private static final int EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE = 42;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700141
142 /** The singleton instance. */
143 private static PhoneInterfaceManager sInstance;
144
Wink Saville3ab207e2014-11-20 13:07:20 -0800145 private PhoneGlobals mApp;
146 private Phone mPhone;
147 private CallManager mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700148 private UserManager mUserManager;
Wink Saville3ab207e2014-11-20 13:07:20 -0800149 private AppOpsManager mAppOps;
150 private MainThreadHandler mMainThreadHandler;
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800151 private SubscriptionController mSubscriptionController;
Wink Saville3ab207e2014-11-20 13:07:20 -0800152 private SharedPreferences mTelephonySharedPreferences;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700153
Derek Tan97ebb422014-09-05 16:55:38 -0700154 private static final String PREF_CARRIERS_ALPHATAG_PREFIX = "carrier_alphtag_";
155 private static final String PREF_CARRIERS_NUMBER_PREFIX = "carrier_number_";
Jeff Sharkey85190e62014-12-05 09:40:12 -0800156 private static final String PREF_CARRIERS_SUBSCRIBER_PREFIX = "carrier_subscriber_";
Derek Tan89e89d42014-07-08 17:00:10 -0700157
158 /**
Shishir Agrawal566b7612013-10-28 14:41:00 -0700159 * A request object to use for transmitting data to an ICC.
160 */
161 private static final class IccAPDUArgument {
162 public int channel, cla, command, p1, p2, p3;
163 public String data;
164
165 public IccAPDUArgument(int channel, int cla, int command,
166 int p1, int p2, int p3, String data) {
167 this.channel = channel;
168 this.cla = cla;
169 this.command = command;
170 this.p1 = p1;
171 this.p2 = p2;
172 this.p3 = p3;
173 this.data = data;
174 }
175 }
176
177 /**
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700178 * A request object to use for transmitting data to an ICC.
179 */
180 private static final class ManualNetworkSelectionArgument {
181 public OperatorInfo operatorInfo;
182 public boolean persistSelection;
183
184 public ManualNetworkSelectionArgument(OperatorInfo operatorInfo, boolean persistSelection) {
185 this.operatorInfo = operatorInfo;
186 this.persistSelection = persistSelection;
187 }
188 }
189
190 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700191 * A request object for use with {@link MainThreadHandler}. Requesters should wait() on the
192 * request after sending. The main thread will notify the request when it is complete.
193 */
194 private static final class MainThreadRequest {
195 /** The argument to use for the request */
196 public Object argument;
197 /** The result of the request that is run on the main thread */
198 public Object result;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800199 // The subscriber id that this request applies to. Defaults to
200 // SubscriptionManager.INVALID_SUBSCRIPTION_ID
201 public Integer subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700202
203 public MainThreadRequest(Object argument) {
204 this.argument = argument;
205 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800206
207 public MainThreadRequest(Object argument, Integer subId) {
208 this.argument = argument;
Sanket Padawe56e75a32016-02-08 12:18:19 -0800209 if (subId != null) {
210 this.subId = subId;
211 }
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800212 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700213 }
214
Sailesh Nepalcc0375f2013-11-13 09:15:18 -0800215 private static final class IncomingThirdPartyCallArgs {
216 public final ComponentName component;
217 public final String callId;
218 public final String callerDisplayName;
219
220 public IncomingThirdPartyCallArgs(ComponentName component, String callId,
221 String callerDisplayName) {
222 this.component = component;
223 this.callId = callId;
224 this.callerDisplayName = callerDisplayName;
225 }
226 }
227
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700228 /**
229 * A handler that processes messages on the main thread in the phone process. Since many
230 * of the Phone calls are not thread safe this is needed to shuttle the requests from the
231 * inbound binder threads to the main thread in the phone process. The Binder thread
232 * may provide a {@link MainThreadRequest} object in the msg.obj field that they are waiting
233 * on, which will be notified when the operation completes and will contain the result of the
234 * request.
235 *
236 * <p>If a MainThreadRequest object is provided in the msg.obj field,
237 * note that request.result must be set to something non-null for the calling thread to
238 * unblock.
239 */
240 private final class MainThreadHandler extends Handler {
241 @Override
242 public void handleMessage(Message msg) {
243 MainThreadRequest request;
244 Message onCompleted;
245 AsyncResult ar;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800246 UiccCard uiccCard;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700247 IccAPDUArgument iccArgument;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700248
249 switch (msg.what) {
Yorke Lee716f67e2015-06-17 15:39:16 -0700250 case CMD_HANDLE_PIN_MMI: {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700251 request = (MainThreadRequest) msg.obj;
Yorke Lee716f67e2015-06-17 15:39:16 -0700252 final Phone phone = getPhoneFromRequest(request);
253 request.result = phone != null ?
254 getPhoneFromRequest(request).handlePinMmi((String) request.argument)
255 : false;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700256 // Wake up the requesting thread
257 synchronized (request) {
258 request.notifyAll();
259 }
260 break;
Yorke Lee716f67e2015-06-17 15:39:16 -0700261 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700262
263 case CMD_HANDLE_NEIGHBORING_CELL:
264 request = (MainThreadRequest) msg.obj;
265 onCompleted = obtainMessage(EVENT_NEIGHBORING_CELL_DONE,
266 request);
267 mPhone.getNeighboringCids(onCompleted);
268 break;
269
270 case EVENT_NEIGHBORING_CELL_DONE:
271 ar = (AsyncResult) msg.obj;
272 request = (MainThreadRequest) ar.userObj;
273 if (ar.exception == null && ar.result != null) {
274 request.result = ar.result;
275 } else {
276 // create an empty list to notify the waiting thread
Jake Hambye994d462014-02-03 13:10:13 -0800277 request.result = new ArrayList<NeighboringCellInfo>(0);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700278 }
279 // Wake up the requesting thread
280 synchronized (request) {
281 request.notifyAll();
282 }
283 break;
284
285 case CMD_ANSWER_RINGING_CALL:
Wink Saville08874612014-08-31 19:19:58 -0700286 request = (MainThreadRequest) msg.obj;
Stuart Scott584921c2015-01-15 17:10:34 -0800287 int answer_subId = request.subId;
Wink Saville08874612014-08-31 19:19:58 -0700288 answerRingingCallInternal(answer_subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700289 break;
290
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700291 case CMD_END_CALL:
292 request = (MainThreadRequest) msg.obj;
Stuart Scott584921c2015-01-15 17:10:34 -0800293 int end_subId = request.subId;
Wink Saville08874612014-08-31 19:19:58 -0700294 final boolean hungUp;
Anthony Leeae4e36d2015-05-21 07:17:46 -0700295 Phone phone = getPhone(end_subId);
296 if (phone == null) {
297 if (DBG) log("CMD_END_CALL: no phone for id: " + end_subId);
298 break;
299 }
300 int phoneType = phone.getPhoneType();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700301 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
302 // CDMA: If the user presses the Power button we treat it as
303 // ending the complete call session
Wink Saville08874612014-08-31 19:19:58 -0700304 hungUp = PhoneUtils.hangupRingingAndActive(getPhone(end_subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700305 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
306 // GSM: End the call as per the Phone state
307 hungUp = PhoneUtils.hangup(mCM);
308 } else {
309 throw new IllegalStateException("Unexpected phone type: " + phoneType);
310 }
311 if (DBG) log("CMD_END_CALL: " + (hungUp ? "hung up!" : "no call to hang up"));
312 request.result = hungUp;
313 // Wake up the requesting thread
314 synchronized (request) {
315 request.notifyAll();
316 }
317 break;
318
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700319 case CMD_TRANSMIT_APDU_LOGICAL_CHANNEL:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700320 request = (MainThreadRequest) msg.obj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700321 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800322 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700323 if (uiccCard == null) {
324 loge("iccTransmitApduLogicalChannel: No UICC");
325 request.result = new IccIoResult(0x6F, 0, (byte[])null);
326 synchronized (request) {
327 request.notifyAll();
328 }
329 } else {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700330 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE,
331 request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700332 uiccCard.iccTransmitApduLogicalChannel(
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700333 iccArgument.channel, iccArgument.cla, iccArgument.command,
334 iccArgument.p1, iccArgument.p2, iccArgument.p3, iccArgument.data,
Shishir Agrawal566b7612013-10-28 14:41:00 -0700335 onCompleted);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700336 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700337 break;
338
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700339 case EVENT_TRANSMIT_APDU_LOGICAL_CHANNEL_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700340 ar = (AsyncResult) msg.obj;
341 request = (MainThreadRequest) ar.userObj;
342 if (ar.exception == null && ar.result != null) {
343 request.result = ar.result;
344 } else {
345 request.result = new IccIoResult(0x6F, 0, (byte[])null);
346 if (ar.result == null) {
347 loge("iccTransmitApduLogicalChannel: Empty response");
Jake Hambye994d462014-02-03 13:10:13 -0800348 } else if (ar.exception instanceof CommandException) {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700349 loge("iccTransmitApduLogicalChannel: CommandException: " +
Jake Hambye994d462014-02-03 13:10:13 -0800350 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700351 } else {
352 loge("iccTransmitApduLogicalChannel: Unknown exception");
353 }
354 }
355 synchronized (request) {
356 request.notifyAll();
357 }
358 break;
359
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700360 case CMD_TRANSMIT_APDU_BASIC_CHANNEL:
361 request = (MainThreadRequest) msg.obj;
362 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800363 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700364 if (uiccCard == null) {
365 loge("iccTransmitApduBasicChannel: No UICC");
366 request.result = new IccIoResult(0x6F, 0, (byte[])null);
367 synchronized (request) {
368 request.notifyAll();
369 }
370 } else {
371 onCompleted = obtainMessage(EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE,
372 request);
373 uiccCard.iccTransmitApduBasicChannel(
374 iccArgument.cla, iccArgument.command, iccArgument.p1, iccArgument.p2,
375 iccArgument.p3, iccArgument.data, onCompleted);
376 }
377 break;
378
379 case EVENT_TRANSMIT_APDU_BASIC_CHANNEL_DONE:
380 ar = (AsyncResult) msg.obj;
381 request = (MainThreadRequest) ar.userObj;
382 if (ar.exception == null && ar.result != null) {
383 request.result = ar.result;
384 } else {
385 request.result = new IccIoResult(0x6F, 0, (byte[])null);
386 if (ar.result == null) {
387 loge("iccTransmitApduBasicChannel: Empty response");
388 } else if (ar.exception instanceof CommandException) {
389 loge("iccTransmitApduBasicChannel: CommandException: " +
390 ar.exception);
391 } else {
392 loge("iccTransmitApduBasicChannel: Unknown exception");
393 }
394 }
395 synchronized (request) {
396 request.notifyAll();
397 }
398 break;
399
400 case CMD_EXCHANGE_SIM_IO:
401 request = (MainThreadRequest) msg.obj;
402 iccArgument = (IccAPDUArgument) request.argument;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800403 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700404 if (uiccCard == null) {
405 loge("iccExchangeSimIO: No UICC");
406 request.result = new IccIoResult(0x6F, 0, (byte[])null);
407 synchronized (request) {
408 request.notifyAll();
409 }
410 } else {
411 onCompleted = obtainMessage(EVENT_EXCHANGE_SIM_IO_DONE,
412 request);
413 uiccCard.iccExchangeSimIO(iccArgument.cla, /* fileID */
414 iccArgument.command, iccArgument.p1, iccArgument.p2, iccArgument.p3,
415 iccArgument.data, onCompleted);
416 }
417 break;
418
419 case EVENT_EXCHANGE_SIM_IO_DONE:
420 ar = (AsyncResult) msg.obj;
421 request = (MainThreadRequest) ar.userObj;
422 if (ar.exception == null && ar.result != null) {
423 request.result = ar.result;
424 } else {
425 request.result = new IccIoResult(0x6f, 0, (byte[])null);
426 }
427 synchronized (request) {
428 request.notifyAll();
429 }
430 break;
431
Derek Tan4d5e5c12014-02-04 11:54:58 -0800432 case CMD_SEND_ENVELOPE:
433 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800434 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700435 if (uiccCard == null) {
436 loge("sendEnvelopeWithStatus: No UICC");
437 request.result = new IccIoResult(0x6F, 0, (byte[])null);
438 synchronized (request) {
439 request.notifyAll();
440 }
441 } else {
442 onCompleted = obtainMessage(EVENT_SEND_ENVELOPE_DONE, request);
443 uiccCard.sendEnvelopeWithStatus((String)request.argument, onCompleted);
444 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800445 break;
446
447 case EVENT_SEND_ENVELOPE_DONE:
448 ar = (AsyncResult) msg.obj;
449 request = (MainThreadRequest) ar.userObj;
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700450 if (ar.exception == null && ar.result != null) {
451 request.result = ar.result;
Derek Tan4d5e5c12014-02-04 11:54:58 -0800452 } else {
Shishir Agrawal9f9877d2014-03-14 09:36:27 -0700453 request.result = new IccIoResult(0x6F, 0, (byte[])null);
454 if (ar.result == null) {
455 loge("sendEnvelopeWithStatus: Empty response");
456 } else if (ar.exception instanceof CommandException) {
457 loge("sendEnvelopeWithStatus: CommandException: " +
458 ar.exception);
459 } else {
460 loge("sendEnvelopeWithStatus: exception:" + ar.exception);
461 }
Derek Tan4d5e5c12014-02-04 11:54:58 -0800462 }
463 synchronized (request) {
464 request.notifyAll();
465 }
466 break;
467
Shishir Agrawal566b7612013-10-28 14:41:00 -0700468 case CMD_OPEN_CHANNEL:
469 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800470 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700471 if (uiccCard == null) {
472 loge("iccOpenLogicalChannel: No UICC");
Shishir Agrawalfc0492a2016-02-17 11:15:33 -0800473 request.result = new IccOpenLogicalChannelResponse(-1,
474 IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE, null);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700475 synchronized (request) {
476 request.notifyAll();
477 }
478 } else {
479 onCompleted = obtainMessage(EVENT_OPEN_CHANNEL_DONE, request);
480 uiccCard.iccOpenLogicalChannel((String)request.argument, onCompleted);
481 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700482 break;
483
484 case EVENT_OPEN_CHANNEL_DONE:
485 ar = (AsyncResult) msg.obj;
486 request = (MainThreadRequest) ar.userObj;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700487 IccOpenLogicalChannelResponse openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700488 if (ar.exception == null && ar.result != null) {
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700489 int[] result = (int[]) ar.result;
490 int channelId = result[0];
491 byte[] selectResponse = null;
492 if (result.length > 1) {
493 selectResponse = new byte[result.length - 1];
494 for (int i = 1; i < result.length; ++i) {
495 selectResponse[i - 1] = (byte) result[i];
496 }
497 }
498 openChannelResp = new IccOpenLogicalChannelResponse(channelId,
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700499 IccOpenLogicalChannelResponse.STATUS_NO_ERROR, selectResponse);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700500 } else {
Shishir Agrawal566b7612013-10-28 14:41:00 -0700501 if (ar.result == null) {
502 loge("iccOpenLogicalChannel: Empty response");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700503 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700504 if (ar.exception != null) {
505 loge("iccOpenLogicalChannel: Exception: " + ar.exception);
506 }
507
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700508 int errorCode = IccOpenLogicalChannelResponse.STATUS_UNKNOWN_ERROR;
Junda Liua754ba12015-05-20 01:17:52 -0700509 if (ar.exception instanceof CommandException) {
510 CommandException.Error error =
511 ((CommandException) (ar.exception)).getCommandError();
512 if (error == CommandException.Error.MISSING_RESOURCE) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700513 errorCode = IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
Junda Liua754ba12015-05-20 01:17:52 -0700514 } else if (error == CommandException.Error.NO_SUCH_ELEMENT) {
Shishir Agrawal527e8bf2014-08-25 08:54:56 -0700515 errorCode = IccOpenLogicalChannelResponse.STATUS_NO_SUCH_ELEMENT;
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -0700516 }
517 }
518 openChannelResp = new IccOpenLogicalChannelResponse(
519 IccOpenLogicalChannelResponse.INVALID_CHANNEL, errorCode, null);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700520 }
Shishir Agrawal82c8a462014-07-31 18:13:17 -0700521 request.result = openChannelResp;
Shishir Agrawal566b7612013-10-28 14:41:00 -0700522 synchronized (request) {
523 request.notifyAll();
524 }
525 break;
526
527 case CMD_CLOSE_CHANNEL:
528 request = (MainThreadRequest) msg.obj;
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800529 uiccCard = getUiccCardFromRequest(request);
Shishir Agrawaleb8771e2014-07-22 11:24:08 -0700530 if (uiccCard == null) {
531 loge("iccCloseLogicalChannel: No UICC");
532 request.result = new IccIoResult(0x6F, 0, (byte[])null);
533 synchronized (request) {
534 request.notifyAll();
535 }
536 } else {
537 onCompleted = obtainMessage(EVENT_CLOSE_CHANNEL_DONE, request);
538 uiccCard.iccCloseLogicalChannel((Integer) request.argument, onCompleted);
539 }
Shishir Agrawal566b7612013-10-28 14:41:00 -0700540 break;
541
542 case EVENT_CLOSE_CHANNEL_DONE:
Jake Hambye994d462014-02-03 13:10:13 -0800543 handleNullReturnEvent(msg, "iccCloseLogicalChannel");
544 break;
545
546 case CMD_NV_READ_ITEM:
547 request = (MainThreadRequest) msg.obj;
548 onCompleted = obtainMessage(EVENT_NV_READ_ITEM_DONE, request);
549 mPhone.nvReadItem((Integer) request.argument, onCompleted);
550 break;
551
552 case EVENT_NV_READ_ITEM_DONE:
Shishir Agrawal566b7612013-10-28 14:41:00 -0700553 ar = (AsyncResult) msg.obj;
554 request = (MainThreadRequest) ar.userObj;
Jake Hambye994d462014-02-03 13:10:13 -0800555 if (ar.exception == null && ar.result != null) {
556 request.result = ar.result; // String
Shishir Agrawal566b7612013-10-28 14:41:00 -0700557 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800558 request.result = "";
559 if (ar.result == null) {
560 loge("nvReadItem: Empty response");
561 } else if (ar.exception instanceof CommandException) {
562 loge("nvReadItem: CommandException: " +
563 ar.exception);
Shishir Agrawal566b7612013-10-28 14:41:00 -0700564 } else {
Jake Hambye994d462014-02-03 13:10:13 -0800565 loge("nvReadItem: Unknown exception");
Shishir Agrawal566b7612013-10-28 14:41:00 -0700566 }
567 }
568 synchronized (request) {
569 request.notifyAll();
570 }
571 break;
572
Jake Hambye994d462014-02-03 13:10:13 -0800573 case CMD_NV_WRITE_ITEM:
574 request = (MainThreadRequest) msg.obj;
575 onCompleted = obtainMessage(EVENT_NV_WRITE_ITEM_DONE, request);
576 Pair<Integer, String> idValue = (Pair<Integer, String>) request.argument;
577 mPhone.nvWriteItem(idValue.first, idValue.second, onCompleted);
578 break;
579
580 case EVENT_NV_WRITE_ITEM_DONE:
581 handleNullReturnEvent(msg, "nvWriteItem");
582 break;
583
584 case CMD_NV_WRITE_CDMA_PRL:
585 request = (MainThreadRequest) msg.obj;
586 onCompleted = obtainMessage(EVENT_NV_WRITE_CDMA_PRL_DONE, request);
587 mPhone.nvWriteCdmaPrl((byte[]) request.argument, onCompleted);
588 break;
589
590 case EVENT_NV_WRITE_CDMA_PRL_DONE:
591 handleNullReturnEvent(msg, "nvWriteCdmaPrl");
592 break;
593
594 case CMD_NV_RESET_CONFIG:
595 request = (MainThreadRequest) msg.obj;
596 onCompleted = obtainMessage(EVENT_NV_RESET_CONFIG_DONE, request);
597 mPhone.nvResetConfig((Integer) request.argument, onCompleted);
598 break;
599
600 case EVENT_NV_RESET_CONFIG_DONE:
601 handleNullReturnEvent(msg, "nvResetConfig");
602 break;
603
Jake Hamby7c27be32014-03-03 13:25:59 -0800604 case CMD_GET_PREFERRED_NETWORK_TYPE:
605 request = (MainThreadRequest) msg.obj;
606 onCompleted = obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE_DONE, request);
Stuart Scott54788802015-03-30 13:18:01 -0700607 getPhoneFromRequest(request).getPreferredNetworkType(onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800608 break;
609
610 case EVENT_GET_PREFERRED_NETWORK_TYPE_DONE:
611 ar = (AsyncResult) msg.obj;
612 request = (MainThreadRequest) ar.userObj;
613 if (ar.exception == null && ar.result != null) {
614 request.result = ar.result; // Integer
615 } else {
Sanket Padawecfc2d352016-01-05 19:52:14 -0800616 request.result = null;
Jake Hamby7c27be32014-03-03 13:25:59 -0800617 if (ar.result == null) {
618 loge("getPreferredNetworkType: Empty response");
619 } else if (ar.exception instanceof CommandException) {
620 loge("getPreferredNetworkType: CommandException: " +
621 ar.exception);
622 } else {
623 loge("getPreferredNetworkType: Unknown exception");
624 }
625 }
626 synchronized (request) {
627 request.notifyAll();
628 }
629 break;
630
631 case CMD_SET_PREFERRED_NETWORK_TYPE:
632 request = (MainThreadRequest) msg.obj;
633 onCompleted = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE_DONE, request);
634 int networkType = (Integer) request.argument;
Stuart Scott54788802015-03-30 13:18:01 -0700635 getPhoneFromRequest(request).setPreferredNetworkType(networkType, onCompleted);
Jake Hamby7c27be32014-03-03 13:25:59 -0800636 break;
637
638 case EVENT_SET_PREFERRED_NETWORK_TYPE_DONE:
639 handleNullReturnEvent(msg, "setPreferredNetworkType");
640 break;
641
Steven Liu4bf01bc2014-07-17 11:05:29 -0500642 case CMD_INVOKE_OEM_RIL_REQUEST_RAW:
643 request = (MainThreadRequest)msg.obj;
644 onCompleted = obtainMessage(EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE, request);
645 mPhone.invokeOemRilRequestRaw((byte[])request.argument, onCompleted);
646 break;
647
648 case EVENT_INVOKE_OEM_RIL_REQUEST_RAW_DONE:
649 ar = (AsyncResult)msg.obj;
650 request = (MainThreadRequest)ar.userObj;
651 request.result = ar;
652 synchronized (request) {
653 request.notifyAll();
654 }
655 break;
656
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800657 case CMD_SET_VOICEMAIL_NUMBER:
658 request = (MainThreadRequest) msg.obj;
659 onCompleted = obtainMessage(EVENT_SET_VOICEMAIL_NUMBER_DONE, request);
660 Pair<String, String> tagNum = (Pair<String, String>) request.argument;
Stuart Scott584921c2015-01-15 17:10:34 -0800661 getPhoneFromRequest(request).setVoiceMailNumber(tagNum.first, tagNum.second,
662 onCompleted);
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800663 break;
664
665 case EVENT_SET_VOICEMAIL_NUMBER_DONE:
666 handleNullReturnEvent(msg, "setVoicemailNumber");
667 break;
668
Stuart Scott54788802015-03-30 13:18:01 -0700669 case CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC:
670 request = (MainThreadRequest) msg.obj;
671 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE,
672 request);
673 getPhoneFromRequest(request).setNetworkSelectionModeAutomatic(onCompleted);
674 break;
675
676 case EVENT_SET_NETWORK_SELECTION_MODE_AUTOMATIC_DONE:
677 handleNullReturnEvent(msg, "setNetworkSelectionModeAutomatic");
678 break;
679
Shishir Agrawal302c8692015-06-19 13:49:39 -0700680 case CMD_PERFORM_NETWORK_SCAN:
681 request = (MainThreadRequest) msg.obj;
682 onCompleted = obtainMessage(EVENT_PERFORM_NETWORK_SCAN_DONE, request);
683 getPhoneFromRequest(request).getAvailableNetworks(onCompleted);
684 break;
685
686 case EVENT_PERFORM_NETWORK_SCAN_DONE:
687 ar = (AsyncResult) msg.obj;
688 request = (MainThreadRequest) ar.userObj;
689 CellNetworkScanResult cellScanResult;
690 if (ar.exception == null && ar.result != null) {
691 cellScanResult = new CellNetworkScanResult(
692 CellNetworkScanResult.STATUS_SUCCESS,
693 (List<OperatorInfo>) ar.result);
694 } else {
695 if (ar.result == null) {
696 loge("getCellNetworkScanResults: Empty response");
697 }
698 if (ar.exception != null) {
699 loge("getCellNetworkScanResults: Exception: " + ar.exception);
700 }
701 int errorCode = CellNetworkScanResult.STATUS_UNKNOWN_ERROR;
702 if (ar.exception instanceof CommandException) {
703 CommandException.Error error =
704 ((CommandException) (ar.exception)).getCommandError();
705 if (error == CommandException.Error.RADIO_NOT_AVAILABLE) {
706 errorCode = CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE;
707 } else if (error == CommandException.Error.GENERIC_FAILURE) {
708 errorCode = CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE;
709 }
710 }
711 cellScanResult = new CellNetworkScanResult(errorCode, null);
712 }
713 request.result = cellScanResult;
714 synchronized (request) {
715 request.notifyAll();
716 }
717 break;
718
719 case CMD_SET_NETWORK_SELECTION_MODE_MANUAL:
720 request = (MainThreadRequest) msg.obj;
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700721 ManualNetworkSelectionArgument selArg =
722 (ManualNetworkSelectionArgument) request.argument;
Shishir Agrawal302c8692015-06-19 13:49:39 -0700723 onCompleted = obtainMessage(EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE,
724 request);
Shishir Agrawal77ba3172015-09-10 14:50:19 -0700725 getPhoneFromRequest(request).selectNetworkManually(selArg.operatorInfo,
726 selArg.persistSelection, onCompleted);
Shishir Agrawal302c8692015-06-19 13:49:39 -0700727 break;
728
729 case EVENT_SET_NETWORK_SELECTION_MODE_MANUAL_DONE:
730 handleNullReturnEvent(msg, "setNetworkSelectionModeManual");
731 break;
732
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700733 case CMD_GET_MODEM_ACTIVITY_INFO:
734 request = (MainThreadRequest) msg.obj;
735 onCompleted = obtainMessage(EVENT_GET_MODEM_ACTIVITY_INFO_DONE, request);
Prerepa Viswanadham61a60ad2015-06-08 18:07:51 -0700736 mPhone.getModemActivityInfo(onCompleted);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700737 break;
738
739 case EVENT_GET_MODEM_ACTIVITY_INFO_DONE:
740 ar = (AsyncResult) msg.obj;
741 request = (MainThreadRequest) ar.userObj;
742 if (ar.exception == null && ar.result != null) {
743 request.result = ar.result;
744 } else {
745 if (ar.result == null) {
746 loge("queryModemActivityInfo: Empty response");
747 } else if (ar.exception instanceof CommandException) {
748 loge("queryModemActivityInfo: CommandException: " +
749 ar.exception);
750 } else {
751 loge("queryModemActivityInfo: Unknown exception");
752 }
753 }
Amit Mahajand4766222016-01-28 15:28:28 -0800754 // Result cannot be null. Return ModemActivityInfo with all fields set to 0.
755 if (request.result == null) {
756 request.result = new ModemActivityInfo(0, 0, 0, null, 0, 0);
757 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -0700758 synchronized (request) {
759 request.notifyAll();
760 }
761 break;
762
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700763 default:
764 Log.w(LOG_TAG, "MainThreadHandler: unexpected message code: " + msg.what);
765 break;
766 }
767 }
Jake Hambye994d462014-02-03 13:10:13 -0800768
769 private void handleNullReturnEvent(Message msg, String command) {
770 AsyncResult ar = (AsyncResult) msg.obj;
771 MainThreadRequest request = (MainThreadRequest) ar.userObj;
772 if (ar.exception == null) {
773 request.result = true;
774 } else {
775 request.result = false;
776 if (ar.exception instanceof CommandException) {
777 loge(command + ": CommandException: " + ar.exception);
778 } else {
779 loge(command + ": Unknown exception");
780 }
781 }
782 synchronized (request) {
783 request.notifyAll();
784 }
785 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700786 }
787
788 /**
789 * Posts the specified command to be executed on the main thread,
790 * waits for the request to complete, and returns the result.
791 * @see #sendRequestAsync
792 */
793 private Object sendRequest(int command, Object argument) {
Sanket Padawe56e75a32016-02-08 12:18:19 -0800794 return sendRequest(command, argument, SubscriptionManager.INVALID_SUBSCRIPTION_ID);
Wink Saville36469e72014-06-11 15:17:00 -0700795 }
796
797 /**
798 * Posts the specified command to be executed on the main thread,
799 * waits for the request to complete, and returns the result.
800 * @see #sendRequestAsync
801 */
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800802 private Object sendRequest(int command, Object argument, Integer subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700803 if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
804 throw new RuntimeException("This method will deadlock if called from the main thread.");
805 }
806
Shishir Agrawal76d5da92014-11-09 16:17:25 -0800807 MainThreadRequest request = new MainThreadRequest(argument, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700808 Message msg = mMainThreadHandler.obtainMessage(command, request);
809 msg.sendToTarget();
810
811 // Wait for the request to complete
812 synchronized (request) {
813 while (request.result == null) {
814 try {
815 request.wait();
816 } catch (InterruptedException e) {
817 // Do nothing, go back and wait until the request is complete
818 }
819 }
820 }
821 return request.result;
822 }
823
824 /**
825 * Asynchronous ("fire and forget") version of sendRequest():
826 * Posts the specified command to be executed on the main thread, and
827 * returns immediately.
828 * @see #sendRequest
829 */
830 private void sendRequestAsync(int command) {
831 mMainThreadHandler.sendEmptyMessage(command);
832 }
833
834 /**
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -0700835 * Same as {@link #sendRequestAsync(int)} except it takes an argument.
836 * @see {@link #sendRequest(int,Object)}
837 */
838 private void sendRequestAsync(int command, Object argument) {
839 MainThreadRequest request = new MainThreadRequest(argument);
840 Message msg = mMainThreadHandler.obtainMessage(command, request);
841 msg.sendToTarget();
842 }
843
844 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700845 * Initialize the singleton PhoneInterfaceManager instance.
846 * This is only done once, at startup, from PhoneApp.onCreate().
847 */
Sailesh Nepal194161e2014-07-03 08:57:44 -0700848 /* package */ static PhoneInterfaceManager init(PhoneGlobals app, Phone phone) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700849 synchronized (PhoneInterfaceManager.class) {
850 if (sInstance == null) {
Sailesh Nepal194161e2014-07-03 08:57:44 -0700851 sInstance = new PhoneInterfaceManager(app, phone);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700852 } else {
853 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
854 }
855 return sInstance;
856 }
857 }
858
859 /** Private constructor; @see init() */
Sailesh Nepal194161e2014-07-03 08:57:44 -0700860 private PhoneInterfaceManager(PhoneGlobals app, Phone phone) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700861 mApp = app;
862 mPhone = phone;
863 mCM = PhoneGlobals.getInstance().mCM;
Stuart Scott981d8582015-04-21 14:09:50 -0700864 mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700865 mAppOps = (AppOpsManager)app.getSystemService(Context.APP_OPS_SERVICE);
866 mMainThreadHandler = new MainThreadHandler();
Andrew Leedf14ead2014-10-17 14:22:52 -0700867 mTelephonySharedPreferences =
Derek Tan97ebb422014-09-05 16:55:38 -0700868 PreferenceManager.getDefaultSharedPreferences(mPhone.getContext());
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800869 mSubscriptionController = SubscriptionController.getInstance();
Wink Saville3ab207e2014-11-20 13:07:20 -0800870
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700871 publish();
872 }
873
874 private void publish() {
875 if (DBG) log("publish: " + this);
876
877 ServiceManager.addService("phone", this);
878 }
879
Stuart Scott584921c2015-01-15 17:10:34 -0800880 private Phone getPhoneFromRequest(MainThreadRequest request) {
Sanket Padawe56e75a32016-02-08 12:18:19 -0800881 return (request.subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID)
882 ? mPhone : getPhone(request.subId);
Stuart Scott584921c2015-01-15 17:10:34 -0800883 }
884
Shishir Agrawalc04d9752016-02-19 10:41:00 -0800885 private UiccCard getUiccCardFromRequest(MainThreadRequest request) {
886 Phone phone = getPhoneFromRequest(request);
887 return phone == null ? null :
888 UiccController.getInstance().getUiccCard(phone.getPhoneId());
889 }
890
Wink Saville36469e72014-06-11 15:17:00 -0700891 // returns phone associated with the subId.
Wink Savilleb564aae2014-10-23 10:18:09 -0700892 private Phone getPhone(int subId) {
Wink Savilleac1bdfd2014-11-20 23:04:44 -0800893 return PhoneFactory.getPhone(mSubscriptionController.getPhoneId(subId));
Wink Saville36469e72014-06-11 15:17:00 -0700894 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700895 //
896 // Implementation of the ITelephony interface.
897 //
898
899 public void dial(String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -0700900 dialForSubscriber(getPreferredVoiceSubscription(), number);
Wink Saville36469e72014-06-11 15:17:00 -0700901 }
902
Wink Savilleb564aae2014-10-23 10:18:09 -0700903 public void dialForSubscriber(int subId, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700904 if (DBG) log("dial: " + number);
905 // No permission check needed here: This is just a wrapper around the
906 // ACTION_DIAL intent, which is available to any app since it puts up
907 // the UI before it does anything.
908
909 String url = createTelUrl(number);
910 if (url == null) {
911 return;
912 }
913
914 // PENDING: should we just silently fail if phone is offhook or ringing?
Wink Saville36469e72014-06-11 15:17:00 -0700915 PhoneConstants.State state = mCM.getState(subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700916 if (state != PhoneConstants.State.OFFHOOK && state != PhoneConstants.State.RINGING) {
917 Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(url));
918 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
919 mApp.startActivity(intent);
920 }
921 }
922
923 public void call(String callingPackage, String number) {
Wink Savilleadd7cc52014-09-08 14:23:09 -0700924 callForSubscriber(getPreferredVoiceSubscription(), callingPackage, number);
Wink Saville36469e72014-06-11 15:17:00 -0700925 }
926
Wink Savilleb564aae2014-10-23 10:18:09 -0700927 public void callForSubscriber(int subId, String callingPackage, String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700928 if (DBG) log("call: " + number);
929
930 // This is just a wrapper around the ACTION_CALL intent, but we still
931 // need to do a permission check since we're calling startActivity()
932 // from the context of the phone app.
933 enforceCallPermission();
934
935 if (mAppOps.noteOp(AppOpsManager.OP_CALL_PHONE, Binder.getCallingUid(), callingPackage)
936 != AppOpsManager.MODE_ALLOWED) {
937 return;
938 }
939
940 String url = createTelUrl(number);
941 if (url == null) {
942 return;
943 }
944
Wink Saville08874612014-08-31 19:19:58 -0700945 boolean isValid = false;
Narayan Kamath1c496c22015-04-16 14:40:19 +0100946 final List<SubscriptionInfo> slist = getActiveSubscriptionInfoList();
Wink Saville3ab207e2014-11-20 13:07:20 -0800947 if (slist != null) {
948 for (SubscriptionInfo subInfoRecord : slist) {
949 if (subInfoRecord.getSubscriptionId() == subId) {
950 isValid = true;
951 break;
952 }
Wink Saville08874612014-08-31 19:19:58 -0700953 }
954 }
955 if (isValid == false) {
956 return;
957 }
958
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700959 Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(url));
Wink Saville36469e72014-06-11 15:17:00 -0700960 intent.putExtra(SUBSCRIPTION_KEY, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700961 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
962 mApp.startActivity(intent);
963 }
964
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700965 /**
966 * End a call based on call state
967 * @return true is a call was ended
968 */
969 public boolean endCall() {
Wink Savilleadd7cc52014-09-08 14:23:09 -0700970 return endCallForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -0700971 }
972
973 /**
974 * End a call based on the call state of the subId
975 * @return true is a call was ended
976 */
Wink Savilleb564aae2014-10-23 10:18:09 -0700977 public boolean endCallForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700978 enforceCallPermission();
Stuart Scott584921c2015-01-15 17:10:34 -0800979 return (Boolean) sendRequest(CMD_END_CALL, null, new Integer(subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700980 }
981
982 public void answerRingingCall() {
Wink Savilleadd7cc52014-09-08 14:23:09 -0700983 answerRingingCallForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -0700984 }
985
Wink Savilleb564aae2014-10-23 10:18:09 -0700986 public void answerRingingCallForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700987 if (DBG) log("answerRingingCall...");
988 // TODO: there should eventually be a separate "ANSWER_PHONE" permission,
989 // but that can probably wait till the big TelephonyManager API overhaul.
990 // For now, protect this call with the MODIFY_PHONE_STATE permission.
991 enforceModifyPermission();
Stuart Scott584921c2015-01-15 17:10:34 -0800992 sendRequest(CMD_ANSWER_RINGING_CALL, null, new Integer(subId));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700993 }
994
995 /**
996 * Make the actual telephony calls to implement answerRingingCall().
997 * This should only be called from the main thread of the Phone app.
998 * @see #answerRingingCall
999 *
1000 * TODO: it would be nice to return true if we answered the call, or
1001 * false if there wasn't actually a ringing incoming call, or some
1002 * other error occurred. (In other words, pass back the return value
1003 * from PhoneUtils.answerCall() or PhoneUtils.answerAndEndActive().)
1004 * But that would require calling this method via sendRequest() rather
1005 * than sendRequestAsync(), and right now we don't actually *need* that
1006 * return value, so let's just return void for now.
1007 */
Wink Savilleb564aae2014-10-23 10:18:09 -07001008 private void answerRingingCallInternal(int subId) {
Wink Saville08874612014-08-31 19:19:58 -07001009 final boolean hasRingingCall = !getPhone(subId).getRingingCall().isIdle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001010 if (hasRingingCall) {
Wink Saville08874612014-08-31 19:19:58 -07001011 final boolean hasActiveCall = !getPhone(subId).getForegroundCall().isIdle();
1012 final boolean hasHoldingCall = !getPhone(subId).getBackgroundCall().isIdle();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001013 if (hasActiveCall && hasHoldingCall) {
1014 // Both lines are in use!
1015 // TODO: provide a flag to let the caller specify what
1016 // policy to use if both lines are in use. (The current
1017 // behavior is hardwired to "answer incoming, end ongoing",
1018 // which is how the CALL button is specced to behave.)
1019 PhoneUtils.answerAndEndActive(mCM, mCM.getFirstActiveRingingCall());
1020 return;
1021 } else {
1022 // answerCall() will automatically hold the current active
1023 // call, if there is one.
1024 PhoneUtils.answerCall(mCM.getFirstActiveRingingCall());
1025 return;
1026 }
1027 } else {
1028 // No call was ringing.
1029 return;
1030 }
1031 }
1032
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001033 /**
Santos Cordon5422a8d2014-09-12 04:20:56 -07001034 * This method is no longer used and can be removed once TelephonyManager stops referring to it.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001035 */
Santos Cordon5422a8d2014-09-12 04:20:56 -07001036 public void silenceRinger() {
1037 Log.e(LOG_TAG, "silenseRinger not supported");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001038 }
1039
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001040 @Override
1041 public boolean isOffhook(String callingPackage) {
1042 return isOffhookForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001043 }
1044
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001045 @Override
1046 public boolean isOffhookForSubscriber(int subId, String callingPackage) {
1047 if (!canReadPhoneState(callingPackage, "isOffhookForSubscriber")) {
1048 return false;
1049 }
1050
Sanket Padawe356d7632015-06-22 14:03:32 -07001051 final Phone phone = getPhone(subId);
1052 if (phone != null) {
1053 return (phone.getState() == PhoneConstants.State.OFFHOOK);
1054 } else {
1055 return false;
1056 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001057 }
1058
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001059 @Override
1060 public boolean isRinging(String callingPackage) {
1061 return (isRingingForSubscriber(getDefaultSubscription(), callingPackage));
Wink Saville36469e72014-06-11 15:17:00 -07001062 }
1063
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001064 @Override
1065 public boolean isRingingForSubscriber(int subId, String callingPackage) {
1066 if (!canReadPhoneState(callingPackage, "isRingingForSubscriber")) {
1067 return false;
1068 }
1069
Sanket Padawe356d7632015-06-22 14:03:32 -07001070 final Phone phone = getPhone(subId);
1071 if (phone != null) {
1072 return (phone.getState() == PhoneConstants.State.RINGING);
1073 } else {
1074 return false;
1075 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001076 }
1077
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001078 @Override
1079 public boolean isIdle(String callingPackage) {
1080 return isIdleForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001081 }
1082
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001083 @Override
1084 public boolean isIdleForSubscriber(int subId, String callingPackage) {
1085 if (!canReadPhoneState(callingPackage, "isIdleForSubscriber")) {
1086 return false;
1087 }
1088
Sanket Padawe356d7632015-06-22 14:03:32 -07001089 final Phone phone = getPhone(subId);
1090 if (phone != null) {
1091 return (phone.getState() == PhoneConstants.State.IDLE);
1092 } else {
1093 return false;
1094 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001095 }
1096
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001097 public boolean supplyPin(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001098 return supplyPinForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001099 }
1100
Wink Savilleb564aae2014-10-23 10:18:09 -07001101 public boolean supplyPinForSubscriber(int subId, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001102 int [] resultArray = supplyPinReportResultForSubscriber(subId, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001103 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1104 }
1105
1106 public boolean supplyPuk(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001107 return supplyPukForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001108 }
1109
Wink Savilleb564aae2014-10-23 10:18:09 -07001110 public boolean supplyPukForSubscriber(int subId, String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001111 int [] resultArray = supplyPukReportResultForSubscriber(subId, puk, pin);
Wink Saville9de0f752013-10-22 19:04:03 -07001112 return (resultArray[0] == PhoneConstants.PIN_RESULT_SUCCESS) ? true : false;
1113 }
1114
1115 /** {@hide} */
1116 public int[] supplyPinReportResult(String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001117 return supplyPinReportResultForSubscriber(getDefaultSubscription(), pin);
Wink Saville36469e72014-06-11 15:17:00 -07001118 }
1119
Wink Savilleb564aae2014-10-23 10:18:09 -07001120 public int[] supplyPinReportResultForSubscriber(int subId, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001121 enforceModifyPermission();
Wink Saville36469e72014-06-11 15:17:00 -07001122 final UnlockSim checkSimPin = new UnlockSim(getPhone(subId).getIccCard());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001123 checkSimPin.start();
1124 return checkSimPin.unlockSim(null, pin);
1125 }
1126
Wink Saville9de0f752013-10-22 19:04:03 -07001127 /** {@hide} */
1128 public int[] supplyPukReportResult(String puk, String pin) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001129 return supplyPukReportResultForSubscriber(getDefaultSubscription(), puk, pin);
Wink Saville36469e72014-06-11 15:17:00 -07001130 }
1131
Wink Savilleb564aae2014-10-23 10:18:09 -07001132 public int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001133 enforceModifyPermission();
Wink Saville36469e72014-06-11 15:17:00 -07001134 final UnlockSim checkSimPuk = new UnlockSim(getPhone(subId).getIccCard());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001135 checkSimPuk.start();
1136 return checkSimPuk.unlockSim(puk, pin);
1137 }
1138
1139 /**
Wink Saville9de0f752013-10-22 19:04:03 -07001140 * Helper thread to turn async call to SimCard#supplyPin into
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001141 * a synchronous one.
1142 */
1143 private static class UnlockSim extends Thread {
1144
1145 private final IccCard mSimCard;
1146
1147 private boolean mDone = false;
Wink Saville9de0f752013-10-22 19:04:03 -07001148 private int mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1149 private int mRetryCount = -1;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001150
1151 // For replies from SimCard interface
1152 private Handler mHandler;
1153
1154 // For async handler to identify request type
1155 private static final int SUPPLY_PIN_COMPLETE = 100;
1156
1157 public UnlockSim(IccCard simCard) {
1158 mSimCard = simCard;
1159 }
1160
1161 @Override
1162 public void run() {
1163 Looper.prepare();
1164 synchronized (UnlockSim.this) {
1165 mHandler = new Handler() {
1166 @Override
1167 public void handleMessage(Message msg) {
1168 AsyncResult ar = (AsyncResult) msg.obj;
1169 switch (msg.what) {
1170 case SUPPLY_PIN_COMPLETE:
1171 Log.d(LOG_TAG, "SUPPLY_PIN_COMPLETE");
1172 synchronized (UnlockSim.this) {
Wink Saville9de0f752013-10-22 19:04:03 -07001173 mRetryCount = msg.arg1;
1174 if (ar.exception != null) {
1175 if (ar.exception instanceof CommandException &&
1176 ((CommandException)(ar.exception)).getCommandError()
1177 == CommandException.Error.PASSWORD_INCORRECT) {
1178 mResult = PhoneConstants.PIN_PASSWORD_INCORRECT;
1179 } else {
1180 mResult = PhoneConstants.PIN_GENERAL_FAILURE;
1181 }
1182 } else {
1183 mResult = PhoneConstants.PIN_RESULT_SUCCESS;
1184 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001185 mDone = true;
1186 UnlockSim.this.notifyAll();
1187 }
1188 break;
1189 }
1190 }
1191 };
1192 UnlockSim.this.notifyAll();
1193 }
1194 Looper.loop();
1195 }
1196
1197 /*
1198 * Use PIN or PUK to unlock SIM card
1199 *
1200 * If PUK is null, unlock SIM card with PIN
1201 *
1202 * If PUK is not null, unlock SIM card with PUK and set PIN code
1203 */
Wink Saville9de0f752013-10-22 19:04:03 -07001204 synchronized int[] unlockSim(String puk, String pin) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001205
1206 while (mHandler == null) {
1207 try {
1208 wait();
1209 } catch (InterruptedException e) {
1210 Thread.currentThread().interrupt();
1211 }
1212 }
1213 Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
1214
1215 if (puk == null) {
1216 mSimCard.supplyPin(pin, callback);
1217 } else {
1218 mSimCard.supplyPuk(puk, pin, callback);
1219 }
1220
1221 while (!mDone) {
1222 try {
1223 Log.d(LOG_TAG, "wait for done");
1224 wait();
1225 } catch (InterruptedException e) {
1226 // Restore the interrupted status
1227 Thread.currentThread().interrupt();
1228 }
1229 }
1230 Log.d(LOG_TAG, "done");
Wink Saville9de0f752013-10-22 19:04:03 -07001231 int[] resultArray = new int[2];
1232 resultArray[0] = mResult;
1233 resultArray[1] = mRetryCount;
1234 return resultArray;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001235 }
1236 }
1237
1238 public void updateServiceLocation() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001239 updateServiceLocationForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001240
1241 }
1242
Wink Savilleb564aae2014-10-23 10:18:09 -07001243 public void updateServiceLocationForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001244 // No permission check needed here: this call is harmless, and it's
1245 // needed for the ServiceState.requestStateUpdate() call (which is
1246 // already intentionally exposed to 3rd parties.)
Sanket Padawe356d7632015-06-22 14:03:32 -07001247 final Phone phone = getPhone(subId);
1248 if (phone != null) {
1249 phone.updateServiceLocation();
1250 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001251 }
1252
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001253 @Override
1254 public boolean isRadioOn(String callingPackage) {
1255 return isRadioOnForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001256 }
1257
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001258 @Override
1259 public boolean isRadioOnForSubscriber(int subId, String callingPackage) {
1260 if (!canReadPhoneState(callingPackage, "isRadioOnForSubscriber")) {
1261 return false;
1262 }
1263 return isRadioOnForSubscriber(subId);
1264 }
1265
1266 private boolean isRadioOnForSubscriber(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07001267 final Phone phone = getPhone(subId);
1268 if (phone != null) {
1269 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF;
1270 } else {
1271 return false;
1272 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001273 }
1274
1275 public void toggleRadioOnOff() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001276 toggleRadioOnOffForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001277
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001278 }
Wink Saville36469e72014-06-11 15:17:00 -07001279
Wink Savilleb564aae2014-10-23 10:18:09 -07001280 public void toggleRadioOnOffForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001281 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001282 final Phone phone = getPhone(subId);
1283 if (phone != null) {
1284 phone.setRadioPower(!isRadioOnForSubscriber(subId));
1285 }
Wink Saville36469e72014-06-11 15:17:00 -07001286 }
1287
1288 public boolean setRadio(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001289 return setRadioForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001290 }
1291
Wink Savilleb564aae2014-10-23 10:18:09 -07001292 public boolean setRadioForSubscriber(int subId, boolean turnOn) {
Wink Saville36469e72014-06-11 15:17:00 -07001293 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001294 final Phone phone = getPhone(subId);
1295 if (phone == null) {
1296 return false;
1297 }
1298 if ((phone.getServiceState().getState() !=
Wink Saville36469e72014-06-11 15:17:00 -07001299 ServiceState.STATE_POWER_OFF) != turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001300 toggleRadioOnOffForSubscriber(subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001301 }
1302 return true;
1303 }
Wink Saville36469e72014-06-11 15:17:00 -07001304
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001305 public boolean needMobileRadioShutdown() {
1306 /*
1307 * If any of the Radios are available, it will need to be
1308 * shutdown. So return true if any Radio is available.
1309 */
1310 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1311 Phone phone = PhoneFactory.getPhone(i);
1312 if (phone != null && phone.isRadioAvailable()) return true;
1313 }
1314 logv(TelephonyManager.getDefault().getPhoneCount() + " Phones are shutdown.");
1315 return false;
1316 }
1317
1318 public void shutdownMobileRadios() {
1319 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
1320 logv("Shutting down Phone " + i);
1321 shutdownRadioUsingPhoneId(i);
1322 }
1323 }
1324
1325 private void shutdownRadioUsingPhoneId(int phoneId) {
1326 enforceModifyPermission();
1327 Phone phone = PhoneFactory.getPhone(phoneId);
1328 if (phone != null && phone.isRadioAvailable()) {
1329 phone.shutdownRadio();
1330 }
1331 }
1332
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001333 public boolean setRadioPower(boolean turnOn) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001334 return setRadioPowerForSubscriber(getDefaultSubscription(), turnOn);
Wink Saville36469e72014-06-11 15:17:00 -07001335 }
1336
Wink Savilleb564aae2014-10-23 10:18:09 -07001337 public boolean setRadioPowerForSubscriber(int subId, boolean turnOn) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001338 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001339 final Phone phone = getPhone(subId);
1340 if (phone != null) {
1341 phone.setRadioPower(turnOn);
1342 return true;
1343 } else {
1344 return false;
1345 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001346 }
1347
Wink Saville36469e72014-06-11 15:17:00 -07001348 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001349 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001350 public boolean enableDataConnectivity() {
1351 enforceModifyPermission();
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001352 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001353 final Phone phone = getPhone(subId);
1354 if (phone != null) {
1355 phone.setDataEnabled(true);
1356 return true;
1357 } else {
1358 return false;
1359 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001360 }
1361
Wink Saville36469e72014-06-11 15:17:00 -07001362 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001363 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001364 public boolean disableDataConnectivity() {
1365 enforceModifyPermission();
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001366 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001367 final Phone phone = getPhone(subId);
1368 if (phone != null) {
1369 phone.setDataEnabled(false);
1370 return true;
1371 } else {
1372 return false;
1373 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001374 }
1375
Wink Saville36469e72014-06-11 15:17:00 -07001376 // FIXME: subId version needed
Sanket Padawe356d7632015-06-22 14:03:32 -07001377 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001378 public boolean isDataConnectivityPossible() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001379 int subId = mSubscriptionController.getDefaultDataSubId();
Sanket Padawe356d7632015-06-22 14:03:32 -07001380 final Phone phone = getPhone(subId);
1381 if (phone != null) {
1382 return phone.isDataConnectivityPossible();
1383 } else {
1384 return false;
1385 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001386 }
1387
1388 public boolean handlePinMmi(String dialString) {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001389 return handlePinMmiForSubscriber(getDefaultSubscription(), dialString);
Wink Saville36469e72014-06-11 15:17:00 -07001390 }
1391
Wink Savilleb564aae2014-10-23 10:18:09 -07001392 public boolean handlePinMmiForSubscriber(int subId, String dialString) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001393 enforceModifyPermission();
Sanket Padawe356d7632015-06-22 14:03:32 -07001394 if (!SubscriptionManager.isValidSubscriptionId(subId)) {
1395 return false;
1396 }
Wink Saville36469e72014-06-11 15:17:00 -07001397 return (Boolean) sendRequest(CMD_HANDLE_PIN_MMI, dialString, subId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001398 }
1399
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001400 public int getCallState() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001401 return getCallStateForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001402 }
1403
Shishir Agrawala9f32182016-04-12 12:00:16 -07001404 public int getCallStateForSlot(int slotId) {
1405 Phone phone = PhoneFactory.getPhone(slotId);
1406 return phone == null ? TelephonyManager.CALL_STATE_IDLE :
1407 DefaultPhoneNotifier.convertCallState(phone.getState());
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001408 }
1409
Sanket Padawe356d7632015-06-22 14:03:32 -07001410 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001411 public int getDataState() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001412 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001413 if (phone != null) {
1414 return DefaultPhoneNotifier.convertDataState(phone.getDataConnectionState());
1415 } else {
1416 return DefaultPhoneNotifier.convertDataState(PhoneConstants.DataState.DISCONNECTED);
1417 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001418 }
1419
Sanket Padawe356d7632015-06-22 14:03:32 -07001420 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001421 public int getDataActivity() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001422 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001423 if (phone != null) {
1424 return DefaultPhoneNotifier.convertDataActivityState(phone.getDataActivityState());
1425 } else {
1426 return TelephonyManager.DATA_ACTIVITY_NONE;
1427 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001428 }
1429
1430 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001431 public Bundle getCellLocation(String callingPackage) {
1432 enforceFineOrCoarseLocationPermission("getCellLocation");
1433
1434 // OP_COARSE_LOCATION controls both fine and coarse location.
1435 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1436 callingPackage) != AppOpsManager.MODE_ALLOWED) {
Amit Mahajan9acc70d2015-06-02 13:17:33 -07001437 log("getCellLocation: returning null; mode != allowed");
Svetoslav64fad262015-04-14 14:35:21 -07001438 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001439 }
1440
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001441 if (checkIfCallerIsSelfOrForegroundUser() ||
1442 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001443 if (DBG_LOC) log("getCellLocation: is active user");
1444 Bundle data = new Bundle();
Legler Wu2c01cdf2014-12-08 19:00:59 +08001445 Phone phone = getPhone(mSubscriptionController.getDefaultDataSubId());
Sanket Padawe356d7632015-06-22 14:03:32 -07001446 if (phone == null) {
1447 return null;
1448 }
Legler Wu2c01cdf2014-12-08 19:00:59 +08001449 phone.getCellLocation().fillInNotifierBundle(data);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001450 return data;
1451 } else {
Amit Mahajan9acc70d2015-06-02 13:17:33 -07001452 log("getCellLocation: suppress non-active user");
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001453 return null;
1454 }
1455 }
1456
Svetoslav64fad262015-04-14 14:35:21 -07001457 private void enforceFineOrCoarseLocationPermission(String message) {
1458 try {
1459 mApp.enforceCallingOrSelfPermission(
1460 android.Manifest.permission.ACCESS_FINE_LOCATION, null);
1461 } catch (SecurityException e) {
1462 // If we have ACCESS_FINE_LOCATION permission, skip the check for ACCESS_COARSE_LOCATION
1463 // A failure should throw the SecurityException from ACCESS_COARSE_LOCATION since this
1464 // is the weaker precondition
1465 mApp.enforceCallingOrSelfPermission(
1466 android.Manifest.permission.ACCESS_COARSE_LOCATION, message);
1467 }
1468 }
1469
1470
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001471 @Override
1472 public void enableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001473 enableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001474 }
1475
Sanket Padawe356d7632015-06-22 14:03:32 -07001476 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001477 public void enableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001478 mApp.enforceCallingOrSelfPermission(
1479 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Sanket Padawe356d7632015-06-22 14:03:32 -07001480 final Phone phone = getPhone(subId);
1481 if (phone != null) {
1482 phone.enableLocationUpdates();
1483 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001484 }
1485
1486 @Override
1487 public void disableLocationUpdates() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001488 disableLocationUpdatesForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001489 }
1490
Sanket Padawe356d7632015-06-22 14:03:32 -07001491 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001492 public void disableLocationUpdatesForSubscriber(int subId) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001493 mApp.enforceCallingOrSelfPermission(
1494 android.Manifest.permission.CONTROL_LOCATION_UPDATES, null);
Sanket Padawe356d7632015-06-22 14:03:32 -07001495 final Phone phone = getPhone(subId);
1496 if (phone != null) {
1497 phone.disableLocationUpdates();
1498 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001499 }
1500
1501 @Override
1502 @SuppressWarnings("unchecked")
1503 public List<NeighboringCellInfo> getNeighboringCellInfo(String callingPackage) {
Svetoslav64fad262015-04-14 14:35:21 -07001504 enforceFineOrCoarseLocationPermission("getNeighboringCellInfo");
1505
1506 // OP_COARSE_LOCATION controls both fine and coarse location.
1507 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1508 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1509 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001510 }
1511
1512 if (mAppOps.noteOp(AppOpsManager.OP_NEIGHBORING_CELLS, Binder.getCallingUid(),
1513 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1514 return null;
1515 }
Svetoslav64fad262015-04-14 14:35:21 -07001516
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001517 if (checkIfCallerIsSelfOrForegroundUser() ||
1518 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001519 if (DBG_LOC) log("getNeighboringCellInfo: is active user");
1520
1521 ArrayList<NeighboringCellInfo> cells = null;
1522
1523 try {
1524 cells = (ArrayList<NeighboringCellInfo>) sendRequest(
Sanket Padawe56e75a32016-02-08 12:18:19 -08001525 CMD_HANDLE_NEIGHBORING_CELL, null,
1526 SubscriptionManager.INVALID_SUBSCRIPTION_ID);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001527 } catch (RuntimeException e) {
Wink Saville36469e72014-06-11 15:17:00 -07001528 Log.e(LOG_TAG, "getNeighboringCellInfo " + e);
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001529 }
1530 return cells;
1531 } else {
1532 if (DBG_LOC) log("getNeighboringCellInfo: suppress non-active user");
1533 return null;
1534 }
1535 }
1536
1537
1538 @Override
Svetoslav64fad262015-04-14 14:35:21 -07001539 public List<CellInfo> getAllCellInfo(String callingPackage) {
1540 enforceFineOrCoarseLocationPermission("getAllCellInfo");
1541
1542 // OP_COARSE_LOCATION controls both fine and coarse location.
1543 if (mAppOps.noteOp(AppOpsManager.OP_COARSE_LOCATION, Binder.getCallingUid(),
1544 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1545 return null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001546 }
1547
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001548 if (checkIfCallerIsSelfOrForegroundUser() ||
1549 checkCallerInteractAcrossUsersFull()) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001550 if (DBG_LOC) log("getAllCellInfo: is active user");
Legler Wu2c01cdf2014-12-08 19:00:59 +08001551 List<CellInfo> cellInfos = new ArrayList<CellInfo>();
1552 for (Phone phone : PhoneFactory.getPhones()) {
Robert Greenwaltd9eb7da2015-08-19 12:18:12 -07001553 final List<CellInfo> info = phone.getAllCellInfo();
1554 if (info != null) cellInfos.addAll(phone.getAllCellInfo());
Legler Wu2c01cdf2014-12-08 19:00:59 +08001555 }
1556 return cellInfos;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001557 } else {
1558 if (DBG_LOC) log("getAllCellInfo: suppress non-active user");
1559 return null;
1560 }
1561 }
1562
Sailesh Nepalbd76e4e2013-10-27 13:59:44 -07001563 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001564 public void setCellInfoListRate(int rateInMillis) {
1565 mPhone.setCellInfoListRate(rateInMillis);
1566 }
1567
Shishir Agrawala9f32182016-04-12 12:00:16 -07001568 @Override
1569 public String getImeiForSlot(int slotId, String callingPackage) {
1570 if (!canReadPhoneState(callingPackage, "getImeiForSlot")) {
1571 return null;
1572 }
1573 Phone phone = PhoneFactory.getPhone(slotId);
1574 return phone == null ? null : phone.getImei();
1575 }
1576
1577 @Override
1578 public String getDeviceSoftwareVersionForSlot(int slotId, String callingPackage) {
1579 if (!canReadPhoneState(callingPackage, "getDeviceSoftwareVersionForSlot")) {
1580 return null;
1581 }
1582 Phone phone = PhoneFactory.getPhone(slotId);
1583 return phone == null ? null : phone.getDeviceSvn();
1584 }
1585
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001586 //
1587 // Internal helper methods.
1588 //
1589
Sanket Padaweee13a9b2016-03-08 17:30:28 -08001590 /**
1591 * Returns true if the caller holds INTERACT_ACROSS_USERS_FULL.
1592 */
1593 private boolean checkCallerInteractAcrossUsersFull() {
1594 return mPhone.getContext().checkCallingOrSelfPermission(
1595 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
1596 == PackageManager.PERMISSION_GRANTED;
1597 }
1598
Jake Hambye994d462014-02-03 13:10:13 -08001599 private static boolean checkIfCallerIsSelfOrForegroundUser() {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001600 boolean ok;
1601
1602 boolean self = Binder.getCallingUid() == Process.myUid();
1603 if (!self) {
1604 // Get the caller's user id then clear the calling identity
1605 // which will be restored in the finally clause.
1606 int callingUser = UserHandle.getCallingUserId();
1607 long ident = Binder.clearCallingIdentity();
1608
1609 try {
1610 // With calling identity cleared the current user is the foreground user.
1611 int foregroundUser = ActivityManager.getCurrentUser();
1612 ok = (foregroundUser == callingUser);
1613 if (DBG_LOC) {
1614 log("checkIfCallerIsSelfOrForegoundUser: foregroundUser=" + foregroundUser
1615 + " callingUser=" + callingUser + " ok=" + ok);
1616 }
1617 } catch (Exception ex) {
1618 if (DBG_LOC) loge("checkIfCallerIsSelfOrForegoundUser: Exception ex=" + ex);
1619 ok = false;
1620 } finally {
1621 Binder.restoreCallingIdentity(ident);
1622 }
1623 } else {
1624 if (DBG_LOC) log("checkIfCallerIsSelfOrForegoundUser: is self");
1625 ok = true;
1626 }
1627 if (DBG_LOC) log("checkIfCallerIsSelfOrForegoundUser: ret=" + ok);
1628 return ok;
1629 }
1630
1631 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001632 * Make sure the caller has the MODIFY_PHONE_STATE permission.
1633 *
1634 * @throws SecurityException if the caller does not have the required permission
1635 */
1636 private void enforceModifyPermission() {
1637 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE, null);
1638 }
1639
1640 /**
Junda Liua2e36012014-07-09 18:30:01 -07001641 * Make sure either system app or the caller has carrier privilege.
1642 *
1643 * @throws SecurityException if the caller does not have the required permission/privilege
1644 */
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001645 private void enforceModifyPermissionOrCarrierPrivilege(int subId) {
Shishir Agrawalf1ac4c92014-07-14 13:54:28 -07001646 int permission = mApp.checkCallingOrSelfPermission(
1647 android.Manifest.permission.MODIFY_PHONE_STATE);
1648 if (permission == PackageManager.PERMISSION_GRANTED) {
1649 return;
1650 }
1651
1652 log("No modify permission, check carrier privilege next.");
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001653 enforceCarrierPrivilege(subId);
Junda Liua2e36012014-07-09 18:30:01 -07001654 }
1655
1656 /**
1657 * Make sure the caller has carrier privilege.
1658 *
1659 * @throws SecurityException if the caller does not have the required permission
1660 */
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001661 private void enforceCarrierPrivilege(int subId) {
1662 if (getCarrierPrivilegeStatus(subId) !=
1663 TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
Shishir Agrawalf1ac4c92014-07-14 13:54:28 -07001664 loge("No Carrier Privilege.");
1665 throw new SecurityException("No Carrier Privilege.");
Junda Liua2e36012014-07-09 18:30:01 -07001666 }
1667 }
1668
1669 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001670 * Make sure the caller has the CALL_PHONE permission.
1671 *
1672 * @throws SecurityException if the caller does not have the required permission
1673 */
1674 private void enforceCallPermission() {
1675 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.CALL_PHONE, null);
1676 }
1677
Stuart Scott8eef64f2015-04-08 15:13:54 -07001678 private void enforceConnectivityInternalPermission() {
1679 mApp.enforceCallingOrSelfPermission(
1680 android.Manifest.permission.CONNECTIVITY_INTERNAL,
1681 "ConnectivityService");
1682 }
1683
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001684 private String createTelUrl(String number) {
1685 if (TextUtils.isEmpty(number)) {
1686 return null;
1687 }
1688
Jake Hambye994d462014-02-03 13:10:13 -08001689 return "tel:" + number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001690 }
1691
Ihab Awadf9e92732013-12-05 18:02:52 -08001692 private static void log(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001693 Log.d(LOG_TAG, "[PhoneIntfMgr] " + msg);
1694 }
1695
Naveen Kalla1fd79bd2014-08-08 00:48:59 -07001696 private static void logv(String msg) {
1697 Log.v(LOG_TAG, "[PhoneIntfMgr] " + msg);
1698 }
1699
Ihab Awadf9e92732013-12-05 18:02:52 -08001700 private static void loge(String msg) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001701 Log.e(LOG_TAG, "[PhoneIntfMgr] " + msg);
1702 }
1703
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001704 @Override
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001705 public int getActivePhoneType() {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001706 return getActivePhoneTypeForSlot(getSlotForDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001707 }
1708
Sanket Padawe356d7632015-06-22 14:03:32 -07001709 @Override
Shishir Agrawala9f32182016-04-12 12:00:16 -07001710 public int getActivePhoneTypeForSlot(int slotId) {
1711 final Phone phone = PhoneFactory.getPhone(slotId);
Sanket Padawe356d7632015-06-22 14:03:32 -07001712 if (phone == null) {
1713 return PhoneConstants.PHONE_TYPE_NONE;
1714 } else {
Shishir Agrawala9f32182016-04-12 12:00:16 -07001715 return phone.getPhoneType();
Sanket Padawe356d7632015-06-22 14:03:32 -07001716 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001717 }
1718
1719 /**
1720 * Returns the CDMA ERI icon index to display
1721 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001722 @Override
1723 public int getCdmaEriIconIndex(String callingPackage) {
1724 return getCdmaEriIconIndexForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001725 }
1726
Sanket Padawe356d7632015-06-22 14:03:32 -07001727 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001728 public int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage) {
1729 if (!canReadPhoneState(callingPackage, "getCdmaEriIconIndexForSubscriber")) {
1730 return -1;
1731 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001732 final Phone phone = getPhone(subId);
1733 if (phone != null) {
1734 return phone.getCdmaEriIconIndex();
1735 } else {
1736 return -1;
1737 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001738 }
1739
1740 /**
1741 * Returns the CDMA ERI icon mode,
1742 * 0 - ON
1743 * 1 - FLASHING
1744 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001745 @Override
1746 public int getCdmaEriIconMode(String callingPackage) {
1747 return getCdmaEriIconModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001748 }
1749
Sanket Padawe356d7632015-06-22 14:03:32 -07001750 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001751 public int getCdmaEriIconModeForSubscriber(int subId, String callingPackage) {
1752 if (!canReadPhoneState(callingPackage, "getCdmaEriIconModeForSubscriber")) {
1753 return -1;
1754 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001755 final Phone phone = getPhone(subId);
1756 if (phone != null) {
1757 return phone.getCdmaEriIconMode();
1758 } else {
1759 return -1;
1760 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001761 }
1762
1763 /**
1764 * Returns the CDMA ERI text,
1765 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001766 @Override
1767 public String getCdmaEriText(String callingPackage) {
1768 return getCdmaEriTextForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001769 }
1770
Sanket Padawe356d7632015-06-22 14:03:32 -07001771 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001772 public String getCdmaEriTextForSubscriber(int subId, String callingPackage) {
1773 if (!canReadPhoneState(callingPackage, "getCdmaEriIconTextForSubscriber")) {
1774 return null;
1775 }
Sanket Padawe356d7632015-06-22 14:03:32 -07001776 final Phone phone = getPhone(subId);
1777 if (phone != null) {
1778 return phone.getCdmaEriText();
1779 } else {
1780 return null;
1781 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001782 }
1783
1784 /**
Junda Liuca05d5d2014-08-14 22:36:34 -07001785 * Returns the CDMA MDN.
1786 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001787 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001788 public String getCdmaMdn(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001789 enforceModifyPermissionOrCarrierPrivilege(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07001790 final Phone phone = getPhone(subId);
1791 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA && phone != null) {
1792 return phone.getLine1Number();
Junda Liuca05d5d2014-08-14 22:36:34 -07001793 } else {
1794 return null;
1795 }
1796 }
1797
1798 /**
1799 * Returns the CDMA MIN.
1800 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001801 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001802 public String getCdmaMin(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001803 enforceModifyPermissionOrCarrierPrivilege(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07001804 final Phone phone = getPhone(subId);
1805 if (phone != null && phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
1806 return phone.getCdmaMin();
Junda Liuca05d5d2014-08-14 22:36:34 -07001807 } else {
1808 return null;
1809 }
1810 }
1811
1812 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001813 * Returns true if CDMA provisioning needs to run.
1814 */
1815 public boolean needsOtaServiceProvisioning() {
1816 return mPhone.needsOtaServiceProvisioning();
1817 }
1818
1819 /**
Shishir Agrawal76d5da92014-11-09 16:17:25 -08001820 * Sets the voice mail number of a given subId.
1821 */
1822 @Override
1823 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08001824 enforceCarrierPrivilege(subId);
Shishir Agrawal76d5da92014-11-09 16:17:25 -08001825 Boolean success = (Boolean) sendRequest(CMD_SET_VOICEMAIL_NUMBER,
1826 new Pair<String, String>(alphaTag, number), new Integer(subId));
1827 return success;
1828 }
1829
1830 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001831 * Returns the unread count of voicemails
1832 */
1833 public int getVoiceMessageCount() {
Wink Savilleadd7cc52014-09-08 14:23:09 -07001834 return getVoiceMessageCountForSubscriber(getDefaultSubscription());
Wink Saville36469e72014-06-11 15:17:00 -07001835 }
1836
1837 /**
1838 * Returns the unread count of voicemails for a subId
1839 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001840 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001841 public int getVoiceMessageCountForSubscriber( int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07001842 final Phone phone = getPhone(subId);
1843 if (phone != null) {
1844 return phone.getVoiceMessageCount();
1845 } else {
1846 return 0;
1847 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001848 }
1849
1850 /**
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07001851 * Returns the data network type.
1852 * Legacy call, permission-free.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001853 *
1854 * @Deprecated to be removed Q3 2013 use {@link #getDataNetworkType}.
1855 */
1856 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07001857 public int getNetworkType() {
1858 final Phone phone = getPhone(getDefaultSubscription());
1859 if (phone != null) {
1860 return phone.getServiceState().getDataNetworkType();
1861 } else {
1862 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1863 }
Wink Saville36469e72014-06-11 15:17:00 -07001864 }
1865
1866 /**
1867 * Returns the network type for a subId
1868 */
1869 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001870 public int getNetworkTypeForSubscriber(int subId, String callingPackage) {
1871 if (!canReadPhoneState(callingPackage, "getNetworkTypeForSubscriber")) {
1872 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1873 }
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07001874
Sanket Padawe356d7632015-06-22 14:03:32 -07001875 final Phone phone = getPhone(subId);
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001876 if (phone != null) {
Sanket Padawe356d7632015-06-22 14:03:32 -07001877 return phone.getServiceState().getDataNetworkType();
1878 } else {
1879 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1880 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001881 }
1882
1883 /**
1884 * Returns the data network type
1885 */
1886 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001887 public int getDataNetworkType(String callingPackage) {
1888 return getDataNetworkTypeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001889 }
1890
1891 /**
1892 * Returns the data network type for a subId
1893 */
1894 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001895 public int getDataNetworkTypeForSubscriber(int subId, String callingPackage) {
1896 if (!canReadPhoneState(callingPackage, "getDataNetworkTypeForSubscriber")) {
1897 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1898 }
1899
Sanket Padawe356d7632015-06-22 14:03:32 -07001900 final Phone phone = getPhone(subId);
1901 if (phone != null) {
1902 return phone.getServiceState().getDataNetworkType();
1903 } else {
1904 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1905 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001906 }
1907
1908 /**
Wink Saville36469e72014-06-11 15:17:00 -07001909 * Returns the Voice network type for a subId
1910 */
1911 @Override
Robert Greenwalta5dcfcb2015-07-10 09:06:29 -07001912 public int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage) {
1913 if (!canReadPhoneState(callingPackage, "getDataNetworkTypeForSubscriber")) {
1914 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1915 }
1916
Sanket Padawe356d7632015-06-22 14:03:32 -07001917 final Phone phone = getPhone(subId);
1918 if (phone != null) {
1919 return phone.getServiceState().getVoiceNetworkType();
1920 } else {
1921 return TelephonyManager.NETWORK_TYPE_UNKNOWN;
1922 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001923 }
1924
1925 /**
1926 * @return true if a ICC card is present
1927 */
1928 public boolean hasIccCard() {
Wink Saville36469e72014-06-11 15:17:00 -07001929 // FIXME Make changes to pass defaultSimId of type int
Amit Mahajana6fc2a82015-01-06 11:53:51 -08001930 return hasIccCardUsingSlotId(mSubscriptionController.getSlotId(getDefaultSubscription()));
Wink Saville36469e72014-06-11 15:17:00 -07001931 }
1932
1933 /**
1934 * @return true if a ICC card is present for a slotId
1935 */
Sanket Padawe356d7632015-06-22 14:03:32 -07001936 @Override
Wink Savilleb564aae2014-10-23 10:18:09 -07001937 public boolean hasIccCardUsingSlotId(int slotId) {
Amit Mahajana6fc2a82015-01-06 11:53:51 -08001938 int subId[] = mSubscriptionController.getSubIdUsingSlotId(slotId);
Sanket Padawe356d7632015-06-22 14:03:32 -07001939 final Phone phone = getPhone(subId[0]);
1940 if (subId != null && phone != null) {
1941 return phone.getIccCard().hasIccCard();
Amit Mahajana6fc2a82015-01-06 11:53:51 -08001942 } else {
1943 return false;
1944 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001945 }
1946
1947 /**
1948 * Return if the current radio is LTE on CDMA. This
1949 * is a tri-state return value as for a period of time
1950 * the mode may be unknown.
1951 *
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001952 * @param callingPackage the name of the package making the call.
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001953 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE}
Jake Hambye994d462014-02-03 13:10:13 -08001954 * or {@link Phone#LTE_ON_CDMA_TRUE}
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001955 */
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001956 @Override
1957 public int getLteOnCdmaMode(String callingPackage) {
1958 return getLteOnCdmaModeForSubscriber(getDefaultSubscription(), callingPackage);
Wink Saville36469e72014-06-11 15:17:00 -07001959 }
1960
Sanket Padawe356d7632015-06-22 14:03:32 -07001961 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07001962 public int getLteOnCdmaModeForSubscriber(int subId, String callingPackage) {
1963 if (!canReadPhoneState(callingPackage, "getLteOnCdmaModeForSubscriber")) {
1964 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
1965 }
1966
Sanket Padawe356d7632015-06-22 14:03:32 -07001967 final Phone phone = getPhone(subId);
1968 if (phone == null) {
1969 return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
1970 } else {
1971 return phone.getLteOnCdmaMode();
1972 }
Wink Saville36469e72014-06-11 15:17:00 -07001973 }
1974
1975 public void setPhone(Phone phone) {
1976 mPhone = phone;
1977 }
1978
1979 /**
1980 * {@hide}
1981 * Returns Default subId, 0 in the case of single standby.
1982 */
Wink Savilleb564aae2014-10-23 10:18:09 -07001983 private int getDefaultSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001984 return mSubscriptionController.getDefaultSubId();
Wink Saville36469e72014-06-11 15:17:00 -07001985 }
1986
Shishir Agrawala9f32182016-04-12 12:00:16 -07001987 private int getSlotForDefaultSubscription() {
1988 return mSubscriptionController.getPhoneId(getDefaultSubscription());
1989 }
1990
Wink Savilleb564aae2014-10-23 10:18:09 -07001991 private int getPreferredVoiceSubscription() {
Wink Savilleac1bdfd2014-11-20 23:04:44 -08001992 return mSubscriptionController.getDefaultVoiceSubId();
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001993 }
Ihab Awadf2177b72013-11-25 13:33:23 -08001994
1995 /**
1996 * @see android.telephony.TelephonyManager.WifiCallingChoices
1997 */
1998 public int getWhenToMakeWifiCalls() {
Sailesh Nepald1e68152013-12-12 19:08:02 -08001999 return Settings.System.getInt(mPhone.getContext().getContentResolver(),
2000 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, getWhenToMakeWifiCallsDefaultPreference());
Ihab Awadf2177b72013-11-25 13:33:23 -08002001 }
2002
2003 /**
2004 * @see android.telephony.TelephonyManager.WifiCallingChoices
2005 */
2006 public void setWhenToMakeWifiCalls(int preference) {
Sailesh Nepald1e68152013-12-12 19:08:02 -08002007 if (DBG) log("setWhenToMakeWifiCallsStr, storing setting = " + preference);
2008 Settings.System.putInt(mPhone.getContext().getContentResolver(),
2009 Settings.System.WHEN_TO_MAKE_WIFI_CALLS, preference);
Ihab Awadf9e92732013-12-05 18:02:52 -08002010 }
2011
Sailesh Nepald1e68152013-12-12 19:08:02 -08002012 private static int getWhenToMakeWifiCallsDefaultPreference() {
Santos Cordonda120f42014-08-06 04:44:34 -07002013 // TODO: Use a build property to choose this value.
Evan Charlton9829e882013-12-19 15:30:38 -08002014 return TelephonyManager.WifiCallingChoices.ALWAYS_USE;
Ihab Awadf2177b72013-11-25 13:33:23 -08002015 }
Shishir Agrawal69f68122013-12-16 17:25:49 -08002016
Shishir Agrawal566b7612013-10-28 14:41:00 -07002017 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002018 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(int subId, String AID) {
2019 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002020
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002021 if (DBG) log("iccOpenLogicalChannel: subId=" + subId + " aid=" + AID);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002022 IccOpenLogicalChannelResponse response = (IccOpenLogicalChannelResponse)sendRequest(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002023 CMD_OPEN_CHANNEL, AID, subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002024 if (DBG) log("iccOpenLogicalChannel: " + response);
2025 return response;
Shishir Agrawal566b7612013-10-28 14:41:00 -07002026 }
2027
2028 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002029 public boolean iccCloseLogicalChannel(int subId, int channel) {
2030 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002031
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002032 if (DBG) log("iccCloseLogicalChannel: subId=" + subId + " chnl=" + channel);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002033 if (channel < 0) {
2034 return false;
2035 }
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002036 Boolean success = (Boolean)sendRequest(CMD_CLOSE_CHANNEL, channel, subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002037 if (DBG) log("iccCloseLogicalChannel: " + success);
2038 return success;
2039 }
2040
2041 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002042 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla,
Shishir Agrawal566b7612013-10-28 14:41:00 -07002043 int command, int p1, int p2, int p3, String data) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002044 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002045
2046 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002047 log("iccTransmitApduLogicalChannel: subId=" + subId + " chnl=" + channel +
2048 " cla=" + cla + " cmd=" + command + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 +
Shishir Agrawal566b7612013-10-28 14:41:00 -07002049 " data=" + data);
2050 }
2051
2052 if (channel < 0) {
2053 return "";
2054 }
2055
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002056 IccIoResult response = (IccIoResult)sendRequest(CMD_TRANSMIT_APDU_LOGICAL_CHANNEL,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002057 new IccAPDUArgument(channel, cla, command, p1, p2, p3, data), subId);
Shishir Agrawal566b7612013-10-28 14:41:00 -07002058 if (DBG) log("iccTransmitApduLogicalChannel: " + response);
2059
Shishir Agrawal566b7612013-10-28 14:41:00 -07002060 // Append the returned status code to the end of the response payload.
2061 String s = Integer.toHexString(
2062 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07002063 if (response.payload != null) {
2064 s = IccUtils.bytesToHexString(response.payload) + s;
2065 }
Shishir Agrawal566b7612013-10-28 14:41:00 -07002066 return s;
2067 }
Jake Hambye994d462014-02-03 13:10:13 -08002068
Evan Charltonc66da362014-05-16 14:06:40 -07002069 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002070 public String iccTransmitApduBasicChannel(int subId, int cla, int command, int p1, int p2,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002071 int p3, String data) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002072 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002073
2074 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002075 log("iccTransmitApduBasicChannel: subId=" + subId + " cla=" + cla + " cmd=" + command
2076 + " p1=" + p1 + " p2=" + p2 + " p3=" + p3 + " data=" + data);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002077 }
2078
2079 IccIoResult response = (IccIoResult)sendRequest(CMD_TRANSMIT_APDU_BASIC_CHANNEL,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002080 new IccAPDUArgument(0, cla, command, p1, p2, p3, data), subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002081 if (DBG) log("iccTransmitApduBasicChannel: " + response);
2082
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002083 // Append the returned status code to the end of the response payload.
2084 String s = Integer.toHexString(
2085 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
Shishir Agrawal5ec14172014-08-05 17:05:45 -07002086 if (response.payload != null) {
2087 s = IccUtils.bytesToHexString(response.payload) + s;
2088 }
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002089 return s;
2090 }
2091
2092 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002093 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3,
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002094 String filePath) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002095 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002096
2097 if (DBG) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002098 log("Exchange SIM_IO " + subId + ":" + fileID + ":" + command + " " +
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002099 p1 + " " + p2 + " " + p3 + ":" + filePath);
2100 }
2101
2102 IccIoResult response =
2103 (IccIoResult)sendRequest(CMD_EXCHANGE_SIM_IO,
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002104 new IccAPDUArgument(-1, fileID, command, p1, p2, p3, filePath),
2105 subId);
Shishir Agrawalda0bb0d2014-07-29 21:18:53 -07002106
2107 if (DBG) {
2108 log("Exchange SIM_IO [R]" + response);
2109 }
2110
2111 byte[] result = null;
2112 int length = 2;
2113 if (response.payload != null) {
2114 length = 2 + response.payload.length;
2115 result = new byte[length];
2116 System.arraycopy(response.payload, 0, result, 0, response.payload.length);
2117 } else {
2118 result = new byte[length];
2119 }
2120
2121 result[length - 1] = (byte) response.sw2;
2122 result[length - 2] = (byte) response.sw1;
2123 return result;
2124 }
2125
2126 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002127 public String sendEnvelopeWithStatus(int subId, String content) {
2128 enforceModifyPermissionOrCarrierPrivilege(subId);
Evan Charltonc66da362014-05-16 14:06:40 -07002129
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002130 IccIoResult response = (IccIoResult)sendRequest(CMD_SEND_ENVELOPE, content, subId);
Evan Charltonc66da362014-05-16 14:06:40 -07002131 if (response.payload == null) {
2132 return "";
2133 }
2134
2135 // Append the returned status code to the end of the response payload.
2136 String s = Integer.toHexString(
2137 (response.sw1 << 8) + response.sw2 + 0x10000).substring(1);
2138 s = IccUtils.bytesToHexString(response.payload) + s;
2139 return s;
2140 }
2141
Jake Hambye994d462014-02-03 13:10:13 -08002142 /**
2143 * Read one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
2144 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
2145 *
2146 * @param itemID the ID of the item to read
2147 * @return the NV item as a String, or null on error.
2148 */
2149 @Override
2150 public String nvReadItem(int itemID) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002151 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002152 if (DBG) log("nvReadItem: item " + itemID);
2153 String value = (String) sendRequest(CMD_NV_READ_ITEM, itemID);
2154 if (DBG) log("nvReadItem: item " + itemID + " is \"" + value + '"');
2155 return value;
2156 }
2157
2158 /**
2159 * Write one of the NV items defined in {@link com.android.internal.telephony.RadioNVItems}
2160 * and {@code ril_nv_items.h}. Used for device configuration by some CDMA operators.
2161 *
2162 * @param itemID the ID of the item to read
2163 * @param itemValue the value to write, as a String
2164 * @return true on success; false on any failure
2165 */
2166 @Override
2167 public boolean nvWriteItem(int itemID, String itemValue) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002168 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002169 if (DBG) log("nvWriteItem: item " + itemID + " value \"" + itemValue + '"');
2170 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_ITEM,
2171 new Pair<Integer, String>(itemID, itemValue));
2172 if (DBG) log("nvWriteItem: item " + itemID + ' ' + (success ? "ok" : "fail"));
2173 return success;
2174 }
2175
2176 /**
2177 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
2178 * Used for device configuration by some CDMA operators.
2179 *
2180 * @param preferredRoamingList byte array containing the new PRL
2181 * @return true on success; false on any failure
2182 */
2183 @Override
2184 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002185 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002186 if (DBG) log("nvWriteCdmaPrl: value: " + HexDump.toHexString(preferredRoamingList));
2187 Boolean success = (Boolean) sendRequest(CMD_NV_WRITE_CDMA_PRL, preferredRoamingList);
2188 if (DBG) log("nvWriteCdmaPrl: " + (success ? "ok" : "fail"));
2189 return success;
2190 }
2191
2192 /**
2193 * Perform the specified type of NV config reset.
2194 * Used for device configuration by some CDMA operators.
2195 *
2196 * @param resetType the type of reset to perform (1 == factory reset; 2 == NV-only reset)
2197 * @return true on success; false on any failure
2198 */
2199 @Override
2200 public boolean nvResetConfig(int resetType) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002201 enforceModifyPermissionOrCarrierPrivilege(getDefaultSubscription());
Jake Hambye994d462014-02-03 13:10:13 -08002202 if (DBG) log("nvResetConfig: type " + resetType);
2203 Boolean success = (Boolean) sendRequest(CMD_NV_RESET_CONFIG, resetType);
2204 if (DBG) log("nvResetConfig: type " + resetType + ' ' + (success ? "ok" : "fail"));
2205 return success;
2206 }
Jake Hamby7c27be32014-03-03 13:25:59 -08002207
2208 /**
Wink Saville36469e72014-06-11 15:17:00 -07002209 * {@hide}
2210 * Returns Default sim, 0 in the case of single standby.
2211 */
2212 public int getDefaultSim() {
2213 //TODO Need to get it from Telephony Devcontroller
2214 return 0;
2215 }
2216
Svet Ganovb320e182015-04-16 12:30:10 -07002217 public String[] getPcscfAddress(String apnType, String callingPackage) {
2218 if (!canReadPhoneState(callingPackage, "getPcscfAddress")) {
2219 return new String[0];
2220 }
2221
2222
ram87fca6f2014-07-18 18:58:44 +05302223 return mPhone.getPcscfAddress(apnType);
Wink Saville36469e72014-06-11 15:17:00 -07002224 }
2225
2226 public void setImsRegistrationState(boolean registered) {
2227 enforceModifyPermission();
2228 mPhone.setImsRegistrationState(registered);
2229 }
2230
2231 /**
Stuart Scott54788802015-03-30 13:18:01 -07002232 * Set the network selection mode to automatic.
2233 *
2234 */
2235 @Override
2236 public void setNetworkSelectionModeAutomatic(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002237 enforceModifyPermissionOrCarrierPrivilege(subId);
Stuart Scott54788802015-03-30 13:18:01 -07002238 if (DBG) log("setNetworkSelectionModeAutomatic: subId " + subId);
2239 sendRequest(CMD_SET_NETWORK_SELECTION_MODE_AUTOMATIC, null, subId);
2240 }
2241
2242 /**
Shishir Agrawal302c8692015-06-19 13:49:39 -07002243 * Set the network selection mode to manual with the selected carrier.
2244 */
2245 @Override
Shishir Agrawal77ba3172015-09-10 14:50:19 -07002246 public boolean setNetworkSelectionModeManual(int subId, OperatorInfo operator,
2247 boolean persistSelection) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002248 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002249 if (DBG) log("setNetworkSelectionModeManual: subId:" + subId + " operator:" + operator);
Shishir Agrawal77ba3172015-09-10 14:50:19 -07002250 ManualNetworkSelectionArgument arg = new ManualNetworkSelectionArgument(operator,
2251 persistSelection);
2252 return (Boolean) sendRequest(CMD_SET_NETWORK_SELECTION_MODE_MANUAL, arg, subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002253 }
2254
2255 /**
2256 * Scans for available networks.
2257 */
2258 @Override
2259 public CellNetworkScanResult getCellNetworkScanResults(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002260 enforceModifyPermissionOrCarrierPrivilege(subId);
Shishir Agrawal302c8692015-06-19 13:49:39 -07002261 if (DBG) log("getCellNetworkScanResults: subId " + subId);
2262 CellNetworkScanResult result = (CellNetworkScanResult) sendRequest(
2263 CMD_PERFORM_NETWORK_SCAN, null, subId);
2264 return result;
2265 }
2266
2267 /**
Junda Liu84d15a22014-07-02 11:21:04 -07002268 * Get the calculated preferred network type.
2269 * Used for debugging incorrect network type.
2270 *
2271 * @return the preferred network type, defined in RILConstants.java.
2272 */
2273 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002274 public int getCalculatedPreferredNetworkType(String callingPackage) {
2275 if (!canReadPhoneState(callingPackage, "getCalculatedPreferredNetworkType")) {
2276 return RILConstants.PREFERRED_NETWORK_MODE;
2277 }
2278
Amit Mahajan43330e02014-11-18 11:54:45 -08002279 return PhoneFactory.calculatePreferredNetworkType(mPhone.getContext(), 0); // wink FIXME: need to get SubId from somewhere.
Junda Liu84d15a22014-07-02 11:21:04 -07002280 }
2281
2282 /**
Jake Hamby7c27be32014-03-03 13:25:59 -08002283 * Get the preferred network type.
2284 * Used for device configuration by some CDMA operators.
2285 *
2286 * @return the preferred network type, defined in RILConstants.java.
2287 */
2288 @Override
Stuart Scott54788802015-03-30 13:18:01 -07002289 public int getPreferredNetworkType(int subId) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002290 enforceModifyPermissionOrCarrierPrivilege(subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002291 if (DBG) log("getPreferredNetworkType");
Stuart Scott54788802015-03-30 13:18:01 -07002292 int[] result = (int[]) sendRequest(CMD_GET_PREFERRED_NETWORK_TYPE, null, subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002293 int networkType = (result != null ? result[0] : -1);
2294 if (DBG) log("getPreferredNetworkType: " + networkType);
2295 return networkType;
2296 }
2297
2298 /**
2299 * Set the preferred network type.
2300 * Used for device configuration by some CDMA operators.
2301 *
2302 * @param networkType the preferred network type, defined in RILConstants.java.
2303 * @return true on success; false on any failure.
2304 */
2305 @Override
Stuart Scott54788802015-03-30 13:18:01 -07002306 public boolean setPreferredNetworkType(int subId, int networkType) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002307 enforceModifyPermissionOrCarrierPrivilege(subId);
Stuart Scott54788802015-03-30 13:18:01 -07002308 if (DBG) log("setPreferredNetworkType: subId " + subId + " type " + networkType);
2309 Boolean success = (Boolean) sendRequest(CMD_SET_PREFERRED_NETWORK_TYPE, networkType, subId);
Jake Hamby7c27be32014-03-03 13:25:59 -08002310 if (DBG) log("setPreferredNetworkType: " + (success ? "ok" : "fail"));
Junda Liu80bc0d12014-07-14 16:36:44 -07002311 if (success) {
2312 Settings.Global.putInt(mPhone.getContext().getContentResolver(),
Stuart Scott54788802015-03-30 13:18:01 -07002313 Settings.Global.PREFERRED_NETWORK_MODE + subId, networkType);
Junda Liu80bc0d12014-07-14 16:36:44 -07002314 }
Jake Hamby7c27be32014-03-03 13:25:59 -08002315 return success;
2316 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002317
2318 /**
Junda Liu475951f2014-11-07 16:45:03 -08002319 * Check TETHER_DUN_REQUIRED and TETHER_DUN_APN settings, net.tethering.noprovisioning
2320 * SystemProperty, and config_tether_apndata to decide whether DUN APN is required for
2321 * tethering.
2322 *
2323 * @return 0: Not required. 1: required. 2: Not set.
2324 * @hide
2325 */
2326 @Override
2327 public int getTetherApnRequired() {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002328 enforceModifyPermission();
Junda Liu475951f2014-11-07 16:45:03 -08002329 int dunRequired = Settings.Global.getInt(mPhone.getContext().getContentResolver(),
2330 Settings.Global.TETHER_DUN_REQUIRED, 2);
2331 // If not set, check net.tethering.noprovisioning, TETHER_DUN_APN setting and
2332 // config_tether_apndata.
2333 if (dunRequired == 2 && mPhone.hasMatchedTetherApnSetting()) {
2334 dunRequired = 1;
2335 }
2336 return dunRequired;
2337 }
2338
2339 /**
Robert Greenwalted86e582014-05-21 20:03:20 -07002340 * Set mobile data enabled
2341 * Used by the user through settings etc to turn on/off mobile data
2342 *
2343 * @param enable {@code true} turn turn data on, else {@code false}
2344 */
2345 @Override
Wink Savillee7353bb2014-12-05 14:21:41 -08002346 public void setDataEnabled(int subId, boolean enable) {
Robert Greenwalted86e582014-05-21 20:03:20 -07002347 enforceModifyPermission();
Wink Savillee7353bb2014-12-05 14:21:41 -08002348 int phoneId = mSubscriptionController.getPhoneId(subId);
Joe Onoratoa601dd22016-02-23 13:03:53 -08002349 if (DBG) log("getDataEnabled: subId=" + subId + " phoneId=" + phoneId);
Wink Savillee7353bb2014-12-05 14:21:41 -08002350 Phone phone = PhoneFactory.getPhone(phoneId);
2351 if (phone != null) {
Joe Onoratoa601dd22016-02-23 13:03:53 -08002352 if (DBG) log("setDataEnabled: subId=" + subId + " enable=" + enable);
Wink Savillee7353bb2014-12-05 14:21:41 -08002353 phone.setDataEnabled(enable);
2354 } else {
2355 loge("setDataEnabled: no phone for subId=" + subId);
2356 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002357 }
2358
2359 /**
Robert Greenwalt646120a2014-05-23 11:54:03 -07002360 * Get whether mobile data is enabled.
2361 *
2362 * Note that this used to be available from ConnectivityService, gated by
2363 * ACCESS_NETWORK_STATE permission, so this will accept either that or
2364 * our MODIFY_PHONE_STATE.
Robert Greenwalted86e582014-05-21 20:03:20 -07002365 *
2366 * @return {@code true} if data is enabled else {@code false}
2367 */
2368 @Override
Wink Savillee7353bb2014-12-05 14:21:41 -08002369 public boolean getDataEnabled(int subId) {
Robert Greenwalt646120a2014-05-23 11:54:03 -07002370 try {
2371 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE,
2372 null);
2373 } catch (Exception e) {
2374 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.MODIFY_PHONE_STATE,
2375 null);
2376 }
Wink Savillee7353bb2014-12-05 14:21:41 -08002377 int phoneId = mSubscriptionController.getPhoneId(subId);
Joe Onoratoa601dd22016-02-23 13:03:53 -08002378 if (DBG) log("getDataEnabled: subId=" + subId + " phoneId=" + phoneId);
Wink Savillee7353bb2014-12-05 14:21:41 -08002379 Phone phone = PhoneFactory.getPhone(phoneId);
2380 if (phone != null) {
2381 boolean retVal = phone.getDataEnabled();
Joe Onoratoa601dd22016-02-23 13:03:53 -08002382 if (DBG) log("getDataEnabled: subId=" + subId + " retVal=" + retVal);
Wink Savillee7353bb2014-12-05 14:21:41 -08002383 return retVal;
2384 } else {
Joe Onoratoa601dd22016-02-23 13:03:53 -08002385 if (DBG) loge("getDataEnabled: no phone subId=" + subId + " retVal=false");
Wink Savillee7353bb2014-12-05 14:21:41 -08002386 return false;
2387 }
Robert Greenwalted86e582014-05-21 20:03:20 -07002388 }
Shishir Agrawal60f9c952014-06-23 12:00:43 -07002389
2390 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002391 public int getCarrierPrivilegeStatus(int subId) {
2392 final Phone phone = getPhone(subId);
2393 if (phone == null) {
2394 loge("getCarrierPrivilegeStatus: Invalid subId");
2395 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
2396 }
2397 UiccCard card = UiccController.getInstance().getUiccCard(phone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002398 if (card == null) {
Shishir Agrawal5e5becd2014-11-18 11:38:23 -08002399 loge("getCarrierPrivilegeStatus: No UICC");
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002400 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2401 }
2402 return card.getCarrierPrivilegeStatusForCurrentTransaction(
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002403 phone.getContext().getPackageManager());
Shishir Agrawal60f9c952014-06-23 12:00:43 -07002404 }
Junda Liu29340342014-07-10 15:23:27 -07002405
2406 @Override
Zach Johnson50ecba32015-05-19 00:24:21 -07002407 public int checkCarrierPrivilegesForPackage(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08002408 if (TextUtils.isEmpty(pkgName))
2409 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Shishir Agrawal21409252015-01-15 23:33:50 -08002410 UiccCard card = UiccController.getInstance().getUiccCard(mPhone.getPhoneId());
Shishir Agrawaleb8771e2014-07-22 11:24:08 -07002411 if (card == null) {
2412 loge("checkCarrierPrivilegesForPackage: No UICC");
2413 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2414 }
Zach Johnson50ecba32015-05-19 00:24:21 -07002415 return card.getCarrierPrivilegeStatus(mPhone.getContext().getPackageManager(), pkgName);
2416 }
2417
2418 @Override
2419 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) {
Junda Liu317d70b2016-03-08 09:33:53 -08002420 if (TextUtils.isEmpty(pkgName))
2421 return TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
Zach Johnson50ecba32015-05-19 00:24:21 -07002422 int result = TelephonyManager.CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
2423 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2424 UiccCard card = UiccController.getInstance().getUiccCard(i);
2425 if (card == null) {
Jonathan Basseri7d320df2015-06-16 12:17:08 -07002426 // No UICC in that slot.
Zach Johnson50ecba32015-05-19 00:24:21 -07002427 continue;
2428 }
2429
2430 result = card.getCarrierPrivilegeStatus(
2431 mPhone.getContext().getPackageManager(), pkgName);
2432 if (result == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
2433 break;
2434 }
2435 }
2436
2437 return result;
Junda Liu29340342014-07-10 15:23:27 -07002438 }
Derek Tan89e89d42014-07-08 17:00:10 -07002439
2440 @Override
Junda Liue64de782015-04-16 17:19:16 -07002441 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) {
2442 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
2443 loge("phoneId " + phoneId + " is not valid.");
2444 return null;
2445 }
2446 UiccCard card = UiccController.getInstance().getUiccCard(phoneId);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002447 if (card == null) {
Diego Pontorieroaf74c862014-08-28 11:51:16 -07002448 loge("getCarrierPackageNamesForIntent: No UICC");
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002449 return null ;
2450 }
Diego Pontorieroaf74c862014-08-28 11:51:16 -07002451 return card.getCarrierPackageNamesForIntent(
Svetoslav483aff72015-04-21 14:16:07 -07002452 mPhone.getContext().getPackageManager(), intent);
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002453 }
2454
Amith Yamasani6e118872016-02-19 12:53:51 -08002455 @Override
2456 public List<String> getPackagesWithCarrierPrivileges() {
2457 PackageManager pm = mPhone.getContext().getPackageManager();
2458 List<String> privilegedPackages = new ArrayList<>();
2459 List<PackageInfo> packages = null;
2460 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
2461 UiccCard card = UiccController.getInstance().getUiccCard(i);
2462 if (card == null) {
2463 // No UICC in that slot.
2464 continue;
2465 }
2466 if (card.hasCarrierPrivilegeRules()) {
2467 if (packages == null) {
2468 // Only check packages in user 0 for now
2469 packages = pm.getInstalledPackagesAsUser(
2470 PackageManager.MATCH_DISABLED_COMPONENTS
2471 | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
2472 | PackageManager.GET_SIGNATURES, UserHandle.USER_SYSTEM);
2473 }
2474 for (int p = packages.size() - 1; p >= 0; p--) {
2475 PackageInfo pkgInfo = packages.get(p);
2476 if (pkgInfo != null && pkgInfo.packageName != null
2477 && card.getCarrierPrivilegeStatus(pkgInfo)
2478 == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) {
2479 privilegedPackages.add(pkgInfo.packageName);
2480 }
2481 }
2482 }
2483 }
2484 return privilegedPackages;
2485 }
2486
Wink Savilleb564aae2014-10-23 10:18:09 -07002487 private String getIccId(int subId) {
Sanket Padawe356d7632015-06-22 14:03:32 -07002488 final Phone phone = getPhone(subId);
2489 UiccCard card = phone == null ? null : phone.getUiccCard();
Derek Tan97ebb422014-09-05 16:55:38 -07002490 if (card == null) {
2491 loge("getIccId: No UICC");
2492 return null;
2493 }
2494 String iccId = card.getIccId();
2495 if (TextUtils.isEmpty(iccId)) {
2496 loge("getIccId: ICC ID is null or empty.");
2497 return null;
2498 }
2499 return iccId;
2500 }
2501
Shishir Agrawaleb6439a2014-07-21 13:19:38 -07002502 @Override
Jeff Sharkey85190e62014-12-05 09:40:12 -08002503 public boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag,
2504 String number) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002505 enforceCarrierPrivilege(subId);
Derek Tan97ebb422014-09-05 16:55:38 -07002506
Jeff Sharkey85190e62014-12-05 09:40:12 -08002507 final String iccId = getIccId(subId);
Sanket Padawe356d7632015-06-22 14:03:32 -07002508 final Phone phone = getPhone(subId);
2509 if (phone == null) {
2510 return false;
2511 }
2512 final String subscriberId = phone.getSubscriberId();
Jeff Sharkey85190e62014-12-05 09:40:12 -08002513
2514 if (DBG_MERGE) {
2515 Slog.d(LOG_TAG, "Setting line number for ICC=" + iccId + ", subscriberId="
2516 + subscriberId + " to " + number);
2517 }
2518
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002519 if (TextUtils.isEmpty(iccId)) {
2520 return false;
Derek Tan97ebb422014-09-05 16:55:38 -07002521 }
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002522
Jeff Sharkey85190e62014-12-05 09:40:12 -08002523 final SharedPreferences.Editor editor = mTelephonySharedPreferences.edit();
2524
2525 final String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002526 if (alphaTag == null) {
2527 editor.remove(alphaTagPrefKey);
2528 } else {
2529 editor.putString(alphaTagPrefKey, alphaTag);
2530 }
2531
Jeff Sharkey85190e62014-12-05 09:40:12 -08002532 // Record both the line number and IMSI for this ICCID, since we need to
2533 // track all merged IMSIs based on line number
2534 final String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
2535 final String subscriberPrefKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002536 if (number == null) {
2537 editor.remove(numberPrefKey);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002538 editor.remove(subscriberPrefKey);
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002539 } else {
2540 editor.putString(numberPrefKey, number);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002541 editor.putString(subscriberPrefKey, subscriberId);
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002542 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08002543
Shishir Agrawal495d7e12014-12-01 11:50:28 -08002544 editor.commit();
2545 return true;
Derek Tan7226c842014-07-02 17:42:23 -07002546 }
2547
2548 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002549 public String getLine1NumberForDisplay(int subId, String callingPackage) {
Makoto Onukifee69342015-06-29 14:44:50 -07002550 // This is open to apps with WRITE_SMS.
2551 if (!canReadPhoneNumber(callingPackage, "getLine1NumberForDisplay")) {
Amit Mahajan9cf11512015-11-09 11:40:48 -08002552 if (DBG_MERGE) log("getLine1NumberForDisplay returning null due to permission");
Svet Ganovb320e182015-04-16 12:30:10 -07002553 return null;
2554 }
Derek Tan97ebb422014-09-05 16:55:38 -07002555
2556 String iccId = getIccId(subId);
2557 if (iccId != null) {
2558 String numberPrefKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
Amit Mahajan9cf11512015-11-09 11:40:48 -08002559 if (DBG_MERGE) {
2560 log("getLine1NumberForDisplay returning " +
2561 mTelephonySharedPreferences.getString(numberPrefKey, null));
2562 }
Andrew Leedf14ead2014-10-17 14:22:52 -07002563 return mTelephonySharedPreferences.getString(numberPrefKey, null);
Derek Tan7226c842014-07-02 17:42:23 -07002564 }
Amit Mahajan9cf11512015-11-09 11:40:48 -08002565 if (DBG_MERGE) log("getLine1NumberForDisplay returning null as iccId is null");
Derek Tan97ebb422014-09-05 16:55:38 -07002566 return null;
Derek Tan7226c842014-07-02 17:42:23 -07002567 }
2568
2569 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002570 public String getLine1AlphaTagForDisplay(int subId, String callingPackage) {
2571 if (!canReadPhoneState(callingPackage, "getLine1AlphaTagForDisplay")) {
2572 return null;
2573 }
Derek Tan97ebb422014-09-05 16:55:38 -07002574
2575 String iccId = getIccId(subId);
2576 if (iccId != null) {
2577 String alphaTagPrefKey = PREF_CARRIERS_ALPHATAG_PREFIX + iccId;
Andrew Leedf14ead2014-10-17 14:22:52 -07002578 return mTelephonySharedPreferences.getString(alphaTagPrefKey, null);
Derek Tan7226c842014-07-02 17:42:23 -07002579 }
Derek Tan97ebb422014-09-05 16:55:38 -07002580 return null;
Derek Tan7226c842014-07-02 17:42:23 -07002581 }
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07002582
2583 @Override
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07002584 public String[] getMergedSubscriberIds(String callingPackage) {
2585 if (!canReadPhoneState(callingPackage, "getMergedSubscriberIds")) {
2586 return null;
2587 }
Jeff Sharkey85190e62014-12-05 09:40:12 -08002588 final Context context = mPhone.getContext();
2589 final TelephonyManager tele = TelephonyManager.from(context);
2590 final SubscriptionManager sub = SubscriptionManager.from(context);
2591
2592 // Figure out what subscribers are currently active
2593 final ArraySet<String> activeSubscriberIds = new ArraySet<>();
Fyodor Kupolov8e53b0b2015-06-17 13:17:50 -07002594 // Clear calling identity, when calling TelephonyManager, because callerUid must be
2595 // the process, where TelephonyManager was instantiated. Otherwise AppOps check will fail.
2596 final long identity = Binder.clearCallingIdentity();
2597 try {
2598 final int[] subIds = sub.getActiveSubscriptionIdList();
2599 for (int subId : subIds) {
2600 activeSubscriberIds.add(tele.getSubscriberId(subId));
2601 }
2602 } finally {
2603 Binder.restoreCallingIdentity(identity);
Jeff Sharkey85190e62014-12-05 09:40:12 -08002604 }
2605
2606 // First pass, find a number override for an active subscriber
2607 String mergeNumber = null;
2608 final Map<String, ?> prefs = mTelephonySharedPreferences.getAll();
2609 for (String key : prefs.keySet()) {
2610 if (key.startsWith(PREF_CARRIERS_SUBSCRIBER_PREFIX)) {
2611 final String subscriberId = (String) prefs.get(key);
2612 if (activeSubscriberIds.contains(subscriberId)) {
2613 final String iccId = key.substring(PREF_CARRIERS_SUBSCRIBER_PREFIX.length());
2614 final String numberKey = PREF_CARRIERS_NUMBER_PREFIX + iccId;
2615 mergeNumber = (String) prefs.get(numberKey);
2616 if (DBG_MERGE) {
2617 Slog.d(LOG_TAG, "Found line number " + mergeNumber
2618 + " for active subscriber " + subscriberId);
2619 }
2620 if (!TextUtils.isEmpty(mergeNumber)) {
2621 break;
2622 }
2623 }
2624 }
2625 }
2626
2627 // Shortcut when no active merged subscribers
2628 if (TextUtils.isEmpty(mergeNumber)) {
2629 return null;
2630 }
2631
2632 // Second pass, find all subscribers under that line override
2633 final ArraySet<String> result = new ArraySet<>();
2634 for (String key : prefs.keySet()) {
2635 if (key.startsWith(PREF_CARRIERS_NUMBER_PREFIX)) {
2636 final String number = (String) prefs.get(key);
2637 if (mergeNumber.equals(number)) {
2638 final String iccId = key.substring(PREF_CARRIERS_NUMBER_PREFIX.length());
2639 final String subscriberKey = PREF_CARRIERS_SUBSCRIBER_PREFIX + iccId;
2640 final String subscriberId = (String) prefs.get(subscriberKey);
2641 if (!TextUtils.isEmpty(subscriberId)) {
2642 result.add(subscriberId);
2643 }
2644 }
2645 }
2646 }
2647
2648 final String[] resultArray = result.toArray(new String[result.size()]);
2649 Arrays.sort(resultArray);
2650 if (DBG_MERGE) {
2651 Slog.d(LOG_TAG, "Found subscribers " + Arrays.toString(resultArray) + " after merge");
2652 }
2653 return resultArray;
2654 }
2655
2656 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002657 public boolean setOperatorBrandOverride(int subId, String brand) {
2658 enforceCarrierPrivilege(subId);
2659 final Phone phone = getPhone(subId);
2660 return phone == null ? false : phone.setOperatorBrandOverride(brand);
Shishir Agrawalb1ebf8c2014-07-17 16:32:41 -07002661 }
Steven Liu4bf01bc2014-07-17 11:05:29 -05002662
2663 @Override
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002664 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08002665 List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
2666 List<String> cdmaNonRoamingList) {
Shishir Agrawalc04d9752016-02-19 10:41:00 -08002667 enforceCarrierPrivilege(subId);
2668 final Phone phone = getPhone(subId);
2669 if (phone == null) {
2670 return false;
2671 }
2672 return phone.setRoamingOverride(gsmRoamingList, gsmNonRoamingList, cdmaRoamingList,
Shishir Agrawal621a47c2014-12-01 10:25:09 -08002673 cdmaNonRoamingList);
2674 }
2675
2676 @Override
Steven Liu4bf01bc2014-07-17 11:05:29 -05002677 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) {
2678 enforceModifyPermission();
2679
2680 int returnValue = 0;
2681 try {
2682 AsyncResult result = (AsyncResult)sendRequest(CMD_INVOKE_OEM_RIL_REQUEST_RAW, oemReq);
2683 if(result.exception == null) {
2684 if (result.result != null) {
2685 byte[] responseData = (byte[])(result.result);
2686 if(responseData.length > oemResp.length) {
2687 Log.w(LOG_TAG, "Buffer to copy response too small: Response length is " +
2688 responseData.length + "bytes. Buffer Size is " +
2689 oemResp.length + "bytes.");
2690 }
2691 System.arraycopy(responseData, 0, oemResp, 0, responseData.length);
2692 returnValue = responseData.length;
2693 }
2694 } else {
2695 CommandException ex = (CommandException) result.exception;
2696 returnValue = ex.getCommandError().ordinal();
2697 if(returnValue > 0) returnValue *= -1;
2698 }
2699 } catch (RuntimeException e) {
2700 Log.w(LOG_TAG, "sendOemRilRequestRaw: Runtime Exception");
2701 returnValue = (CommandException.Error.GENERIC_FAILURE.ordinal());
2702 if(returnValue > 0) returnValue *= -1;
2703 }
2704
2705 return returnValue;
2706 }
Wink Saville5d475dd2014-10-17 15:00:58 -07002707
2708 @Override
2709 public void setRadioCapability(RadioAccessFamily[] rafs) {
2710 try {
2711 ProxyController.getInstance().setRadioCapability(rafs);
2712 } catch (RuntimeException e) {
2713 Log.w(LOG_TAG, "setRadioCapability: Runtime Exception");
2714 }
2715 }
2716
2717 @Override
Robert Greenwalt36b23af2015-07-06 17:59:14 -07002718 public int getRadioAccessFamily(int phoneId, String callingPackage) {
2719 if (!canReadPhoneState(callingPackage, "getRadioAccessFamily")) {
2720 return RadioAccessFamily.RAF_UNKNOWN;
2721 }
2722
Wink Saville5d475dd2014-10-17 15:00:58 -07002723 return ProxyController.getInstance().getRadioAccessFamily(phoneId);
2724 }
Andrew Leedf14ead2014-10-17 14:22:52 -07002725
2726 @Override
2727 public void enableVideoCalling(boolean enable) {
2728 enforceModifyPermission();
Tyler Gunnfdd69de2015-12-04 21:24:38 -08002729 ImsManager.setVtSetting(mPhone.getContext(), enable);
Andrew Leedf14ead2014-10-17 14:22:52 -07002730 }
2731
2732 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002733 public boolean isVideoCallingEnabled(String callingPackage) {
2734 if (!canReadPhoneState(callingPackage, "isVideoCallingEnabled")) {
2735 return false;
2736 }
2737
Andrew Lee77527ac2014-10-21 16:57:39 -07002738 // Check the user preference and the system-level IMS setting. Even if the user has
2739 // enabled video calling, if IMS is disabled we aren't able to support video calling.
2740 // In the long run, we may instead need to check if there exists a connection service
2741 // which can support video calling.
Andrew Lee312e8172014-10-23 17:01:36 -07002742 return ImsManager.isVtEnabledByPlatform(mPhone.getContext())
2743 && ImsManager.isEnhanced4gLteModeSettingEnabledByUser(mPhone.getContext())
Tyler Gunnfdd69de2015-12-04 21:24:38 -08002744 && ImsManager.isVtEnabledByUser(mPhone.getContext());
Andrew Leedf14ead2014-10-17 14:22:52 -07002745 }
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06002746
Andrew Leea1239f22015-03-02 17:44:07 -08002747 @Override
2748 public boolean canChangeDtmfToneLength() {
Jonathan Basseri9504c6b2015-06-04 14:23:32 -07002749 return mApp.getCarrierConfig().getBoolean(CarrierConfigManager.KEY_DTMF_TYPE_ENABLED_BOOL);
Andrew Leea1239f22015-03-02 17:44:07 -08002750 }
2751
2752 @Override
2753 public boolean isWorldPhone() {
Jonathan Basseri9504c6b2015-06-04 14:23:32 -07002754 return mApp.getCarrierConfig().getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL);
Andrew Leea1239f22015-03-02 17:44:07 -08002755 }
2756
Andrew Lee9431b832015-03-09 18:46:45 -07002757 @Override
2758 public boolean isTtyModeSupported() {
2759 TelecomManager telecomManager = TelecomManager.from(mPhone.getContext());
2760 TelephonyManager telephonyManager =
2761 (TelephonyManager) mPhone.getContext().getSystemService(Context.TELEPHONY_SERVICE);
2762 return !telephonyManager.isMultiSimEnabled() && telecomManager.isTtySupported();
2763 }
2764
2765 @Override
2766 public boolean isHearingAidCompatibilitySupported() {
2767 return mPhone.getContext().getResources().getBoolean(R.bool.hac_enabled);
2768 }
2769
Sanket Padawe7310cc72015-01-14 09:53:20 -08002770 /**
2771 * Returns the unique device ID of phone, for example, the IMEI for
2772 * GSM and the MEID for CDMA phones. Return null if device ID is not available.
2773 *
2774 * <p>Requires Permission:
2775 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
2776 */
2777 @Override
Svet Ganovb320e182015-04-16 12:30:10 -07002778 public String getDeviceId(String callingPackage) {
2779 if (!canReadPhoneState(callingPackage, "getDeviceId")) {
2780 return null;
2781 }
2782
Sanket Padawe7310cc72015-01-14 09:53:20 -08002783 final Phone phone = PhoneFactory.getPhone(0);
2784 if (phone != null) {
2785 return phone.getDeviceId();
2786 } else {
2787 return null;
2788 }
2789 }
2790
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06002791 /*
2792 * {@hide}
2793 * Returns the IMS Registration Status
2794 */
Santos Cordon7a1885b2015-02-03 11:15:19 -08002795 @Override
Libin.Tang@motorola.comafe82642014-12-18 13:27:53 -06002796 public boolean isImsRegistered() {
2797 return mPhone.isImsRegistered();
2798 }
Santos Cordon7a1885b2015-02-03 11:15:19 -08002799
2800 @Override
2801 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
2802 return PhoneUtils.getSubIdForPhoneAccount(phoneAccount);
2803 }
Nathan Harolddcfc7932015-03-18 10:01:20 -07002804
Nathan Haroldc55097a2015-03-11 18:14:50 -07002805 /*
2806 * {@hide}
2807 * Returns the IMS Registration Status
2808 */
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07002809 public boolean isWifiCallingAvailable() {
Nathan Haroldc55097a2015-03-11 18:14:50 -07002810 return mPhone.isWifiCallingEnabled();
2811 }
2812
2813 /*
2814 * {@hide}
2815 * Returns the IMS Registration Status
2816 */
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07002817 public boolean isVolteAvailable() {
Nathan Haroldc55097a2015-03-11 18:14:50 -07002818 return mPhone.isVolteEnabled();
2819 }
Svet Ganovb320e182015-04-16 12:30:10 -07002820
Etan Cohen3b7a1bc2015-05-28 15:57:13 -07002821 /*
2822 * {@hide} Returns the IMS Registration Status
2823 */
2824 public boolean isVideoTelephonyAvailable() {
2825 return mPhone.isVideoEnabled();
2826 }
2827
Svet Ganovb320e182015-04-16 12:30:10 -07002828 private boolean canReadPhoneState(String callingPackage, String message) {
Etan Cohen921655c2015-06-24 13:54:50 -07002829 try {
Amit Mahajan83ea23b2015-07-30 16:05:11 -07002830 mApp.enforceCallingOrSelfPermission(
Etan Cohen921655c2015-06-24 13:54:50 -07002831 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, message);
2832
Amit Mahajan83ea23b2015-07-30 16:05:11 -07002833 // SKIP checking for run-time permission since caller or self has PRIVILEDGED permission
Etan Cohen921655c2015-06-24 13:54:50 -07002834 return true;
Amit Mahajan785783f2015-06-29 10:36:50 -07002835 } catch (SecurityException e) {
2836 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_PHONE_STATE,
2837 message);
Etan Cohen921655c2015-06-24 13:54:50 -07002838 }
Svet Ganovb320e182015-04-16 12:30:10 -07002839
2840 if (mAppOps.noteOp(AppOpsManager.OP_READ_PHONE_STATE, Binder.getCallingUid(),
2841 callingPackage) != AppOpsManager.MODE_ALLOWED) {
2842 return false;
2843 }
2844
2845 return true;
2846 }
Stuart Scott8eef64f2015-04-08 15:13:54 -07002847
Makoto Onukifee69342015-06-29 14:44:50 -07002848 /**
Amit Mahajanb9b49782015-09-15 18:16:32 -07002849 * Besides READ_PHONE_STATE, WRITE_SMS and READ_SMS also allow apps to get phone numbers.
Makoto Onukifee69342015-06-29 14:44:50 -07002850 */
2851 private boolean canReadPhoneNumber(String callingPackage, String message) {
Makoto Onukie4072d12015-08-03 15:12:23 -07002852 // Default SMS app can always read it.
2853 if (mAppOps.noteOp(AppOpsManager.OP_WRITE_SMS,
2854 Binder.getCallingUid(), callingPackage) == AppOpsManager.MODE_ALLOWED) {
2855 return true;
2856 }
2857 try {
2858 return canReadPhoneState(callingPackage, message);
Amit Mahajanb9b49782015-09-15 18:16:32 -07002859 } catch (SecurityException readPhoneStateSecurityException) {
2860 try {
2861 // Can be read with READ_SMS too.
2862 mApp.enforceCallingOrSelfPermission(android.Manifest.permission.READ_SMS, message);
2863 return mAppOps.noteOp(AppOpsManager.OP_READ_SMS,
2864 Binder.getCallingUid(), callingPackage) == AppOpsManager.MODE_ALLOWED;
2865 } catch (SecurityException readSmsSecurityException) {
2866 // Throw exception with message including both READ_PHONE_STATE and READ_SMS
2867 // permissions
2868 throw new SecurityException(message + ": Neither user " + Binder.getCallingUid() +
2869 " nor current process has " + android.Manifest.permission.READ_PHONE_STATE +
2870 " or " + android.Manifest.permission.READ_SMS + ".");
2871 }
Makoto Onukie4072d12015-08-03 15:12:23 -07002872 }
Makoto Onukifee69342015-06-29 14:44:50 -07002873 }
2874
Stuart Scott8eef64f2015-04-08 15:13:54 -07002875 @Override
2876 public void factoryReset(int subId) {
2877 enforceConnectivityInternalPermission();
Stuart Scott981d8582015-04-21 14:09:50 -07002878 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
2879 return;
2880 }
2881
Svet Ganovcc087f82015-05-12 20:35:54 -07002882 final long identity = Binder.clearCallingIdentity();
2883 try {
Stuart Scott981d8582015-04-21 14:09:50 -07002884 if (SubscriptionManager.isUsableSubIdValue(subId) && !mUserManager.hasUserRestriction(
2885 UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
Svet Ganovcc087f82015-05-12 20:35:54 -07002886 // Enable data
2887 setDataEnabled(subId, true);
2888 // Set network selection mode to automatic
2889 setNetworkSelectionModeAutomatic(subId);
2890 // Set preferred mobile network type to the best available
2891 setPreferredNetworkType(subId, Phone.PREFERRED_NT_MODE);
2892 // Turn off roaming
2893 SubscriptionManager.from(mApp).setDataRoaming(0, subId);
2894 }
2895 } finally {
2896 Binder.restoreCallingIdentity(identity);
Stuart Scott8eef64f2015-04-08 15:13:54 -07002897 }
2898 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01002899
2900 @Override
2901 public String getLocaleFromDefaultSim() {
2902 // We query all subscriptions instead of just the active ones, because
2903 // this might be called early on in the provisioning flow when the
2904 // subscriptions potentially aren't active yet.
2905 final List<SubscriptionInfo> slist = getAllSubscriptionInfoList();
2906 if (slist == null || slist.isEmpty()) {
2907 return null;
2908 }
2909
2910 // This function may be called very early, say, from the setup wizard, at
2911 // which point we won't have a default subscription set. If that's the case
2912 // we just choose the first, which will be valid in "most cases".
2913 final int defaultSubId = getDefaultSubscription();
2914 SubscriptionInfo info = null;
2915 if (defaultSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
2916 info = slist.get(0);
2917 } else {
2918 for (SubscriptionInfo item : slist) {
2919 if (item.getSubscriptionId() == defaultSubId) {
2920 info = item;
2921 break;
2922 }
2923 }
2924
2925 if (info == null) {
2926 return null;
2927 }
2928 }
2929
2930 // Try and fetch the locale from the carrier properties or from the SIM language
2931 // preferences (EF-PL and EF-LI)...
Tony Hill183b2de2015-06-24 14:53:58 +01002932 final int mcc = info.getMcc();
Narayan Kamath1c496c22015-04-16 14:40:19 +01002933 final Phone defaultPhone = getPhone(info.getSubscriptionId());
Narayan Kamath011676f2015-07-29 12:04:08 +01002934 String simLanguage = null;
Narayan Kamath1c496c22015-04-16 14:40:19 +01002935 if (defaultPhone != null) {
2936 final Locale localeFromDefaultSim = defaultPhone.getLocaleFromSimAndCarrierPrefs();
2937 if (localeFromDefaultSim != null) {
Narayan Kamath011676f2015-07-29 12:04:08 +01002938 if (!localeFromDefaultSim.getCountry().isEmpty()) {
Tony Hill183b2de2015-06-24 14:53:58 +01002939 if (DBG) log("Using locale from default SIM:" + localeFromDefaultSim);
2940 return localeFromDefaultSim.toLanguageTag();
Narayan Kamath011676f2015-07-29 12:04:08 +01002941 } else {
2942 simLanguage = localeFromDefaultSim.getLanguage();
Tony Hill183b2de2015-06-24 14:53:58 +01002943 }
Narayan Kamath1c496c22015-04-16 14:40:19 +01002944 }
2945 }
2946
Narayan Kamath011676f2015-07-29 12:04:08 +01002947 // The SIM language preferences only store a language (e.g. fr = French), not an
2948 // exact locale (e.g. fr_FR = French/France). So, if the locale returned from
2949 // the SIM and carrier preferences does not include a country we add the country
2950 // determined from the SIM MCC to provide an exact locale.
2951 final Locale mccLocale = MccTable.getLocaleFromMcc(mPhone.getContext(), mcc, simLanguage);
Tony Hill183b2de2015-06-24 14:53:58 +01002952 if (mccLocale != null) {
2953 if (DBG) log("No locale from default SIM, using mcc locale:" + mccLocale);
2954 return mccLocale.toLanguageTag();
Narayan Kamath1c496c22015-04-16 14:40:19 +01002955 }
2956
Tony Hill183b2de2015-06-24 14:53:58 +01002957 if (DBG) log("No locale found - returning null");
Narayan Kamath1c496c22015-04-16 14:40:19 +01002958 return null;
2959 }
2960
2961 private List<SubscriptionInfo> getAllSubscriptionInfoList() {
2962 final long identity = Binder.clearCallingIdentity();
2963 try {
2964 return mSubscriptionController.getAllSubInfoList(
2965 mPhone.getContext().getOpPackageName());
2966 } finally {
2967 Binder.restoreCallingIdentity(identity);
2968 }
2969 }
2970
2971 private List<SubscriptionInfo> getActiveSubscriptionInfoList() {
2972 final long identity = Binder.clearCallingIdentity();
2973 try {
2974 return mSubscriptionController.getActiveSubscriptionInfoList(
2975 mPhone.getContext().getOpPackageName());
2976 } finally {
2977 Binder.restoreCallingIdentity(identity);
2978 }
2979 }
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07002980
2981 /**
Adam Lesinski903a54c2016-04-11 14:49:52 -07002982 * Responds to the ResultReceiver with the {@link android.telephony.ModemActivityInfo} object
2983 * representing the state of the modem.
2984 *
2985 * NOTE: This clears the modem state, so there should only every be one caller.
2986 * @hide
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07002987 */
2988 @Override
Adam Lesinski903a54c2016-04-11 14:49:52 -07002989 public void requestModemActivityInfo(ResultReceiver result) {
2990 enforceModifyPermission();
2991
2992 ModemActivityInfo info = (ModemActivityInfo) sendRequest(CMD_GET_MODEM_ACTIVITY_INFO, null);
2993 Bundle bundle = new Bundle();
2994 bundle.putParcelable(TelephonyManager.MODEM_ACTIVITY_RESULT_KEY, info);
2995 result.send(0, bundle);
Prerepa Viswanadham7fcff692015-06-03 11:20:55 -07002996 }
Jack Yu85bd38a2015-11-09 11:34:32 -08002997
2998 /**
2999 * {@hide}
3000 * Returns the service state information on specified subscription.
3001 */
3002 @Override
3003 public ServiceState getServiceStateForSubscriber(int subId, String callingPackage) {
3004
3005 if (!canReadPhoneState(callingPackage, "getServiceStateForSubscriber")) {
3006 return null;
3007 }
3008
3009 final Phone phone = getPhone(subId);
3010 if (phone == null) {
3011 return null;
3012 }
3013
3014 return phone.getServiceState();
3015 }
Nancy Chen31f9ba12016-01-06 11:42:12 -08003016
3017 /**
3018 * Returns the URI for the per-account voicemail ringtone set in Phone settings.
3019 *
3020 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
3021 * voicemail ringtone.
3022 * @return The URI for the ringtone to play when receiving a voicemail from a specific
3023 * PhoneAccount.
3024 */
3025 @Override
3026 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) {
3027 final Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
3028 if (phone == null) {
3029 return null;
3030 }
3031
3032 return VoicemailNotificationSettingsUtil.getRingtoneUri(phone);
3033 }
3034
3035 /**
3036 * Returns whether vibration is set for voicemail notification in Phone settings.
3037 *
3038 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the
3039 * voicemail vibration setting.
3040 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise.
3041 */
3042 @Override
3043 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) {
3044 final Phone phone = PhoneUtils.getPhoneForPhoneAccountHandle(accountHandle);
3045 if (phone == null) {
3046 return false;
3047 }
3048
3049 return VoicemailNotificationSettingsUtil.isVibrationEnabled(phone);
3050 }
3051
Santos Cordon7d4ddf62013-07-10 11:58:08 -07003052}