blob: a34abc029c23b6c41f6e51090af3198ab6b71c82 [file] [log] [blame]
Brad Ebinger4dc095a2018-04-03 15:17:52 -07001/*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.phone;
18
Hall Liud892bec2018-11-30 14:51:45 -080019import android.os.Binder;
20import android.os.Process;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070021import android.os.RemoteException;
22import android.os.ShellCommand;
sqian2fff4a32018-11-05 14:18:37 -080023import android.os.UserHandle;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070024import android.telephony.SubscriptionManager;
sqian9d4df8b2019-01-15 18:32:07 -080025import android.telephony.emergency.EmergencyNumber;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070026import android.util.Log;
27
28import com.android.internal.telephony.ITelephony;
sqian9d4df8b2019-01-15 18:32:07 -080029import com.android.internal.telephony.emergency.EmergencyNumberTracker;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070030
31import java.io.PrintWriter;
sqian9d4df8b2019-01-15 18:32:07 -080032import java.util.ArrayList;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070033
34/**
35 * Takes actions based on the adb commands given by "adb shell cmd phone ...". Be careful, no
36 * permission checks have been done before onCommand was called. Make sure any commands processed
37 * here also contain the appropriate permissions checks.
38 */
39
40public class TelephonyShellCommand extends ShellCommand {
41
42 private static final String LOG_TAG = "TelephonyShellCommand";
43 // Don't commit with this true.
44 private static final boolean VDBG = true;
Brad Ebinger0aa2f242018-04-12 09:49:23 -070045 private static final int DEFAULT_PHONE_ID = 0;
Brad Ebinger4dc095a2018-04-03 15:17:52 -070046
47 private static final String IMS_SUBCOMMAND = "ims";
sqian2fff4a32018-11-05 14:18:37 -080048 private static final String SMS_SUBCOMMAND = "sms";
Hall Liud892bec2018-11-30 14:51:45 -080049 private static final String NUMBER_VERIFICATION_SUBCOMMAND = "numverify";
sqian9d4df8b2019-01-15 18:32:07 -080050 private static final String EMERGENCY_NUMBER_TEST_MODE = "emergency-number-test-mode";
Hall Liud892bec2018-11-30 14:51:45 -080051
Brad Ebinger4dc095a2018-04-03 15:17:52 -070052 private static final String IMS_SET_CARRIER_SERVICE = "set-ims-service";
53 private static final String IMS_GET_CARRIER_SERVICE = "get-ims-service";
54 private static final String IMS_ENABLE = "enable";
55 private static final String IMS_DISABLE = "disable";
Tyler Gunn7bcdc742019-10-04 15:56:59 -070056 // Used to disable or enable processing of conference event package data from the network.
57 // This is handy for testing scenarios where CEP data does not exist on a network which does
58 // support CEP data.
59 private static final String IMS_CEP = "conference-event-package";
Brad Ebinger4dc095a2018-04-03 15:17:52 -070060
sqian2fff4a32018-11-05 14:18:37 -080061 private static final String SMS_GET_APPS = "get-apps";
62 private static final String SMS_GET_DEFAULT_APP = "get-default-app";
63 private static final String SMS_SET_DEFAULT_APP = "set-default-app";
64
Hall Liud892bec2018-11-30 14:51:45 -080065 private static final String NUMBER_VERIFICATION_OVERRIDE_PACKAGE = "override-package";
Hall Liuca5af3a2018-12-04 16:58:23 -080066 private static final String NUMBER_VERIFICATION_FAKE_CALL = "fake-call";
Hall Liud892bec2018-11-30 14:51:45 -080067
Brad Ebinger4dc095a2018-04-03 15:17:52 -070068 // Take advantage of existing methods that already contain permissions checks when possible.
69 private final ITelephony mInterface;
70
71 public TelephonyShellCommand(ITelephony binder) {
72 mInterface = binder;
73 }
74
75 @Override
76 public int onCommand(String cmd) {
77 if (cmd == null) {
78 return handleDefaultCommands(null);
79 }
80
81 switch (cmd) {
82 case IMS_SUBCOMMAND: {
83 return handleImsCommand();
84 }
sqian2fff4a32018-11-05 14:18:37 -080085 case SMS_SUBCOMMAND: {
86 return handleSmsCommand();
87 }
Hall Liud892bec2018-11-30 14:51:45 -080088 case NUMBER_VERIFICATION_SUBCOMMAND:
89 return handleNumberVerificationCommand();
sqian9d4df8b2019-01-15 18:32:07 -080090 case EMERGENCY_NUMBER_TEST_MODE:
91 return handleEmergencyNumberTestModeCommand();
Brad Ebinger4dc095a2018-04-03 15:17:52 -070092 default: {
93 return handleDefaultCommands(cmd);
94 }
95 }
96 }
97
98 @Override
99 public void onHelp() {
100 PrintWriter pw = getOutPrintWriter();
101 pw.println("Telephony Commands:");
102 pw.println(" help");
103 pw.println(" Print this help text.");
104 pw.println(" ims");
105 pw.println(" IMS Commands.");
sqian2fff4a32018-11-05 14:18:37 -0800106 pw.println(" sms");
107 pw.println(" SMS Commands.");
sqian9d4df8b2019-01-15 18:32:07 -0800108 pw.println(" emergency-number-test-mode");
109 pw.println(" Emergency Number Test Mode Commands.");
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700110 onHelpIms();
sqian2fff4a32018-11-05 14:18:37 -0800111 onHelpSms();
sqian9d4df8b2019-01-15 18:32:07 -0800112 onHelpEmergencyNumber();
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700113 }
114
115 private void onHelpIms() {
116 PrintWriter pw = getOutPrintWriter();
117 pw.println("IMS Commands:");
118 pw.println(" ims set-ims-service [-s SLOT_ID] (-c | -d) PACKAGE_NAME");
119 pw.println(" Sets the ImsService defined in PACKAGE_NAME to to be the bound");
120 pw.println(" ImsService. Options are:");
121 pw.println(" -s: the slot ID that the ImsService should be bound for. If no option");
122 pw.println(" is specified, it will choose the default voice SIM slot.");
123 pw.println(" -c: Override the ImsService defined in the carrier configuration.");
124 pw.println(" -d: Override the ImsService defined in the device overlay.");
125 pw.println(" ims get-ims-service [-s SLOT_ID] [-c | -d]");
126 pw.println(" Gets the package name of the currently defined ImsService.");
127 pw.println(" Options are:");
128 pw.println(" -s: The SIM slot ID for the registered ImsService. If no option");
129 pw.println(" is specified, it will choose the default voice SIM slot.");
130 pw.println(" -c: The ImsService defined as the carrier configured ImsService.");
131 pw.println(" -c: The ImsService defined as the device default ImsService.");
132 pw.println(" ims enable [-s SLOT_ID]");
133 pw.println(" enables IMS for the SIM slot specified, or for the default voice SIM slot");
134 pw.println(" if none is specified.");
135 pw.println(" ims disable [-s SLOT_ID]");
136 pw.println(" disables IMS for the SIM slot specified, or for the default voice SIM");
137 pw.println(" slot if none is specified.");
Tyler Gunn7bcdc742019-10-04 15:56:59 -0700138 pw.println(" ims conference-event-package [enable/disable]");
139 pw.println(" enables or disables handling or network conference event package data.");
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700140 }
141
sqian2fff4a32018-11-05 14:18:37 -0800142 private void onHelpSms() {
143 PrintWriter pw = getOutPrintWriter();
144 pw.println("SMS Commands:");
145 pw.println(" sms get-apps [--user USER_ID]");
146 pw.println(" Print all SMS apps on a user.");
147 pw.println(" sms get-default-app [--user USER_ID]");
148 pw.println(" Get the default SMS app.");
149 pw.println(" sms set-default-app [--user USER_ID] PACKAGE_NAME");
150 pw.println(" Set PACKAGE_NAME as the default SMS app.");
151 }
152
Hall Liud892bec2018-11-30 14:51:45 -0800153
154 private void onHelpNumberVerification() {
155 PrintWriter pw = getOutPrintWriter();
156 pw.println("Number verification commands");
157 pw.println(" numverify override-package PACKAGE_NAME;");
158 pw.println(" Set the authorized package for number verification.");
159 pw.println(" Leave the package name blank to reset.");
Hall Liuca5af3a2018-12-04 16:58:23 -0800160 pw.println(" numverify fake-call NUMBER;");
161 pw.println(" Fake an incoming call from NUMBER. This is for testing. Output will be");
162 pw.println(" 1 if the call would have been intercepted, 0 otherwise.");
Hall Liud892bec2018-11-30 14:51:45 -0800163 }
164
sqian9d4df8b2019-01-15 18:32:07 -0800165 private void onHelpEmergencyNumber() {
166 PrintWriter pw = getOutPrintWriter();
167 pw.println("Emergency Number Test Mode Commands:");
168 pw.println(" emergency-number-test-mode ");
169 pw.println(" Add(-a), Clear(-c), Print (-p) or Remove(-r) the emergency number list in"
170 + " the test mode");
171 pw.println(" -a <emergency number address>: add an emergency number address for the"
sqian9121f982019-03-14 19:45:39 -0700172 + " test mode, only allows '0'-'9', '*', '#' or '+'.");
sqian9d4df8b2019-01-15 18:32:07 -0800173 pw.println(" -c: clear the emergency number list in the test mode.");
174 pw.println(" -r <emergency number address>: remove an existing emergency number"
sqian9121f982019-03-14 19:45:39 -0700175 + " address added by the test mode, only allows '0'-'9', '*', '#' or '+'.");
sqian9d4df8b2019-01-15 18:32:07 -0800176 pw.println(" -p: get the full emergency number list in the test mode.");
177 }
178
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700179 private int handleImsCommand() {
180 String arg = getNextArg();
181 if (arg == null) {
182 onHelpIms();
183 return 0;
184 }
185
186 switch (arg) {
187 case IMS_SET_CARRIER_SERVICE: {
188 return handleImsSetServiceCommand();
189 }
190 case IMS_GET_CARRIER_SERVICE: {
191 return handleImsGetServiceCommand();
192 }
193 case IMS_ENABLE: {
194 return handleEnableIms();
195 }
196 case IMS_DISABLE: {
197 return handleDisableIms();
198 }
Tyler Gunn7bcdc742019-10-04 15:56:59 -0700199 case IMS_CEP: {
200 return handleCepChange();
201 }
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700202 }
203
204 return -1;
205 }
206
sqian9d4df8b2019-01-15 18:32:07 -0800207 private int handleEmergencyNumberTestModeCommand() {
208 PrintWriter errPw = getErrPrintWriter();
209 String opt = getNextOption();
210 if (opt == null) {
211 onHelpEmergencyNumber();
212 return 0;
213 }
214
215 switch (opt) {
216 case "-a": {
217 String emergencyNumberCmd = getNextArgRequired();
218 if (emergencyNumberCmd == null
219 || !EmergencyNumber.validateEmergencyNumberAddress(emergencyNumberCmd)) {
sqian9121f982019-03-14 19:45:39 -0700220 errPw.println("An emergency number (only allow '0'-'9', '*', '#' or '+') needs"
sqian9d4df8b2019-01-15 18:32:07 -0800221 + " to be specified after -a in the command ");
222 return -1;
223 }
224 try {
225 mInterface.updateEmergencyNumberListTestMode(
226 EmergencyNumberTracker.ADD_EMERGENCY_NUMBER_TEST_MODE,
227 new EmergencyNumber(emergencyNumberCmd, "", "",
228 EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED,
229 new ArrayList<String>(),
230 EmergencyNumber.EMERGENCY_NUMBER_SOURCE_TEST,
231 EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN));
232 } catch (RemoteException ex) {
233 Log.w(LOG_TAG, "emergency-number-test-mode -a " + emergencyNumberCmd
234 + ", error " + ex.getMessage());
235 errPw.println("Exception: " + ex.getMessage());
236 return -1;
237 }
238 break;
239 }
240 case "-c": {
241 try {
242 mInterface.updateEmergencyNumberListTestMode(
243 EmergencyNumberTracker.RESET_EMERGENCY_NUMBER_TEST_MODE, null);
244 } catch (RemoteException ex) {
245 Log.w(LOG_TAG, "emergency-number-test-mode -c " + "error " + ex.getMessage());
246 errPw.println("Exception: " + ex.getMessage());
247 return -1;
248 }
249 break;
250 }
251 case "-r": {
252 String emergencyNumberCmd = getNextArgRequired();
253 if (emergencyNumberCmd == null
254 || !EmergencyNumber.validateEmergencyNumberAddress(emergencyNumberCmd)) {
sqian9121f982019-03-14 19:45:39 -0700255 errPw.println("An emergency number (only allow '0'-'9', '*', '#' or '+') needs"
sqian9d4df8b2019-01-15 18:32:07 -0800256 + " to be specified after -r in the command ");
257 return -1;
258 }
259 try {
260 mInterface.updateEmergencyNumberListTestMode(
261 EmergencyNumberTracker.REMOVE_EMERGENCY_NUMBER_TEST_MODE,
262 new EmergencyNumber(emergencyNumberCmd, "", "",
263 EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED,
264 new ArrayList<String>(),
265 EmergencyNumber.EMERGENCY_NUMBER_SOURCE_TEST,
266 EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN));
267 } catch (RemoteException ex) {
268 Log.w(LOG_TAG, "emergency-number-test-mode -r " + emergencyNumberCmd
269 + ", error " + ex.getMessage());
270 errPw.println("Exception: " + ex.getMessage());
271 return -1;
272 }
273 break;
274 }
275 case "-p": {
276 try {
277 getOutPrintWriter().println(mInterface.getEmergencyNumberListTestMode());
278 } catch (RemoteException ex) {
279 Log.w(LOG_TAG, "emergency-number-test-mode -p " + "error " + ex.getMessage());
280 errPw.println("Exception: " + ex.getMessage());
281 return -1;
282 }
283 break;
284 }
285 default:
286 onHelpEmergencyNumber();
287 break;
288 }
289 return 0;
290 }
291
Hall Liud892bec2018-11-30 14:51:45 -0800292 private int handleNumberVerificationCommand() {
293 String arg = getNextArg();
294 if (arg == null) {
295 onHelpNumberVerification();
296 return 0;
297 }
298
Hall Liuca5af3a2018-12-04 16:58:23 -0800299 if (!checkShellUid()) {
300 return -1;
301 }
302
Hall Liud892bec2018-11-30 14:51:45 -0800303 switch (arg) {
304 case NUMBER_VERIFICATION_OVERRIDE_PACKAGE: {
Hall Liud892bec2018-11-30 14:51:45 -0800305 NumberVerificationManager.overrideAuthorizedPackage(getNextArg());
306 return 0;
307 }
Hall Liuca5af3a2018-12-04 16:58:23 -0800308 case NUMBER_VERIFICATION_FAKE_CALL: {
309 boolean val = NumberVerificationManager.getInstance()
310 .checkIncomingCall(getNextArg());
311 getOutPrintWriter().println(val ? "1" : "0");
312 return 0;
313 }
Hall Liud892bec2018-11-30 14:51:45 -0800314 }
315
316 return -1;
317 }
318
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700319 // ims set-ims-service
320 private int handleImsSetServiceCommand() {
321 PrintWriter errPw = getErrPrintWriter();
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700322 int slotId = getDefaultSlot();
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700323 Boolean isCarrierService = null;
324
325 String opt;
326 while ((opt = getNextOption()) != null) {
327 switch (opt) {
328 case "-s": {
329 try {
330 slotId = Integer.parseInt(getNextArgRequired());
331 } catch (NumberFormatException e) {
332 errPw.println("ims set-ims-service requires an integer as a SLOT_ID.");
333 return -1;
334 }
335 break;
336 }
337 case "-c": {
338 isCarrierService = true;
339 break;
340 }
341 case "-d": {
342 isCarrierService = false;
343 break;
344 }
345 }
346 }
347 // Mandatory param, either -c or -d
348 if (isCarrierService == null) {
349 errPw.println("ims set-ims-service requires either \"-c\" or \"-d\" to be set.");
350 return -1;
351 }
352
353 String packageName = getNextArg();
354
355 try {
356 if (packageName == null) {
357 packageName = "";
358 }
359 boolean result = mInterface.setImsService(slotId, isCarrierService, packageName);
360 if (VDBG) {
361 Log.v(LOG_TAG, "ims set-ims-service -s " + slotId + " "
362 + (isCarrierService ? "-c " : "-d ") + packageName + ", result=" + result);
363 }
364 getOutPrintWriter().println(result);
365 } catch (RemoteException e) {
366 Log.w(LOG_TAG, "ims set-ims-service -s " + slotId + " "
367 + (isCarrierService ? "-c " : "-d ") + packageName + ", error"
368 + e.getMessage());
369 errPw.println("Exception: " + e.getMessage());
370 return -1;
371 }
372 return 0;
373 }
374
375 // ims get-ims-service
376 private int handleImsGetServiceCommand() {
377 PrintWriter errPw = getErrPrintWriter();
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700378 int slotId = getDefaultSlot();
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700379 Boolean isCarrierService = null;
380
381 String opt;
382 while ((opt = getNextOption()) != null) {
383 switch (opt) {
384 case "-s": {
385 try {
386 slotId = Integer.parseInt(getNextArgRequired());
387 } catch (NumberFormatException e) {
388 errPw.println("ims set-ims-service requires an integer as a SLOT_ID.");
389 return -1;
390 }
391 break;
392 }
393 case "-c": {
394 isCarrierService = true;
395 break;
396 }
397 case "-d": {
398 isCarrierService = false;
399 break;
400 }
401 }
402 }
403 // Mandatory param, either -c or -d
404 if (isCarrierService == null) {
405 errPw.println("ims set-ims-service requires either \"-c\" or \"-d\" to be set.");
406 return -1;
407 }
408
409 String result;
410 try {
411 result = mInterface.getImsService(slotId, isCarrierService);
412 } catch (RemoteException e) {
413 return -1;
414 }
415 if (VDBG) {
416 Log.v(LOG_TAG, "ims get-ims-service -s " + slotId + " "
417 + (isCarrierService ? "-c " : "-d ") + ", returned: " + result);
418 }
419 getOutPrintWriter().println(result);
420 return 0;
421 }
422
423 private int handleEnableIms() {
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700424 int slotId = getDefaultSlot();
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700425 String opt;
426 while ((opt = getNextOption()) != null) {
427 switch (opt) {
428 case "-s": {
429 try {
430 slotId = Integer.parseInt(getNextArgRequired());
431 } catch (NumberFormatException e) {
432 getErrPrintWriter().println("ims enable requires an integer as a SLOT_ID.");
433 return -1;
434 }
435 break;
436 }
437 }
438 }
439 try {
440 mInterface.enableIms(slotId);
441 } catch (RemoteException e) {
442 return -1;
443 }
444 if (VDBG) {
445 Log.v(LOG_TAG, "ims enable -s " + slotId);
446 }
447 return 0;
448 }
449
450 private int handleDisableIms() {
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700451 int slotId = getDefaultSlot();
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700452 String opt;
453 while ((opt = getNextOption()) != null) {
454 switch (opt) {
455 case "-s": {
456 try {
457 slotId = Integer.parseInt(getNextArgRequired());
458 } catch (NumberFormatException e) {
459 getErrPrintWriter().println(
460 "ims disable requires an integer as a SLOT_ID.");
461 return -1;
462 }
463 break;
464 }
465 }
466 }
467 try {
468 mInterface.disableIms(slotId);
469 } catch (RemoteException e) {
470 return -1;
471 }
472 if (VDBG) {
473 Log.v(LOG_TAG, "ims disable -s " + slotId);
474 }
475 return 0;
476 }
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700477
Tyler Gunn7bcdc742019-10-04 15:56:59 -0700478 private int handleCepChange() {
479 Log.i(LOG_TAG, "handleCepChange");
480 String opt = getNextArg();
481 if (opt == null) {
482 return -1;
483 }
484 boolean isCepEnabled = opt.equals("enable");
485
486 try {
487 mInterface.setCepEnabled(isCepEnabled);
488 } catch (RemoteException e) {
489 return -1;
490 }
491 return 0;
492 }
493
Brad Ebinger0aa2f242018-04-12 09:49:23 -0700494 private int getDefaultSlot() {
495 int slotId = SubscriptionManager.getDefaultVoicePhoneId();
496 if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX
497 || slotId == SubscriptionManager.DEFAULT_PHONE_INDEX) {
498 // If there is no default, default to slot 0.
499 slotId = DEFAULT_PHONE_ID;
500 }
501 return slotId;
502 }
sqian2fff4a32018-11-05 14:18:37 -0800503
504 private int handleSmsCommand() {
505 String arg = getNextArg();
506 if (arg == null) {
507 onHelpSms();
508 return 0;
509 }
510
511 try {
512 switch (arg) {
513 case SMS_GET_APPS: {
514 return handleSmsGetApps();
515 }
516 case SMS_GET_DEFAULT_APP: {
517 return handleSmsGetDefaultApp();
518 }
519 case SMS_SET_DEFAULT_APP: {
520 return handleSmsSetDefaultApp();
521 }
522 default:
523 getErrPrintWriter().println("Unknown command " + arg);
524 }
525 } catch (RemoteException e) {
526 getErrPrintWriter().println("RemoteException: " + e.getMessage());
527 }
528
529 return -1;
530 }
531
532 private int maybeParseUserIdArg() {
533 int userId = UserHandle.USER_SYSTEM;
534 String opt;
535 while ((opt = getNextOption()) != null) {
536 switch (opt) {
537 case "--user": {
538 try {
539 userId = Integer.parseInt(getNextArgRequired());
540 } catch (NumberFormatException e) {
541 getErrPrintWriter().println("Invalid user ID for --user");
542 return -1;
543 }
544 break;
545 }
546 }
547 }
548 return userId;
549 }
550
551 private int handleSmsGetApps() throws RemoteException {
552 final int userId = maybeParseUserIdArg();
553 if (userId < 0) {
554 return -1;
555 }
556
557 for (String packageName : mInterface.getSmsApps(userId)) {
558 getOutPrintWriter().println(packageName);
559 }
560 return 0;
561 }
562
563 private int handleSmsGetDefaultApp() throws RemoteException {
564 final int userId = maybeParseUserIdArg();
565 if (userId < 0) {
566 return -1;
567 }
568
569 getOutPrintWriter().println(mInterface.getDefaultSmsApp(userId));
570 return 0;
571 }
572
573 private int handleSmsSetDefaultApp() throws RemoteException {
574 final int userId = maybeParseUserIdArg();
575 if (userId < 0) {
576 return -1;
577 }
578
579 String packageName = getNextArgRequired();
580 mInterface.setDefaultSmsApp(userId, packageName);
581 getOutPrintWriter().println("SMS app set to " + mInterface.getDefaultSmsApp(userId));
582 return 0;
583 }
Hall Liud892bec2018-11-30 14:51:45 -0800584
585 private boolean checkShellUid() {
Hall Liu2ddfc7e2018-12-06 13:09:45 -0800586 // adb can run as root or as shell, depending on whether the device is rooted.
587 return Binder.getCallingUid() == Process.SHELL_UID
588 || Binder.getCallingUid() == Process.ROOT_UID;
Hall Liud892bec2018-11-30 14:51:45 -0800589 }
Brad Ebinger4dc095a2018-04-03 15:17:52 -0700590}