core/java/android/app/ActivityManagerNative.java

   1 /*
   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
  17 package android.app;
  18
  19 import android.annotation.UserIdInt;
  20 import android.app.ActivityManager.StackInfo;
  21 import android.app.assist.AssistContent;
  22 import android.app.assist.AssistStructure;
  23 import android.content.ComponentName;
  24 import android.content.IIntentReceiver;
  25 import android.content.IIntentSender;
  26 import android.content.Intent;
  27 import android.content.IntentFilter;
  28 import android.content.IntentSender;
  29 import android.content.UriPermission;
  30 import android.content.pm.ApplicationInfo;
  31 import android.content.pm.ConfigurationInfo;
  32 import android.content.pm.IPackageDataObserver;
  33 import android.content.pm.ParceledListSlice;
  34 import android.content.pm.UserInfo;
  35 import android.content.res.Configuration;
  36 import android.graphics.Bitmap;
  37 import android.graphics.Point;
  38 import android.graphics.Rect;
  39 import android.net.Uri;
  40 import android.os.Binder;
  41 import android.os.Bundle;
  42 import android.os.Debug;
  43 import android.os.IBinder;
  44 import android.os.IProgressListener;
  45 import android.os.Parcel;
  46 import android.os.ParcelFileDescriptor;
  47 import android.os.Parcelable;
  48 import android.os.PersistableBundle;
  49 import android.os.RemoteException;
  50 import android.os.ServiceManager;
  51 import android.os.StrictMode;
  52 import android.service.voice.IVoiceInteractionSession;
  53 import android.text.TextUtils;
  54 import android.util.Log;
  55 import android.util.Singleton;
  56 import com.android.internal.app.IVoiceInteractor;
  57 import com.android.internal.os.IResultReceiver;
  58
  59 import java.util.ArrayList;
  60 import java.util.List;
  61
  62 /** {@hide} */
  63 public abstract class ActivityManagerNative extends Binder implements IActivityManager
  64 {
  65     /**
  66      * Cast a Binder object into an activity manager interface, generating
  67      * a proxy if needed.
  68      */
  69     static public IActivityManager asInterface(IBinder obj) {
  70         if (obj == null) {
  71             return null;
  72         }
  73         IActivityManager in =
  74             (IActivityManager)obj.queryLocalInterface(descriptor);
  75         if (in != null) {
  76             return in;
  77         }
  78
  79         return new ActivityManagerProxy(obj);
  80     }
  81
  82     /**
  83      * Retrieve the system's default/global activity manager.
  84      */
  85     static public IActivityManager getDefault() {
  86         return gDefault.get();
  87     }
  88
  89     /**
  90      * Convenience for checking whether the system is ready.  For internal use only.
  91      */
  92     static public boolean isSystemReady() {
  93         if (!sSystemReady) {
  94             sSystemReady = getDefault().testIsSystemReady();
  95         }
  96         return sSystemReady;
  97     }
  98     static volatile boolean sSystemReady = false;
  99
 100     static public void broadcastStickyIntent(Intent intent, String permission, int userId) {
 101         broadcastStickyIntent(intent, permission, AppOpsManager.OP_NONE, userId);
 102     }
 103
 104     /**
 105      * Convenience for sending a sticky broadcast.  For internal use only.
 106      * If you don't care about permission, use null.
 107      */
 108     static public void broadcastStickyIntent(Intent intent, String permission, int appOp,
 109             int userId) {
 110         try {
 111             getDefault().broadcastIntent(
 112                     null, intent, null, null, Activity.RESULT_OK, null, null,
 113                     null /*permission*/, appOp, null, false, true, userId);
 114         } catch (RemoteException ex) {
 115         }
 116     }
 117
 118     static public void noteWakeupAlarm(PendingIntent ps, int sourceUid, String sourcePkg,
 119             String tag) {
 120         try {
 121             getDefault().noteWakeupAlarm((ps != null) ? ps.getTarget() : null,
 122                     sourceUid, sourcePkg, tag);
 123         } catch (RemoteException ex) {
 124         }
 125     }
 126
 127     static public void noteAlarmStart(PendingIntent ps, int sourceUid, String tag) {
 128         try {
 129             getDefault().noteAlarmStart((ps != null) ? ps.getTarget() : null, sourceUid, tag);
 130         } catch (RemoteException ex) {
 131         }
 132     }
 133
 134     static public void noteAlarmFinish(PendingIntent ps, int sourceUid, String tag) {
 135         try {
 136             getDefault().noteAlarmFinish((ps != null) ? ps.getTarget() : null, sourceUid, tag);
 137         } catch (RemoteException ex) {
 138         }
 139     }
 140
 141     public ActivityManagerNative() {
 142         attachInterface(this, descriptor);
 143     }
 144
 145     @Override
 146     public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
 147             throws RemoteException {
 148         switch (code) {
 149         case START_ACTIVITY_TRANSACTION:
 150         {
 151             data.enforceInterface(IActivityManager.descriptor);
 152             IBinder b = data.readStrongBinder();
 153             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 154             String callingPackage = data.readString();
 155             Intent intent = Intent.CREATOR.createFromParcel(data);
 156             String resolvedType = data.readString();
 157             IBinder resultTo = data.readStrongBinder();
 158             String resultWho = data.readString();
 159             int requestCode = data.readInt();
 160             int startFlags = data.readInt();
 161             ProfilerInfo profilerInfo = data.readInt() != 0
 162                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
 163             Bundle options = data.readInt() != 0
 164                     ? Bundle.CREATOR.createFromParcel(data) : null;
 165             int result = startActivity(app, callingPackage, intent, resolvedType,
 166                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
 167             reply.writeNoException();
 168             reply.writeInt(result);
 169             return true;
 170         }
 171
 172         case START_ACTIVITY_AS_USER_TRANSACTION:
 173         {
 174             data.enforceInterface(IActivityManager.descriptor);
 175             IBinder b = data.readStrongBinder();
 176             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 177             String callingPackage = data.readString();
 178             Intent intent = Intent.CREATOR.createFromParcel(data);
 179             String resolvedType = data.readString();
 180             IBinder resultTo = data.readStrongBinder();
 181             String resultWho = data.readString();
 182             int requestCode = data.readInt();
 183             int startFlags = data.readInt();
 184             ProfilerInfo profilerInfo = data.readInt() != 0
 185                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
 186             Bundle options = data.readInt() != 0
 187                     ? Bundle.CREATOR.createFromParcel(data) : null;
 188             int userId = data.readInt();
 189             int result = startActivityAsUser(app, callingPackage, intent, resolvedType,
 190                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options, userId);
 191             reply.writeNoException();
 192             reply.writeInt(result);
 193             return true;
 194         }
 195
 196         case START_ACTIVITY_AS_CALLER_TRANSACTION:
 197         {
 198             data.enforceInterface(IActivityManager.descriptor);
 199             IBinder b = data.readStrongBinder();
 200             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 201             String callingPackage = data.readString();
 202             Intent intent = Intent.CREATOR.createFromParcel(data);
 203             String resolvedType = data.readString();
 204             IBinder resultTo = data.readStrongBinder();
 205             String resultWho = data.readString();
 206             int requestCode = data.readInt();
 207             int startFlags = data.readInt();
 208             ProfilerInfo profilerInfo = data.readInt() != 0
 209                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
 210             Bundle options = data.readInt() != 0
 211                     ? Bundle.CREATOR.createFromParcel(data) : null;
 212             boolean ignoreTargetSecurity = data.readInt() != 0;
 213             int userId = data.readInt();
 214             int result = startActivityAsCaller(app, callingPackage, intent, resolvedType,
 215                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options,
 216                     ignoreTargetSecurity, userId);
 217             reply.writeNoException();
 218             reply.writeInt(result);
 219             return true;
 220         }
 221
 222         case START_ACTIVITY_AND_WAIT_TRANSACTION:
 223         {
 224             data.enforceInterface(IActivityManager.descriptor);
 225             IBinder b = data.readStrongBinder();
 226             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 227             String callingPackage = data.readString();
 228             Intent intent = Intent.CREATOR.createFromParcel(data);
 229             String resolvedType = data.readString();
 230             IBinder resultTo = data.readStrongBinder();
 231             String resultWho = data.readString();
 232             int requestCode = data.readInt();
 233             int startFlags = data.readInt();
 234             ProfilerInfo profilerInfo = data.readInt() != 0
 235                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
 236             Bundle options = data.readInt() != 0
 237                     ? Bundle.CREATOR.createFromParcel(data) : null;
 238             int userId = data.readInt();
 239             WaitResult result = startActivityAndWait(app, callingPackage, intent, resolvedType,
 240                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options, userId);
 241             reply.writeNoException();
 242             result.writeToParcel(reply, 0);
 243             return true;
 244         }
 245
 246         case START_ACTIVITY_WITH_CONFIG_TRANSACTION:
 247         {
 248             data.enforceInterface(IActivityManager.descriptor);
 249             IBinder b = data.readStrongBinder();
 250             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 251             String callingPackage = data.readString();
 252             Intent intent = Intent.CREATOR.createFromParcel(data);
 253             String resolvedType = data.readString();
 254             IBinder resultTo = data.readStrongBinder();
 255             String resultWho = data.readString();
 256             int requestCode = data.readInt();
 257             int startFlags = data.readInt();
 258             Configuration config = Configuration.CREATOR.createFromParcel(data);
 259             Bundle options = data.readInt() != 0
 260                     ? Bundle.CREATOR.createFromParcel(data) : null;
 261             int userId = data.readInt();
 262             int result = startActivityWithConfig(app, callingPackage, intent, resolvedType,
 263                     resultTo, resultWho, requestCode, startFlags, config, options, userId);
 264             reply.writeNoException();
 265             reply.writeInt(result);
 266             return true;
 267         }
 268
 269         case START_ACTIVITY_INTENT_SENDER_TRANSACTION:
 270         {
 271             data.enforceInterface(IActivityManager.descriptor);
 272             IBinder b = data.readStrongBinder();
 273             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 274             IntentSender intent = IntentSender.CREATOR.createFromParcel(data);
 275             Intent fillInIntent = null;
 276             if (data.readInt() != 0) {
 277                 fillInIntent = Intent.CREATOR.createFromParcel(data);
 278             }
 279             String resolvedType = data.readString();
 280             IBinder resultTo = data.readStrongBinder();
 281             String resultWho = data.readString();
 282             int requestCode = data.readInt();
 283             int flagsMask = data.readInt();
 284             int flagsValues = data.readInt();
 285             Bundle options = data.readInt() != 0
 286                     ? Bundle.CREATOR.createFromParcel(data) : null;
 287             int result = startActivityIntentSender(app, intent,
 288                     fillInIntent, resolvedType, resultTo, resultWho,
 289                     requestCode, flagsMask, flagsValues, options);
 290             reply.writeNoException();
 291             reply.writeInt(result);
 292             return true;
 293         }
 294
 295         case START_VOICE_ACTIVITY_TRANSACTION:
 296         {
 297             data.enforceInterface(IActivityManager.descriptor);
 298             String callingPackage = data.readString();
 299             int callingPid = data.readInt();
 300             int callingUid = data.readInt();
 301             Intent intent = Intent.CREATOR.createFromParcel(data);
 302             String resolvedType = data.readString();
 303             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
 304                     data.readStrongBinder());
 305             IVoiceInteractor interactor = IVoiceInteractor.Stub.asInterface(
 306                     data.readStrongBinder());
 307             int startFlags = data.readInt();
 308             ProfilerInfo profilerInfo = data.readInt() != 0
 309                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
 310             Bundle options = data.readInt() != 0
 311                     ? Bundle.CREATOR.createFromParcel(data) : null;
 312             int userId = data.readInt();
 313             int result = startVoiceActivity(callingPackage, callingPid, callingUid, intent,
 314                     resolvedType, session, interactor, startFlags, profilerInfo, options, userId);
 315             reply.writeNoException();
 316             reply.writeInt(result);
 317             return true;
 318         }
 319
 320         case START_LOCAL_VOICE_INTERACTION_TRANSACTION:
 321         {
 322             data.enforceInterface(IActivityManager.descriptor);
 323             IBinder token = data.readStrongBinder();
 324             Bundle options = data.readBundle();
 325             startLocalVoiceInteraction(token, options);
 326             reply.writeNoException();
 327             return true;
 328         }
 329
 330         case STOP_LOCAL_VOICE_INTERACTION_TRANSACTION:
 331         {
 332             data.enforceInterface(IActivityManager.descriptor);
 333             IBinder token = data.readStrongBinder();
 334             stopLocalVoiceInteraction(token);
 335             reply.writeNoException();
 336             return true;
 337         }
 338
 339         case SUPPORTS_LOCAL_VOICE_INTERACTION_TRANSACTION:
 340         {
 341             data.enforceInterface(IActivityManager.descriptor);
 342             boolean result = supportsLocalVoiceInteraction();
 343             reply.writeNoException();
 344             reply.writeInt(result? 1 : 0);
 345             return true;
 346         }
 347
 348         case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
 349         {
 350             data.enforceInterface(IActivityManager.descriptor);
 351             IBinder callingActivity = data.readStrongBinder();
 352             Intent intent = Intent.CREATOR.createFromParcel(data);
 353             Bundle options = data.readInt() != 0
 354                     ? Bundle.CREATOR.createFromParcel(data) : null;
 355             boolean result = startNextMatchingActivity(callingActivity, intent, options);
 356             reply.writeNoException();
 357             reply.writeInt(result ? 1 : 0);
 358             return true;
 359         }
 360
 361         case START_ACTIVITY_FROM_RECENTS_TRANSACTION:
 362         {
 363             data.enforceInterface(IActivityManager.descriptor);
 364             final int taskId = data.readInt();
 365             final Bundle options =
 366                     data.readInt() == 0 ? null : Bundle.CREATOR.createFromParcel(data);
 367             final int result = startActivityFromRecents(taskId, options);
 368             reply.writeNoException();
 369             reply.writeInt(result);
 370             return true;
 371         }
 372
 373         case FINISH_ACTIVITY_TRANSACTION: {
 374             data.enforceInterface(IActivityManager.descriptor);
 375             IBinder token = data.readStrongBinder();
 376             Intent resultData = null;
 377             int resultCode = data.readInt();
 378             if (data.readInt() != 0) {
 379                 resultData = Intent.CREATOR.createFromParcel(data);
 380             }
 381             int finishTask = data.readInt();
 382             boolean res = finishActivity(token, resultCode, resultData, finishTask);
 383             reply.writeNoException();
 384             reply.writeInt(res ? 1 : 0);
 385             return true;
 386         }
 387
 388         case FINISH_SUB_ACTIVITY_TRANSACTION: {
 389             data.enforceInterface(IActivityManager.descriptor);
 390             IBinder token = data.readStrongBinder();
 391             String resultWho = data.readString();
 392             int requestCode = data.readInt();
 393             finishSubActivity(token, resultWho, requestCode);
 394             reply.writeNoException();
 395             return true;
 396         }
 397
 398         case FINISH_ACTIVITY_AFFINITY_TRANSACTION: {
 399             data.enforceInterface(IActivityManager.descriptor);
 400             IBinder token = data.readStrongBinder();
 401             boolean res = finishActivityAffinity(token);
 402             reply.writeNoException();
 403             reply.writeInt(res ? 1 : 0);
 404             return true;
 405         }
 406
 407         case FINISH_VOICE_TASK_TRANSACTION: {
 408             data.enforceInterface(IActivityManager.descriptor);
 409             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
 410                     data.readStrongBinder());
 411             finishVoiceTask(session);
 412             reply.writeNoException();
 413             return true;
 414         }
 415
 416         case RELEASE_ACTIVITY_INSTANCE_TRANSACTION: {
 417             data.enforceInterface(IActivityManager.descriptor);
 418             IBinder token = data.readStrongBinder();
 419             boolean res = releaseActivityInstance(token);
 420             reply.writeNoException();
 421             reply.writeInt(res ? 1 : 0);
 422             return true;
 423         }
 424
 425         case RELEASE_SOME_ACTIVITIES_TRANSACTION: {
 426             data.enforceInterface(IActivityManager.descriptor);
 427             IApplicationThread app = ApplicationThreadNative.asInterface(data.readStrongBinder());
 428             releaseSomeActivities(app);
 429             reply.writeNoException();
 430             return true;
 431         }
 432
 433         case WILL_ACTIVITY_BE_VISIBLE_TRANSACTION: {
 434             data.enforceInterface(IActivityManager.descriptor);
 435             IBinder token = data.readStrongBinder();
 436             boolean res = willActivityBeVisible(token);
 437             reply.writeNoException();
 438             reply.writeInt(res ? 1 : 0);
 439             return true;
 440         }
 441
 442         case REGISTER_RECEIVER_TRANSACTION:
 443         {
 444             data.enforceInterface(IActivityManager.descriptor);
 445             IBinder b = data.readStrongBinder();
 446             IApplicationThread app =
 447                 b != null ? ApplicationThreadNative.asInterface(b) : null;
 448             String packageName = data.readString();
 449             b = data.readStrongBinder();
 450             IIntentReceiver rec
 451                 = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
 452             IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
 453             String perm = data.readString();
 454             int userId = data.readInt();
 455             Intent intent = registerReceiver(app, packageName, rec, filter, perm, userId);
 456             reply.writeNoException();
 457             if (intent != null) {
 458                 reply.writeInt(1);
 459                 intent.writeToParcel(reply, 0);
 460             } else {
 461                 reply.writeInt(0);
 462             }
 463             return true;
 464         }
 465
 466         case UNREGISTER_RECEIVER_TRANSACTION:
 467         {
 468             data.enforceInterface(IActivityManager.descriptor);
 469             IBinder b = data.readStrongBinder();
 470             if (b == null) {
 471                 return true;
 472             }
 473             IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
 474             unregisterReceiver(rec);
 475             reply.writeNoException();
 476             return true;
 477         }
 478
 479         case BROADCAST_INTENT_TRANSACTION:
 480         {
 481             data.enforceInterface(IActivityManager.descriptor);
 482             IBinder b = data.readStrongBinder();
 483             IApplicationThread app =
 484                 b != null ? ApplicationThreadNative.asInterface(b) : null;
 485             Intent intent = Intent.CREATOR.createFromParcel(data);
 486             String resolvedType = data.readString();
 487             b = data.readStrongBinder();
 488             IIntentReceiver resultTo =
 489                 b != null ? IIntentReceiver.Stub.asInterface(b) : null;
 490             int resultCode = data.readInt();
 491             String resultData = data.readString();
 492             Bundle resultExtras = data.readBundle();
 493             String[] perms = data.readStringArray();
 494             int appOp = data.readInt();
 495             Bundle options = data.readBundle();
 496             boolean serialized = data.readInt() != 0;
 497             boolean sticky = data.readInt() != 0;
 498             int userId = data.readInt();
 499             int res = broadcastIntent(app, intent, resolvedType, resultTo,
 500                     resultCode, resultData, resultExtras, perms, appOp,
 501                     options, serialized, sticky, userId);
 502             reply.writeNoException();
 503             reply.writeInt(res);
 504             return true;
 505         }
 506
 507         case UNBROADCAST_INTENT_TRANSACTION:
 508         {
 509             data.enforceInterface(IActivityManager.descriptor);
 510             IBinder b = data.readStrongBinder();
 511             IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
 512             Intent intent = Intent.CREATOR.createFromParcel(data);
 513             int userId = data.readInt();
 514             unbroadcastIntent(app, intent, userId);
 515             reply.writeNoException();
 516             return true;
 517         }
 518
 519         case FINISH_RECEIVER_TRANSACTION: {
 520             data.enforceInterface(IActivityManager.descriptor);
 521             IBinder who = data.readStrongBinder();
 522             int resultCode = data.readInt();
 523             String resultData = data.readString();
 524             Bundle resultExtras = data.readBundle();
 525             boolean resultAbort = data.readInt() != 0;
 526             int intentFlags = data.readInt();
 527             if (who != null) {
 528                 finishReceiver(who, resultCode, resultData, resultExtras, resultAbort, intentFlags);
 529             }
 530             reply.writeNoException();
 531             return true;
 532         }
 533
 534         case ATTACH_APPLICATION_TRANSACTION: {
 535             data.enforceInterface(IActivityManager.descriptor);
 536             IApplicationThread app = ApplicationThreadNative.asInterface(
 537                     data.readStrongBinder());
 538             if (app != null) {
 539                 attachApplication(app);
 540             }
 541             reply.writeNoException();
 542             return true;
 543         }
 544
 545         case ACTIVITY_IDLE_TRANSACTION: {
 546             data.enforceInterface(IActivityManager.descriptor);
 547             IBinder token = data.readStrongBinder();
 548             Configuration config = null;
 549             if (data.readInt() != 0) {
 550                 config = Configuration.CREATOR.createFromParcel(data);
 551             }
 552             boolean stopProfiling = data.readInt() != 0;
 553             if (token != null) {
 554                 activityIdle(token, config, stopProfiling);
 555             }
 556             reply.writeNoException();
 557             return true;
 558         }
 559
 560         case ACTIVITY_RESUMED_TRANSACTION: {
 561             data.enforceInterface(IActivityManager.descriptor);
 562             IBinder token = data.readStrongBinder();
 563             activityResumed(token);
 564             reply.writeNoException();
 565             return true;
 566         }
 567
 568         case ACTIVITY_PAUSED_TRANSACTION: {
 569             data.enforceInterface(IActivityManager.descriptor);
 570             IBinder token = data.readStrongBinder();
 571             activityPaused(token);
 572             reply.writeNoException();
 573             return true;
 574         }
 575
 576         case ACTIVITY_STOPPED_TRANSACTION: {
 577             data.enforceInterface(IActivityManager.descriptor);
 578             IBinder token = data.readStrongBinder();
 579             Bundle map = data.readBundle();
 580             PersistableBundle persistentState = data.readPersistableBundle();
 581             CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
 582             activityStopped(token, map, persistentState, description);
 583             reply.writeNoException();
 584             return true;
 585         }
 586
 587         case ACTIVITY_SLEPT_TRANSACTION: {
 588             data.enforceInterface(IActivityManager.descriptor);
 589             IBinder token = data.readStrongBinder();
 590             activitySlept(token);
 591             reply.writeNoException();
 592             return true;
 593         }
 594
 595         case ACTIVITY_DESTROYED_TRANSACTION: {
 596             data.enforceInterface(IActivityManager.descriptor);
 597             IBinder token = data.readStrongBinder();
 598             activityDestroyed(token);
 599             reply.writeNoException();
 600             return true;
 601         }
 602
 603         case ACTIVITY_RELAUNCHED_TRANSACTION: {
 604             data.enforceInterface(IActivityManager.descriptor);
 605             IBinder token = data.readStrongBinder();
 606             activityRelaunched(token);
 607             reply.writeNoException();
 608             return true;
 609         }
 610
 611         case GET_CALLING_PACKAGE_TRANSACTION: {
 612             data.enforceInterface(IActivityManager.descriptor);
 613             IBinder token = data.readStrongBinder();
 614             String res = token != null ? getCallingPackage(token) : null;
 615             reply.writeNoException();
 616             reply.writeString(res);
 617             return true;
 618         }
 619
 620         case GET_CALLING_ACTIVITY_TRANSACTION: {
 621             data.enforceInterface(IActivityManager.descriptor);
 622             IBinder token = data.readStrongBinder();
 623             ComponentName cn = getCallingActivity(token);
 624             reply.writeNoException();
 625             ComponentName.writeToParcel(cn, reply);
 626             return true;
 627         }
 628
 629         case GET_APP_TASKS_TRANSACTION: {
 630             data.enforceInterface(IActivityManager.descriptor);
 631             String callingPackage = data.readString();
 632             List<IAppTask> list = getAppTasks(callingPackage);
 633             reply.writeNoException();
 634             int N = list != null ? list.size() : -1;
 635             reply.writeInt(N);
 636             int i;
 637             for (i=0; i<N; i++) {
 638                 IAppTask task = list.get(i);
 639                 reply.writeStrongBinder(task.asBinder());
 640             }
 641             return true;
 642         }
 643
 644         case ADD_APP_TASK_TRANSACTION: {
 645             data.enforceInterface(IActivityManager.descriptor);
 646             IBinder activityToken = data.readStrongBinder();
 647             Intent intent = Intent.CREATOR.createFromParcel(data);
 648             ActivityManager.TaskDescription descr
 649                     = ActivityManager.TaskDescription.CREATOR.createFromParcel(data);
 650             Bitmap thumbnail = Bitmap.CREATOR.createFromParcel(data);
 651             int res = addAppTask(activityToken, intent, descr, thumbnail);
 652             reply.writeNoException();
 653             reply.writeInt(res);
 654             return true;
 655         }
 656
 657         case GET_APP_TASK_THUMBNAIL_SIZE_TRANSACTION: {
 658             data.enforceInterface(IActivityManager.descriptor);
 659             Point size = getAppTaskThumbnailSize();
 660             reply.writeNoException();
 661             size.writeToParcel(reply, 0);
 662             return true;
 663         }
 664
 665         case GET_TASKS_TRANSACTION: {
 666             data.enforceInterface(IActivityManager.descriptor);
 667             int maxNum = data.readInt();
 668             int fl = data.readInt();
 669             List<ActivityManager.RunningTaskInfo> list = getTasks(maxNum, fl);
 670             reply.writeNoException();
 671             int N = list != null ? list.size() : -1;
 672             reply.writeInt(N);
 673             int i;
 674             for (i=0; i<N; i++) {
 675                 ActivityManager.RunningTaskInfo info = list.get(i);
 676                 info.writeToParcel(reply, 0);
 677             }
 678             return true;
 679         }
 680
 681         case GET_RECENT_TASKS_TRANSACTION: {
 682             data.enforceInterface(IActivityManager.descriptor);
 683             int maxNum = data.readInt();
 684             int fl = data.readInt();
 685             int userId = data.readInt();
 686             ParceledListSlice<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
 687                     fl, userId);
 688             reply.writeNoException();
 689             list.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
 690             return true;
 691         }
 692
 693         case GET_TASK_THUMBNAIL_TRANSACTION: {
 694             data.enforceInterface(IActivityManager.descriptor);
 695             int id = data.readInt();
 696             ActivityManager.TaskThumbnail taskThumbnail = getTaskThumbnail(id);
 697             reply.writeNoException();
 698             if (taskThumbnail != null) {
 699                 reply.writeInt(1);
 700                 taskThumbnail.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
 701             } else {
 702                 reply.writeInt(0);
 703             }
 704             return true;
 705         }
 706
 707         case GET_SERVICES_TRANSACTION: {
 708             data.enforceInterface(IActivityManager.descriptor);
 709             int maxNum = data.readInt();
 710             int fl = data.readInt();
 711             List<ActivityManager.RunningServiceInfo> list = getServices(maxNum, fl);
 712             reply.writeNoException();
 713             int N = list != null ? list.size() : -1;
 714             reply.writeInt(N);
 715             int i;
 716             for (i=0; i<N; i++) {
 717                 ActivityManager.RunningServiceInfo info = list.get(i);
 718                 info.writeToParcel(reply, 0);
 719             }
 720             return true;
 721         }
 722
 723         case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION: {
 724             data.enforceInterface(IActivityManager.descriptor);
 725             List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
 726             reply.writeNoException();
 727             reply.writeTypedList(list);
 728             return true;
 729         }
 730
 731         case GET_RUNNING_APP_PROCESSES_TRANSACTION: {
 732             data.enforceInterface(IActivityManager.descriptor);
 733             List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
 734             reply.writeNoException();
 735             reply.writeTypedList(list);
 736             return true;
 737         }
 738
 739         case GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION: {
 740             data.enforceInterface(IActivityManager.descriptor);
 741             List<ApplicationInfo> list = getRunningExternalApplications();
 742             reply.writeNoException();
 743             reply.writeTypedList(list);
 744             return true;
 745         }
 746
 747         case MOVE_TASK_TO_FRONT_TRANSACTION: {
 748             data.enforceInterface(IActivityManager.descriptor);
 749             int task = data.readInt();
 750             int fl = data.readInt();
 751             Bundle options = data.readInt() != 0
 752                     ? Bundle.CREATOR.createFromParcel(data) : null;
 753             moveTaskToFront(task, fl, options);
 754             reply.writeNoException();
 755             return true;
 756         }
 757
 758         case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION: {
 759             data.enforceInterface(IActivityManager.descriptor);
 760             IBinder token = data.readStrongBinder();
 761             boolean nonRoot = data.readInt() != 0;
 762             boolean res = moveActivityTaskToBack(token, nonRoot);
 763             reply.writeNoException();
 764             reply.writeInt(res ? 1 : 0);
 765             return true;
 766         }
 767
 768         case MOVE_TASK_BACKWARDS_TRANSACTION: {
 769             data.enforceInterface(IActivityManager.descriptor);
 770             int task = data.readInt();
 771             moveTaskBackwards(task);
 772             reply.writeNoException();
 773             return true;
 774         }
 775
 776         case MOVE_TASK_TO_STACK_TRANSACTION: {
 777             data.enforceInterface(IActivityManager.descriptor);
 778             int taskId = data.readInt();
 779             int stackId = data.readInt();
 780             boolean toTop = data.readInt() != 0;
 781             moveTaskToStack(taskId, stackId, toTop);
 782             reply.writeNoException();
 783             return true;
 784         }
 785
 786         case MOVE_TASK_TO_DOCKED_STACK_TRANSACTION: {
 787             data.enforceInterface(IActivityManager.descriptor);
 788             int taskId = data.readInt();
 789             int createMode = data.readInt();
 790             boolean toTop = data.readInt() != 0;
 791             boolean animate = data.readInt() != 0;
 792             Rect bounds = null;
 793             boolean hasBounds = data.readInt() != 0;
 794             if (hasBounds) {
 795                 bounds = Rect.CREATOR.createFromParcel(data);
 796             }
 797             final boolean moveHomeStackFront = data.readInt() != 0;
 798             final boolean res = moveTaskToDockedStack(
 799                     taskId, createMode, toTop, animate, bounds, moveHomeStackFront);
 800             reply.writeNoException();
 801             reply.writeInt(res ? 1 : 0);
 802             return true;
 803         }
 804
 805         case MOVE_TOP_ACTIVITY_TO_PINNED_STACK_TRANSACTION: {
 806             data.enforceInterface(IActivityManager.descriptor);
 807             final int stackId = data.readInt();
 808             final Rect r = Rect.CREATOR.createFromParcel(data);
 809             final boolean res = moveTopActivityToPinnedStack(stackId, r);
 810             reply.writeNoException();
 811             reply.writeInt(res ? 1 : 0);
 812             return true;
 813         }
 814
 815         case RESIZE_STACK_TRANSACTION: {
 816             data.enforceInterface(IActivityManager.descriptor);
 817             final int stackId = data.readInt();
 818             final boolean hasRect = data.readInt() != 0;
 819             Rect r = null;
 820             if (hasRect) {
 821                 r = Rect.CREATOR.createFromParcel(data);
 822             }
 823             final boolean allowResizeInDockedMode = data.readInt() == 1;
 824             final boolean preserveWindows = data.readInt() == 1;
 825             final boolean animate = data.readInt() == 1;
 826             final int animationDuration = data.readInt();
 827             resizeStack(stackId,
 828                     r, allowResizeInDockedMode, preserveWindows, animate, animationDuration);
 829             reply.writeNoException();
 830             return true;
 831         }
 832         case RESIZE_PINNED_STACK_TRANSACTION: {
 833             data.enforceInterface(IActivityManager.descriptor);
 834             final boolean hasBounds = data.readInt() != 0;
 835             Rect bounds = null;
 836             if (hasBounds) {
 837                 bounds = Rect.CREATOR.createFromParcel(data);
 838             }
 839             final boolean hasTempPinnedTaskBounds = data.readInt() != 0;
 840             Rect tempPinnedTaskBounds = null;
 841             if (hasTempPinnedTaskBounds) {
 842                 tempPinnedTaskBounds = Rect.CREATOR.createFromParcel(data);
 843             }
 844             resizePinnedStack(bounds, tempPinnedTaskBounds);
 845             return true;
 846         }
 847         case SWAP_DOCKED_AND_FULLSCREEN_STACK: {
 848             data.enforceInterface(IActivityManager.descriptor);
 849             swapDockedAndFullscreenStack();
 850             reply.writeNoException();
 851             return true;
 852         }
 853         case RESIZE_DOCKED_STACK_TRANSACTION: {
 854             data.enforceInterface(IActivityManager.descriptor);
 855             final boolean hasBounds = data.readInt() != 0;
 856             Rect bounds = null;
 857             if (hasBounds) {
 858                 bounds = Rect.CREATOR.createFromParcel(data);
 859             }
 860             final boolean hasTempDockedTaskBounds = data.readInt() != 0;
 861             Rect tempDockedTaskBounds = null;
 862             if (hasTempDockedTaskBounds) {
 863                 tempDockedTaskBounds = Rect.CREATOR.createFromParcel(data);
 864             }
 865             final boolean hasTempDockedTaskInsetBounds = data.readInt() != 0;
 866             Rect tempDockedTaskInsetBounds = null;
 867             if (hasTempDockedTaskInsetBounds) {
 868                 tempDockedTaskInsetBounds = Rect.CREATOR.createFromParcel(data);
 869             }
 870             final boolean hasTempOtherTaskBounds = data.readInt() != 0;
 871             Rect tempOtherTaskBounds = null;
 872             if (hasTempOtherTaskBounds) {
 873                 tempOtherTaskBounds = Rect.CREATOR.createFromParcel(data);
 874             }
 875             final boolean hasTempOtherTaskInsetBounds = data.readInt() != 0;
 876             Rect tempOtherTaskInsetBounds = null;
 877             if (hasTempOtherTaskInsetBounds) {
 878                 tempOtherTaskInsetBounds = Rect.CREATOR.createFromParcel(data);
 879             }
 880             resizeDockedStack(bounds, tempDockedTaskBounds, tempDockedTaskInsetBounds,
 881                     tempOtherTaskBounds, tempOtherTaskInsetBounds);
 882             reply.writeNoException();
 883             return true;
 884         }
 885
 886         case POSITION_TASK_IN_STACK_TRANSACTION: {
 887             data.enforceInterface(IActivityManager.descriptor);
 888             int taskId = data.readInt();
 889             int stackId = data.readInt();
 890             int position = data.readInt();
 891             positionTaskInStack(taskId, stackId, position);
 892             reply.writeNoException();
 893             return true;
 894         }
 895
 896         case GET_ALL_STACK_INFOS_TRANSACTION: {
 897             data.enforceInterface(IActivityManager.descriptor);
 898             List<StackInfo> list = getAllStackInfos();
 899             reply.writeNoException();
 900             reply.writeTypedList(list);
 901             return true;
 902         }
 903
 904         case GET_STACK_INFO_TRANSACTION: {
 905             data.enforceInterface(IActivityManager.descriptor);
 906             int stackId = data.readInt();
 907             StackInfo info = getStackInfo(stackId);
 908             reply.writeNoException();
 909             if (info != null) {
 910                 reply.writeInt(1);
 911                 info.writeToParcel(reply, 0);
 912             } else {
 913                 reply.writeInt(0);
 914             }
 915             return true;
 916         }
 917
 918         case IS_IN_HOME_STACK_TRANSACTION: {
 919             data.enforceInterface(IActivityManager.descriptor);
 920             int taskId = data.readInt();
 921             boolean isInHomeStack = isInHomeStack(taskId);
 922             reply.writeNoException();
 923             reply.writeInt(isInHomeStack ? 1 : 0);
 924             return true;
 925         }
 926
 927         case SET_FOCUSED_STACK_TRANSACTION: {
 928             data.enforceInterface(IActivityManager.descriptor);
 929             int stackId = data.readInt();
 930             setFocusedStack(stackId);
 931             reply.writeNoException();
 932             return true;
 933         }
 934
 935         case GET_FOCUSED_STACK_ID_TRANSACTION: {
 936             data.enforceInterface(IActivityManager.descriptor);
 937             int focusedStackId = getFocusedStackId();
 938             reply.writeNoException();
 939             reply.writeInt(focusedStackId);
 940             return true;
 941         }
 942
 943         case SET_FOCUSED_TASK_TRANSACTION: {
 944             data.enforceInterface(IActivityManager.descriptor);
 945             int taskId = data.readInt();
 946             setFocusedTask(taskId);
 947             reply.writeNoException();
 948             return true;
 949         }
 950
 951         case REGISTER_TASK_STACK_LISTENER_TRANSACTION: {
 952             data.enforceInterface(IActivityManager.descriptor);
 953             IBinder token = data.readStrongBinder();
 954             registerTaskStackListener(ITaskStackListener.Stub.asInterface(token));
 955             reply.writeNoException();
 956             return true;
 957         }
 958
 959         case GET_TASK_FOR_ACTIVITY_TRANSACTION: {
 960             data.enforceInterface(IActivityManager.descriptor);
 961             IBinder token = data.readStrongBinder();
 962             boolean onlyRoot = data.readInt() != 0;
 963             int res = token != null
 964                 ? getTaskForActivity(token, onlyRoot) : -1;
 965                 reply.writeNoException();
 966             reply.writeInt(res);
 967             return true;
 968         }
 969
 970         case GET_CONTENT_PROVIDER_TRANSACTION: {
 971             data.enforceInterface(IActivityManager.descriptor);
 972             IBinder b = data.readStrongBinder();
 973             IApplicationThread app = ApplicationThreadNative.asInterface(b);
 974             String name = data.readString();
 975             int userId = data.readInt();
 976             boolean stable = data.readInt() != 0;
 977             ContentProviderHolder cph = getContentProvider(app, name, userId, stable);
 978             reply.writeNoException();
 979             if (cph != null) {
 980                 reply.writeInt(1);
 981                 cph.writeToParcel(reply, 0);
 982             } else {
 983                 reply.writeInt(0);
 984             }
 985             return true;
 986         }
 987
 988         case GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
 989             data.enforceInterface(IActivityManager.descriptor);
 990             String name = data.readString();
 991             int userId = data.readInt();
 992             IBinder token = data.readStrongBinder();
 993             ContentProviderHolder cph = getContentProviderExternal(name, userId, token);
 994             reply.writeNoException();
 995             if (cph != null) {
 996                 reply.writeInt(1);
 997                 cph.writeToParcel(reply, 0);
 998             } else {
 999                 reply.writeInt(0);
1000             }
1001             return true;
1002         }
1003
1004         case PUBLISH_CONTENT_PROVIDERS_TRANSACTION: {
1005             data.enforceInterface(IActivityManager.descriptor);
1006             IBinder b = data.readStrongBinder();
1007             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1008             ArrayList<ContentProviderHolder> providers =
1009                 data.createTypedArrayList(ContentProviderHolder.CREATOR);
1010             publishContentProviders(app, providers);
1011             reply.writeNoException();
1012             return true;
1013         }
1014
1015         case REF_CONTENT_PROVIDER_TRANSACTION: {
1016             data.enforceInterface(IActivityManager.descriptor);
1017             IBinder b = data.readStrongBinder();
1018             int stable = data.readInt();
1019             int unstable = data.readInt();
1020             boolean res = refContentProvider(b, stable, unstable);
1021             reply.writeNoException();
1022             reply.writeInt(res ? 1 : 0);
1023             return true;
1024         }
1025
1026         case UNSTABLE_PROVIDER_DIED_TRANSACTION: {
1027             data.enforceInterface(IActivityManager.descriptor);
1028             IBinder b = data.readStrongBinder();
1029             unstableProviderDied(b);
1030             reply.writeNoException();
1031             return true;
1032         }
1033
1034         case APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION: {
1035             data.enforceInterface(IActivityManager.descriptor);
1036             IBinder b = data.readStrongBinder();
1037             appNotRespondingViaProvider(b);
1038             reply.writeNoException();
1039             return true;
1040         }
1041
1042         case REMOVE_CONTENT_PROVIDER_TRANSACTION: {
1043             data.enforceInterface(IActivityManager.descriptor);
1044             IBinder b = data.readStrongBinder();
1045             boolean stable = data.readInt() != 0;
1046             removeContentProvider(b, stable);
1047             reply.writeNoException();
1048             return true;
1049         }
1050
1051         case REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
1052             data.enforceInterface(IActivityManager.descriptor);
1053             String name = data.readString();
1054             IBinder token = data.readStrongBinder();
1055             removeContentProviderExternal(name, token);
1056             reply.writeNoException();
1057             return true;
1058         }
1059
1060         case GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION: {
1061             data.enforceInterface(IActivityManager.descriptor);
1062             ComponentName comp = ComponentName.CREATOR.createFromParcel(data);
1063             PendingIntent pi = getRunningServiceControlPanel(comp);
1064             reply.writeNoException();
1065             PendingIntent.writePendingIntentOrNullToParcel(pi, reply);
1066             return true;
1067         }
1068
1069         case START_SERVICE_TRANSACTION: {
1070             data.enforceInterface(IActivityManager.descriptor);
1071             IBinder b = data.readStrongBinder();
1072             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1073             Intent service = Intent.CREATOR.createFromParcel(data);
1074             String resolvedType = data.readString();
1075             String callingPackage = data.readString();
1076             int userId = data.readInt();
1077             ComponentName cn = startService(app, service, resolvedType, callingPackage, userId);
1078             reply.writeNoException();
1079             ComponentName.writeToParcel(cn, reply);
1080             return true;
1081         }
1082
1083         case STOP_SERVICE_TRANSACTION: {
1084             data.enforceInterface(IActivityManager.descriptor);
1085             IBinder b = data.readStrongBinder();
1086             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1087             Intent service = Intent.CREATOR.createFromParcel(data);
1088             String resolvedType = data.readString();
1089             int userId = data.readInt();
1090             int res = stopService(app, service, resolvedType, userId);
1091             reply.writeNoException();
1092             reply.writeInt(res);
1093             return true;
1094         }
1095
1096         case STOP_SERVICE_TOKEN_TRANSACTION: {
1097             data.enforceInterface(IActivityManager.descriptor);
1098             ComponentName className = ComponentName.readFromParcel(data);
1099             IBinder token = data.readStrongBinder();
1100             int startId = data.readInt();
1101             boolean res = stopServiceToken(className, token, startId);
1102             reply.writeNoException();
1103             reply.writeInt(res ? 1 : 0);
1104             return true;
1105         }
1106
1107         case SET_SERVICE_FOREGROUND_TRANSACTION: {
1108             data.enforceInterface(IActivityManager.descriptor);
1109             ComponentName className = ComponentName.readFromParcel(data);
1110             IBinder token = data.readStrongBinder();
1111             int id = data.readInt();
1112             Notification notification = null;
1113             if (data.readInt() != 0) {
1114                 notification = Notification.CREATOR.createFromParcel(data);
1115             }
1116             int sflags = data.readInt();
1117             setServiceForeground(className, token, id, notification, sflags);
1118             reply.writeNoException();
1119             return true;
1120         }
1121
1122         case BIND_SERVICE_TRANSACTION: {
1123             data.enforceInterface(IActivityManager.descriptor);
1124             IBinder b = data.readStrongBinder();
1125             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1126             IBinder token = data.readStrongBinder();
1127             Intent service = Intent.CREATOR.createFromParcel(data);
1128             String resolvedType = data.readString();
1129             b = data.readStrongBinder();
1130             int fl = data.readInt();
1131             String callingPackage = data.readString();
1132             int userId = data.readInt();
1133             IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
1134             int res = bindService(app, token, service, resolvedType, conn, fl,
1135                     callingPackage, userId);
1136             reply.writeNoException();
1137             reply.writeInt(res);
1138             return true;
1139         }
1140
1141         case UNBIND_SERVICE_TRANSACTION: {
1142             data.enforceInterface(IActivityManager.descriptor);
1143             IBinder b = data.readStrongBinder();
1144             IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
1145             boolean res = unbindService(conn);
1146             reply.writeNoException();
1147             reply.writeInt(res ? 1 : 0);
1148             return true;
1149         }
1150
1151         case PUBLISH_SERVICE_TRANSACTION: {
1152             data.enforceInterface(IActivityManager.descriptor);
1153             IBinder token = data.readStrongBinder();
1154             Intent intent = Intent.CREATOR.createFromParcel(data);
1155             IBinder service = data.readStrongBinder();
1156             publishService(token, intent, service);
1157             reply.writeNoException();
1158             return true;
1159         }
1160
1161         case UNBIND_FINISHED_TRANSACTION: {
1162             data.enforceInterface(IActivityManager.descriptor);
1163             IBinder token = data.readStrongBinder();
1164             Intent intent = Intent.CREATOR.createFromParcel(data);
1165             boolean doRebind = data.readInt() != 0;
1166             unbindFinished(token, intent, doRebind);
1167             reply.writeNoException();
1168             return true;
1169         }
1170
1171         case SERVICE_DONE_EXECUTING_TRANSACTION: {
1172             data.enforceInterface(IActivityManager.descriptor);
1173             IBinder token = data.readStrongBinder();
1174             int type = data.readInt();
1175             int startId = data.readInt();
1176             int res = data.readInt();
1177             serviceDoneExecuting(token, type, startId, res);
1178             reply.writeNoException();
1179             return true;
1180         }
1181
1182         case START_INSTRUMENTATION_TRANSACTION: {
1183             data.enforceInterface(IActivityManager.descriptor);
1184             ComponentName className = ComponentName.readFromParcel(data);
1185             String profileFile = data.readString();
1186             int fl = data.readInt();
1187             Bundle arguments = data.readBundle();
1188             IBinder b = data.readStrongBinder();
1189             IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
1190             b = data.readStrongBinder();
1191             IUiAutomationConnection c = IUiAutomationConnection.Stub.asInterface(b);
1192             int userId = data.readInt();
1193             String abiOverride = data.readString();
1194             boolean res = startInstrumentation(className, profileFile, fl, arguments, w, c, userId,
1195                     abiOverride);
1196             reply.writeNoException();
1197             reply.writeInt(res ? 1 : 0);
1198             return true;
1199         }
1200
1201
1202         case FINISH_INSTRUMENTATION_TRANSACTION: {
1203             data.enforceInterface(IActivityManager.descriptor);
1204             IBinder b = data.readStrongBinder();
1205             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1206             int resultCode = data.readInt();
1207             Bundle results = data.readBundle();
1208             finishInstrumentation(app, resultCode, results);
1209             reply.writeNoException();
1210             return true;
1211         }
1212
1213         case GET_CONFIGURATION_TRANSACTION: {
1214             data.enforceInterface(IActivityManager.descriptor);
1215             Configuration config = getConfiguration();
1216             reply.writeNoException();
1217             config.writeToParcel(reply, 0);
1218             return true;
1219         }
1220
1221         case UPDATE_CONFIGURATION_TRANSACTION: {
1222             data.enforceInterface(IActivityManager.descriptor);
1223             Configuration config = Configuration.CREATOR.createFromParcel(data);
1224             updateConfiguration(config);
1225             reply.writeNoException();
1226             return true;
1227         }
1228
1229         case SET_REQUESTED_ORIENTATION_TRANSACTION: {
1230             data.enforceInterface(IActivityManager.descriptor);
1231             IBinder token = data.readStrongBinder();
1232             int requestedOrientation = data.readInt();
1233             setRequestedOrientation(token, requestedOrientation);
1234             reply.writeNoException();
1235             return true;
1236         }
1237
1238         case GET_REQUESTED_ORIENTATION_TRANSACTION: {
1239             data.enforceInterface(IActivityManager.descriptor);
1240             IBinder token = data.readStrongBinder();
1241             int req = getRequestedOrientation(token);
1242             reply.writeNoException();
1243             reply.writeInt(req);
1244             return true;
1245         }
1246
1247         case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION: {
1248             data.enforceInterface(IActivityManager.descriptor);
1249             IBinder token = data.readStrongBinder();
1250             ComponentName cn = getActivityClassForToken(token);
1251             reply.writeNoException();
1252             ComponentName.writeToParcel(cn, reply);
1253             return true;
1254         }
1255
1256         case GET_PACKAGE_FOR_TOKEN_TRANSACTION: {
1257             data.enforceInterface(IActivityManager.descriptor);
1258             IBinder token = data.readStrongBinder();
1259             reply.writeNoException();
1260             reply.writeString(getPackageForToken(token));
1261             return true;
1262         }
1263
1264         case GET_INTENT_SENDER_TRANSACTION: {
1265             data.enforceInterface(IActivityManager.descriptor);
1266             int type = data.readInt();
1267             String packageName = data.readString();
1268             IBinder token = data.readStrongBinder();
1269             String resultWho = data.readString();
1270             int requestCode = data.readInt();
1271             Intent[] requestIntents;
1272             String[] requestResolvedTypes;
1273             if (data.readInt() != 0) {
1274                 requestIntents = data.createTypedArray(Intent.CREATOR);
1275                 requestResolvedTypes = data.createStringArray();
1276             } else {
1277                 requestIntents = null;
1278                 requestResolvedTypes = null;
1279             }
1280             int fl = data.readInt();
1281             Bundle options = data.readInt() != 0
1282                     ? Bundle.CREATOR.createFromParcel(data) : null;
1283             int userId = data.readInt();
1284             IIntentSender res = getIntentSender(type, packageName, token,
1285                     resultWho, requestCode, requestIntents,
1286                     requestResolvedTypes, fl, options, userId);
1287             reply.writeNoException();
1288             reply.writeStrongBinder(res != null ? res.asBinder() : null);
1289             return true;
1290         }
1291
1292         case CANCEL_INTENT_SENDER_TRANSACTION: {
1293             data.enforceInterface(IActivityManager.descriptor);
1294             IIntentSender r = IIntentSender.Stub.asInterface(
1295                 data.readStrongBinder());
1296             cancelIntentSender(r);
1297             reply.writeNoException();
1298             return true;
1299         }
1300
1301         case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION: {
1302             data.enforceInterface(IActivityManager.descriptor);
1303             IIntentSender r = IIntentSender.Stub.asInterface(
1304                 data.readStrongBinder());
1305             String res = getPackageForIntentSender(r);
1306             reply.writeNoException();
1307             reply.writeString(res);
1308             return true;
1309         }
1310
1311         case GET_UID_FOR_INTENT_SENDER_TRANSACTION: {
1312             data.enforceInterface(IActivityManager.descriptor);
1313             IIntentSender r = IIntentSender.Stub.asInterface(
1314                 data.readStrongBinder());
1315             int res = getUidForIntentSender(r);
1316             reply.writeNoException();
1317             reply.writeInt(res);
1318             return true;
1319         }
1320
1321         case HANDLE_INCOMING_USER_TRANSACTION: {
1322             data.enforceInterface(IActivityManager.descriptor);
1323             int callingPid = data.readInt();
1324             int callingUid = data.readInt();
1325             int userId = data.readInt();
1326             boolean allowAll = data.readInt() != 0 ;
1327             boolean requireFull = data.readInt() != 0;
1328             String name = data.readString();
1329             String callerPackage = data.readString();
1330             int res = handleIncomingUser(callingPid, callingUid, userId, allowAll,
1331                     requireFull, name, callerPackage);
1332             reply.writeNoException();
1333             reply.writeInt(res);
1334             return true;
1335         }
1336
1337         case SET_PROCESS_LIMIT_TRANSACTION: {
1338             data.enforceInterface(IActivityManager.descriptor);
1339             int max = data.readInt();
1340             setProcessLimit(max);
1341             reply.writeNoException();
1342             return true;
1343         }
1344
1345         case GET_PROCESS_LIMIT_TRANSACTION: {
1346             data.enforceInterface(IActivityManager.descriptor);
1347             int limit = getProcessLimit();
1348             reply.writeNoException();
1349             reply.writeInt(limit);
1350             return true;
1351         }
1352
1353         case SET_PROCESS_FOREGROUND_TRANSACTION: {
1354             data.enforceInterface(IActivityManager.descriptor);
1355             IBinder token = data.readStrongBinder();
1356             int pid = data.readInt();
1357             boolean isForeground = data.readInt() != 0;
1358             setProcessForeground(token, pid, isForeground);
1359             reply.writeNoException();
1360             return true;
1361         }
1362
1363         case CHECK_PERMISSION_TRANSACTION: {
1364             data.enforceInterface(IActivityManager.descriptor);
1365             String perm = data.readString();
1366             int pid = data.readInt();
1367             int uid = data.readInt();
1368             int res = checkPermission(perm, pid, uid);
1369             reply.writeNoException();
1370             reply.writeInt(res);
1371             return true;
1372         }
1373
1374         case CHECK_PERMISSION_WITH_TOKEN_TRANSACTION: {
1375             data.enforceInterface(IActivityManager.descriptor);
1376             String perm = data.readString();
1377             int pid = data.readInt();
1378             int uid = data.readInt();
1379             IBinder token = data.readStrongBinder();
1380             int res = checkPermissionWithToken(perm, pid, uid, token);
1381             reply.writeNoException();
1382             reply.writeInt(res);
1383             return true;
1384         }
1385
1386         case CHECK_URI_PERMISSION_TRANSACTION: {
1387             data.enforceInterface(IActivityManager.descriptor);
1388             Uri uri = Uri.CREATOR.createFromParcel(data);
1389             int pid = data.readInt();
1390             int uid = data.readInt();
1391             int mode = data.readInt();
1392             int userId = data.readInt();
1393             IBinder callerToken = data.readStrongBinder();
1394             int res = checkUriPermission(uri, pid, uid, mode, userId, callerToken);
1395             reply.writeNoException();
1396             reply.writeInt(res);
1397             return true;
1398         }
1399
1400         case CLEAR_APP_DATA_TRANSACTION: {
1401             data.enforceInterface(IActivityManager.descriptor);
1402             String packageName = data.readString();
1403             IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(
1404                     data.readStrongBinder());
1405             int userId = data.readInt();
1406             boolean res = clearApplicationUserData(packageName, observer, userId);
1407             reply.writeNoException();
1408             reply.writeInt(res ? 1 : 0);
1409             return true;
1410         }
1411
1412         case GRANT_URI_PERMISSION_TRANSACTION: {
1413             data.enforceInterface(IActivityManager.descriptor);
1414             IBinder b = data.readStrongBinder();
1415             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1416             String targetPkg = data.readString();
1417             Uri uri = Uri.CREATOR.createFromParcel(data);
1418             int mode = data.readInt();
1419             int userId = data.readInt();
1420             grantUriPermission(app, targetPkg, uri, mode, userId);
1421             reply.writeNoException();
1422             return true;
1423         }
1424
1425         case REVOKE_URI_PERMISSION_TRANSACTION: {
1426             data.enforceInterface(IActivityManager.descriptor);
1427             IBinder b = data.readStrongBinder();
1428             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1429             Uri uri = Uri.CREATOR.createFromParcel(data);
1430             int mode = data.readInt();
1431             int userId = data.readInt();
1432             revokeUriPermission(app, uri, mode, userId);
1433             reply.writeNoException();
1434             return true;
1435         }
1436
1437         case TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
1438             data.enforceInterface(IActivityManager.descriptor);
1439             Uri uri = Uri.CREATOR.createFromParcel(data);
1440             int mode = data.readInt();
1441             int userId = data.readInt();
1442             takePersistableUriPermission(uri, mode, userId);
1443             reply.writeNoException();
1444             return true;
1445         }
1446
1447         case RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
1448             data.enforceInterface(IActivityManager.descriptor);
1449             Uri uri = Uri.CREATOR.createFromParcel(data);
1450             int mode = data.readInt();
1451             int userId = data.readInt();
1452             releasePersistableUriPermission(uri, mode, userId);
1453             reply.writeNoException();
1454             return true;
1455         }
1456
1457         case GET_PERSISTED_URI_PERMISSIONS_TRANSACTION: {
1458             data.enforceInterface(IActivityManager.descriptor);
1459             final String packageName = data.readString();
1460             final boolean incoming = data.readInt() != 0;
1461             final ParceledListSlice<UriPermission> perms = getPersistedUriPermissions(
1462                     packageName, incoming);
1463             reply.writeNoException();
1464             perms.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1465             return true;
1466         }
1467
1468         case GET_GRANTED_URI_PERMISSIONS_TRANSACTION: {
1469             data.enforceInterface(IActivityManager.descriptor);
1470             final String packageName = data.readString();
1471             final int userId = data.readInt();
1472             final ParceledListSlice<UriPermission> perms = getGrantedUriPermissions(packageName,
1473                     userId);
1474             reply.writeNoException();
1475             perms.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1476             return true;
1477         }
1478
1479         case CLEAR_GRANTED_URI_PERMISSIONS_TRANSACTION: {
1480             data.enforceInterface(IActivityManager.descriptor);
1481             final String packageName = data.readString();
1482             final int userId = data.readInt();
1483             clearGrantedUriPermissions(packageName, userId);
1484             reply.writeNoException();
1485             return true;
1486         }
1487
1488         case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: {
1489             data.enforceInterface(IActivityManager.descriptor);
1490             IBinder b = data.readStrongBinder();
1491             IApplicationThread app = ApplicationThreadNative.asInterface(b);
1492             boolean waiting = data.readInt() != 0;
1493             showWaitingForDebugger(app, waiting);
1494             reply.writeNoException();
1495             return true;
1496         }
1497
1498         case GET_MEMORY_INFO_TRANSACTION: {
1499             data.enforceInterface(IActivityManager.descriptor);
1500             ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
1501             getMemoryInfo(mi);
1502             reply.writeNoException();
1503             mi.writeToParcel(reply, 0);
1504             return true;
1505         }
1506
1507         case UNHANDLED_BACK_TRANSACTION: {
1508             data.enforceInterface(IActivityManager.descriptor);
1509             unhandledBack();
1510             reply.writeNoException();
1511             return true;
1512         }
1513
1514         case OPEN_CONTENT_URI_TRANSACTION: {
1515             data.enforceInterface(IActivityManager.descriptor);
1516             Uri uri = Uri.parse(data.readString());
1517             ParcelFileDescriptor pfd = openContentUri(uri);
1518             reply.writeNoException();
1519             if (pfd != null) {
1520                 reply.writeInt(1);
1521                 pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1522             } else {
1523                 reply.writeInt(0);
1524             }
1525             return true;
1526         }
1527
1528         case SET_LOCK_SCREEN_SHOWN_TRANSACTION: {
1529             data.enforceInterface(IActivityManager.descriptor);
1530             final boolean showing = data.readInt() != 0;
1531             final boolean occluded = data.readInt() != 0;
1532             setLockScreenShown(showing, occluded);
1533             reply.writeNoException();
1534             return true;
1535         }
1536
1537         case SET_DEBUG_APP_TRANSACTION: {
1538             data.enforceInterface(IActivityManager.descriptor);
1539             String pn = data.readString();
1540             boolean wfd = data.readInt() != 0;
1541             boolean per = data.readInt() != 0;
1542             setDebugApp(pn, wfd, per);
1543             reply.writeNoException();
1544             return true;
1545         }
1546
1547         case SET_ALWAYS_FINISH_TRANSACTION: {
1548             data.enforceInterface(IActivityManager.descriptor);
1549             boolean enabled = data.readInt() != 0;
1550             setAlwaysFinish(enabled);
1551             reply.writeNoException();
1552             return true;
1553         }
1554
1555         case SET_ACTIVITY_CONTROLLER_TRANSACTION: {
1556             data.enforceInterface(IActivityManager.descriptor);
1557             IActivityController watcher = IActivityController.Stub.asInterface(
1558                     data.readStrongBinder());
1559             boolean imAMonkey = data.readInt() != 0;
1560             setActivityController(watcher, imAMonkey);
1561             reply.writeNoException();
1562             return true;
1563         }
1564
1565         case SET_LENIENT_BACKGROUND_CHECK_TRANSACTION: {
1566             data.enforceInterface(IActivityManager.descriptor);
1567             boolean enabled = data.readInt() != 0;
1568             setLenientBackgroundCheck(enabled);
1569             reply.writeNoException();
1570             return true;
1571         }
1572
1573         case GET_MEMORY_TRIM_LEVEL_TRANSACTION: {
1574             data.enforceInterface(IActivityManager.descriptor);
1575             int level = getMemoryTrimLevel();
1576             reply.writeNoException();
1577             reply.writeInt(level);
1578             return true;
1579         }
1580
1581         case ENTER_SAFE_MODE_TRANSACTION: {
1582             data.enforceInterface(IActivityManager.descriptor);
1583             enterSafeMode();
1584             reply.writeNoException();
1585             return true;
1586         }
1587
1588         case NOTE_WAKEUP_ALARM_TRANSACTION: {
1589             data.enforceInterface(IActivityManager.descriptor);
1590             IIntentSender is = IIntentSender.Stub.asInterface(
1591                     data.readStrongBinder());
1592             int sourceUid = data.readInt();
1593             String sourcePkg = data.readString();
1594             String tag = data.readString();
1595             noteWakeupAlarm(is, sourceUid, sourcePkg, tag);
1596             reply.writeNoException();
1597             return true;
1598         }
1599
1600         case NOTE_ALARM_START_TRANSACTION: {
1601             data.enforceInterface(IActivityManager.descriptor);
1602             IIntentSender is = IIntentSender.Stub.asInterface(
1603                     data.readStrongBinder());
1604             int sourceUid = data.readInt();
1605             String tag = data.readString();
1606             noteAlarmStart(is, sourceUid, tag);
1607             reply.writeNoException();
1608             return true;
1609         }
1610
1611         case NOTE_ALARM_FINISH_TRANSACTION: {
1612             data.enforceInterface(IActivityManager.descriptor);
1613             IIntentSender is = IIntentSender.Stub.asInterface(
1614                     data.readStrongBinder());
1615             int sourceUid = data.readInt();
1616             String tag = data.readString();
1617             noteAlarmFinish(is, sourceUid, tag);
1618             reply.writeNoException();
1619             return true;
1620         }
1621
1622         case KILL_PIDS_TRANSACTION: {
1623             data.enforceInterface(IActivityManager.descriptor);
1624             int[] pids = data.createIntArray();
1625             String reason = data.readString();
1626             boolean secure = data.readInt() != 0;
1627             boolean res = killPids(pids, reason, secure);
1628             reply.writeNoException();
1629             reply.writeInt(res ? 1 : 0);
1630             return true;
1631         }
1632
1633         case KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION: {
1634             data.enforceInterface(IActivityManager.descriptor);
1635             String reason = data.readString();
1636             boolean res = killProcessesBelowForeground(reason);
1637             reply.writeNoException();
1638             reply.writeInt(res ? 1 : 0);
1639             return true;
1640         }
1641
1642         case HANDLE_APPLICATION_CRASH_TRANSACTION: {
1643             data.enforceInterface(IActivityManager.descriptor);
1644             IBinder app = data.readStrongBinder();
1645             ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
1646             handleApplicationCrash(app, ci);
1647             reply.writeNoException();
1648             return true;
1649         }
1650
1651         case HANDLE_APPLICATION_WTF_TRANSACTION: {
1652             data.enforceInterface(IActivityManager.descriptor);
1653             IBinder app = data.readStrongBinder();
1654             String tag = data.readString();
1655             boolean system = data.readInt() != 0;
1656             ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
1657             boolean res = handleApplicationWtf(app, tag, system, ci);
1658             reply.writeNoException();
1659             reply.writeInt(res ? 1 : 0);
1660             return true;
1661         }
1662
1663         case HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION: {
1664             data.enforceInterface(IActivityManager.descriptor);
1665             IBinder app = data.readStrongBinder();
1666             int violationMask = data.readInt();
1667             StrictMode.ViolationInfo info = new StrictMode.ViolationInfo(data);
1668             handleApplicationStrictModeViolation(app, violationMask, info);
1669             reply.writeNoException();
1670             return true;
1671         }
1672
1673         case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION: {
1674             data.enforceInterface(IActivityManager.descriptor);
1675             int sig = data.readInt();
1676             signalPersistentProcesses(sig);
1677             reply.writeNoException();
1678             return true;
1679         }
1680
1681         case KILL_BACKGROUND_PROCESSES_TRANSACTION: {
1682             data.enforceInterface(IActivityManager.descriptor);
1683             String packageName = data.readString();
1684             int userId = data.readInt();
1685             killBackgroundProcesses(packageName, userId);
1686             reply.writeNoException();
1687             return true;
1688         }
1689
1690         case KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION: {
1691             data.enforceInterface(IActivityManager.descriptor);
1692             killAllBackgroundProcesses();
1693             reply.writeNoException();
1694             return true;
1695         }
1696
1697         case KILL_PACKAGE_DEPENDENTS_TRANSACTION: {
1698             data.enforceInterface(IActivityManager.descriptor);
1699             String packageName = data.readString();
1700             int userId = data.readInt();
1701             killPackageDependents(packageName, userId);
1702             reply.writeNoException();
1703             return true;
1704         }
1705
1706         case FORCE_STOP_PACKAGE_TRANSACTION: {
1707             data.enforceInterface(IActivityManager.descriptor);
1708             String packageName = data.readString();
1709             int userId = data.readInt();
1710             forceStopPackage(packageName, userId);
1711             reply.writeNoException();
1712             return true;
1713         }
1714
1715         case GET_MY_MEMORY_STATE_TRANSACTION: {
1716             data.enforceInterface(IActivityManager.descriptor);
1717             ActivityManager.RunningAppProcessInfo info =
1718                     new ActivityManager.RunningAppProcessInfo();
1719             getMyMemoryState(info);
1720             reply.writeNoException();
1721             info.writeToParcel(reply, 0);
1722             return true;
1723         }
1724
1725         case GET_DEVICE_CONFIGURATION_TRANSACTION: {
1726             data.enforceInterface(IActivityManager.descriptor);
1727             ConfigurationInfo config = getDeviceConfigurationInfo();
1728             reply.writeNoException();
1729             config.writeToParcel(reply, 0);
1730             return true;
1731         }
1732
1733         case PROFILE_CONTROL_TRANSACTION: {
1734             data.enforceInterface(IActivityManager.descriptor);
1735             String process = data.readString();
1736             int userId = data.readInt();
1737             boolean start = data.readInt() != 0;
1738             int profileType = data.readInt();
1739             ProfilerInfo profilerInfo = data.readInt() != 0
1740                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
1741             boolean res = profileControl(process, userId, start, profilerInfo, profileType);
1742             reply.writeNoException();
1743             reply.writeInt(res ? 1 : 0);
1744             return true;
1745         }
1746
1747         case SHUTDOWN_TRANSACTION: {
1748             data.enforceInterface(IActivityManager.descriptor);
1749             boolean res = shutdown(data.readInt());
1750             reply.writeNoException();
1751             reply.writeInt(res ? 1 : 0);
1752             return true;
1753         }
1754
1755         case STOP_APP_SWITCHES_TRANSACTION: {
1756             data.enforceInterface(IActivityManager.descriptor);
1757             stopAppSwitches();
1758             reply.writeNoException();
1759             return true;
1760         }
1761
1762         case RESUME_APP_SWITCHES_TRANSACTION: {
1763             data.enforceInterface(IActivityManager.descriptor);
1764             resumeAppSwitches();
1765             reply.writeNoException();
1766             return true;
1767         }
1768
1769         case PEEK_SERVICE_TRANSACTION: {
1770             data.enforceInterface(IActivityManager.descriptor);
1771             Intent service = Intent.CREATOR.createFromParcel(data);
1772             String resolvedType = data.readString();
1773             String callingPackage = data.readString();
1774             IBinder binder = peekService(service, resolvedType, callingPackage);
1775             reply.writeNoException();
1776             reply.writeStrongBinder(binder);
1777             return true;
1778         }
1779
1780         case START_BACKUP_AGENT_TRANSACTION: {
1781             data.enforceInterface(IActivityManager.descriptor);
1782             String packageName = data.readString();
1783             int backupRestoreMode = data.readInt();
1784             int userId = data.readInt();
1785             boolean success = bindBackupAgent(packageName, backupRestoreMode, userId);
1786             reply.writeNoException();
1787             reply.writeInt(success ? 1 : 0);
1788             return true;
1789         }
1790
1791         case BACKUP_AGENT_CREATED_TRANSACTION: {
1792             data.enforceInterface(IActivityManager.descriptor);
1793             String packageName = data.readString();
1794             IBinder agent = data.readStrongBinder();
1795             backupAgentCreated(packageName, agent);
1796             reply.writeNoException();
1797             return true;
1798         }
1799
1800         case UNBIND_BACKUP_AGENT_TRANSACTION: {
1801             data.enforceInterface(IActivityManager.descriptor);
1802             ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
1803             unbindBackupAgent(info);
1804             reply.writeNoException();
1805             return true;
1806         }
1807
1808         case ADD_PACKAGE_DEPENDENCY_TRANSACTION: {
1809             data.enforceInterface(IActivityManager.descriptor);
1810             String packageName = data.readString();
1811             addPackageDependency(packageName);
1812             reply.writeNoException();
1813             return true;
1814         }
1815
1816         case KILL_APPLICATION_TRANSACTION: {
1817             data.enforceInterface(IActivityManager.descriptor);
1818             String pkg = data.readString();
1819             int appId = data.readInt();
1820             int userId = data.readInt();
1821             String reason = data.readString();
1822             killApplication(pkg, appId, userId, reason);
1823             reply.writeNoException();
1824             return true;
1825         }
1826
1827         case CLOSE_SYSTEM_DIALOGS_TRANSACTION: {
1828             data.enforceInterface(IActivityManager.descriptor);
1829             String reason = data.readString();
1830             closeSystemDialogs(reason);
1831             reply.writeNoException();
1832             return true;
1833         }
1834
1835         case GET_PROCESS_MEMORY_INFO_TRANSACTION: {
1836             data.enforceInterface(IActivityManager.descriptor);
1837             int[] pids = data.createIntArray();
1838             Debug.MemoryInfo[] res =  getProcessMemoryInfo(pids);
1839             reply.writeNoException();
1840             reply.writeTypedArray(res, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1841             return true;
1842         }
1843
1844         case KILL_APPLICATION_PROCESS_TRANSACTION: {
1845             data.enforceInterface(IActivityManager.descriptor);
1846             String processName = data.readString();
1847             int uid = data.readInt();
1848             killApplicationProcess(processName, uid);
1849             reply.writeNoException();
1850             return true;
1851         }
1852
1853         case OVERRIDE_PENDING_TRANSITION_TRANSACTION: {
1854             data.enforceInterface(IActivityManager.descriptor);
1855             IBinder token = data.readStrongBinder();
1856             String packageName = data.readString();
1857             int enterAnim = data.readInt();
1858             int exitAnim = data.readInt();
1859             overridePendingTransition(token, packageName, enterAnim, exitAnim);
1860             reply.writeNoException();
1861             return true;
1862         }
1863
1864         case IS_USER_A_MONKEY_TRANSACTION: {
1865             data.enforceInterface(IActivityManager.descriptor);
1866             boolean areThey = isUserAMonkey();
1867             reply.writeNoException();
1868             reply.writeInt(areThey ? 1 : 0);
1869             return true;
1870         }
1871
1872         case SET_USER_IS_MONKEY_TRANSACTION: {
1873             data.enforceInterface(IActivityManager.descriptor);
1874             final boolean monkey = (data.readInt() == 1);
1875             setUserIsMonkey(monkey);
1876             reply.writeNoException();
1877             return true;
1878         }
1879
1880         case FINISH_HEAVY_WEIGHT_APP_TRANSACTION: {
1881             data.enforceInterface(IActivityManager.descriptor);
1882             finishHeavyWeightApp();
1883             reply.writeNoException();
1884             return true;
1885         }
1886
1887         case IS_IMMERSIVE_TRANSACTION: {
1888             data.enforceInterface(IActivityManager.descriptor);
1889             IBinder token = data.readStrongBinder();
1890             boolean isit = isImmersive(token);
1891             reply.writeNoException();
1892             reply.writeInt(isit ? 1 : 0);
1893             return true;
1894         }
1895
1896         case IS_TOP_OF_TASK_TRANSACTION: {
1897             data.enforceInterface(IActivityManager.descriptor);
1898             IBinder token = data.readStrongBinder();
1899             final boolean isTopOfTask = isTopOfTask(token);
1900             reply.writeNoException();
1901             reply.writeInt(isTopOfTask ? 1 : 0);
1902             return true;
1903         }
1904
1905         case CONVERT_FROM_TRANSLUCENT_TRANSACTION: {
1906             data.enforceInterface(IActivityManager.descriptor);
1907             IBinder token = data.readStrongBinder();
1908             boolean converted = convertFromTranslucent(token);
1909             reply.writeNoException();
1910             reply.writeInt(converted ? 1 : 0);
1911             return true;
1912         }
1913
1914         case CONVERT_TO_TRANSLUCENT_TRANSACTION: {
1915             data.enforceInterface(IActivityManager.descriptor);
1916             IBinder token = data.readStrongBinder();
1917             final Bundle bundle;
1918             if (data.readInt() == 0) {
1919                 bundle = null;
1920             } else {
1921                 bundle = data.readBundle();
1922             }
1923             final ActivityOptions options = ActivityOptions.fromBundle(bundle);
1924             boolean converted = convertToTranslucent(token, options);
1925             reply.writeNoException();
1926             reply.writeInt(converted ? 1 : 0);
1927             return true;
1928         }
1929
1930         case GET_ACTIVITY_OPTIONS_TRANSACTION: {
1931             data.enforceInterface(IActivityManager.descriptor);
1932             IBinder token = data.readStrongBinder();
1933             final ActivityOptions options = getActivityOptions(token);
1934             reply.writeNoException();
1935             reply.writeBundle(options == null ? null : options.toBundle());
1936             return true;
1937         }
1938
1939         case SET_IMMERSIVE_TRANSACTION: {
1940             data.enforceInterface(IActivityManager.descriptor);
1941             IBinder token = data.readStrongBinder();
1942             boolean imm = data.readInt() == 1;
1943             setImmersive(token, imm);
1944             reply.writeNoException();
1945             return true;
1946         }
1947
1948         case IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION: {
1949             data.enforceInterface(IActivityManager.descriptor);
1950             boolean isit = isTopActivityImmersive();
1951             reply.writeNoException();
1952             reply.writeInt(isit ? 1 : 0);
1953             return true;
1954         }
1955
1956         case CRASH_APPLICATION_TRANSACTION: {
1957             data.enforceInterface(IActivityManager.descriptor);
1958             int uid = data.readInt();
1959             int initialPid = data.readInt();
1960             String packageName = data.readString();
1961             String message = data.readString();
1962             crashApplication(uid, initialPid, packageName, message);
1963             reply.writeNoException();
1964             return true;
1965         }
1966
1967         case GET_PROVIDER_MIME_TYPE_TRANSACTION: {
1968             data.enforceInterface(IActivityManager.descriptor);
1969             Uri uri = Uri.CREATOR.createFromParcel(data);
1970             int userId = data.readInt();
1971             String type = getProviderMimeType(uri, userId);
1972             reply.writeNoException();
1973             reply.writeString(type);
1974             return true;
1975         }
1976
1977         case NEW_URI_PERMISSION_OWNER_TRANSACTION: {
1978             data.enforceInterface(IActivityManager.descriptor);
1979             String name = data.readString();
1980             IBinder perm = newUriPermissionOwner(name);
1981             reply.writeNoException();
1982             reply.writeStrongBinder(perm);
1983             return true;
1984         }
1985
1986         case GET_URI_PERMISSION_OWNER_FOR_ACTIVITY_TRANSACTION: {
1987             data.enforceInterface(IActivityManager.descriptor);
1988             IBinder activityToken = data.readStrongBinder();
1989             IBinder perm = getUriPermissionOwnerForActivity(activityToken);
1990             reply.writeNoException();
1991             reply.writeStrongBinder(perm);
1992             return true;
1993         }
1994
1995         case GRANT_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
1996             data.enforceInterface(IActivityManager.descriptor);
1997             IBinder owner = data.readStrongBinder();
1998             int fromUid = data.readInt();
1999             String targetPkg = data.readString();
2000             Uri uri = Uri.CREATOR.createFromParcel(data);
2001             int mode = data.readInt();
2002             int sourceUserId = data.readInt();
2003             int targetUserId = data.readInt();
2004             grantUriPermissionFromOwner(owner, fromUid, targetPkg, uri, mode, sourceUserId,
2005                     targetUserId);
2006             reply.writeNoException();
2007             return true;
2008         }
2009
2010         case REVOKE_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
2011             data.enforceInterface(IActivityManager.descriptor);
2012             IBinder owner = data.readStrongBinder();
2013             Uri uri = null;
2014             if (data.readInt() != 0) {
2015                 uri = Uri.CREATOR.createFromParcel(data);
2016             }
2017             int mode = data.readInt();
2018             int userId = data.readInt();
2019             revokeUriPermissionFromOwner(owner, uri, mode, userId);
2020             reply.writeNoException();
2021             return true;
2022         }
2023
2024         case CHECK_GRANT_URI_PERMISSION_TRANSACTION: {
2025             data.enforceInterface(IActivityManager.descriptor);
2026             int callingUid = data.readInt();
2027             String targetPkg = data.readString();
2028             Uri uri = Uri.CREATOR.createFromParcel(data);
2029             int modeFlags = data.readInt();
2030             int userId = data.readInt();
2031             int res = checkGrantUriPermission(callingUid, targetPkg, uri, modeFlags, userId);
2032             reply.writeNoException();
2033             reply.writeInt(res);
2034             return true;
2035         }
2036
2037         case DUMP_HEAP_TRANSACTION: {
2038             data.enforceInterface(IActivityManager.descriptor);
2039             String process = data.readString();
2040             int userId = data.readInt();
2041             boolean managed = data.readInt() != 0;
2042             String path = data.readString();
2043             ParcelFileDescriptor fd = data.readInt() != 0
2044                     ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
2045             boolean res = dumpHeap(process, userId, managed, path, fd);
2046             reply.writeNoException();
2047             reply.writeInt(res ? 1 : 0);
2048             return true;
2049         }
2050
2051         case START_ACTIVITIES_TRANSACTION:
2052         {
2053             data.enforceInterface(IActivityManager.descriptor);
2054             IBinder b = data.readStrongBinder();
2055             IApplicationThread app = ApplicationThreadNative.asInterface(b);
2056             String callingPackage = data.readString();
2057             Intent[] intents = data.createTypedArray(Intent.CREATOR);
2058             String[] resolvedTypes = data.createStringArray();
2059             IBinder resultTo = data.readStrongBinder();
2060             Bundle options = data.readInt() != 0
2061                     ? Bundle.CREATOR.createFromParcel(data) : null;
2062             int userId = data.readInt();
2063             int result = startActivities(app, callingPackage, intents, resolvedTypes, resultTo,
2064                     options, userId);
2065             reply.writeNoException();
2066             reply.writeInt(result);
2067             return true;
2068         }
2069
2070         case GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
2071         {
2072             data.enforceInterface(IActivityManager.descriptor);
2073             int mode = getFrontActivityScreenCompatMode();
2074             reply.writeNoException();
2075             reply.writeInt(mode);
2076             return true;
2077         }
2078
2079         case SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
2080         {
2081             data.enforceInterface(IActivityManager.descriptor);
2082             int mode = data.readInt();
2083             setFrontActivityScreenCompatMode(mode);
2084             reply.writeNoException();
2085             reply.writeInt(mode);
2086             return true;
2087         }
2088
2089         case GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
2090         {
2091             data.enforceInterface(IActivityManager.descriptor);
2092             String pkg = data.readString();
2093             int mode = getPackageScreenCompatMode(pkg);
2094             reply.writeNoException();
2095             reply.writeInt(mode);
2096             return true;
2097         }
2098
2099         case SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
2100         {
2101             data.enforceInterface(IActivityManager.descriptor);
2102             String pkg = data.readString();
2103             int mode = data.readInt();
2104             setPackageScreenCompatMode(pkg, mode);
2105             reply.writeNoException();
2106             return true;
2107         }
2108
2109         case SWITCH_USER_TRANSACTION: {
2110             data.enforceInterface(IActivityManager.descriptor);
2111             int userid = data.readInt();
2112             boolean result = switchUser(userid);
2113             reply.writeNoException();
2114             reply.writeInt(result ? 1 : 0);
2115             return true;
2116         }
2117
2118         case START_USER_IN_BACKGROUND_TRANSACTION: {
2119             data.enforceInterface(IActivityManager.descriptor);
2120             int userid = data.readInt();
2121             boolean result = startUserInBackground(userid);
2122             reply.writeNoException();
2123             reply.writeInt(result ? 1 : 0);
2124             return true;
2125         }
2126
2127         case UNLOCK_USER_TRANSACTION: {
2128             data.enforceInterface(IActivityManager.descriptor);
2129             int userId = data.readInt();
2130             byte[] token = data.createByteArray();
2131             byte[] secret = data.createByteArray();
2132             IProgressListener listener = IProgressListener.Stub
2133                     .asInterface(data.readStrongBinder());
2134             boolean result = unlockUser(userId, token, secret, listener);
2135             reply.writeNoException();
2136             reply.writeInt(result ? 1 : 0);
2137             return true;
2138         }
2139
2140         case STOP_USER_TRANSACTION: {
2141             data.enforceInterface(IActivityManager.descriptor);
2142             int userid = data.readInt();
2143             boolean force = data.readInt() != 0;
2144             IStopUserCallback callback = IStopUserCallback.Stub.asInterface(
2145                     data.readStrongBinder());
2146             int result = stopUser(userid, force, callback);
2147             reply.writeNoException();
2148             reply.writeInt(result);
2149             return true;
2150         }
2151
2152         case GET_CURRENT_USER_TRANSACTION: {
2153             data.enforceInterface(IActivityManager.descriptor);
2154             UserInfo userInfo = getCurrentUser();
2155             reply.writeNoException();
2156             userInfo.writeToParcel(reply, 0);
2157             return true;
2158         }
2159
2160         case IS_USER_RUNNING_TRANSACTION: {
2161             data.enforceInterface(IActivityManager.descriptor);
2162             int userid = data.readInt();
2163             int _flags = data.readInt();
2164             boolean result = isUserRunning(userid, _flags);
2165             reply.writeNoException();
2166             reply.writeInt(result ? 1 : 0);
2167             return true;
2168         }
2169
2170         case GET_RUNNING_USER_IDS_TRANSACTION: {
2171             data.enforceInterface(IActivityManager.descriptor);
2172             int[] result = getRunningUserIds();
2173             reply.writeNoException();
2174             reply.writeIntArray(result);
2175             return true;
2176         }
2177
2178         case REMOVE_TASK_TRANSACTION:
2179         {
2180             data.enforceInterface(IActivityManager.descriptor);
2181             int taskId = data.readInt();
2182             boolean result = removeTask(taskId);
2183             reply.writeNoException();
2184             reply.writeInt(result ? 1 : 0);
2185             return true;
2186         }
2187
2188         case REGISTER_PROCESS_OBSERVER_TRANSACTION: {
2189             data.enforceInterface(IActivityManager.descriptor);
2190             IProcessObserver observer = IProcessObserver.Stub.asInterface(
2191                     data.readStrongBinder());
2192             registerProcessObserver(observer);
2193             return true;
2194         }
2195
2196         case UNREGISTER_PROCESS_OBSERVER_TRANSACTION: {
2197             data.enforceInterface(IActivityManager.descriptor);
2198             IProcessObserver observer = IProcessObserver.Stub.asInterface(
2199                     data.readStrongBinder());
2200             unregisterProcessObserver(observer);
2201             return true;
2202         }
2203
2204         case REGISTER_UID_OBSERVER_TRANSACTION: {
2205             data.enforceInterface(IActivityManager.descriptor);
2206             IUidObserver observer = IUidObserver.Stub.asInterface(
2207                     data.readStrongBinder());
2208             int which = data.readInt();
2209             registerUidObserver(observer, which);
2210             return true;
2211         }
2212
2213         case UNREGISTER_UID_OBSERVER_TRANSACTION: {
2214             data.enforceInterface(IActivityManager.descriptor);
2215             IUidObserver observer = IUidObserver.Stub.asInterface(
2216                     data.readStrongBinder());
2217             unregisterUidObserver(observer);
2218             return true;
2219         }
2220
2221         case GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
2222         {
2223             data.enforceInterface(IActivityManager.descriptor);
2224             String pkg = data.readString();
2225             boolean ask = getPackageAskScreenCompat(pkg);
2226             reply.writeNoException();
2227             reply.writeInt(ask ? 1 : 0);
2228             return true;
2229         }
2230
2231         case SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
2232         {
2233             data.enforceInterface(IActivityManager.descriptor);
2234             String pkg = data.readString();
2235             boolean ask = data.readInt() != 0;
2236             setPackageAskScreenCompat(pkg, ask);
2237             reply.writeNoException();
2238             return true;
2239         }
2240
2241         case IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION: {
2242             data.enforceInterface(IActivityManager.descriptor);
2243             IIntentSender r = IIntentSender.Stub.asInterface(
2244                     data.readStrongBinder());
2245             boolean res = isIntentSenderTargetedToPackage(r);
2246             reply.writeNoException();
2247             reply.writeInt(res ? 1 : 0);
2248             return true;
2249         }
2250
2251         case IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION: {
2252             data.enforceInterface(IActivityManager.descriptor);
2253             IIntentSender r = IIntentSender.Stub.asInterface(
2254                 data.readStrongBinder());
2255             boolean res = isIntentSenderAnActivity(r);
2256             reply.writeNoException();
2257             reply.writeInt(res ? 1 : 0);
2258             return true;
2259         }
2260
2261         case GET_INTENT_FOR_INTENT_SENDER_TRANSACTION: {
2262             data.enforceInterface(IActivityManager.descriptor);
2263             IIntentSender r = IIntentSender.Stub.asInterface(
2264                 data.readStrongBinder());
2265             Intent intent = getIntentForIntentSender(r);
2266             reply.writeNoException();
2267             if (intent != null) {
2268                 reply.writeInt(1);
2269                 intent.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
2270             } else {
2271                 reply.writeInt(0);
2272             }
2273             return true;
2274         }
2275
2276         case GET_TAG_FOR_INTENT_SENDER_TRANSACTION: {
2277             data.enforceInterface(IActivityManager.descriptor);
2278             IIntentSender r = IIntentSender.Stub.asInterface(
2279                 data.readStrongBinder());
2280             String prefix = data.readString();
2281             String tag = getTagForIntentSender(r, prefix);
2282             reply.writeNoException();
2283             reply.writeString(tag);
2284             return true;
2285         }
2286
2287         case UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION: {
2288             data.enforceInterface(IActivityManager.descriptor);
2289             Configuration config = Configuration.CREATOR.createFromParcel(data);
2290             updatePersistentConfiguration(config);
2291             reply.writeNoException();
2292             return true;
2293         }
2294
2295         case GET_PROCESS_PSS_TRANSACTION: {
2296             data.enforceInterface(IActivityManager.descriptor);
2297             int[] pids = data.createIntArray();
2298             long[] pss = getProcessPss(pids);
2299             reply.writeNoException();
2300             reply.writeLongArray(pss);
2301             return true;
2302         }
2303
2304         case SHOW_BOOT_MESSAGE_TRANSACTION: {
2305             data.enforceInterface(IActivityManager.descriptor);
2306             CharSequence msg = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
2307             boolean always = data.readInt() != 0;
2308             showBootMessage(msg, always);
2309             reply.writeNoException();
2310             return true;
2311         }
2312
2313         case KEYGUARD_WAITING_FOR_ACTIVITY_DRAWN_TRANSACTION: {
2314             data.enforceInterface(IActivityManager.descriptor);
2315             keyguardWaitingForActivityDrawn();
2316             reply.writeNoException();
2317             return true;
2318         }
2319
2320         case KEYGUARD_GOING_AWAY_TRANSACTION: {
2321             data.enforceInterface(IActivityManager.descriptor);
2322             keyguardGoingAway(data.readInt());
2323             reply.writeNoException();
2324             return true;
2325         }
2326
2327         case SHOULD_UP_RECREATE_TASK_TRANSACTION: {
2328             data.enforceInterface(IActivityManager.descriptor);
2329             IBinder token = data.readStrongBinder();
2330             String destAffinity = data.readString();
2331             boolean res = shouldUpRecreateTask(token, destAffinity);
2332             reply.writeNoException();
2333             reply.writeInt(res ? 1 : 0);
2334             return true;
2335         }
2336
2337         case NAVIGATE_UP_TO_TRANSACTION: {
2338             data.enforceInterface(IActivityManager.descriptor);
2339             IBinder token = data.readStrongBinder();
2340             Intent target = Intent.CREATOR.createFromParcel(data);
2341             int resultCode = data.readInt();
2342             Intent resultData = null;
2343             if (data.readInt() != 0) {
2344                 resultData = Intent.CREATOR.createFromParcel(data);
2345             }
2346             boolean res = navigateUpTo(token, target, resultCode, resultData);
2347             reply.writeNoException();
2348             reply.writeInt(res ? 1 : 0);
2349             return true;
2350         }
2351
2352         case GET_LAUNCHED_FROM_UID_TRANSACTION: {
2353             data.enforceInterface(IActivityManager.descriptor);
2354             IBinder token = data.readStrongBinder();
2355             int res = getLaunchedFromUid(token);
2356             reply.writeNoException();
2357             reply.writeInt(res);
2358             return true;
2359         }
2360
2361         case GET_LAUNCHED_FROM_PACKAGE_TRANSACTION: {
2362             data.enforceInterface(IActivityManager.descriptor);
2363             IBinder token = data.readStrongBinder();
2364             String res = getLaunchedFromPackage(token);
2365             reply.writeNoException();
2366             reply.writeString(res);
2367             return true;
2368         }
2369
2370         case REGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
2371             data.enforceInterface(IActivityManager.descriptor);
2372             IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
2373                     data.readStrongBinder());
2374             String name = data.readString();
2375             registerUserSwitchObserver(observer, name);
2376             reply.writeNoException();
2377             return true;
2378         }
2379
2380         case UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
2381             data.enforceInterface(IActivityManager.descriptor);
2382             IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
2383                     data.readStrongBinder());
2384             unregisterUserSwitchObserver(observer);
2385             reply.writeNoException();
2386             return true;
2387         }
2388
2389         case REQUEST_BUG_REPORT_TRANSACTION: {
2390             data.enforceInterface(IActivityManager.descriptor);
2391             int bugreportType = data.readInt();
2392             requestBugReport(bugreportType);
2393             reply.writeNoException();
2394             return true;
2395         }
2396
2397         case INPUT_DISPATCHING_TIMED_OUT_TRANSACTION: {
2398             data.enforceInterface(IActivityManager.descriptor);
2399             int pid = data.readInt();
2400             boolean aboveSystem = data.readInt() != 0;
2401             String reason = data.readString();
2402             long res = inputDispatchingTimedOut(pid, aboveSystem, reason);
2403             reply.writeNoException();
2404             reply.writeLong(res);
2405             return true;
2406         }
2407
2408         case GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
2409             data.enforceInterface(IActivityManager.descriptor);
2410             int requestType = data.readInt();
2411             Bundle res = getAssistContextExtras(requestType);
2412             reply.writeNoException();
2413             reply.writeBundle(res);
2414             return true;
2415         }
2416
2417         case REQUEST_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
2418             data.enforceInterface(IActivityManager.descriptor);
2419             int requestType = data.readInt();
2420             IResultReceiver receiver = IResultReceiver.Stub.asInterface(data.readStrongBinder());
2421             Bundle receiverExtras = data.readBundle();
2422             IBinder activityToken = data.readStrongBinder();
2423             boolean focused = data.readInt() == 1;
2424             boolean newSessionId = data.readInt() == 1;
2425             boolean res = requestAssistContextExtras(requestType, receiver, receiverExtras,
2426                     activityToken, focused, newSessionId);
2427             reply.writeNoException();
2428             reply.writeInt(res ? 1 : 0);
2429             return true;
2430         }
2431
2432         case REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
2433             data.enforceInterface(IActivityManager.descriptor);
2434             IBinder token = data.readStrongBinder();
2435             Bundle extras = data.readBundle();
2436             AssistStructure structure = AssistStructure.CREATOR.createFromParcel(data);
2437             AssistContent content = AssistContent.CREATOR.createFromParcel(data);
2438             Uri referrer = data.readInt() != 0 ? Uri.CREATOR.createFromParcel(data) : null;
2439             reportAssistContextExtras(token, extras, structure, content, referrer);
2440             reply.writeNoException();
2441             return true;
2442         }
2443
2444         case LAUNCH_ASSIST_INTENT_TRANSACTION: {
2445             data.enforceInterface(IActivityManager.descriptor);
2446             Intent intent = Intent.CREATOR.createFromParcel(data);
2447             int requestType = data.readInt();
2448             String hint = data.readString();
2449             int userHandle = data.readInt();
2450             Bundle args = data.readBundle();
2451             boolean res = launchAssistIntent(intent, requestType, hint, userHandle, args);
2452             reply.writeNoException();
2453             reply.writeInt(res ? 1 : 0);
2454             return true;
2455         }
2456
2457         case IS_SCREEN_CAPTURE_ALLOWED_ON_CURRENT_ACTIVITY_TRANSACTION: {
2458             data.enforceInterface(IActivityManager.descriptor);
2459             boolean res = isAssistDataAllowedOnCurrentActivity();
2460             reply.writeNoException();
2461             reply.writeInt(res ? 1 : 0);
2462             return true;
2463         }
2464
2465         case SHOW_ASSIST_FROM_ACTIVITY_TRANSACTION: {
2466             data.enforceInterface(IActivityManager.descriptor);
2467             IBinder token = data.readStrongBinder();
2468             Bundle args = data.readBundle();
2469             boolean res = showAssistFromActivity(token, args);
2470             reply.writeNoException();
2471             reply.writeInt(res ? 1 : 0);
2472             return true;
2473         }
2474
2475         case KILL_UID_TRANSACTION: {
2476             data.enforceInterface(IActivityManager.descriptor);
2477             int appId = data.readInt();
2478             int userId = data.readInt();
2479             String reason = data.readString();
2480             killUid(appId, userId, reason);
2481             reply.writeNoException();
2482             return true;
2483         }
2484
2485         case HANG_TRANSACTION: {
2486             data.enforceInterface(IActivityManager.descriptor);
2487             IBinder who = data.readStrongBinder();
2488             boolean allowRestart = data.readInt() != 0;
2489             hang(who, allowRestart);
2490             reply.writeNoException();
2491             return true;
2492         }
2493
2494         case REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION: {
2495             data.enforceInterface(IActivityManager.descriptor);
2496             IBinder token = data.readStrongBinder();
2497             reportActivityFullyDrawn(token);
2498             reply.writeNoException();
2499             return true;
2500         }
2501
2502         case NOTIFY_ACTIVITY_DRAWN_TRANSACTION: {
2503             data.enforceInterface(IActivityManager.descriptor);
2504             IBinder token = data.readStrongBinder();
2505             notifyActivityDrawn(token);
2506             reply.writeNoException();
2507             return true;
2508         }
2509
2510         case RESTART_TRANSACTION: {
2511             data.enforceInterface(IActivityManager.descriptor);
2512             restart();
2513             reply.writeNoException();
2514             return true;
2515         }
2516
2517         case PERFORM_IDLE_MAINTENANCE_TRANSACTION: {
2518             data.enforceInterface(IActivityManager.descriptor);
2519             performIdleMaintenance();
2520             reply.writeNoException();
2521             return true;
2522         }
2523
2524         case CREATE_VIRTUAL_ACTIVITY_CONTAINER_TRANSACTION: {
2525             data.enforceInterface(IActivityManager.descriptor);
2526             IBinder parentActivityToken = data.readStrongBinder();
2527             IActivityContainerCallback callback =
2528                     IActivityContainerCallback.Stub.asInterface(data.readStrongBinder());
2529             IActivityContainer activityContainer =
2530                     createVirtualActivityContainer(parentActivityToken, callback);
2531             reply.writeNoException();
2532             if (activityContainer != null) {
2533                 reply.writeInt(1);
2534                 reply.writeStrongBinder(activityContainer.asBinder());
2535             } else {
2536                 reply.writeInt(0);
2537             }
2538             return true;
2539         }
2540
2541         case DELETE_ACTIVITY_CONTAINER_TRANSACTION:  {
2542             data.enforceInterface(IActivityManager.descriptor);
2543             IActivityContainer activityContainer =
2544                     IActivityContainer.Stub.asInterface(data.readStrongBinder());
2545             deleteActivityContainer(activityContainer);
2546             reply.writeNoException();
2547             return true;
2548         }
2549
2550         case CREATE_STACK_ON_DISPLAY: {
2551             data.enforceInterface(IActivityManager.descriptor);
2552             int displayId = data.readInt();
2553             IActivityContainer activityContainer = createStackOnDisplay(displayId);
2554             reply.writeNoException();
2555             if (activityContainer != null) {
2556                 reply.writeInt(1);
2557                 reply.writeStrongBinder(activityContainer.asBinder());
2558             } else {
2559                 reply.writeInt(0);
2560             }
2561             return true;
2562         }
2563
2564         case GET_ACTIVITY_DISPLAY_ID_TRANSACTION: {
2565             data.enforceInterface(IActivityManager.descriptor);
2566             IBinder activityToken = data.readStrongBinder();
2567             int displayId = getActivityDisplayId(activityToken);
2568             reply.writeNoException();
2569             reply.writeInt(displayId);
2570             return true;
2571         }
2572
2573         case START_LOCK_TASK_BY_TASK_ID_TRANSACTION: {
2574             data.enforceInterface(IActivityManager.descriptor);
2575             final int taskId = data.readInt();
2576             startLockTaskMode(taskId);
2577             reply.writeNoException();
2578             return true;
2579         }
2580
2581         case START_LOCK_TASK_BY_TOKEN_TRANSACTION: {
2582             data.enforceInterface(IActivityManager.descriptor);
2583             IBinder token = data.readStrongBinder();
2584             startLockTaskMode(token);
2585             reply.writeNoException();
2586             return true;
2587         }
2588
2589         case START_SYSTEM_LOCK_TASK_TRANSACTION: {
2590             data.enforceInterface(IActivityManager.descriptor);
2591             int taskId = data.readInt();
2592             startSystemLockTaskMode(taskId);
2593             reply.writeNoException();
2594             return true;
2595         }
2596
2597         case STOP_LOCK_TASK_MODE_TRANSACTION: {
2598             data.enforceInterface(IActivityManager.descriptor);
2599             stopLockTaskMode();
2600             reply.writeNoException();
2601             return true;
2602         }
2603
2604         case STOP_SYSTEM_LOCK_TASK_TRANSACTION: {
2605             data.enforceInterface(IActivityManager.descriptor);
2606             stopSystemLockTaskMode();
2607             reply.writeNoException();
2608             return true;
2609         }
2610
2611         case IS_IN_LOCK_TASK_MODE_TRANSACTION: {
2612             data.enforceInterface(IActivityManager.descriptor);
2613             final boolean isInLockTaskMode = isInLockTaskMode();
2614             reply.writeNoException();
2615             reply.writeInt(isInLockTaskMode ? 1 : 0);
2616             return true;
2617         }
2618
2619         case GET_LOCK_TASK_MODE_STATE_TRANSACTION: {
2620             data.enforceInterface(IActivityManager.descriptor);
2621             final int lockTaskModeState = getLockTaskModeState();
2622             reply.writeNoException();
2623             reply.writeInt(lockTaskModeState);
2624             return true;
2625         }
2626
2627         case SHOW_LOCK_TASK_ESCAPE_MESSAGE_TRANSACTION: {
2628             data.enforceInterface(IActivityManager.descriptor);
2629             final IBinder token = data.readStrongBinder();
2630             showLockTaskEscapeMessage(token);
2631             reply.writeNoException();
2632             return true;
2633         }
2634
2635         case SET_TASK_DESCRIPTION_TRANSACTION: {
2636             data.enforceInterface(IActivityManager.descriptor);
2637             IBinder token = data.readStrongBinder();
2638             ActivityManager.TaskDescription values =
2639                     ActivityManager.TaskDescription.CREATOR.createFromParcel(data);
2640             setTaskDescription(token, values);
2641             reply.writeNoException();
2642             return true;
2643         }
2644
2645         case SET_TASK_RESIZEABLE_TRANSACTION: {
2646             data.enforceInterface(IActivityManager.descriptor);
2647             final int taskId = data.readInt();
2648             final int resizeableMode = data.readInt();
2649             setTaskResizeable(taskId, resizeableMode);
2650             reply.writeNoException();
2651             return true;
2652         }
2653
2654         case RESIZE_TASK_TRANSACTION: {
2655             data.enforceInterface(IActivityManager.descriptor);
2656             int taskId = data.readInt();
2657             int resizeMode = data.readInt();
2658             Rect r = Rect.CREATOR.createFromParcel(data);
2659             resizeTask(taskId, r, resizeMode);
2660             reply.writeNoException();
2661             return true;
2662         }
2663
2664         case GET_TASK_BOUNDS_TRANSACTION: {
2665             data.enforceInterface(IActivityManager.descriptor);
2666             int taskId = data.readInt();
2667             Rect r = getTaskBounds(taskId);
2668             reply.writeNoException();
2669             r.writeToParcel(reply, 0);
2670             return true;
2671         }
2672
2673         case GET_TASK_DESCRIPTION_ICON_TRANSACTION: {
2674             data.enforceInterface(IActivityManager.descriptor);
2675             String filename = data.readString();
2676             int userId = data.readInt();
2677             Bitmap icon = getTaskDescriptionIcon(filename, userId);
2678             reply.writeNoException();
2679             if (icon == null) {
2680                 reply.writeInt(0);
2681             } else {
2682                 reply.writeInt(1);
2683                 icon.writeToParcel(reply, 0);
2684             }
2685             return true;
2686         }
2687
2688         case START_IN_PLACE_ANIMATION_TRANSACTION: {
2689             data.enforceInterface(IActivityManager.descriptor);
2690             final Bundle bundle;
2691             if (data.readInt() == 0) {
2692                 bundle = null;
2693             } else {
2694                 bundle = data.readBundle();
2695             }
2696             final ActivityOptions options = ActivityOptions.fromBundle(bundle);
2697             startInPlaceAnimationOnFrontMostApplication(options);
2698             reply.writeNoException();
2699             return true;
2700         }
2701
2702         case REQUEST_VISIBLE_BEHIND_TRANSACTION: {
2703             data.enforceInterface(IActivityManager.descriptor);
2704             IBinder token = data.readStrongBinder();
2705             boolean enable = data.readInt() > 0;
2706             boolean success = requestVisibleBehind(token, enable);
2707             reply.writeNoException();
2708             reply.writeInt(success ? 1 : 0);
2709             return true;
2710         }
2711
2712         case IS_BACKGROUND_VISIBLE_BEHIND_TRANSACTION: {
2713             data.enforceInterface(IActivityManager.descriptor);
2714             IBinder token = data.readStrongBinder();
2715             final boolean enabled = isBackgroundVisibleBehind(token);
2716             reply.writeNoException();
2717             reply.writeInt(enabled ? 1 : 0);
2718             return true;
2719         }
2720
2721         case BACKGROUND_RESOURCES_RELEASED_TRANSACTION: {
2722             data.enforceInterface(IActivityManager.descriptor);
2723             IBinder token = data.readStrongBinder();
2724             backgroundResourcesReleased(token);
2725             reply.writeNoException();
2726             return true;
2727         }
2728
2729         case NOTIFY_LAUNCH_TASK_BEHIND_COMPLETE_TRANSACTION: {
2730             data.enforceInterface(IActivityManager.descriptor);
2731             IBinder token = data.readStrongBinder();
2732             notifyLaunchTaskBehindComplete(token);
2733             reply.writeNoException();
2734             return true;
2735         }
2736
2737         case NOTIFY_ENTER_ANIMATION_COMPLETE_TRANSACTION: {
2738             data.enforceInterface(IActivityManager.descriptor);
2739             IBinder token = data.readStrongBinder();
2740             notifyEnterAnimationComplete(token);
2741             reply.writeNoException();
2742             return true;
2743         }
2744
2745         case BOOT_ANIMATION_COMPLETE_TRANSACTION: {
2746             data.enforceInterface(IActivityManager.descriptor);
2747             bootAnimationComplete();
2748             reply.writeNoException();
2749             return true;
2750         }
2751
2752         case NOTIFY_CLEARTEXT_NETWORK_TRANSACTION: {
2753             data.enforceInterface(IActivityManager.descriptor);
2754             final int uid = data.readInt();
2755             final byte[] firstPacket = data.createByteArray();
2756             notifyCleartextNetwork(uid, firstPacket);
2757             reply.writeNoException();
2758             return true;
2759         }
2760
2761         case SET_DUMP_HEAP_DEBUG_LIMIT_TRANSACTION: {
2762             data.enforceInterface(IActivityManager.descriptor);
2763             String procName = data.readString();
2764             int uid = data.readInt();
2765             long maxMemSize = data.readLong();
2766             String reportPackage = data.readString();
2767             setDumpHeapDebugLimit(procName, uid, maxMemSize, reportPackage);
2768             reply.writeNoException();
2769             return true;
2770         }
2771
2772         case DUMP_HEAP_FINISHED_TRANSACTION: {
2773             data.enforceInterface(IActivityManager.descriptor);
2774             String path = data.readString();
2775             dumpHeapFinished(path);
2776             reply.writeNoException();
2777             return true;
2778         }
2779
2780         case SET_VOICE_KEEP_AWAKE_TRANSACTION: {
2781             data.enforceInterface(IActivityManager.descriptor);
2782             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
2783                     data.readStrongBinder());
2784             boolean keepAwake = data.readInt() != 0;
2785             setVoiceKeepAwake(session, keepAwake);
2786             reply.writeNoException();
2787             return true;
2788         }
2789
2790         case UPDATE_LOCK_TASK_PACKAGES_TRANSACTION: {
2791             data.enforceInterface(IActivityManager.descriptor);
2792             int userId = data.readInt();
2793             String[] packages = data.readStringArray();
2794             updateLockTaskPackages(userId, packages);
2795             reply.writeNoException();
2796             return true;
2797         }
2798
2799         case UPDATE_DEVICE_OWNER_TRANSACTION: {
2800             data.enforceInterface(IActivityManager.descriptor);
2801             String packageName = data.readString();
2802             updateDeviceOwner(packageName);
2803             reply.writeNoException();
2804             return true;
2805         }
2806
2807         case GET_PACKAGE_PROCESS_STATE_TRANSACTION: {
2808             data.enforceInterface(IActivityManager.descriptor);
2809             String pkg = data.readString();
2810             String callingPackage = data.readString();
2811             int res = getPackageProcessState(pkg, callingPackage);
2812             reply.writeNoException();
2813             reply.writeInt(res);
2814             return true;
2815         }
2816
2817         case SET_PROCESS_MEMORY_TRIM_TRANSACTION: {
2818             data.enforceInterface(IActivityManager.descriptor);
2819             String process = data.readString();
2820             int userId = data.readInt();
2821             int level = data.readInt();
2822             boolean res = setProcessMemoryTrimLevel(process, userId, level);
2823             reply.writeNoException();
2824             reply.writeInt(res ? 1 : 0);
2825             return true;
2826         }
2827
2828         case IS_ROOT_VOICE_INTERACTION_TRANSACTION: {
2829             data.enforceInterface(IActivityManager.descriptor);
2830             IBinder token = data.readStrongBinder();
2831             boolean res = isRootVoiceInteraction(token);
2832             reply.writeNoException();
2833             reply.writeInt(res ? 1 : 0);
2834             return true;
2835         }
2836
2837         case START_BINDER_TRACKING_TRANSACTION: {
2838             data.enforceInterface(IActivityManager.descriptor);
2839             boolean res = startBinderTracking();
2840             reply.writeNoException();
2841             reply.writeInt(res ? 1 : 0);
2842             return true;
2843         }
2844
2845         case STOP_BINDER_TRACKING_AND_DUMP_TRANSACTION: {
2846             data.enforceInterface(IActivityManager.descriptor);
2847             ParcelFileDescriptor fd = data.readInt() != 0
2848                     ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
2849             boolean res = stopBinderTrackingAndDump(fd);
2850             reply.writeNoException();
2851             reply.writeInt(res ? 1 : 0);
2852             return true;
2853         }
2854         case GET_ACTIVITY_STACK_ID_TRANSACTION: {
2855             data.enforceInterface(IActivityManager.descriptor);
2856             IBinder token = data.readStrongBinder();
2857             int stackId = getActivityStackId(token);
2858             reply.writeNoException();
2859             reply.writeInt(stackId);
2860             return true;
2861         }
2862         case EXIT_FREEFORM_MODE_TRANSACTION: {
2863             data.enforceInterface(IActivityManager.descriptor);
2864             IBinder token = data.readStrongBinder();
2865             exitFreeformMode(token);
2866             reply.writeNoException();
2867             return true;
2868         }
2869         case REPORT_SIZE_CONFIGURATIONS: {
2870             data.enforceInterface(IActivityManager.descriptor);
2871             IBinder token = data.readStrongBinder();
2872             int[] horizontal = readIntArray(data);
2873             int[] vertical = readIntArray(data);
2874             int[] smallest = readIntArray(data);
2875             reportSizeConfigurations(token, horizontal, vertical, smallest);
2876             return true;
2877         }
2878         case SUPPRESS_RESIZE_CONFIG_CHANGES_TRANSACTION: {
2879             data.enforceInterface(IActivityManager.descriptor);
2880             final boolean suppress = data.readInt() == 1;
2881             suppressResizeConfigChanges(suppress);
2882             reply.writeNoException();
2883             return true;
2884         }
2885         case MOVE_TASKS_TO_FULLSCREEN_STACK_TRANSACTION: {
2886             data.enforceInterface(IActivityManager.descriptor);
2887             final int stackId = data.readInt();
2888             final boolean onTop = data.readInt() == 1;
2889             moveTasksToFullscreenStack(stackId, onTop);
2890             reply.writeNoException();
2891             return true;
2892         }
2893         case GET_APP_START_MODE_TRANSACTION: {
2894             data.enforceInterface(IActivityManager.descriptor);
2895             final int uid = data.readInt();
2896             final String pkg = data.readString();
2897             int res = getAppStartMode(uid, pkg);
2898             reply.writeNoException();
2899             reply.writeInt(res);
2900             return true;
2901         }
2902         case IN_MULTI_WINDOW_TRANSACTION: {
2903             data.enforceInterface(IActivityManager.descriptor);
2904             final IBinder token = data.readStrongBinder();
2905             final boolean inMultiWindow = isInMultiWindowMode(token);
2906             reply.writeNoException();
2907             reply.writeInt(inMultiWindow ? 1 : 0);
2908             return true;
2909         }
2910         case IN_PICTURE_IN_PICTURE_TRANSACTION: {
2911             data.enforceInterface(IActivityManager.descriptor);
2912             final IBinder token = data.readStrongBinder();
2913             final boolean inPip = isInPictureInPictureMode(token);
2914             reply.writeNoException();
2915             reply.writeInt(inPip ? 1 : 0);
2916             return true;
2917         }
2918         case ENTER_PICTURE_IN_PICTURE_TRANSACTION: {
2919             data.enforceInterface(IActivityManager.descriptor);
2920             final IBinder token = data.readStrongBinder();
2921             enterPictureInPictureMode(token);
2922             reply.writeNoException();
2923             return true;
2924         }
2925         case SET_VR_MODE_TRANSACTION: {
2926             data.enforceInterface(IActivityManager.descriptor);
2927             final IBinder token = data.readStrongBinder();
2928             final boolean enable = data.readInt() == 1;
2929             final ComponentName packageName = ComponentName.CREATOR.createFromParcel(data);
2930             int res = setVrMode(token, enable, packageName);
2931             reply.writeNoException();
2932             reply.writeInt(res);
2933             return true;
2934         }
2935         case IS_VR_PACKAGE_ENABLED_TRANSACTION: {
2936             data.enforceInterface(IActivityManager.descriptor);
2937             final ComponentName packageName = ComponentName.CREATOR.createFromParcel(data);
2938             boolean res = isVrModePackageEnabled(packageName);
2939             reply.writeNoException();
2940             reply.writeInt(res ? 1 : 0);
2941             return true;
2942         }
2943         case IS_APP_FOREGROUND_TRANSACTION: {
2944             data.enforceInterface(IActivityManager.descriptor);
2945             final int userHandle = data.readInt();
2946             final boolean isForeground = isAppForeground(userHandle);
2947             reply.writeNoException();
2948             reply.writeInt(isForeground ? 1 : 0);
2949             return true;
2950         }
2951         case NOTIFY_PINNED_STACK_ANIMATION_ENDED_TRANSACTION: {
2952             data.enforceInterface(IActivityManager.descriptor);
2953             reply.writeNoException();
2954             return true;
2955         }
2956         case REMOVE_STACK: {
2957             data.enforceInterface(IActivityManager.descriptor);
2958             final int stackId = data.readInt();
2959             removeStack(stackId);
2960             reply.writeNoException();
2961             return true;
2962         }
2963         case NOTIFY_LOCKED_PROFILE: {
2964             data.enforceInterface(IActivityManager.descriptor);
2965             final int userId = data.readInt();
2966             notifyLockedProfile(userId);
2967             reply.writeNoException();
2968             return true;
2969         }
2970         case START_CONFIRM_DEVICE_CREDENTIAL_INTENT: {
2971             data.enforceInterface(IActivityManager.descriptor);
2972             final Intent intent = Intent.CREATOR.createFromParcel(data);
2973             startConfirmDeviceCredentialIntent(intent);
2974             reply.writeNoException();
2975             return true;
2976         }
2977         case SEND_IDLE_JOB_TRIGGER_TRANSACTION: {
2978             data.enforceInterface(IActivityManager.descriptor);
2979             sendIdleJobTrigger();
2980             reply.writeNoException();
2981             return true;
2982         }
2983         case SEND_INTENT_SENDER_TRANSACTION: {
2984             data.enforceInterface(IActivityManager.descriptor);
2985             IIntentSender sender = IIntentSender.Stub.asInterface(data.readStrongBinder());
2986             int scode = data.readInt();
2987             Intent intent = data.readInt() != 0 ? Intent.CREATOR.createFromParcel(data) : null;
2988             String resolvedType = data.readString();
2989             IIntentReceiver finishedReceiver = IIntentReceiver.Stub.asInterface(
2990                     data.readStrongBinder());
2991             String requiredPermission = data.readString();
2992             Bundle options = data.readInt() != 0 ? Bundle.CREATOR.createFromParcel(data) : null;
2993             int result = sendIntentSender(sender, scode, intent, resolvedType, finishedReceiver,
2994                     requiredPermission, options);
2995             reply.writeNoException();
2996             reply.writeInt(result);
2997             return true;
2998         }
2999         case SET_VR_THREAD_TRANSACTION: {
3000             data.enforceInterface(IActivityManager.descriptor);
3001             final int tid = data.readInt();
3002             setVrThread(tid);
3003             reply.writeNoException();
3004             return true;
3005         }
3006         case SET_RENDER_THREAD_TRANSACTION: {
3007             data.enforceInterface(IActivityManager.descriptor);
3008             final int tid = data.readInt();
3009             setRenderThread(tid);
3010             reply.writeNoException();
3011             return true;
3012         }
3013         case SET_HAS_TOP_UI: {
3014             data.enforceInterface(IActivityManager.descriptor);
3015             final boolean hasTopUi = data.readInt() != 0;
3016             setHasTopUi(hasTopUi);
3017             reply.writeNoException();
3018             return true;
3019         }
3020         }
3021
3022         return super.onTransact(code, data, reply, flags);
3023     }
3024
3025     private int[] readIntArray(Parcel data) {
3026         int[] smallest = null;
3027         int smallestSize = data.readInt();
3028         if (smallestSize > 0) {
3029             smallest = new int[smallestSize];
3030             data.readIntArray(smallest);
3031         }
3032         return smallest;
3033     }
3034
3035     public IBinder asBinder() {
3036         return this;
3037     }
3038
3039     private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
3040         protected IActivityManager create() {
3041             IBinder b = ServiceManager.getService("activity");
3042             if (false) {
3043                 Log.v("ActivityManager", "default service binder = " + b);
3044             }
3045             IActivityManager am = asInterface(b);
3046             if (false) {
3047                 Log.v("ActivityManager", "default service = " + am);
3048             }
3049             return am;
3050         }
3051     };
3052 }
3053
3054 class ActivityManagerProxy implements IActivityManager
3055 {
3056     public ActivityManagerProxy(IBinder remote)
3057     {
3058         mRemote = remote;
3059     }
3060
3061     public IBinder asBinder()
3062     {
3063         return mRemote;
3064     }
3065
3066     public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
3067             String resolvedType, IBinder resultTo, String resultWho, int requestCode,
3068             int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
3069         Parcel data = Parcel.obtain();
3070         Parcel reply = Parcel.obtain();
3071         data.writeInterfaceToken(IActivityManager.descriptor);
3072         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3073         data.writeString(callingPackage);
3074         intent.writeToParcel(data, 0);
3075         data.writeString(resolvedType);
3076         data.writeStrongBinder(resultTo);
3077         data.writeString(resultWho);
3078         data.writeInt(requestCode);
3079         data.writeInt(startFlags);
3080         if (profilerInfo != null) {
3081             data.writeInt(1);
3082             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3083         } else {
3084             data.writeInt(0);
3085         }
3086         if (options != null) {
3087             data.writeInt(1);
3088             options.writeToParcel(data, 0);
3089         } else {
3090             data.writeInt(0);
3091         }
3092         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
3093         reply.readException();
3094         int result = reply.readInt();
3095         reply.recycle();
3096         data.recycle();
3097         return result;
3098     }
3099
3100     public int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent,
3101             String resolvedType, IBinder resultTo, String resultWho, int requestCode,
3102             int startFlags, ProfilerInfo profilerInfo, Bundle options,
3103             int userId) throws RemoteException {
3104         Parcel data = Parcel.obtain();
3105         Parcel reply = Parcel.obtain();
3106         data.writeInterfaceToken(IActivityManager.descriptor);
3107         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3108         data.writeString(callingPackage);
3109         intent.writeToParcel(data, 0);
3110         data.writeString(resolvedType);
3111         data.writeStrongBinder(resultTo);
3112         data.writeString(resultWho);
3113         data.writeInt(requestCode);
3114         data.writeInt(startFlags);
3115         if (profilerInfo != null) {
3116             data.writeInt(1);
3117             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3118         } else {
3119             data.writeInt(0);
3120         }
3121         if (options != null) {
3122             data.writeInt(1);
3123             options.writeToParcel(data, 0);
3124         } else {
3125             data.writeInt(0);
3126         }
3127         data.writeInt(userId);
3128         mRemote.transact(START_ACTIVITY_AS_USER_TRANSACTION, data, reply, 0);
3129         reply.readException();
3130         int result = reply.readInt();
3131         reply.recycle();
3132         data.recycle();
3133         return result;
3134     }
3135     public int startActivityAsCaller(IApplicationThread caller, String callingPackage,
3136             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
3137             int startFlags, ProfilerInfo profilerInfo, Bundle options, boolean ignoreTargetSecurity,
3138             int userId) throws RemoteException {
3139         Parcel data = Parcel.obtain();
3140         Parcel reply = Parcel.obtain();
3141         data.writeInterfaceToken(IActivityManager.descriptor);
3142         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3143         data.writeString(callingPackage);
3144         intent.writeToParcel(data, 0);
3145         data.writeString(resolvedType);
3146         data.writeStrongBinder(resultTo);
3147         data.writeString(resultWho);
3148         data.writeInt(requestCode);
3149         data.writeInt(startFlags);
3150         if (profilerInfo != null) {
3151             data.writeInt(1);
3152             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3153         } else {
3154             data.writeInt(0);
3155         }
3156         if (options != null) {
3157             data.writeInt(1);
3158             options.writeToParcel(data, 0);
3159         } else {
3160             data.writeInt(0);
3161         }
3162         data.writeInt(ignoreTargetSecurity ? 1 : 0);
3163         data.writeInt(userId);
3164         mRemote.transact(START_ACTIVITY_AS_CALLER_TRANSACTION, data, reply, 0);
3165         reply.readException();
3166         int result = reply.readInt();
3167         reply.recycle();
3168         data.recycle();
3169         return result;
3170     }
3171     public WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,
3172             Intent intent, String resolvedType, IBinder resultTo, String resultWho,
3173             int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle options,
3174             int userId) throws RemoteException {
3175         Parcel data = Parcel.obtain();
3176         Parcel reply = Parcel.obtain();
3177         data.writeInterfaceToken(IActivityManager.descriptor);
3178         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3179         data.writeString(callingPackage);
3180         intent.writeToParcel(data, 0);
3181         data.writeString(resolvedType);
3182         data.writeStrongBinder(resultTo);
3183         data.writeString(resultWho);
3184         data.writeInt(requestCode);
3185         data.writeInt(startFlags);
3186         if (profilerInfo != null) {
3187             data.writeInt(1);
3188             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3189         } else {
3190             data.writeInt(0);
3191         }
3192         if (options != null) {
3193             data.writeInt(1);
3194             options.writeToParcel(data, 0);
3195         } else {
3196             data.writeInt(0);
3197         }
3198         data.writeInt(userId);
3199         mRemote.transact(START_ACTIVITY_AND_WAIT_TRANSACTION, data, reply, 0);
3200         reply.readException();
3201         WaitResult result = WaitResult.CREATOR.createFromParcel(reply);
3202         reply.recycle();
3203         data.recycle();
3204         return result;
3205     }
3206     public int startActivityWithConfig(IApplicationThread caller, String callingPackage,
3207             Intent intent, String resolvedType, IBinder resultTo, String resultWho,
3208             int requestCode, int startFlags, Configuration config,
3209             Bundle options, int userId) throws RemoteException {
3210         Parcel data = Parcel.obtain();
3211         Parcel reply = Parcel.obtain();
3212         data.writeInterfaceToken(IActivityManager.descriptor);
3213         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3214         data.writeString(callingPackage);
3215         intent.writeToParcel(data, 0);
3216         data.writeString(resolvedType);
3217         data.writeStrongBinder(resultTo);
3218         data.writeString(resultWho);
3219         data.writeInt(requestCode);
3220         data.writeInt(startFlags);
3221         config.writeToParcel(data, 0);
3222         if (options != null) {
3223             data.writeInt(1);
3224             options.writeToParcel(data, 0);
3225         } else {
3226             data.writeInt(0);
3227         }
3228         data.writeInt(userId);
3229         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
3230         reply.readException();
3231         int result = reply.readInt();
3232         reply.recycle();
3233         data.recycle();
3234         return result;
3235     }
3236     public int startActivityIntentSender(IApplicationThread caller,
3237             IntentSender intent, Intent fillInIntent, String resolvedType,
3238             IBinder resultTo, String resultWho, int requestCode,
3239             int flagsMask, int flagsValues, Bundle options) throws RemoteException {
3240         Parcel data = Parcel.obtain();
3241         Parcel reply = Parcel.obtain();
3242         data.writeInterfaceToken(IActivityManager.descriptor);
3243         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3244         intent.writeToParcel(data, 0);
3245         if (fillInIntent != null) {
3246             data.writeInt(1);
3247             fillInIntent.writeToParcel(data, 0);
3248         } else {
3249             data.writeInt(0);
3250         }
3251         data.writeString(resolvedType);
3252         data.writeStrongBinder(resultTo);
3253         data.writeString(resultWho);
3254         data.writeInt(requestCode);
3255         data.writeInt(flagsMask);
3256         data.writeInt(flagsValues);
3257         if (options != null) {
3258             data.writeInt(1);
3259             options.writeToParcel(data, 0);
3260         } else {
3261             data.writeInt(0);
3262         }
3263         mRemote.transact(START_ACTIVITY_INTENT_SENDER_TRANSACTION, data, reply, 0);
3264         reply.readException();
3265         int result = reply.readInt();
3266         reply.recycle();
3267         data.recycle();
3268         return result;
3269     }
3270     public int startVoiceActivity(String callingPackage, int callingPid, int callingUid,
3271             Intent intent, String resolvedType, IVoiceInteractionSession session,
3272             IVoiceInteractor interactor, int startFlags, ProfilerInfo profilerInfo,
3273             Bundle options, int userId) throws RemoteException {
3274         Parcel data = Parcel.obtain();
3275         Parcel reply = Parcel.obtain();
3276         data.writeInterfaceToken(IActivityManager.descriptor);
3277         data.writeString(callingPackage);
3278         data.writeInt(callingPid);
3279         data.writeInt(callingUid);
3280         intent.writeToParcel(data, 0);
3281         data.writeString(resolvedType);
3282         data.writeStrongBinder(session.asBinder());
3283         data.writeStrongBinder(interactor.asBinder());
3284         data.writeInt(startFlags);
3285         if (profilerInfo != null) {
3286             data.writeInt(1);
3287             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3288         } else {
3289             data.writeInt(0);
3290         }
3291         if (options != null) {
3292             data.writeInt(1);
3293             options.writeToParcel(data, 0);
3294         } else {
3295             data.writeInt(0);
3296         }
3297         data.writeInt(userId);
3298         mRemote.transact(START_VOICE_ACTIVITY_TRANSACTION, data, reply, 0);
3299         reply.readException();
3300         int result = reply.readInt();
3301         reply.recycle();
3302         data.recycle();
3303         return result;
3304     }
3305
3306     public void startLocalVoiceInteraction(IBinder callingActivity, Bundle options)
3307             throws RemoteException {
3308         Parcel data = Parcel.obtain();
3309         Parcel reply = Parcel.obtain();
3310         data.writeInterfaceToken(IActivityManager.descriptor);
3311         data.writeStrongBinder(callingActivity);
3312         data.writeBundle(options);
3313         mRemote.transact(START_LOCAL_VOICE_INTERACTION_TRANSACTION, data, reply, 0);
3314         reply.readException();
3315         reply.recycle();
3316         data.recycle();
3317     }
3318
3319     public void stopLocalVoiceInteraction(IBinder callingActivity) throws RemoteException {
3320         Parcel data = Parcel.obtain();
3321         Parcel reply = Parcel.obtain();
3322         data.writeInterfaceToken(IActivityManager.descriptor);
3323         data.writeStrongBinder(callingActivity);
3324         mRemote.transact(STOP_LOCAL_VOICE_INTERACTION_TRANSACTION, data, reply, 0);
3325         reply.readException();
3326         reply.recycle();
3327         data.recycle();
3328     }
3329
3330     public boolean supportsLocalVoiceInteraction() throws RemoteException {
3331         Parcel data = Parcel.obtain();
3332         Parcel reply = Parcel.obtain();
3333         data.writeInterfaceToken(IActivityManager.descriptor);
3334         mRemote.transact(SUPPORTS_LOCAL_VOICE_INTERACTION_TRANSACTION, data, reply, 0);
3335         reply.readException();
3336         int result = reply.readInt();
3337         reply.recycle();
3338         data.recycle();
3339         return result != 0;
3340     }
3341
3342     public boolean startNextMatchingActivity(IBinder callingActivity,
3343             Intent intent, Bundle options) throws RemoteException {
3344         Parcel data = Parcel.obtain();
3345         Parcel reply = Parcel.obtain();
3346         data.writeInterfaceToken(IActivityManager.descriptor);
3347         data.writeStrongBinder(callingActivity);
3348         intent.writeToParcel(data, 0);
3349         if (options != null) {
3350             data.writeInt(1);
3351             options.writeToParcel(data, 0);
3352         } else {
3353             data.writeInt(0);
3354         }
3355         mRemote.transact(START_NEXT_MATCHING_ACTIVITY_TRANSACTION, data, reply, 0);
3356         reply.readException();
3357         int result = reply.readInt();
3358         reply.recycle();
3359         data.recycle();
3360         return result != 0;
3361     }
3362     public int startActivityFromRecents(int taskId, Bundle options)
3363             throws RemoteException {
3364         Parcel data = Parcel.obtain();
3365         Parcel reply = Parcel.obtain();
3366         data.writeInterfaceToken(IActivityManager.descriptor);
3367         data.writeInt(taskId);
3368         if (options == null) {
3369             data.writeInt(0);
3370         } else {
3371             data.writeInt(1);
3372             options.writeToParcel(data, 0);
3373         }
3374         mRemote.transact(START_ACTIVITY_FROM_RECENTS_TRANSACTION, data, reply, 0);
3375         reply.readException();
3376         int result = reply.readInt();
3377         reply.recycle();
3378         data.recycle();
3379         return result;
3380     }
3381     public boolean finishActivity(IBinder token, int resultCode, Intent resultData, int finishTask)
3382             throws RemoteException {
3383         Parcel data = Parcel.obtain();
3384         Parcel reply = Parcel.obtain();
3385         data.writeInterfaceToken(IActivityManager.descriptor);
3386         data.writeStrongBinder(token);
3387         data.writeInt(resultCode);
3388         if (resultData != null) {
3389             data.writeInt(1);
3390             resultData.writeToParcel(data, 0);
3391         } else {
3392             data.writeInt(0);
3393         }
3394         data.writeInt(finishTask);
3395         mRemote.transact(FINISH_ACTIVITY_TRANSACTION, data, reply, 0);
3396         reply.readException();
3397         boolean res = reply.readInt() != 0;
3398         data.recycle();
3399         reply.recycle();
3400         return res;
3401     }
3402     public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException
3403     {
3404         Parcel data = Parcel.obtain();
3405         Parcel reply = Parcel.obtain();
3406         data.writeInterfaceToken(IActivityManager.descriptor);
3407         data.writeStrongBinder(token);
3408         data.writeString(resultWho);
3409         data.writeInt(requestCode);
3410         mRemote.transact(FINISH_SUB_ACTIVITY_TRANSACTION, data, reply, 0);
3411         reply.readException();
3412         data.recycle();
3413         reply.recycle();
3414     }
3415     public boolean finishActivityAffinity(IBinder token) throws RemoteException {
3416         Parcel data = Parcel.obtain();
3417         Parcel reply = Parcel.obtain();
3418         data.writeInterfaceToken(IActivityManager.descriptor);
3419         data.writeStrongBinder(token);
3420         mRemote.transact(FINISH_ACTIVITY_AFFINITY_TRANSACTION, data, reply, 0);
3421         reply.readException();
3422         boolean res = reply.readInt() != 0;
3423         data.recycle();
3424         reply.recycle();
3425         return res;
3426     }
3427     public void finishVoiceTask(IVoiceInteractionSession session) throws RemoteException {
3428         Parcel data = Parcel.obtain();
3429         Parcel reply = Parcel.obtain();
3430         data.writeInterfaceToken(IActivityManager.descriptor);
3431         data.writeStrongBinder(session.asBinder());
3432         mRemote.transact(FINISH_VOICE_TASK_TRANSACTION, data, reply, 0);
3433         reply.readException();
3434         data.recycle();
3435         reply.recycle();
3436     }
3437     public boolean releaseActivityInstance(IBinder token) throws RemoteException {
3438         Parcel data = Parcel.obtain();
3439         Parcel reply = Parcel.obtain();
3440         data.writeInterfaceToken(IActivityManager.descriptor);
3441         data.writeStrongBinder(token);
3442         mRemote.transact(RELEASE_ACTIVITY_INSTANCE_TRANSACTION, data, reply, 0);
3443         reply.readException();
3444         boolean res = reply.readInt() != 0;
3445         data.recycle();
3446         reply.recycle();
3447         return res;
3448     }
3449     public void releaseSomeActivities(IApplicationThread app) throws RemoteException {
3450         Parcel data = Parcel.obtain();
3451         Parcel reply = Parcel.obtain();
3452         data.writeInterfaceToken(IActivityManager.descriptor);
3453         data.writeStrongBinder(app.asBinder());
3454         mRemote.transact(RELEASE_SOME_ACTIVITIES_TRANSACTION, data, reply, 0);
3455         reply.readException();
3456         data.recycle();
3457         reply.recycle();
3458     }
3459     public boolean willActivityBeVisible(IBinder token) throws RemoteException {
3460         Parcel data = Parcel.obtain();
3461         Parcel reply = Parcel.obtain();
3462         data.writeInterfaceToken(IActivityManager.descriptor);
3463         data.writeStrongBinder(token);
3464         mRemote.transact(WILL_ACTIVITY_BE_VISIBLE_TRANSACTION, data, reply, 0);
3465         reply.readException();
3466         boolean res = reply.readInt() != 0;
3467         data.recycle();
3468         reply.recycle();
3469         return res;
3470     }
3471     public Intent registerReceiver(IApplicationThread caller, String packageName,
3472             IIntentReceiver receiver,
3473             IntentFilter filter, String perm, int userId) throws RemoteException
3474     {
3475         Parcel data = Parcel.obtain();
3476         Parcel reply = Parcel.obtain();
3477         data.writeInterfaceToken(IActivityManager.descriptor);
3478         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3479         data.writeString(packageName);
3480         data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
3481         filter.writeToParcel(data, 0);
3482         data.writeString(perm);
3483         data.writeInt(userId);
3484         mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);
3485         reply.readException();
3486         Intent intent = null;
3487         int haveIntent = reply.readInt();
3488         if (haveIntent != 0) {
3489             intent = Intent.CREATOR.createFromParcel(reply);
3490         }
3491         reply.recycle();
3492         data.recycle();
3493         return intent;
3494     }
3495     public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException
3496     {
3497         Parcel data = Parcel.obtain();
3498         Parcel reply = Parcel.obtain();
3499         data.writeInterfaceToken(IActivityManager.descriptor);
3500         data.writeStrongBinder(receiver.asBinder());
3501         mRemote.transact(UNREGISTER_RECEIVER_TRANSACTION, data, reply, 0);
3502         reply.readException();
3503         data.recycle();
3504         reply.recycle();
3505     }
3506     public int broadcastIntent(IApplicationThread caller,
3507             Intent intent, String resolvedType, IIntentReceiver resultTo,
3508             int resultCode, String resultData, Bundle map,
3509             String[] requiredPermissions, int appOp, Bundle options, boolean serialized,
3510             boolean sticky, int userId) throws RemoteException
3511     {
3512         Parcel data = Parcel.obtain();
3513         Parcel reply = Parcel.obtain();
3514         data.writeInterfaceToken(IActivityManager.descriptor);
3515         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3516         intent.writeToParcel(data, 0);
3517         data.writeString(resolvedType);
3518         data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);
3519         data.writeInt(resultCode);
3520         data.writeString(resultData);
3521         data.writeBundle(map);
3522         data.writeStringArray(requiredPermissions);
3523         data.writeInt(appOp);
3524         data.writeBundle(options);
3525         data.writeInt(serialized ? 1 : 0);
3526         data.writeInt(sticky ? 1 : 0);
3527         data.writeInt(userId);
3528         mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
3529         reply.readException();
3530         int res = reply.readInt();
3531         reply.recycle();
3532         data.recycle();
3533         return res;
3534     }
3535     public void unbroadcastIntent(IApplicationThread caller, Intent intent, int userId)
3536             throws RemoteException
3537     {
3538         Parcel data = Parcel.obtain();
3539         Parcel reply = Parcel.obtain();
3540         data.writeInterfaceToken(IActivityManager.descriptor);
3541         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3542         intent.writeToParcel(data, 0);
3543         data.writeInt(userId);
3544         mRemote.transact(UNBROADCAST_INTENT_TRANSACTION, data, reply, 0);
3545         reply.readException();
3546         data.recycle();
3547         reply.recycle();
3548     }
3549     public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map,
3550             boolean abortBroadcast, int flags) throws RemoteException
3551     {
3552         Parcel data = Parcel.obtain();
3553         Parcel reply = Parcel.obtain();
3554         data.writeInterfaceToken(IActivityManager.descriptor);
3555         data.writeStrongBinder(who);
3556         data.writeInt(resultCode);
3557         data.writeString(resultData);
3558         data.writeBundle(map);
3559         data.writeInt(abortBroadcast ? 1 : 0);
3560         data.writeInt(flags);
3561         mRemote.transact(FINISH_RECEIVER_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3562         reply.readException();
3563         data.recycle();
3564         reply.recycle();
3565     }
3566     public void attachApplication(IApplicationThread app) throws RemoteException
3567     {
3568         Parcel data = Parcel.obtain();
3569         Parcel reply = Parcel.obtain();
3570         data.writeInterfaceToken(IActivityManager.descriptor);
3571         data.writeStrongBinder(app.asBinder());
3572         mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
3573         reply.readException();
3574         data.recycle();
3575         reply.recycle();
3576     }
3577     public void activityIdle(IBinder token, Configuration config, boolean stopProfiling)
3578             throws RemoteException
3579     {
3580         Parcel data = Parcel.obtain();
3581         Parcel reply = Parcel.obtain();
3582         data.writeInterfaceToken(IActivityManager.descriptor);
3583         data.writeStrongBinder(token);
3584         if (config != null) {
3585             data.writeInt(1);
3586             config.writeToParcel(data, 0);
3587         } else {
3588             data.writeInt(0);
3589         }
3590         data.writeInt(stopProfiling ? 1 : 0);
3591         mRemote.transact(ACTIVITY_IDLE_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3592         reply.readException();
3593         data.recycle();
3594         reply.recycle();
3595     }
3596     public void activityResumed(IBinder token) throws RemoteException
3597     {
3598         Parcel data = Parcel.obtain();
3599         Parcel reply = Parcel.obtain();
3600         data.writeInterfaceToken(IActivityManager.descriptor);
3601         data.writeStrongBinder(token);
3602         mRemote.transact(ACTIVITY_RESUMED_TRANSACTION, data, reply, 0);
3603         reply.readException();
3604         data.recycle();
3605         reply.recycle();
3606     }
3607     public void activityPaused(IBinder token) throws RemoteException
3608     {
3609         Parcel data = Parcel.obtain();
3610         Parcel reply = Parcel.obtain();
3611         data.writeInterfaceToken(IActivityManager.descriptor);
3612         data.writeStrongBinder(token);
3613         mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
3614         reply.readException();
3615         data.recycle();
3616         reply.recycle();
3617     }
3618     public void activityStopped(IBinder token, Bundle state,
3619             PersistableBundle persistentState, CharSequence description) throws RemoteException
3620     {
3621         Parcel data = Parcel.obtain();
3622         Parcel reply = Parcel.obtain();
3623         data.writeInterfaceToken(IActivityManager.descriptor);
3624         data.writeStrongBinder(token);
3625         data.writeBundle(state);
3626         data.writePersistableBundle(persistentState);
3627         TextUtils.writeToParcel(description, data, 0);
3628         mRemote.transact(ACTIVITY_STOPPED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3629         reply.readException();
3630         data.recycle();
3631         reply.recycle();
3632     }
3633     public void activitySlept(IBinder token) throws RemoteException
3634     {
3635         Parcel data = Parcel.obtain();
3636         Parcel reply = Parcel.obtain();
3637         data.writeInterfaceToken(IActivityManager.descriptor);
3638         data.writeStrongBinder(token);
3639         mRemote.transact(ACTIVITY_SLEPT_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3640         reply.readException();
3641         data.recycle();
3642         reply.recycle();
3643     }
3644     public void activityDestroyed(IBinder token) throws RemoteException
3645     {
3646         Parcel data = Parcel.obtain();
3647         Parcel reply = Parcel.obtain();
3648         data.writeInterfaceToken(IActivityManager.descriptor);
3649         data.writeStrongBinder(token);
3650         mRemote.transact(ACTIVITY_DESTROYED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3651         reply.readException();
3652         data.recycle();
3653         reply.recycle();
3654     }
3655     public void activityRelaunched(IBinder token) throws RemoteException
3656     {
3657         Parcel data = Parcel.obtain();
3658         Parcel reply = Parcel.obtain();
3659         data.writeInterfaceToken(IActivityManager.descriptor);
3660         data.writeStrongBinder(token);
3661         mRemote.transact(ACTIVITY_RELAUNCHED_TRANSACTION, data, reply, 0);
3662         reply.readException();
3663         data.recycle();
3664         reply.recycle();
3665     }
3666     public String getCallingPackage(IBinder token) throws RemoteException
3667     {
3668         Parcel data = Parcel.obtain();
3669         Parcel reply = Parcel.obtain();
3670         data.writeInterfaceToken(IActivityManager.descriptor);
3671         data.writeStrongBinder(token);
3672         mRemote.transact(GET_CALLING_PACKAGE_TRANSACTION, data, reply, 0);
3673         reply.readException();
3674         String res = reply.readString();
3675         data.recycle();
3676         reply.recycle();
3677         return res;
3678     }
3679     public ComponentName getCallingActivity(IBinder token)
3680             throws RemoteException {
3681         Parcel data = Parcel.obtain();
3682         Parcel reply = Parcel.obtain();
3683         data.writeInterfaceToken(IActivityManager.descriptor);
3684         data.writeStrongBinder(token);
3685         mRemote.transact(GET_CALLING_ACTIVITY_TRANSACTION, data, reply, 0);
3686         reply.readException();
3687         ComponentName res = ComponentName.readFromParcel(reply);
3688         data.recycle();
3689         reply.recycle();
3690         return res;
3691     }
3692     public List<IAppTask> getAppTasks(String callingPackage) throws RemoteException {
3693         Parcel data = Parcel.obtain();
3694         Parcel reply = Parcel.obtain();
3695         data.writeInterfaceToken(IActivityManager.descriptor);
3696         data.writeString(callingPackage);
3697         mRemote.transact(GET_APP_TASKS_TRANSACTION, data, reply, 0);
3698         reply.readException();
3699         ArrayList<IAppTask> list = null;
3700         int N = reply.readInt();
3701         if (N >= 0) {
3702             list = new ArrayList<>();
3703             while (N > 0) {
3704                 IAppTask task = IAppTask.Stub.asInterface(reply.readStrongBinder());
3705                 list.add(task);
3706                 N--;
3707             }
3708         }
3709         data.recycle();
3710         reply.recycle();
3711         return list;
3712     }
3713     public int addAppTask(IBinder activityToken, Intent intent,
3714             ActivityManager.TaskDescription description, Bitmap thumbnail) throws RemoteException {
3715         Parcel data = Parcel.obtain();
3716         Parcel reply = Parcel.obtain();
3717         data.writeInterfaceToken(IActivityManager.descriptor);
3718         data.writeStrongBinder(activityToken);
3719         intent.writeToParcel(data, 0);
3720         description.writeToParcel(data, 0);
3721         thumbnail.writeToParcel(data, 0);
3722         mRemote.transact(ADD_APP_TASK_TRANSACTION, data, reply, 0);
3723         reply.readException();
3724         int res = reply.readInt();
3725         data.recycle();
3726         reply.recycle();
3727         return res;
3728     }
3729     public Point getAppTaskThumbnailSize() throws RemoteException {
3730         Parcel data = Parcel.obtain();
3731         Parcel reply = Parcel.obtain();
3732         data.writeInterfaceToken(IActivityManager.descriptor);
3733         mRemote.transact(GET_APP_TASK_THUMBNAIL_SIZE_TRANSACTION, data, reply, 0);
3734         reply.readException();
3735         Point size = Point.CREATOR.createFromParcel(reply);
3736         data.recycle();
3737         reply.recycle();
3738         return size;
3739     }
3740     public List<ActivityManager.RunningTaskInfo> getTasks(int maxNum, int flags)
3741             throws RemoteException {
3742         Parcel data = Parcel.obtain();
3743         Parcel reply = Parcel.obtain();
3744         data.writeInterfaceToken(IActivityManager.descriptor);
3745         data.writeInt(maxNum);
3746         data.writeInt(flags);
3747         mRemote.transact(GET_TASKS_TRANSACTION, data, reply, 0);
3748         reply.readException();
3749         ArrayList<ActivityManager.RunningTaskInfo> list = null;
3750         int N = reply.readInt();
3751         if (N >= 0) {
3752             list = new ArrayList<>();
3753             while (N > 0) {
3754                 ActivityManager.RunningTaskInfo info =
3755                         ActivityManager.RunningTaskInfo.CREATOR
3756                                 .createFromParcel(reply);
3757                 list.add(info);
3758                 N--;
3759             }
3760         }
3761         data.recycle();
3762         reply.recycle();
3763         return list;
3764     }
3765     public ParceledListSlice<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
3766             int flags, int userId) throws RemoteException {
3767         Parcel data = Parcel.obtain();
3768         Parcel reply = Parcel.obtain();
3769         data.writeInterfaceToken(IActivityManager.descriptor);
3770         data.writeInt(maxNum);
3771         data.writeInt(flags);
3772         data.writeInt(userId);
3773         mRemote.transact(GET_RECENT_TASKS_TRANSACTION, data, reply, 0);
3774         reply.readException();
3775         final ParceledListSlice<ActivityManager.RecentTaskInfo> list = ParceledListSlice.CREATOR
3776                 .createFromParcel(reply);
3777         data.recycle();
3778         reply.recycle();
3779         return list;
3780     }
3781     public ActivityManager.TaskThumbnail getTaskThumbnail(int id) throws RemoteException {
3782         Parcel data = Parcel.obtain();
3783         Parcel reply = Parcel.obtain();
3784         data.writeInterfaceToken(IActivityManager.descriptor);
3785         data.writeInt(id);
3786         mRemote.transact(GET_TASK_THUMBNAIL_TRANSACTION, data, reply, 0);
3787         reply.readException();
3788         ActivityManager.TaskThumbnail taskThumbnail = null;
3789         if (reply.readInt() != 0) {
3790             taskThumbnail = ActivityManager.TaskThumbnail.CREATOR.createFromParcel(reply);
3791         }
3792         data.recycle();
3793         reply.recycle();
3794         return taskThumbnail;
3795     }
3796     public List<ActivityManager.RunningServiceInfo> getServices(int maxNum, int flags)
3797             throws RemoteException {
3798         Parcel data = Parcel.obtain();
3799         Parcel reply = Parcel.obtain();
3800         data.writeInterfaceToken(IActivityManager.descriptor);
3801         data.writeInt(maxNum);
3802         data.writeInt(flags);
3803         mRemote.transact(GET_SERVICES_TRANSACTION, data, reply, 0);
3804         reply.readException();
3805         ArrayList<ActivityManager.RunningServiceInfo> list = null;
3806         int N = reply.readInt();
3807         if (N >= 0) {
3808             list = new ArrayList<>();
3809             while (N > 0) {
3810                 ActivityManager.RunningServiceInfo info =
3811                         ActivityManager.RunningServiceInfo.CREATOR
3812                         .createFromParcel(reply);
3813                 list.add(info);
3814                 N--;
3815             }
3816         }
3817         data.recycle();
3818         reply.recycle();
3819         return list;
3820     }
3821     public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState()
3822             throws RemoteException {
3823         Parcel data = Parcel.obtain();
3824         Parcel reply = Parcel.obtain();
3825         data.writeInterfaceToken(IActivityManager.descriptor);
3826         mRemote.transact(GET_PROCESSES_IN_ERROR_STATE_TRANSACTION, data, reply, 0);
3827         reply.readException();
3828         ArrayList<ActivityManager.ProcessErrorStateInfo> list
3829             = reply.createTypedArrayList(ActivityManager.ProcessErrorStateInfo.CREATOR);
3830         data.recycle();
3831         reply.recycle();
3832         return list;
3833     }
3834     public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()
3835             throws RemoteException {
3836         Parcel data = Parcel.obtain();
3837         Parcel reply = Parcel.obtain();
3838         data.writeInterfaceToken(IActivityManager.descriptor);
3839         mRemote.transact(GET_RUNNING_APP_PROCESSES_TRANSACTION, data, reply, 0);
3840         reply.readException();
3841         ArrayList<ActivityManager.RunningAppProcessInfo> list
3842         = reply.createTypedArrayList(ActivityManager.RunningAppProcessInfo.CREATOR);
3843         data.recycle();
3844         reply.recycle();
3845         return list;
3846     }
3847     public List<ApplicationInfo> getRunningExternalApplications()
3848             throws RemoteException {
3849         Parcel data = Parcel.obtain();
3850         Parcel reply = Parcel.obtain();
3851         data.writeInterfaceToken(IActivityManager.descriptor);
3852         mRemote.transact(GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION, data, reply, 0);
3853         reply.readException();
3854         ArrayList<ApplicationInfo> list
3855         = reply.createTypedArrayList(ApplicationInfo.CREATOR);
3856         data.recycle();
3857         reply.recycle();
3858         return list;
3859     }
3860     public void moveTaskToFront(int task, int flags, Bundle options) throws RemoteException
3861     {
3862         Parcel data = Parcel.obtain();
3863         Parcel reply = Parcel.obtain();
3864         data.writeInterfaceToken(IActivityManager.descriptor);
3865         data.writeInt(task);
3866         data.writeInt(flags);
3867         if (options != null) {
3868             data.writeInt(1);
3869             options.writeToParcel(data, 0);
3870         } else {
3871             data.writeInt(0);
3872         }
3873         mRemote.transact(MOVE_TASK_TO_FRONT_TRANSACTION, data, reply, 0);
3874         reply.readException();
3875         data.recycle();
3876         reply.recycle();
3877     }
3878     public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot)
3879             throws RemoteException {
3880         Parcel data = Parcel.obtain();
3881         Parcel reply = Parcel.obtain();
3882         data.writeInterfaceToken(IActivityManager.descriptor);
3883         data.writeStrongBinder(token);
3884         data.writeInt(nonRoot ? 1 : 0);
3885         mRemote.transact(MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION, data, reply, 0);
3886         reply.readException();
3887         boolean res = reply.readInt() != 0;
3888         data.recycle();
3889         reply.recycle();
3890         return res;
3891     }
3892     public void moveTaskBackwards(int task) throws RemoteException
3893     {
3894         Parcel data = Parcel.obtain();
3895         Parcel reply = Parcel.obtain();
3896         data.writeInterfaceToken(IActivityManager.descriptor);
3897         data.writeInt(task);
3898         mRemote.transact(MOVE_TASK_BACKWARDS_TRANSACTION, data, reply, 0);
3899         reply.readException();
3900         data.recycle();
3901         reply.recycle();
3902     }
3903     @Override
3904     public void moveTaskToStack(int taskId, int stackId, boolean toTop) throws RemoteException
3905     {
3906         Parcel data = Parcel.obtain();
3907         Parcel reply = Parcel.obtain();
3908         data.writeInterfaceToken(IActivityManager.descriptor);
3909         data.writeInt(taskId);
3910         data.writeInt(stackId);
3911         data.writeInt(toTop ? 1 : 0);
3912         mRemote.transact(MOVE_TASK_TO_STACK_TRANSACTION, data, reply, 0);
3913         reply.readException();
3914         data.recycle();
3915         reply.recycle();
3916     }
3917     @Override
3918     public boolean moveTaskToDockedStack(int taskId, int createMode, boolean toTop, boolean animate,
3919             Rect initialBounds, boolean moveHomeStackFront) throws RemoteException
3920     {
3921         Parcel data = Parcel.obtain();
3922         Parcel reply = Parcel.obtain();
3923         data.writeInterfaceToken(IActivityManager.descriptor);
3924         data.writeInt(taskId);
3925         data.writeInt(createMode);
3926         data.writeInt(toTop ? 1 : 0);
3927         data.writeInt(animate ? 1 : 0);
3928         if (initialBounds != null) {
3929             data.writeInt(1);
3930             initialBounds.writeToParcel(data, 0);
3931         } else {
3932             data.writeInt(0);
3933         }
3934         data.writeInt(moveHomeStackFront ? 1 : 0);
3935         mRemote.transact(MOVE_TASK_TO_DOCKED_STACK_TRANSACTION, data, reply, 0);
3936         reply.readException();
3937         boolean res = reply.readInt() > 0;
3938         data.recycle();
3939         reply.recycle();
3940         return res;
3941     }
3942     @Override
3943     public boolean moveTopActivityToPinnedStack(int stackId, Rect r)
3944         throws RemoteException
3945     {
3946         Parcel data = Parcel.obtain();
3947         Parcel reply = Parcel.obtain();
3948         data.writeInterfaceToken(IActivityManager.descriptor);
3949         data.writeInt(stackId);
3950         r.writeToParcel(data, 0);
3951         mRemote.transact(MOVE_TOP_ACTIVITY_TO_PINNED_STACK_TRANSACTION, data, reply, 0);
3952         reply.readException();
3953         final boolean res = reply.readInt() != 0;
3954         data.recycle();
3955         reply.recycle();
3956         return res;
3957     }
3958     @Override
3959     public void resizeStack(int stackId, Rect r, boolean allowResizeInDockedMode,
3960             boolean preserveWindows, boolean animate, int animationDuration)
3961             throws RemoteException {
3962         Parcel data = Parcel.obtain();
3963         Parcel reply = Parcel.obtain();
3964         data.writeInterfaceToken(IActivityManager.descriptor);
3965         data.writeInt(stackId);
3966         if (r != null) {
3967             data.writeInt(1);
3968             r.writeToParcel(data, 0);
3969         } else {
3970             data.writeInt(0);
3971         }
3972         data.writeInt(allowResizeInDockedMode ? 1 : 0);
3973         data.writeInt(preserveWindows ? 1 : 0);
3974         data.writeInt(animate ? 1 : 0);
3975         data.writeInt(animationDuration);
3976         mRemote.transact(RESIZE_STACK_TRANSACTION, data, reply, 0);
3977         reply.readException();
3978         data.recycle();
3979         reply.recycle();
3980     }
3981     @Override
3982     public void swapDockedAndFullscreenStack() throws RemoteException
3983     {
3984         Parcel data = Parcel.obtain();
3985         Parcel reply = Parcel.obtain();
3986         data.writeInterfaceToken(IActivityManager.descriptor);
3987         mRemote.transact(SWAP_DOCKED_AND_FULLSCREEN_STACK, data, reply, 0);
3988         reply.readException();
3989         data.recycle();
3990         reply.recycle();
3991     }
3992     @Override
3993     public void resizeDockedStack(Rect dockedBounds, Rect tempDockedTaskBounds,
3994             Rect tempDockedTaskInsetBounds,
3995             Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds)
3996             throws RemoteException
3997     {
3998         Parcel data = Parcel.obtain();
3999         Parcel reply = Parcel.obtain();
4000         data.writeInterfaceToken(IActivityManager.descriptor);
4001         if (dockedBounds != null) {
4002             data.writeInt(1);
4003             dockedBounds.writeToParcel(data, 0);
4004         } else {
4005             data.writeInt(0);
4006         }
4007         if (tempDockedTaskBounds != null) {
4008             data.writeInt(1);
4009             tempDockedTaskBounds.writeToParcel(data, 0);
4010         } else {
4011             data.writeInt(0);
4012         }
4013         if (tempDockedTaskInsetBounds != null) {
4014             data.writeInt(1);
4015             tempDockedTaskInsetBounds.writeToParcel(data, 0);
4016         } else {
4017             data.writeInt(0);
4018         }
4019         if (tempOtherTaskBounds != null) {
4020             data.writeInt(1);
4021             tempOtherTaskBounds.writeToParcel(data, 0);
4022         } else {
4023             data.writeInt(0);
4024         }
4025         if (tempOtherTaskInsetBounds != null) {
4026             data.writeInt(1);
4027             tempOtherTaskInsetBounds.writeToParcel(data, 0);
4028         } else {
4029             data.writeInt(0);
4030         }
4031         mRemote.transact(RESIZE_DOCKED_STACK_TRANSACTION, data, reply, 0);
4032         reply.readException();
4033         data.recycle();
4034         reply.recycle();
4035     }
4036
4037     @Override
4038     public void resizePinnedStack(Rect pinnedBounds, Rect tempPinnedTaskBounds) throws RemoteException
4039     {
4040         Parcel data = Parcel.obtain();
4041         Parcel reply = Parcel.obtain();
4042         data.writeInterfaceToken(IActivityManager.descriptor);
4043         if (pinnedBounds != null) {
4044             data.writeInt(1);
4045             pinnedBounds.writeToParcel(data, 0);
4046         } else {
4047             data.writeInt(0);
4048         }
4049         if (tempPinnedTaskBounds != null) {
4050             data.writeInt(1);
4051             tempPinnedTaskBounds.writeToParcel(data, 0);
4052         } else {
4053             data.writeInt(0);
4054         }
4055         mRemote.transact(RESIZE_PINNED_STACK_TRANSACTION, data, reply, 0);
4056         reply.readException();
4057         data.recycle();
4058         reply.recycle();
4059     }
4060
4061     @Override
4062     public void positionTaskInStack(int taskId, int stackId, int position) throws RemoteException
4063     {
4064         Parcel data = Parcel.obtain();
4065         Parcel reply = Parcel.obtain();
4066         data.writeInterfaceToken(IActivityManager.descriptor);
4067         data.writeInt(taskId);
4068         data.writeInt(stackId);
4069         data.writeInt(position);
4070         mRemote.transact(POSITION_TASK_IN_STACK_TRANSACTION, data, reply, 0);
4071         reply.readException();
4072         data.recycle();
4073         reply.recycle();
4074     }
4075     @Override
4076     public List<StackInfo> getAllStackInfos() throws RemoteException
4077     {
4078         Parcel data = Parcel.obtain();
4079         Parcel reply = Parcel.obtain();
4080         data.writeInterfaceToken(IActivityManager.descriptor);
4081         mRemote.transact(GET_ALL_STACK_INFOS_TRANSACTION, data, reply, 0);
4082         reply.readException();
4083         ArrayList<StackInfo> list = reply.createTypedArrayList(StackInfo.CREATOR);
4084         data.recycle();
4085         reply.recycle();
4086         return list;
4087     }
4088     @Override
4089     public StackInfo getStackInfo(int stackId) throws RemoteException
4090     {
4091         Parcel data = Parcel.obtain();
4092         Parcel reply = Parcel.obtain();
4093         data.writeInterfaceToken(IActivityManager.descriptor);
4094         data.writeInt(stackId);
4095         mRemote.transact(GET_STACK_INFO_TRANSACTION, data, reply, 0);
4096         reply.readException();
4097         int res = reply.readInt();
4098         StackInfo info = null;
4099         if (res != 0) {
4100             info = StackInfo.CREATOR.createFromParcel(reply);
4101         }
4102         data.recycle();
4103         reply.recycle();
4104         return info;
4105     }
4106     @Override
4107     public boolean isInHomeStack(int taskId) throws RemoteException {
4108         Parcel data = Parcel.obtain();
4109         Parcel reply = Parcel.obtain();
4110         data.writeInterfaceToken(IActivityManager.descriptor);
4111         data.writeInt(taskId);
4112         mRemote.transact(IS_IN_HOME_STACK_TRANSACTION, data, reply, 0);
4113         reply.readException();
4114         boolean isInHomeStack = reply.readInt() > 0;
4115         data.recycle();
4116         reply.recycle();
4117         return isInHomeStack;
4118     }
4119     @Override
4120     public void setFocusedStack(int stackId) throws RemoteException
4121     {
4122         Parcel data = Parcel.obtain();
4123         Parcel reply = Parcel.obtain();
4124         data.writeInterfaceToken(IActivityManager.descriptor);
4125         data.writeInt(stackId);
4126         mRemote.transact(SET_FOCUSED_STACK_TRANSACTION, data, reply, 0);
4127         reply.readException();
4128         data.recycle();
4129         reply.recycle();
4130     }
4131     @Override
4132     public int getFocusedStackId() throws RemoteException {
4133         Parcel data = Parcel.obtain();
4134         Parcel reply = Parcel.obtain();
4135         data.writeInterfaceToken(IActivityManager.descriptor);
4136         mRemote.transact(GET_FOCUSED_STACK_ID_TRANSACTION, data, reply, 0);
4137         reply.readException();
4138         int focusedStackId = reply.readInt();
4139         data.recycle();
4140         reply.recycle();
4141         return focusedStackId;
4142     }
4143     @Override
4144     public void setFocusedTask(int taskId) throws RemoteException
4145     {
4146         Parcel data = Parcel.obtain();
4147         Parcel reply = Parcel.obtain();
4148         data.writeInterfaceToken(IActivityManager.descriptor);
4149         data.writeInt(taskId);
4150         mRemote.transact(SET_FOCUSED_TASK_TRANSACTION, data, reply, 0);
4151         reply.readException();
4152         data.recycle();
4153         reply.recycle();
4154     }
4155     @Override
4156     public void registerTaskStackListener(ITaskStackListener listener) throws RemoteException
4157     {
4158         Parcel data = Parcel.obtain();
4159         Parcel reply = Parcel.obtain();
4160         data.writeInterfaceToken(IActivityManager.descriptor);
4161         data.writeStrongBinder(listener.asBinder());
4162         mRemote.transact(REGISTER_TASK_STACK_LISTENER_TRANSACTION, data, reply, 0);
4163         reply.readException();
4164         data.recycle();
4165         reply.recycle();
4166     }
4167     public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException
4168     {
4169         Parcel data = Parcel.obtain();
4170         Parcel reply = Parcel.obtain();
4171         data.writeInterfaceToken(IActivityManager.descriptor);
4172         data.writeStrongBinder(token);
4173         data.writeInt(onlyRoot ? 1 : 0);
4174         mRemote.transact(GET_TASK_FOR_ACTIVITY_TRANSACTION, data, reply, 0);
4175         reply.readException();
4176         int res = reply.readInt();
4177         data.recycle();
4178         reply.recycle();
4179         return res;
4180     }
4181     public ContentProviderHolder getContentProvider(IApplicationThread caller,
4182             String name, int userId, boolean stable) throws RemoteException {
4183         Parcel data = Parcel.obtain();
4184         Parcel reply = Parcel.obtain();
4185         data.writeInterfaceToken(IActivityManager.descriptor);
4186         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4187         data.writeString(name);
4188         data.writeInt(userId);
4189         data.writeInt(stable ? 1 : 0);
4190         mRemote.transact(GET_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
4191         reply.readException();
4192         int res = reply.readInt();
4193         ContentProviderHolder cph = null;
4194         if (res != 0) {
4195             cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
4196         }
4197         data.recycle();
4198         reply.recycle();
4199         return cph;
4200     }
4201     public ContentProviderHolder getContentProviderExternal(String name, int userId, IBinder token)
4202             throws RemoteException {
4203         Parcel data = Parcel.obtain();
4204         Parcel reply = Parcel.obtain();
4205         data.writeInterfaceToken(IActivityManager.descriptor);
4206         data.writeString(name);
4207         data.writeInt(userId);
4208         data.writeStrongBinder(token);
4209         mRemote.transact(GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION, data, reply, 0);
4210         reply.readException();
4211         int res = reply.readInt();
4212         ContentProviderHolder cph = null;
4213         if (res != 0) {
4214             cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
4215         }
4216         data.recycle();
4217         reply.recycle();
4218         return cph;
4219     }
4220     public void publishContentProviders(IApplicationThread caller,
4221             List<ContentProviderHolder> providers) throws RemoteException
4222     {
4223         Parcel data = Parcel.obtain();
4224         Parcel reply = Parcel.obtain();
4225         data.writeInterfaceToken(IActivityManager.descriptor);
4226         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4227         data.writeTypedList(providers);
4228         mRemote.transact(PUBLISH_CONTENT_PROVIDERS_TRANSACTION, data, reply, 0);
4229         reply.readException();
4230         data.recycle();
4231         reply.recycle();
4232     }
4233     public boolean refContentProvider(IBinder connection, int stable, int unstable)
4234             throws RemoteException {
4235         Parcel data = Parcel.obtain();
4236         Parcel reply = Parcel.obtain();
4237         data.writeInterfaceToken(IActivityManager.descriptor);
4238         data.writeStrongBinder(connection);
4239         data.writeInt(stable);
4240         data.writeInt(unstable);
4241         mRemote.transact(REF_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
4242         reply.readException();
4243         boolean res = reply.readInt() != 0;
4244         data.recycle();
4245         reply.recycle();
4246         return res;
4247     }
4248
4249     public void unstableProviderDied(IBinder connection) throws RemoteException {
4250         Parcel data = Parcel.obtain();
4251         Parcel reply = Parcel.obtain();
4252         data.writeInterfaceToken(IActivityManager.descriptor);
4253         data.writeStrongBinder(connection);
4254         mRemote.transact(UNSTABLE_PROVIDER_DIED_TRANSACTION, data, reply, 0);
4255         reply.readException();
4256         data.recycle();
4257         reply.recycle();
4258     }
4259
4260     @Override
4261     public void appNotRespondingViaProvider(IBinder connection) throws RemoteException {
4262         Parcel data = Parcel.obtain();
4263         Parcel reply = Parcel.obtain();
4264         data.writeInterfaceToken(IActivityManager.descriptor);
4265         data.writeStrongBinder(connection);
4266         mRemote.transact(APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION, data, reply, 0);
4267         reply.readException();
4268         data.recycle();
4269         reply.recycle();
4270     }
4271
4272     public void removeContentProvider(IBinder connection, boolean stable) throws RemoteException {
4273         Parcel data = Parcel.obtain();
4274         Parcel reply = Parcel.obtain();
4275         data.writeInterfaceToken(IActivityManager.descriptor);
4276         data.writeStrongBinder(connection);
4277         data.writeInt(stable ? 1 : 0);
4278         mRemote.transact(REMOVE_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
4279         reply.readException();
4280         data.recycle();
4281         reply.recycle();
4282     }
4283
4284     public void removeContentProviderExternal(String name, IBinder token) throws RemoteException {
4285         Parcel data = Parcel.obtain();
4286         Parcel reply = Parcel.obtain();
4287         data.writeInterfaceToken(IActivityManager.descriptor);
4288         data.writeString(name);
4289         data.writeStrongBinder(token);
4290         mRemote.transact(REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION, data, reply, 0);
4291         reply.readException();
4292         data.recycle();
4293         reply.recycle();
4294     }
4295
4296     public PendingIntent getRunningServiceControlPanel(ComponentName service)
4297             throws RemoteException
4298     {
4299         Parcel data = Parcel.obtain();
4300         Parcel reply = Parcel.obtain();
4301         data.writeInterfaceToken(IActivityManager.descriptor);
4302         service.writeToParcel(data, 0);
4303         mRemote.transact(GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION, data, reply, 0);
4304         reply.readException();
4305         PendingIntent res = PendingIntent.readPendingIntentOrNullFromParcel(reply);
4306         data.recycle();
4307         reply.recycle();
4308         return res;
4309     }
4310
4311     public ComponentName startService(IApplicationThread caller, Intent service,
4312             String resolvedType, String callingPackage, int userId) throws RemoteException
4313     {
4314         Parcel data = Parcel.obtain();
4315         Parcel reply = Parcel.obtain();
4316         data.writeInterfaceToken(IActivityManager.descriptor);
4317         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4318         service.writeToParcel(data, 0);
4319         data.writeString(resolvedType);
4320         data.writeString(callingPackage);
4321         data.writeInt(userId);
4322         mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
4323         reply.readException();
4324         ComponentName res = ComponentName.readFromParcel(reply);
4325         data.recycle();
4326         reply.recycle();
4327         return res;
4328     }
4329     public int stopService(IApplicationThread caller, Intent service,
4330             String resolvedType, int userId) throws RemoteException
4331     {
4332         Parcel data = Parcel.obtain();
4333         Parcel reply = Parcel.obtain();
4334         data.writeInterfaceToken(IActivityManager.descriptor);
4335         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4336         service.writeToParcel(data, 0);
4337         data.writeString(resolvedType);
4338         data.writeInt(userId);
4339         mRemote.transact(STOP_SERVICE_TRANSACTION, data, reply, 0);
4340         reply.readException();
4341         int res = reply.readInt();
4342         reply.recycle();
4343         data.recycle();
4344         return res;
4345     }
4346     public boolean stopServiceToken(ComponentName className, IBinder token,
4347             int startId) throws RemoteException {
4348         Parcel data = Parcel.obtain();
4349         Parcel reply = Parcel.obtain();
4350         data.writeInterfaceToken(IActivityManager.descriptor);
4351         ComponentName.writeToParcel(className, data);
4352         data.writeStrongBinder(token);
4353         data.writeInt(startId);
4354         mRemote.transact(STOP_SERVICE_TOKEN_TRANSACTION, data, reply, 0);
4355         reply.readException();
4356         boolean res = reply.readInt() != 0;
4357         data.recycle();
4358         reply.recycle();
4359         return res;
4360     }
4361     public void setServiceForeground(ComponentName className, IBinder token,
4362             int id, Notification notification, int flags) throws RemoteException {
4363         Parcel data = Parcel.obtain();
4364         Parcel reply = Parcel.obtain();
4365         data.writeInterfaceToken(IActivityManager.descriptor);
4366         ComponentName.writeToParcel(className, data);
4367         data.writeStrongBinder(token);
4368         data.writeInt(id);
4369         if (notification != null) {
4370             data.writeInt(1);
4371             notification.writeToParcel(data, 0);
4372         } else {
4373             data.writeInt(0);
4374         }
4375         data.writeInt(flags);
4376         mRemote.transact(SET_SERVICE_FOREGROUND_TRANSACTION, data, reply, 0);
4377         reply.readException();
4378         data.recycle();
4379         reply.recycle();
4380     }
4381     public int bindService(IApplicationThread caller, IBinder token,
4382             Intent service, String resolvedType, IServiceConnection connection,
4383             int flags,  String callingPackage, int userId) throws RemoteException {
4384         Parcel data = Parcel.obtain();
4385         Parcel reply = Parcel.obtain();
4386         data.writeInterfaceToken(IActivityManager.descriptor);
4387         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4388         data.writeStrongBinder(token);
4389         service.writeToParcel(data, 0);
4390         data.writeString(resolvedType);
4391         data.writeStrongBinder(connection.asBinder());
4392         data.writeInt(flags);
4393         data.writeString(callingPackage);
4394         data.writeInt(userId);
4395         mRemote.transact(BIND_SERVICE_TRANSACTION, data, reply, 0);
4396         reply.readException();
4397         int res = reply.readInt();
4398         data.recycle();
4399         reply.recycle();
4400         return res;
4401     }
4402     public boolean unbindService(IServiceConnection connection) throws RemoteException
4403     {
4404         Parcel data = Parcel.obtain();
4405         Parcel reply = Parcel.obtain();
4406         data.writeInterfaceToken(IActivityManager.descriptor);
4407         data.writeStrongBinder(connection.asBinder());
4408         mRemote.transact(UNBIND_SERVICE_TRANSACTION, data, reply, 0);
4409         reply.readException();
4410         boolean res = reply.readInt() != 0;
4411         data.recycle();
4412         reply.recycle();
4413         return res;
4414     }
4415
4416     public void publishService(IBinder token,
4417             Intent intent, IBinder service) throws RemoteException {
4418         Parcel data = Parcel.obtain();
4419         Parcel reply = Parcel.obtain();
4420         data.writeInterfaceToken(IActivityManager.descriptor);
4421         data.writeStrongBinder(token);
4422         intent.writeToParcel(data, 0);
4423         data.writeStrongBinder(service);
4424         mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);
4425         reply.readException();
4426         data.recycle();
4427         reply.recycle();
4428     }
4429
4430     public void unbindFinished(IBinder token, Intent intent, boolean doRebind)
4431             throws RemoteException {
4432         Parcel data = Parcel.obtain();
4433         Parcel reply = Parcel.obtain();
4434         data.writeInterfaceToken(IActivityManager.descriptor);
4435         data.writeStrongBinder(token);
4436         intent.writeToParcel(data, 0);
4437         data.writeInt(doRebind ? 1 : 0);
4438         mRemote.transact(UNBIND_FINISHED_TRANSACTION, data, reply, 0);
4439         reply.readException();
4440         data.recycle();
4441         reply.recycle();
4442     }
4443
4444     public void serviceDoneExecuting(IBinder token, int type, int startId,
4445             int res) throws RemoteException {
4446         Parcel data = Parcel.obtain();
4447         Parcel reply = Parcel.obtain();
4448         data.writeInterfaceToken(IActivityManager.descriptor);
4449         data.writeStrongBinder(token);
4450         data.writeInt(type);
4451         data.writeInt(startId);
4452         data.writeInt(res);
4453         mRemote.transact(SERVICE_DONE_EXECUTING_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
4454         reply.readException();
4455         data.recycle();
4456         reply.recycle();
4457     }
4458
4459     public IBinder peekService(Intent service, String resolvedType, String callingPackage)
4460             throws RemoteException {
4461         Parcel data = Parcel.obtain();
4462         Parcel reply = Parcel.obtain();
4463         data.writeInterfaceToken(IActivityManager.descriptor);
4464         service.writeToParcel(data, 0);
4465         data.writeString(resolvedType);
4466         data.writeString(callingPackage);
4467         mRemote.transact(PEEK_SERVICE_TRANSACTION, data, reply, 0);
4468         reply.readException();
4469         IBinder binder = reply.readStrongBinder();
4470         reply.recycle();
4471         data.recycle();
4472         return binder;
4473     }
4474
4475     public boolean bindBackupAgent(String packageName, int backupRestoreMode, int userId)
4476             throws RemoteException {
4477         Parcel data = Parcel.obtain();
4478         Parcel reply = Parcel.obtain();
4479         data.writeInterfaceToken(IActivityManager.descriptor);
4480         data.writeString(packageName);
4481         data.writeInt(backupRestoreMode);
4482         data.writeInt(userId);
4483         mRemote.transact(START_BACKUP_AGENT_TRANSACTION, data, reply, 0);
4484         reply.readException();
4485         boolean success = reply.readInt() != 0;
4486         reply.recycle();
4487         data.recycle();
4488         return success;
4489     }
4490
4491     public void clearPendingBackup() throws RemoteException {
4492         Parcel data = Parcel.obtain();
4493         Parcel reply = Parcel.obtain();
4494         data.writeInterfaceToken(IActivityManager.descriptor);
4495         mRemote.transact(CLEAR_PENDING_BACKUP_TRANSACTION, data, reply, 0);
4496         reply.recycle();
4497         data.recycle();
4498     }
4499
4500     public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException {
4501         Parcel data = Parcel.obtain();
4502         Parcel reply = Parcel.obtain();
4503         data.writeInterfaceToken(IActivityManager.descriptor);
4504         data.writeString(packageName);
4505         data.writeStrongBinder(agent);
4506         mRemote.transact(BACKUP_AGENT_CREATED_TRANSACTION, data, reply, 0);
4507         reply.recycle();
4508         data.recycle();
4509     }
4510
4511     public void unbindBackupAgent(ApplicationInfo app) throws RemoteException {
4512         Parcel data = Parcel.obtain();
4513         Parcel reply = Parcel.obtain();
4514         data.writeInterfaceToken(IActivityManager.descriptor);
4515         app.writeToParcel(data, 0);
4516         mRemote.transact(UNBIND_BACKUP_AGENT_TRANSACTION, data, reply, 0);
4517         reply.readException();
4518         reply.recycle();
4519         data.recycle();
4520     }
4521
4522     public boolean startInstrumentation(ComponentName className, String profileFile,
4523             int flags, Bundle arguments, IInstrumentationWatcher watcher,
4524             IUiAutomationConnection connection, int userId, String instructionSet)
4525             throws RemoteException {
4526         Parcel data = Parcel.obtain();
4527         Parcel reply = Parcel.obtain();
4528         data.writeInterfaceToken(IActivityManager.descriptor);
4529         ComponentName.writeToParcel(className, data);
4530         data.writeString(profileFile);
4531         data.writeInt(flags);
4532         data.writeBundle(arguments);
4533         data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
4534         data.writeStrongBinder(connection != null ? connection.asBinder() : null);
4535         data.writeInt(userId);
4536         data.writeString(instructionSet);
4537         mRemote.transact(START_INSTRUMENTATION_TRANSACTION, data, reply, 0);
4538         reply.readException();
4539         boolean res = reply.readInt() != 0;
4540         reply.recycle();
4541         data.recycle();
4542         return res;
4543     }
4544
4545     public void finishInstrumentation(IApplicationThread target,
4546             int resultCode, Bundle results) throws RemoteException {
4547         Parcel data = Parcel.obtain();
4548         Parcel reply = Parcel.obtain();
4549         data.writeInterfaceToken(IActivityManager.descriptor);
4550         data.writeStrongBinder(target != null ? target.asBinder() : null);
4551         data.writeInt(resultCode);
4552         data.writeBundle(results);
4553         mRemote.transact(FINISH_INSTRUMENTATION_TRANSACTION, data, reply, 0);
4554         reply.readException();
4555         data.recycle();
4556         reply.recycle();
4557     }
4558     public Configuration getConfiguration() throws RemoteException
4559     {
4560         Parcel data = Parcel.obtain();
4561         Parcel reply = Parcel.obtain();
4562         data.writeInterfaceToken(IActivityManager.descriptor);
4563         mRemote.transact(GET_CONFIGURATION_TRANSACTION, data, reply, 0);
4564         reply.readException();
4565         Configuration res = Configuration.CREATOR.createFromParcel(reply);
4566         reply.recycle();
4567         data.recycle();
4568         return res;
4569     }
4570     public void updateConfiguration(Configuration values) throws RemoteException
4571     {
4572         Parcel data = Parcel.obtain();
4573         Parcel reply = Parcel.obtain();
4574         data.writeInterfaceToken(IActivityManager.descriptor);
4575         values.writeToParcel(data, 0);
4576         mRemote.transact(UPDATE_CONFIGURATION_TRANSACTION, data, reply, 0);
4577         reply.readException();
4578         data.recycle();
4579         reply.recycle();
4580     }
4581     public void setRequestedOrientation(IBinder token, int requestedOrientation)
4582             throws RemoteException {
4583         Parcel data = Parcel.obtain();
4584         Parcel reply = Parcel.obtain();
4585         data.writeInterfaceToken(IActivityManager.descriptor);
4586         data.writeStrongBinder(token);
4587         data.writeInt(requestedOrientation);
4588         mRemote.transact(SET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
4589         reply.readException();
4590         data.recycle();
4591         reply.recycle();
4592     }
4593     public int getRequestedOrientation(IBinder token) throws RemoteException {
4594         Parcel data = Parcel.obtain();
4595         Parcel reply = Parcel.obtain();
4596         data.writeInterfaceToken(IActivityManager.descriptor);
4597         data.writeStrongBinder(token);
4598         mRemote.transact(GET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
4599         reply.readException();
4600         int res = reply.readInt();
4601         data.recycle();
4602         reply.recycle();
4603         return res;
4604     }
4605     public ComponentName getActivityClassForToken(IBinder token)
4606             throws RemoteException {
4607         Parcel data = Parcel.obtain();
4608         Parcel reply = Parcel.obtain();
4609         data.writeInterfaceToken(IActivityManager.descriptor);
4610         data.writeStrongBinder(token);
4611         mRemote.transact(GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION, data, reply, 0);
4612         reply.readException();
4613         ComponentName res = ComponentName.readFromParcel(reply);
4614         data.recycle();
4615         reply.recycle();
4616         return res;
4617     }
4618     public String getPackageForToken(IBinder token) throws RemoteException
4619     {
4620         Parcel data = Parcel.obtain();
4621         Parcel reply = Parcel.obtain();
4622         data.writeInterfaceToken(IActivityManager.descriptor);
4623         data.writeStrongBinder(token);
4624         mRemote.transact(GET_PACKAGE_FOR_TOKEN_TRANSACTION, data, reply, 0);
4625         reply.readException();
4626         String res = reply.readString();
4627         data.recycle();
4628         reply.recycle();
4629         return res;
4630     }
4631     public IIntentSender getIntentSender(int type,
4632             String packageName, IBinder token, String resultWho,
4633             int requestCode, Intent[] intents, String[] resolvedTypes, int flags,
4634             Bundle options, int userId) throws RemoteException {
4635         Parcel data = Parcel.obtain();
4636         Parcel reply = Parcel.obtain();
4637         data.writeInterfaceToken(IActivityManager.descriptor);
4638         data.writeInt(type);
4639         data.writeString(packageName);
4640         data.writeStrongBinder(token);
4641         data.writeString(resultWho);
4642         data.writeInt(requestCode);
4643         if (intents != null) {
4644             data.writeInt(1);
4645             data.writeTypedArray(intents, 0);
4646             data.writeStringArray(resolvedTypes);
4647         } else {
4648             data.writeInt(0);
4649         }
4650         data.writeInt(flags);
4651         if (options != null) {
4652             data.writeInt(1);
4653             options.writeToParcel(data, 0);
4654         } else {
4655             data.writeInt(0);
4656         }
4657         data.writeInt(userId);
4658         mRemote.transact(GET_INTENT_SENDER_TRANSACTION, data, reply, 0);
4659         reply.readException();
4660         IIntentSender res = IIntentSender.Stub.asInterface(
4661                 reply.readStrongBinder());
4662         data.recycle();
4663         reply.recycle();
4664         return res;
4665     }
4666     public void cancelIntentSender(IIntentSender sender) throws RemoteException {
4667         Parcel data = Parcel.obtain();
4668         Parcel reply = Parcel.obtain();
4669         data.writeInterfaceToken(IActivityManager.descriptor);
4670         data.writeStrongBinder(sender.asBinder());
4671         mRemote.transact(CANCEL_INTENT_SENDER_TRANSACTION, data, reply, 0);
4672         reply.readException();
4673         data.recycle();
4674         reply.recycle();
4675     }
4676     public String getPackageForIntentSender(IIntentSender sender) throws RemoteException {
4677         Parcel data = Parcel.obtain();
4678         Parcel reply = Parcel.obtain();
4679         data.writeInterfaceToken(IActivityManager.descriptor);
4680         data.writeStrongBinder(sender.asBinder());
4681         mRemote.transact(GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
4682         reply.readException();
4683         String res = reply.readString();
4684         data.recycle();
4685         reply.recycle();
4686         return res;
4687     }
4688     public int getUidForIntentSender(IIntentSender sender) throws RemoteException {
4689         Parcel data = Parcel.obtain();
4690         Parcel reply = Parcel.obtain();
4691         data.writeInterfaceToken(IActivityManager.descriptor);
4692         data.writeStrongBinder(sender.asBinder());
4693         mRemote.transact(GET_UID_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
4694         reply.readException();
4695         int res = reply.readInt();
4696         data.recycle();
4697         reply.recycle();
4698         return res;
4699     }
4700     public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll,
4701             boolean requireFull, String name, String callerPackage) throws RemoteException {
4702         Parcel data = Parcel.obtain();
4703         Parcel reply = Parcel.obtain();
4704         data.writeInterfaceToken(IActivityManager.descriptor);
4705         data.writeInt(callingPid);
4706         data.writeInt(callingUid);
4707         data.writeInt(userId);
4708         data.writeInt(allowAll ? 1 : 0);
4709         data.writeInt(requireFull ? 1 : 0);
4710         data.writeString(name);
4711         data.writeString(callerPackage);
4712         mRemote.transact(HANDLE_INCOMING_USER_TRANSACTION, data, reply, 0);
4713         reply.readException();
4714         int res = reply.readInt();
4715         data.recycle();
4716         reply.recycle();
4717         return res;
4718     }
4719     public void setProcessLimit(int max) throws RemoteException
4720     {
4721         Parcel data = Parcel.obtain();
4722         Parcel reply = Parcel.obtain();
4723         data.writeInterfaceToken(IActivityManager.descriptor);
4724         data.writeInt(max);
4725         mRemote.transact(SET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
4726         reply.readException();
4727         data.recycle();
4728         reply.recycle();
4729     }
4730     public int getProcessLimit() throws RemoteException
4731     {
4732         Parcel data = Parcel.obtain();
4733         Parcel reply = Parcel.obtain();
4734         data.writeInterfaceToken(IActivityManager.descriptor);
4735         mRemote.transact(GET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
4736         reply.readException();
4737         int res = reply.readInt();
4738         data.recycle();
4739         reply.recycle();
4740         return res;
4741     }
4742     public void setProcessForeground(IBinder token, int pid,
4743             boolean isForeground) throws RemoteException {
4744         Parcel data = Parcel.obtain();
4745         Parcel reply = Parcel.obtain();
4746         data.writeInterfaceToken(IActivityManager.descriptor);
4747         data.writeStrongBinder(token);
4748         data.writeInt(pid);
4749         data.writeInt(isForeground ? 1 : 0);
4750         mRemote.transact(SET_PROCESS_FOREGROUND_TRANSACTION, data, reply, 0);
4751         reply.readException();
4752         data.recycle();
4753         reply.recycle();
4754     }
4755     public int checkPermission(String permission, int pid, int uid)
4756             throws RemoteException {
4757         Parcel data = Parcel.obtain();
4758         Parcel reply = Parcel.obtain();
4759         data.writeInterfaceToken(IActivityManager.descriptor);
4760         data.writeString(permission);
4761         data.writeInt(pid);
4762         data.writeInt(uid);
4763         mRemote.transact(CHECK_PERMISSION_TRANSACTION, data, reply, 0);
4764         reply.readException();
4765         int res = reply.readInt();
4766         data.recycle();
4767         reply.recycle();
4768         return res;
4769     }
4770     public int checkPermissionWithToken(String permission, int pid, int uid, IBinder callerToken)
4771             throws RemoteException {
4772         Parcel data = Parcel.obtain();
4773         Parcel reply = Parcel.obtain();
4774         data.writeInterfaceToken(IActivityManager.descriptor);
4775         data.writeString(permission);
4776         data.writeInt(pid);
4777         data.writeInt(uid);
4778         data.writeStrongBinder(callerToken);
4779         mRemote.transact(CHECK_PERMISSION_WITH_TOKEN_TRANSACTION, data, reply, 0);
4780         reply.readException();
4781         int res = reply.readInt();
4782         data.recycle();
4783         reply.recycle();
4784         return res;
4785     }
4786     public boolean clearApplicationUserData(final String packageName,
4787             final IPackageDataObserver observer, final int userId) throws RemoteException {
4788         Parcel data = Parcel.obtain();
4789         Parcel reply = Parcel.obtain();
4790         data.writeInterfaceToken(IActivityManager.descriptor);
4791         data.writeString(packageName);
4792         data.writeStrongBinder((observer != null) ? observer.asBinder() : null);
4793         data.writeInt(userId);
4794         mRemote.transact(CLEAR_APP_DATA_TRANSACTION, data, reply, 0);
4795         reply.readException();
4796         boolean res = reply.readInt() != 0;
4797         data.recycle();
4798         reply.recycle();
4799         return res;
4800     }
4801     public int checkUriPermission(Uri uri, int pid, int uid, int mode, int userId,
4802             IBinder callerToken) throws RemoteException {
4803         Parcel data = Parcel.obtain();
4804         Parcel reply = Parcel.obtain();
4805         data.writeInterfaceToken(IActivityManager.descriptor);
4806         uri.writeToParcel(data, 0);
4807         data.writeInt(pid);
4808         data.writeInt(uid);
4809         data.writeInt(mode);
4810         data.writeInt(userId);
4811         data.writeStrongBinder(callerToken);
4812         mRemote.transact(CHECK_URI_PERMISSION_TRANSACTION, data, reply, 0);
4813         reply.readException();
4814         int res = reply.readInt();
4815         data.recycle();
4816         reply.recycle();
4817         return res;
4818     }
4819     public void grantUriPermission(IApplicationThread caller, String targetPkg,
4820             Uri uri, int mode, int userId) throws RemoteException {
4821         Parcel data = Parcel.obtain();
4822         Parcel reply = Parcel.obtain();
4823         data.writeInterfaceToken(IActivityManager.descriptor);
4824         data.writeStrongBinder(caller.asBinder());
4825         data.writeString(targetPkg);
4826         uri.writeToParcel(data, 0);
4827         data.writeInt(mode);
4828         data.writeInt(userId);
4829         mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
4830         reply.readException();
4831         data.recycle();
4832         reply.recycle();
4833     }
4834     public void revokeUriPermission(IApplicationThread caller, Uri uri,
4835             int mode, int userId) throws RemoteException {
4836         Parcel data = Parcel.obtain();
4837         Parcel reply = Parcel.obtain();
4838         data.writeInterfaceToken(IActivityManager.descriptor);
4839         data.writeStrongBinder(caller.asBinder());
4840         uri.writeToParcel(data, 0);
4841         data.writeInt(mode);
4842         data.writeInt(userId);
4843         mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
4844         reply.readException();
4845         data.recycle();
4846         reply.recycle();
4847     }
4848
4849     @Override
4850     public void takePersistableUriPermission(Uri uri, int mode, int userId)
4851             throws RemoteException {
4852         Parcel data = Parcel.obtain();
4853         Parcel reply = Parcel.obtain();
4854         data.writeInterfaceToken(IActivityManager.descriptor);
4855         uri.writeToParcel(data, 0);
4856         data.writeInt(mode);
4857         data.writeInt(userId);
4858         mRemote.transact(TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION, data, reply, 0);
4859         reply.readException();
4860         data.recycle();
4861         reply.recycle();
4862     }
4863
4864     @Override
4865     public void releasePersistableUriPermission(Uri uri, int mode, int userId)
4866             throws RemoteException {
4867         Parcel data = Parcel.obtain();
4868         Parcel reply = Parcel.obtain();
4869         data.writeInterfaceToken(IActivityManager.descriptor);
4870         uri.writeToParcel(data, 0);
4871         data.writeInt(mode);
4872         data.writeInt(userId);
4873         mRemote.transact(RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION, data, reply, 0);
4874         reply.readException();
4875         data.recycle();
4876         reply.recycle();
4877     }
4878
4879     @Override
4880     public ParceledListSlice<UriPermission> getPersistedUriPermissions(
4881             String packageName, boolean incoming) throws RemoteException {
4882         Parcel data = Parcel.obtain();
4883         Parcel reply = Parcel.obtain();
4884         data.writeInterfaceToken(IActivityManager.descriptor);
4885         data.writeString(packageName);
4886         data.writeInt(incoming ? 1 : 0);
4887         mRemote.transact(GET_PERSISTED_URI_PERMISSIONS_TRANSACTION, data, reply, 0);
4888         reply.readException();
4889         @SuppressWarnings("unchecked")
4890         final ParceledListSlice<UriPermission> perms = ParceledListSlice.CREATOR.createFromParcel(
4891                 reply);
4892         data.recycle();
4893         reply.recycle();
4894         return perms;
4895     }
4896
4897     @Override
4898     public ParceledListSlice<UriPermission> getGrantedUriPermissions(String packageName, int userId)
4899             throws RemoteException {
4900         Parcel data = Parcel.obtain();
4901         Parcel reply = Parcel.obtain();
4902         data.writeInterfaceToken(IActivityManager.descriptor);
4903         data.writeString(packageName);
4904         data.writeInt(userId);
4905         mRemote.transact(GET_GRANTED_URI_PERMISSIONS_TRANSACTION, data, reply, 0);
4906         reply.readException();
4907         @SuppressWarnings("unchecked")
4908         final ParceledListSlice<UriPermission> perms = ParceledListSlice.CREATOR.createFromParcel(
4909                 reply);
4910         data.recycle();
4911         reply.recycle();
4912         return perms;
4913     }
4914
4915     @Override
4916     public void clearGrantedUriPermissions(String packageName, int userId) throws RemoteException {
4917         Parcel data = Parcel.obtain();
4918         Parcel reply = Parcel.obtain();
4919         data.writeInterfaceToken(IActivityManager.descriptor);
4920         data.writeString(packageName);
4921         data.writeInt(userId);
4922         mRemote.transact(CLEAR_GRANTED_URI_PERMISSIONS_TRANSACTION, data, reply, 0);
4923         reply.readException();
4924         data.recycle();
4925         reply.recycle();
4926     }
4927
4928     public void showWaitingForDebugger(IApplicationThread who, boolean waiting)
4929             throws RemoteException {
4930         Parcel data = Parcel.obtain();
4931         Parcel reply = Parcel.obtain();
4932         data.writeInterfaceToken(IActivityManager.descriptor);
4933         data.writeStrongBinder(who.asBinder());
4934         data.writeInt(waiting ? 1 : 0);
4935         mRemote.transact(SHOW_WAITING_FOR_DEBUGGER_TRANSACTION, data, reply, 0);
4936         reply.readException();
4937         data.recycle();
4938         reply.recycle();
4939     }
4940     public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException {
4941         Parcel data = Parcel.obtain();
4942         Parcel reply = Parcel.obtain();
4943         data.writeInterfaceToken(IActivityManager.descriptor);
4944         mRemote.transact(GET_MEMORY_INFO_TRANSACTION, data, reply, 0);
4945         reply.readException();
4946         outInfo.readFromParcel(reply);
4947         data.recycle();
4948         reply.recycle();
4949     }
4950     public void unhandledBack() throws RemoteException
4951     {
4952         Parcel data = Parcel.obtain();
4953         Parcel reply = Parcel.obtain();
4954         data.writeInterfaceToken(IActivityManager.descriptor);
4955         mRemote.transact(UNHANDLED_BACK_TRANSACTION, data, reply, 0);
4956         reply.readException();
4957         data.recycle();
4958         reply.recycle();
4959     }
4960     public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException
4961     {
4962         Parcel data = Parcel.obtain();
4963         Parcel reply = Parcel.obtain();
4964         data.writeInterfaceToken(IActivityManager.descriptor);
4965         mRemote.transact(OPEN_CONTENT_URI_TRANSACTION, data, reply, 0);
4966         reply.readException();
4967         ParcelFileDescriptor pfd = null;
4968         if (reply.readInt() != 0) {
4969             pfd = ParcelFileDescriptor.CREATOR.createFromParcel(reply);
4970         }
4971         data.recycle();
4972         reply.recycle();
4973         return pfd;
4974     }
4975     public void setLockScreenShown(boolean showing, boolean occluded) throws RemoteException
4976     {
4977         Parcel data = Parcel.obtain();
4978         Parcel reply = Parcel.obtain();
4979         data.writeInterfaceToken(IActivityManager.descriptor);
4980         data.writeInt(showing ? 1 : 0);
4981         data.writeInt(occluded ? 1 : 0);
4982         mRemote.transact(SET_LOCK_SCREEN_SHOWN_TRANSACTION, data, reply, 0);
4983         reply.readException();
4984         data.recycle();
4985         reply.recycle();
4986     }
4987     public void setDebugApp(
4988         String packageName, boolean waitForDebugger, boolean persistent)
4989         throws RemoteException
4990     {
4991         Parcel data = Parcel.obtain();
4992         Parcel reply = Parcel.obtain();
4993         data.writeInterfaceToken(IActivityManager.descriptor);
4994         data.writeString(packageName);
4995         data.writeInt(waitForDebugger ? 1 : 0);
4996         data.writeInt(persistent ? 1 : 0);
4997         mRemote.transact(SET_DEBUG_APP_TRANSACTION, data, reply, 0);
4998         reply.readException();
4999         data.recycle();
5000         reply.recycle();
5001     }
5002     public void setAlwaysFinish(boolean enabled) throws RemoteException
5003     {
5004         Parcel data = Parcel.obtain();
5005         Parcel reply = Parcel.obtain();
5006         data.writeInterfaceToken(IActivityManager.descriptor);
5007         data.writeInt(enabled ? 1 : 0);
5008         mRemote.transact(SET_ALWAYS_FINISH_TRANSACTION, data, reply, 0);
5009         reply.readException();
5010         data.recycle();
5011         reply.recycle();
5012     }
5013     public void setActivityController(IActivityController watcher, boolean imAMonkey)
5014             throws RemoteException
5015     {
5016         Parcel data = Parcel.obtain();
5017         Parcel reply = Parcel.obtain();
5018         data.writeInterfaceToken(IActivityManager.descriptor);
5019         data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
5020         data.writeInt(imAMonkey ? 1 : 0);
5021         mRemote.transact(SET_ACTIVITY_CONTROLLER_TRANSACTION, data, reply, 0);
5022         reply.readException();
5023         data.recycle();
5024         reply.recycle();
5025     }
5026     public void setLenientBackgroundCheck(boolean enabled) throws RemoteException
5027     {
5028         Parcel data = Parcel.obtain();
5029         Parcel reply = Parcel.obtain();
5030         data.writeInterfaceToken(IActivityManager.descriptor);
5031         data.writeInt(enabled ? 1 : 0);
5032         mRemote.transact(SET_LENIENT_BACKGROUND_CHECK_TRANSACTION, data, reply, 0);
5033         reply.readException();
5034         data.recycle();
5035         reply.recycle();
5036     }
5037     public int getMemoryTrimLevel() throws RemoteException
5038     {
5039         Parcel data = Parcel.obtain();
5040         Parcel reply = Parcel.obtain();
5041         data.writeInterfaceToken(IActivityManager.descriptor);
5042         mRemote.transact(GET_MEMORY_TRIM_LEVEL_TRANSACTION, data, reply, 0);
5043         reply.readException();
5044         int level = reply.readInt();
5045         data.recycle();
5046         reply.recycle();
5047         return level;
5048     }
5049     public void enterSafeMode() throws RemoteException {
5050         Parcel data = Parcel.obtain();
5051         data.writeInterfaceToken(IActivityManager.descriptor);
5052         mRemote.transact(ENTER_SAFE_MODE_TRANSACTION, data, null, 0);
5053         data.recycle();
5054     }
5055     public void noteWakeupAlarm(IIntentSender sender, int sourceUid, String sourcePkg, String tag)
5056             throws RemoteException {
5057         Parcel data = Parcel.obtain();
5058         data.writeInterfaceToken(IActivityManager.descriptor);
5059         data.writeStrongBinder(sender.asBinder());
5060         data.writeInt(sourceUid);
5061         data.writeString(sourcePkg);
5062         data.writeString(tag);
5063         mRemote.transact(NOTE_WAKEUP_ALARM_TRANSACTION, data, null, 0);
5064         data.recycle();
5065     }
5066     public void noteAlarmStart(IIntentSender sender, int sourceUid, String tag)
5067             throws RemoteException {
5068         Parcel data = Parcel.obtain();
5069         data.writeInterfaceToken(IActivityManager.descriptor);
5070         data.writeStrongBinder(sender.asBinder());
5071         data.writeInt(sourceUid);
5072         data.writeString(tag);
5073         mRemote.transact(NOTE_ALARM_START_TRANSACTION, data, null, 0);
5074         data.recycle();
5075     }
5076     public void noteAlarmFinish(IIntentSender sender, int sourceUid, String tag)
5077             throws RemoteException {
5078         Parcel data = Parcel.obtain();
5079         data.writeInterfaceToken(IActivityManager.descriptor);
5080         data.writeStrongBinder(sender.asBinder());
5081         data.writeInt(sourceUid);
5082         data.writeString(tag);
5083         mRemote.transact(NOTE_ALARM_FINISH_TRANSACTION, data, null, 0);
5084         data.recycle();
5085     }
5086     public boolean killPids(int[] pids, String reason, boolean secure) throws RemoteException {
5087         Parcel data = Parcel.obtain();
5088         Parcel reply = Parcel.obtain();
5089         data.writeInterfaceToken(IActivityManager.descriptor);
5090         data.writeIntArray(pids);
5091         data.writeString(reason);
5092         data.writeInt(secure ? 1 : 0);
5093         mRemote.transact(KILL_PIDS_TRANSACTION, data, reply, 0);
5094         reply.readException();
5095         boolean res = reply.readInt() != 0;
5096         data.recycle();
5097         reply.recycle();
5098         return res;
5099     }
5100     @Override
5101     public boolean killProcessesBelowForeground(String reason) throws RemoteException {
5102         Parcel data = Parcel.obtain();
5103         Parcel reply = Parcel.obtain();
5104         data.writeInterfaceToken(IActivityManager.descriptor);
5105         data.writeString(reason);
5106         mRemote.transact(KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION, data, reply, 0);
5107         boolean res = reply.readInt() != 0;
5108         data.recycle();
5109         reply.recycle();
5110         return res;
5111     }
5112     public boolean testIsSystemReady()
5113     {
5114         /* this base class version is never called */
5115         return true;
5116     }
5117     public void handleApplicationCrash(IBinder app,
5118             ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException
5119     {
5120         Parcel data = Parcel.obtain();
5121         Parcel reply = Parcel.obtain();
5122         data.writeInterfaceToken(IActivityManager.descriptor);
5123         data.writeStrongBinder(app);
5124         crashInfo.writeToParcel(data, 0);
5125         mRemote.transact(HANDLE_APPLICATION_CRASH_TRANSACTION, data, reply, 0);
5126         reply.readException();
5127         reply.recycle();
5128         data.recycle();
5129     }
5130
5131     public boolean handleApplicationWtf(IBinder app, String tag, boolean system,
5132             ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException
5133     {
5134         Parcel data = Parcel.obtain();
5135         Parcel reply = Parcel.obtain();
5136         data.writeInterfaceToken(IActivityManager.descriptor);
5137         data.writeStrongBinder(app);
5138         data.writeString(tag);
5139         data.writeInt(system ? 1 : 0);
5140         crashInfo.writeToParcel(data, 0);
5141         mRemote.transact(HANDLE_APPLICATION_WTF_TRANSACTION, data, reply, 0);
5142         reply.readException();
5143         boolean res = reply.readInt() != 0;
5144         reply.recycle();
5145         data.recycle();
5146         return res;
5147     }
5148
5149     public void handleApplicationStrictModeViolation(IBinder app,
5150             int violationMask,
5151             StrictMode.ViolationInfo info) throws RemoteException
5152     {
5153         Parcel data = Parcel.obtain();
5154         Parcel reply = Parcel.obtain();
5155         data.writeInterfaceToken(IActivityManager.descriptor);
5156         data.writeStrongBinder(app);
5157         data.writeInt(violationMask);
5158         info.writeToParcel(data, 0);
5159         mRemote.transact(HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION, data, reply, 0);
5160         reply.readException();
5161         reply.recycle();
5162         data.recycle();
5163     }
5164
5165     public void signalPersistentProcesses(int sig) throws RemoteException {
5166         Parcel data = Parcel.obtain();
5167         Parcel reply = Parcel.obtain();
5168         data.writeInterfaceToken(IActivityManager.descriptor);
5169         data.writeInt(sig);
5170         mRemote.transact(SIGNAL_PERSISTENT_PROCESSES_TRANSACTION, data, reply, 0);
5171         reply.readException();
5172         data.recycle();
5173         reply.recycle();
5174     }
5175
5176     public void killBackgroundProcesses(String packageName, int userId) throws RemoteException {
5177         Parcel data = Parcel.obtain();
5178         Parcel reply = Parcel.obtain();
5179         data.writeInterfaceToken(IActivityManager.descriptor);
5180         data.writeString(packageName);
5181         data.writeInt(userId);
5182         mRemote.transact(KILL_BACKGROUND_PROCESSES_TRANSACTION, data, reply, 0);
5183         reply.readException();
5184         data.recycle();
5185         reply.recycle();
5186     }
5187
5188     public void killAllBackgroundProcesses() throws RemoteException {
5189         Parcel data = Parcel.obtain();
5190         Parcel reply = Parcel.obtain();
5191         data.writeInterfaceToken(IActivityManager.descriptor);
5192         mRemote.transact(KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION, data, reply, 0);
5193         reply.readException();
5194         data.recycle();
5195         reply.recycle();
5196     }
5197
5198     public void killPackageDependents(String packageName, int userId) throws RemoteException {
5199         Parcel data = Parcel.obtain();
5200         Parcel reply = Parcel.obtain();
5201         data.writeInterfaceToken(IActivityManager.descriptor);
5202         data.writeString(packageName);
5203         data.writeInt(userId);
5204         mRemote.transact(KILL_PACKAGE_DEPENDENTS_TRANSACTION, data, reply, 0);
5205         reply.readException();
5206         data.recycle();
5207         reply.recycle();
5208     }
5209
5210     public void forceStopPackage(String packageName, int userId) throws RemoteException {
5211         Parcel data = Parcel.obtain();
5212         Parcel reply = Parcel.obtain();
5213         data.writeInterfaceToken(IActivityManager.descriptor);
5214         data.writeString(packageName);
5215         data.writeInt(userId);
5216         mRemote.transact(FORCE_STOP_PACKAGE_TRANSACTION, data, reply, 0);
5217         reply.readException();
5218         data.recycle();
5219         reply.recycle();
5220     }
5221
5222     public void getMyMemoryState(ActivityManager.RunningAppProcessInfo outInfo)
5223             throws RemoteException
5224     {
5225         Parcel data = Parcel.obtain();
5226         Parcel reply = Parcel.obtain();
5227         data.writeInterfaceToken(IActivityManager.descriptor);
5228         mRemote.transact(GET_MY_MEMORY_STATE_TRANSACTION, data, reply, 0);
5229         reply.readException();
5230         outInfo.readFromParcel(reply);
5231         reply.recycle();
5232         data.recycle();
5233     }
5234
5235     public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException
5236     {
5237         Parcel data = Parcel.obtain();
5238         Parcel reply = Parcel.obtain();
5239         data.writeInterfaceToken(IActivityManager.descriptor);
5240         mRemote.transact(GET_DEVICE_CONFIGURATION_TRANSACTION, data, reply, 0);
5241         reply.readException();
5242         ConfigurationInfo res = ConfigurationInfo.CREATOR.createFromParcel(reply);
5243         reply.recycle();
5244         data.recycle();
5245         return res;
5246     }
5247
5248     public boolean profileControl(String process, int userId, boolean start,
5249             ProfilerInfo profilerInfo, int profileType) throws RemoteException
5250     {
5251         Parcel data = Parcel.obtain();
5252         Parcel reply = Parcel.obtain();
5253         data.writeInterfaceToken(IActivityManager.descriptor);
5254         data.writeString(process);
5255         data.writeInt(userId);
5256         data.writeInt(start ? 1 : 0);
5257         data.writeInt(profileType);
5258         if (profilerInfo != null) {
5259             data.writeInt(1);
5260             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
5261         } else {
5262             data.writeInt(0);
5263         }
5264         mRemote.transact(PROFILE_CONTROL_TRANSACTION, data, reply, 0);
5265         reply.readException();
5266         boolean res = reply.readInt() != 0;
5267         reply.recycle();
5268         data.recycle();
5269         return res;
5270     }
5271
5272     public boolean shutdown(int timeout) throws RemoteException
5273     {
5274         Parcel data = Parcel.obtain();
5275         Parcel reply = Parcel.obtain();
5276         data.writeInterfaceToken(IActivityManager.descriptor);
5277         data.writeInt(timeout);
5278         mRemote.transact(SHUTDOWN_TRANSACTION, data, reply, 0);
5279         reply.readException();
5280         boolean res = reply.readInt() != 0;
5281         reply.recycle();
5282         data.recycle();
5283         return res;
5284     }
5285
5286     public void stopAppSwitches() throws RemoteException {
5287         Parcel data = Parcel.obtain();
5288         Parcel reply = Parcel.obtain();
5289         data.writeInterfaceToken(IActivityManager.descriptor);
5290         mRemote.transact(STOP_APP_SWITCHES_TRANSACTION, data, reply, 0);
5291         reply.readException();
5292         reply.recycle();
5293         data.recycle();
5294     }
5295
5296     public void resumeAppSwitches() throws RemoteException {
5297         Parcel data = Parcel.obtain();
5298         Parcel reply = Parcel.obtain();
5299         data.writeInterfaceToken(IActivityManager.descriptor);
5300         mRemote.transact(RESUME_APP_SWITCHES_TRANSACTION, data, reply, 0);
5301         reply.readException();
5302         reply.recycle();
5303         data.recycle();
5304     }
5305
5306     public void addPackageDependency(String packageName) throws RemoteException {
5307         Parcel data = Parcel.obtain();
5308         Parcel reply = Parcel.obtain();
5309         data.writeInterfaceToken(IActivityManager.descriptor);
5310         data.writeString(packageName);
5311         mRemote.transact(ADD_PACKAGE_DEPENDENCY_TRANSACTION, data, reply, 0);
5312         reply.readException();
5313         data.recycle();
5314         reply.recycle();
5315     }
5316
5317     public void killApplication(String pkg, int appId, int userId, String reason)
5318             throws RemoteException {
5319         Parcel data = Parcel.obtain();
5320         Parcel reply = Parcel.obtain();
5321         data.writeInterfaceToken(IActivityManager.descriptor);
5322         data.writeString(pkg);
5323         data.writeInt(appId);
5324         data.writeInt(userId);
5325         data.writeString(reason);
5326         mRemote.transact(KILL_APPLICATION_TRANSACTION, data, reply, 0);
5327         reply.readException();
5328         data.recycle();
5329         reply.recycle();
5330     }
5331
5332     public void closeSystemDialogs(String reason) throws RemoteException {
5333         Parcel data = Parcel.obtain();
5334         Parcel reply = Parcel.obtain();
5335         data.writeInterfaceToken(IActivityManager.descriptor);
5336         data.writeString(reason);
5337         mRemote.transact(CLOSE_SYSTEM_DIALOGS_TRANSACTION, data, reply, 0);
5338         reply.readException();
5339         data.recycle();
5340         reply.recycle();
5341     }
5342
5343     public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids)
5344             throws RemoteException {
5345         Parcel data = Parcel.obtain();
5346         Parcel reply = Parcel.obtain();
5347         data.writeInterfaceToken(IActivityManager.descriptor);
5348         data.writeIntArray(pids);
5349         mRemote.transact(GET_PROCESS_MEMORY_INFO_TRANSACTION, data, reply, 0);
5350         reply.readException();
5351         Debug.MemoryInfo[] res = reply.createTypedArray(Debug.MemoryInfo.CREATOR);
5352         data.recycle();
5353         reply.recycle();
5354         return res;
5355     }
5356
5357     public void killApplicationProcess(String processName, int uid) throws RemoteException {
5358         Parcel data = Parcel.obtain();
5359         Parcel reply = Parcel.obtain();
5360         data.writeInterfaceToken(IActivityManager.descriptor);
5361         data.writeString(processName);
5362         data.writeInt(uid);
5363         mRemote.transact(KILL_APPLICATION_PROCESS_TRANSACTION, data, reply, 0);
5364         reply.readException();
5365         data.recycle();
5366         reply.recycle();
5367     }
5368
5369     public void overridePendingTransition(IBinder token, String packageName,
5370             int enterAnim, int exitAnim) throws RemoteException {
5371         Parcel data = Parcel.obtain();
5372         Parcel reply = Parcel.obtain();
5373         data.writeInterfaceToken(IActivityManager.descriptor);
5374         data.writeStrongBinder(token);
5375         data.writeString(packageName);
5376         data.writeInt(enterAnim);
5377         data.writeInt(exitAnim);
5378         mRemote.transact(OVERRIDE_PENDING_TRANSITION_TRANSACTION, data, reply, 0);
5379         reply.readException();
5380         data.recycle();
5381         reply.recycle();
5382     }
5383
5384     public boolean isUserAMonkey() throws RemoteException {
5385         Parcel data = Parcel.obtain();
5386         Parcel reply = Parcel.obtain();
5387         data.writeInterfaceToken(IActivityManager.descriptor);
5388         mRemote.transact(IS_USER_A_MONKEY_TRANSACTION, data, reply, 0);
5389         reply.readException();
5390         boolean res = reply.readInt() != 0;
5391         data.recycle();
5392         reply.recycle();
5393         return res;
5394     }
5395
5396     public void setUserIsMonkey(boolean monkey) throws RemoteException {
5397         Parcel data = Parcel.obtain();
5398         Parcel reply = Parcel.obtain();
5399         data.writeInterfaceToken(IActivityManager.descriptor);
5400         data.writeInt(monkey ? 1 : 0);
5401         mRemote.transact(SET_USER_IS_MONKEY_TRANSACTION, data, reply, 0);
5402         reply.readException();
5403         data.recycle();
5404         reply.recycle();
5405     }
5406
5407     public void finishHeavyWeightApp() throws RemoteException {
5408         Parcel data = Parcel.obtain();
5409         Parcel reply = Parcel.obtain();
5410         data.writeInterfaceToken(IActivityManager.descriptor);
5411         mRemote.transact(FINISH_HEAVY_WEIGHT_APP_TRANSACTION, data, reply, 0);
5412         reply.readException();
5413         data.recycle();
5414         reply.recycle();
5415     }
5416
5417     public boolean convertFromTranslucent(IBinder token)
5418             throws RemoteException {
5419         Parcel data = Parcel.obtain();
5420         Parcel reply = Parcel.obtain();
5421         data.writeInterfaceToken(IActivityManager.descriptor);
5422         data.writeStrongBinder(token);
5423         mRemote.transact(CONVERT_FROM_TRANSLUCENT_TRANSACTION, data, reply, 0);
5424         reply.readException();
5425         boolean res = reply.readInt() != 0;
5426         data.recycle();
5427         reply.recycle();
5428         return res;
5429     }
5430
5431     public boolean convertToTranslucent(IBinder token, ActivityOptions options)
5432             throws RemoteException {
5433         Parcel data = Parcel.obtain();
5434         Parcel reply = Parcel.obtain();
5435         data.writeInterfaceToken(IActivityManager.descriptor);
5436         data.writeStrongBinder(token);
5437         if (options == null) {
5438             data.writeInt(0);
5439         } else {
5440             data.writeInt(1);
5441             data.writeBundle(options.toBundle());
5442         }
5443         mRemote.transact(CONVERT_TO_TRANSLUCENT_TRANSACTION, data, reply, 0);
5444         reply.readException();
5445         boolean res = reply.readInt() != 0;
5446         data.recycle();
5447         reply.recycle();
5448         return res;
5449     }
5450
5451     public ActivityOptions getActivityOptions(IBinder token) throws RemoteException {
5452         Parcel data = Parcel.obtain();
5453         Parcel reply = Parcel.obtain();
5454         data.writeInterfaceToken(IActivityManager.descriptor);
5455         data.writeStrongBinder(token);
5456         mRemote.transact(GET_ACTIVITY_OPTIONS_TRANSACTION, data, reply, 0);
5457         reply.readException();
5458         ActivityOptions options = ActivityOptions.fromBundle(reply.readBundle());
5459         data.recycle();
5460         reply.recycle();
5461         return options;
5462     }
5463
5464     public void setImmersive(IBinder token, boolean immersive)
5465             throws RemoteException {
5466         Parcel data = Parcel.obtain();
5467         Parcel reply = Parcel.obtain();
5468         data.writeInterfaceToken(IActivityManager.descriptor);
5469         data.writeStrongBinder(token);
5470         data.writeInt(immersive ? 1 : 0);
5471         mRemote.transact(SET_IMMERSIVE_TRANSACTION, data, reply, 0);
5472         reply.readException();
5473         data.recycle();
5474         reply.recycle();
5475     }
5476
5477     public boolean isImmersive(IBinder token)
5478             throws RemoteException {
5479         Parcel data = Parcel.obtain();
5480         Parcel reply = Parcel.obtain();
5481         data.writeInterfaceToken(IActivityManager.descriptor);
5482         data.writeStrongBinder(token);
5483         mRemote.transact(IS_IMMERSIVE_TRANSACTION, data, reply, 0);
5484         reply.readException();
5485         boolean res = reply.readInt() == 1;
5486         data.recycle();
5487         reply.recycle();
5488         return res;
5489     }
5490
5491     public boolean isTopOfTask(IBinder token) throws RemoteException {
5492         Parcel data = Parcel.obtain();
5493         Parcel reply = Parcel.obtain();
5494         data.writeInterfaceToken(IActivityManager.descriptor);
5495         data.writeStrongBinder(token);
5496         mRemote.transact(IS_TOP_OF_TASK_TRANSACTION, data, reply, 0);
5497         reply.readException();
5498         boolean res = reply.readInt() == 1;
5499         data.recycle();
5500         reply.recycle();
5501         return res;
5502     }
5503
5504     public boolean isTopActivityImmersive()
5505             throws RemoteException {
5506         Parcel data = Parcel.obtain();
5507         Parcel reply = Parcel.obtain();
5508         data.writeInterfaceToken(IActivityManager.descriptor);
5509         mRemote.transact(IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION, data, reply, 0);
5510         reply.readException();
5511         boolean res = reply.readInt() == 1;
5512         data.recycle();
5513         reply.recycle();
5514         return res;
5515     }
5516
5517     public void crashApplication(int uid, int initialPid, String packageName,
5518             String message) throws RemoteException {
5519         Parcel data = Parcel.obtain();
5520         Parcel reply = Parcel.obtain();
5521         data.writeInterfaceToken(IActivityManager.descriptor);
5522         data.writeInt(uid);
5523         data.writeInt(initialPid);
5524         data.writeString(packageName);
5525         data.writeString(message);
5526         mRemote.transact(CRASH_APPLICATION_TRANSACTION, data, reply, 0);
5527         reply.readException();
5528         data.recycle();
5529         reply.recycle();
5530     }
5531
5532     public String getProviderMimeType(Uri uri, int userId) throws RemoteException {
5533         Parcel data = Parcel.obtain();
5534         Parcel reply = Parcel.obtain();
5535         data.writeInterfaceToken(IActivityManager.descriptor);
5536         uri.writeToParcel(data, 0);
5537         data.writeInt(userId);
5538         mRemote.transact(GET_PROVIDER_MIME_TYPE_TRANSACTION, data, reply, 0);
5539         reply.readException();
5540         String res = reply.readString();
5541         data.recycle();
5542         reply.recycle();
5543         return res;
5544     }
5545
5546     public IBinder newUriPermissionOwner(String name)
5547             throws RemoteException {
5548         Parcel data = Parcel.obtain();
5549         Parcel reply = Parcel.obtain();
5550         data.writeInterfaceToken(IActivityManager.descriptor);
5551         data.writeString(name);
5552         mRemote.transact(NEW_URI_PERMISSION_OWNER_TRANSACTION, data, reply, 0);
5553         reply.readException();
5554         IBinder res = reply.readStrongBinder();
5555         data.recycle();
5556         reply.recycle();
5557         return res;
5558     }
5559
5560     public IBinder getUriPermissionOwnerForActivity(IBinder activityToken) throws RemoteException {
5561         Parcel data = Parcel.obtain();
5562         Parcel reply = Parcel.obtain();
5563         data.writeInterfaceToken(IActivityManager.descriptor);
5564         data.writeStrongBinder(activityToken);
5565         mRemote.transact(GET_URI_PERMISSION_OWNER_FOR_ACTIVITY_TRANSACTION, data, reply, 0);
5566         reply.readException();
5567         IBinder res = reply.readStrongBinder();
5568         data.recycle();
5569         reply.recycle();
5570         return res;
5571     }
5572
5573     public void grantUriPermissionFromOwner(IBinder owner, int fromUid, String targetPkg,
5574             Uri uri, int mode, int sourceUserId, int targetUserId) throws RemoteException {
5575         Parcel data = Parcel.obtain();
5576         Parcel reply = Parcel.obtain();
5577         data.writeInterfaceToken(IActivityManager.descriptor);
5578         data.writeStrongBinder(owner);
5579         data.writeInt(fromUid);
5580         data.writeString(targetPkg);
5581         uri.writeToParcel(data, 0);
5582         data.writeInt(mode);
5583         data.writeInt(sourceUserId);
5584         data.writeInt(targetUserId);
5585         mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
5586         reply.readException();
5587         data.recycle();
5588         reply.recycle();
5589     }
5590
5591     public void revokeUriPermissionFromOwner(IBinder owner, Uri uri,
5592             int mode, int userId) throws RemoteException {
5593         Parcel data = Parcel.obtain();
5594         Parcel reply = Parcel.obtain();
5595         data.writeInterfaceToken(IActivityManager.descriptor);
5596         data.writeStrongBinder(owner);
5597         if (uri != null) {
5598             data.writeInt(1);
5599             uri.writeToParcel(data, 0);
5600         } else {
5601             data.writeInt(0);
5602         }
5603         data.writeInt(mode);
5604         data.writeInt(userId);
5605         mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
5606         reply.readException();
5607         data.recycle();
5608         reply.recycle();
5609     }
5610
5611     public int checkGrantUriPermission(int callingUid, String targetPkg,
5612             Uri uri, int modeFlags, int userId) throws RemoteException {
5613         Parcel data = Parcel.obtain();
5614         Parcel reply = Parcel.obtain();
5615         data.writeInterfaceToken(IActivityManager.descriptor);
5616         data.writeInt(callingUid);
5617         data.writeString(targetPkg);
5618         uri.writeToParcel(data, 0);
5619         data.writeInt(modeFlags);
5620         data.writeInt(userId);
5621         mRemote.transact(CHECK_GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
5622         reply.readException();
5623         int res = reply.readInt();
5624         data.recycle();
5625         reply.recycle();
5626         return res;
5627     }
5628
5629     public boolean dumpHeap(String process, int userId, boolean managed,
5630             String path, ParcelFileDescriptor fd) throws RemoteException {
5631         Parcel data = Parcel.obtain();
5632         Parcel reply = Parcel.obtain();
5633         data.writeInterfaceToken(IActivityManager.descriptor);
5634         data.writeString(process);
5635         data.writeInt(userId);
5636         data.writeInt(managed ? 1 : 0);
5637         data.writeString(path);
5638         if (fd != null) {
5639             data.writeInt(1);
5640             fd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
5641         } else {
5642             data.writeInt(0);
5643         }
5644         mRemote.transact(DUMP_HEAP_TRANSACTION, data, reply, 0);
5645         reply.readException();
5646         boolean res = reply.readInt() != 0;
5647         reply.recycle();
5648         data.recycle();
5649         return res;
5650     }
5651
5652     public int startActivities(IApplicationThread caller, String callingPackage,
5653             Intent[] intents, String[] resolvedTypes, IBinder resultTo,
5654             Bundle options, int userId) throws RemoteException {
5655         Parcel data = Parcel.obtain();
5656         Parcel reply = Parcel.obtain();
5657         data.writeInterfaceToken(IActivityManager.descriptor);
5658         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
5659         data.writeString(callingPackage);
5660         data.writeTypedArray(intents, 0);
5661         data.writeStringArray(resolvedTypes);
5662         data.writeStrongBinder(resultTo);
5663         if (options != null) {
5664             data.writeInt(1);
5665             options.writeToParcel(data, 0);
5666         } else {
5667             data.writeInt(0);
5668         }
5669         data.writeInt(userId);
5670         mRemote.transact(START_ACTIVITIES_TRANSACTION, data, reply, 0);
5671         reply.readException();
5672         int result = reply.readInt();
5673         reply.recycle();
5674         data.recycle();
5675         return result;
5676     }
5677
5678     public int getFrontActivityScreenCompatMode() throws RemoteException {
5679         Parcel data = Parcel.obtain();
5680         Parcel reply = Parcel.obtain();
5681         data.writeInterfaceToken(IActivityManager.descriptor);
5682         mRemote.transact(GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
5683         reply.readException();
5684         int mode = reply.readInt();
5685         reply.recycle();
5686         data.recycle();
5687         return mode;
5688     }
5689
5690     public void setFrontActivityScreenCompatMode(int mode) throws RemoteException {
5691         Parcel data = Parcel.obtain();
5692         Parcel reply = Parcel.obtain();
5693         data.writeInterfaceToken(IActivityManager.descriptor);
5694         data.writeInt(mode);
5695         mRemote.transact(SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
5696         reply.readException();
5697         reply.recycle();
5698         data.recycle();
5699     }
5700
5701     public int getPackageScreenCompatMode(String packageName) throws RemoteException {
5702         Parcel data = Parcel.obtain();
5703         Parcel reply = Parcel.obtain();
5704         data.writeInterfaceToken(IActivityManager.descriptor);
5705         data.writeString(packageName);
5706         mRemote.transact(GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
5707         reply.readException();
5708         int mode = reply.readInt();
5709         reply.recycle();
5710         data.recycle();
5711         return mode;
5712     }
5713
5714     public void setPackageScreenCompatMode(String packageName, int mode)
5715             throws RemoteException {
5716         Parcel data = Parcel.obtain();
5717         Parcel reply = Parcel.obtain();
5718         data.writeInterfaceToken(IActivityManager.descriptor);
5719         data.writeString(packageName);
5720         data.writeInt(mode);
5721         mRemote.transact(SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
5722         reply.readException();
5723         reply.recycle();
5724         data.recycle();
5725     }
5726
5727     public boolean getPackageAskScreenCompat(String packageName) throws RemoteException {
5728         Parcel data = Parcel.obtain();
5729         Parcel reply = Parcel.obtain();
5730         data.writeInterfaceToken(IActivityManager.descriptor);
5731         data.writeString(packageName);
5732         mRemote.transact(GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION, data, reply, 0);
5733         reply.readException();
5734         boolean ask = reply.readInt() != 0;
5735         reply.recycle();
5736         data.recycle();
5737         return ask;
5738     }
5739
5740     public void setPackageAskScreenCompat(String packageName, boolean ask)
5741             throws RemoteException {
5742         Parcel data = Parcel.obtain();
5743         Parcel reply = Parcel.obtain();
5744         data.writeInterfaceToken(IActivityManager.descriptor);
5745         data.writeString(packageName);
5746         data.writeInt(ask ? 1 : 0);
5747         mRemote.transact(SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION, data, reply, 0);
5748         reply.readException();
5749         reply.recycle();
5750         data.recycle();
5751     }
5752
5753     public boolean switchUser(int userid) throws RemoteException {
5754         Parcel data = Parcel.obtain();
5755         Parcel reply = Parcel.obtain();
5756         data.writeInterfaceToken(IActivityManager.descriptor);
5757         data.writeInt(userid);
5758         mRemote.transact(SWITCH_USER_TRANSACTION, data, reply, 0);
5759         reply.readException();
5760         boolean result = reply.readInt() != 0;
5761         reply.recycle();
5762         data.recycle();
5763         return result;
5764     }
5765
5766     public boolean startUserInBackground(int userid) throws RemoteException {
5767         Parcel data = Parcel.obtain();
5768         Parcel reply = Parcel.obtain();
5769         data.writeInterfaceToken(IActivityManager.descriptor);
5770         data.writeInt(userid);
5771         mRemote.transact(START_USER_IN_BACKGROUND_TRANSACTION, data, reply, 0);
5772         reply.readException();
5773         boolean result = reply.readInt() != 0;
5774         reply.recycle();
5775         data.recycle();
5776         return result;
5777     }
5778
5779     public boolean unlockUser(int userId, byte[] token, byte[] secret, IProgressListener listener)
5780             throws RemoteException {
5781         Parcel data = Parcel.obtain();
5782         Parcel reply = Parcel.obtain();
5783         data.writeInterfaceToken(IActivityManager.descriptor);
5784         data.writeInt(userId);
5785         data.writeByteArray(token);
5786         data.writeByteArray(secret);
5787         data.writeStrongInterface(listener);
5788         mRemote.transact(IActivityManager.UNLOCK_USER_TRANSACTION, data, reply, 0);
5789         reply.readException();
5790         boolean result = reply.readInt() != 0;
5791         reply.recycle();
5792         data.recycle();
5793         return result;
5794     }
5795
5796     public int stopUser(int userid, boolean force, IStopUserCallback callback)
5797             throws RemoteException {
5798         Parcel data = Parcel.obtain();
5799         Parcel reply = Parcel.obtain();
5800         data.writeInterfaceToken(IActivityManager.descriptor);
5801         data.writeInt(userid);
5802         data.writeInt(force ? 1 : 0);
5803         data.writeStrongInterface(callback);
5804         mRemote.transact(STOP_USER_TRANSACTION, data, reply, 0);
5805         reply.readException();
5806         int result = reply.readInt();
5807         reply.recycle();
5808         data.recycle();
5809         return result;
5810     }
5811
5812     public UserInfo getCurrentUser() throws RemoteException {
5813         Parcel data = Parcel.obtain();
5814         Parcel reply = Parcel.obtain();
5815         data.writeInterfaceToken(IActivityManager.descriptor);
5816         mRemote.transact(GET_CURRENT_USER_TRANSACTION, data, reply, 0);
5817         reply.readException();
5818         UserInfo userInfo = UserInfo.CREATOR.createFromParcel(reply);
5819         reply.recycle();
5820         data.recycle();
5821         return userInfo;
5822     }
5823
5824     public boolean isUserRunning(int userid, int flags) throws RemoteException {
5825         Parcel data = Parcel.obtain();
5826         Parcel reply = Parcel.obtain();
5827         data.writeInterfaceToken(IActivityManager.descriptor);
5828         data.writeInt(userid);
5829         data.writeInt(flags);
5830         mRemote.transact(IS_USER_RUNNING_TRANSACTION, data, reply, 0);
5831         reply.readException();
5832         boolean result = reply.readInt() != 0;
5833         reply.recycle();
5834         data.recycle();
5835         return result;
5836     }
5837
5838     public int[] getRunningUserIds() throws RemoteException {
5839         Parcel data = Parcel.obtain();
5840         Parcel reply = Parcel.obtain();
5841         data.writeInterfaceToken(IActivityManager.descriptor);
5842         mRemote.transact(GET_RUNNING_USER_IDS_TRANSACTION, data, reply, 0);
5843         reply.readException();
5844         int[] result = reply.createIntArray();
5845         reply.recycle();
5846         data.recycle();
5847         return result;
5848     }
5849
5850     public boolean removeTask(int taskId) throws RemoteException {
5851         Parcel data = Parcel.obtain();
5852         Parcel reply = Parcel.obtain();
5853         data.writeInterfaceToken(IActivityManager.descriptor);
5854         data.writeInt(taskId);
5855         mRemote.transact(REMOVE_TASK_TRANSACTION, data, reply, 0);
5856         reply.readException();
5857         boolean result = reply.readInt() != 0;
5858         reply.recycle();
5859         data.recycle();
5860         return result;
5861     }
5862
5863     public void registerProcessObserver(IProcessObserver observer) throws RemoteException {
5864         Parcel data = Parcel.obtain();
5865         Parcel reply = Parcel.obtain();
5866         data.writeInterfaceToken(IActivityManager.descriptor);
5867         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
5868         mRemote.transact(REGISTER_PROCESS_OBSERVER_TRANSACTION, data, reply, 0);
5869         reply.readException();
5870         data.recycle();
5871         reply.recycle();
5872     }
5873
5874     public void unregisterProcessObserver(IProcessObserver observer) throws RemoteException {
5875         Parcel data = Parcel.obtain();
5876         Parcel reply = Parcel.obtain();
5877         data.writeInterfaceToken(IActivityManager.descriptor);
5878         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
5879         mRemote.transact(UNREGISTER_PROCESS_OBSERVER_TRANSACTION, data, reply, 0);
5880         reply.readException();
5881         data.recycle();
5882         reply.recycle();
5883     }
5884
5885     public void registerUidObserver(IUidObserver observer, int which) throws RemoteException {
5886         Parcel data = Parcel.obtain();
5887         Parcel reply = Parcel.obtain();
5888         data.writeInterfaceToken(IActivityManager.descriptor);
5889         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
5890         data.writeInt(which);
5891         mRemote.transact(REGISTER_UID_OBSERVER_TRANSACTION, data, reply, 0);
5892         reply.readException();
5893         data.recycle();
5894         reply.recycle();
5895     }
5896
5897     public void unregisterUidObserver(IUidObserver observer) throws RemoteException {
5898         Parcel data = Parcel.obtain();
5899         Parcel reply = Parcel.obtain();
5900         data.writeInterfaceToken(IActivityManager.descriptor);
5901         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
5902         mRemote.transact(UNREGISTER_UID_OBSERVER_TRANSACTION, data, reply, 0);
5903         reply.readException();
5904         data.recycle();
5905         reply.recycle();
5906     }
5907
5908     public boolean isIntentSenderTargetedToPackage(IIntentSender sender) throws RemoteException {
5909         Parcel data = Parcel.obtain();
5910         Parcel reply = Parcel.obtain();
5911         data.writeInterfaceToken(IActivityManager.descriptor);
5912         data.writeStrongBinder(sender.asBinder());
5913         mRemote.transact(IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION, data, reply, 0);
5914         reply.readException();
5915         boolean res = reply.readInt() != 0;
5916         data.recycle();
5917         reply.recycle();
5918         return res;
5919     }
5920
5921     public boolean isIntentSenderAnActivity(IIntentSender sender) throws RemoteException {
5922         Parcel data = Parcel.obtain();
5923         Parcel reply = Parcel.obtain();
5924         data.writeInterfaceToken(IActivityManager.descriptor);
5925         data.writeStrongBinder(sender.asBinder());
5926         mRemote.transact(IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION, data, reply, 0);
5927         reply.readException();
5928         boolean res = reply.readInt() != 0;
5929         data.recycle();
5930         reply.recycle();
5931         return res;
5932     }
5933
5934     public Intent getIntentForIntentSender(IIntentSender sender) throws RemoteException {
5935         Parcel data = Parcel.obtain();
5936         Parcel reply = Parcel.obtain();
5937         data.writeInterfaceToken(IActivityManager.descriptor);
5938         data.writeStrongBinder(sender.asBinder());
5939         mRemote.transact(GET_INTENT_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
5940         reply.readException();
5941         Intent res = reply.readInt() != 0
5942                 ? Intent.CREATOR.createFromParcel(reply) : null;
5943         data.recycle();
5944         reply.recycle();
5945         return res;
5946     }
5947
5948     public String getTagForIntentSender(IIntentSender sender, String prefix)
5949             throws RemoteException {
5950         Parcel data = Parcel.obtain();
5951         Parcel reply = Parcel.obtain();
5952         data.writeInterfaceToken(IActivityManager.descriptor);
5953         data.writeStrongBinder(sender.asBinder());
5954         data.writeString(prefix);
5955         mRemote.transact(GET_TAG_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
5956         reply.readException();
5957         String res = reply.readString();
5958         data.recycle();
5959         reply.recycle();
5960         return res;
5961     }
5962
5963     public void updatePersistentConfiguration(Configuration values) throws RemoteException
5964     {
5965         Parcel data = Parcel.obtain();
5966         Parcel reply = Parcel.obtain();
5967         data.writeInterfaceToken(IActivityManager.descriptor);
5968         values.writeToParcel(data, 0);
5969         mRemote.transact(UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION, data, reply, 0);
5970         reply.readException();
5971         data.recycle();
5972         reply.recycle();
5973     }
5974
5975     public long[] getProcessPss(int[] pids) throws RemoteException {
5976         Parcel data = Parcel.obtain();
5977         Parcel reply = Parcel.obtain();
5978         data.writeInterfaceToken(IActivityManager.descriptor);
5979         data.writeIntArray(pids);
5980         mRemote.transact(GET_PROCESS_PSS_TRANSACTION, data, reply, 0);
5981         reply.readException();
5982         long[] res = reply.createLongArray();
5983         data.recycle();
5984         reply.recycle();
5985         return res;
5986     }
5987
5988     public void showBootMessage(CharSequence msg, boolean always) throws RemoteException {
5989         Parcel data = Parcel.obtain();
5990         Parcel reply = Parcel.obtain();
5991         data.writeInterfaceToken(IActivityManager.descriptor);
5992         TextUtils.writeToParcel(msg, data, 0);
5993         data.writeInt(always ? 1 : 0);
5994         mRemote.transact(SHOW_BOOT_MESSAGE_TRANSACTION, data, reply, 0);
5995         reply.readException();
5996         data.recycle();
5997         reply.recycle();
5998     }
5999
6000     public void keyguardWaitingForActivityDrawn() throws RemoteException {
6001         Parcel data = Parcel.obtain();
6002         Parcel reply = Parcel.obtain();
6003         data.writeInterfaceToken(IActivityManager.descriptor);
6004         mRemote.transact(KEYGUARD_WAITING_FOR_ACTIVITY_DRAWN_TRANSACTION, data, reply, 0);
6005         reply.readException();
6006         data.recycle();
6007         reply.recycle();
6008     }
6009
6010     public void keyguardGoingAway(int flags)
6011             throws RemoteException {
6012         Parcel data = Parcel.obtain();
6013         Parcel reply = Parcel.obtain();
6014         data.writeInterfaceToken(IActivityManager.descriptor);
6015         data.writeInt(flags);
6016         mRemote.transact(KEYGUARD_GOING_AWAY_TRANSACTION, data, reply, 0);
6017         reply.readException();
6018         data.recycle();
6019         reply.recycle();
6020     }
6021
6022     public boolean shouldUpRecreateTask(IBinder token, String destAffinity)
6023             throws RemoteException {
6024         Parcel data = Parcel.obtain();
6025         Parcel reply = Parcel.obtain();
6026         data.writeInterfaceToken(IActivityManager.descriptor);
6027         data.writeStrongBinder(token);
6028         data.writeString(destAffinity);
6029         mRemote.transact(SHOULD_UP_RECREATE_TASK_TRANSACTION, data, reply, 0);
6030         reply.readException();
6031         boolean result = reply.readInt() != 0;
6032         data.recycle();
6033         reply.recycle();
6034         return result;
6035     }
6036
6037     public boolean navigateUpTo(IBinder token, Intent target, int resultCode, Intent resultData)
6038             throws RemoteException {
6039         Parcel data = Parcel.obtain();
6040         Parcel reply = Parcel.obtain();
6041         data.writeInterfaceToken(IActivityManager.descriptor);
6042         data.writeStrongBinder(token);
6043         target.writeToParcel(data, 0);
6044         data.writeInt(resultCode);
6045         if (resultData != null) {
6046             data.writeInt(1);
6047             resultData.writeToParcel(data, 0);
6048         } else {
6049             data.writeInt(0);
6050         }
6051         mRemote.transact(NAVIGATE_UP_TO_TRANSACTION, data, reply, 0);
6052         reply.readException();
6053         boolean result = reply.readInt() != 0;
6054         data.recycle();
6055         reply.recycle();
6056         return result;
6057     }
6058
6059     public int getLaunchedFromUid(IBinder activityToken) throws RemoteException {
6060         Parcel data = Parcel.obtain();
6061         Parcel reply = Parcel.obtain();
6062         data.writeInterfaceToken(IActivityManager.descriptor);
6063         data.writeStrongBinder(activityToken);
6064         mRemote.transact(GET_LAUNCHED_FROM_UID_TRANSACTION, data, reply, 0);
6065         reply.readException();
6066         int result = reply.readInt();
6067         data.recycle();
6068         reply.recycle();
6069         return result;
6070     }
6071
6072     public String getLaunchedFromPackage(IBinder activityToken) throws RemoteException {
6073         Parcel data = Parcel.obtain();
6074         Parcel reply = Parcel.obtain();
6075         data.writeInterfaceToken(IActivityManager.descriptor);
6076         data.writeStrongBinder(activityToken);
6077         mRemote.transact(GET_LAUNCHED_FROM_PACKAGE_TRANSACTION, data, reply, 0);
6078         reply.readException();
6079         String result = reply.readString();
6080         data.recycle();
6081         reply.recycle();
6082         return result;
6083     }
6084
6085     public void registerUserSwitchObserver(IUserSwitchObserver observer,
6086             String name) throws RemoteException {
6087         Parcel data = Parcel.obtain();
6088         Parcel reply = Parcel.obtain();
6089         data.writeInterfaceToken(IActivityManager.descriptor);
6090         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
6091         data.writeString(name);
6092         mRemote.transact(REGISTER_USER_SWITCH_OBSERVER_TRANSACTION, data, reply, 0);
6093         reply.readException();
6094         data.recycle();
6095         reply.recycle();
6096     }
6097
6098     public void unregisterUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException {
6099         Parcel data = Parcel.obtain();
6100         Parcel reply = Parcel.obtain();
6101         data.writeInterfaceToken(IActivityManager.descriptor);
6102         data.writeStrongBinder(observer != null ? observer.asBinder() : null);
6103         mRemote.transact(UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION, data, reply, 0);
6104         reply.readException();
6105         data.recycle();
6106         reply.recycle();
6107     }
6108
6109     public void requestBugReport(@ActivityManager.BugreportMode int bugreportType)
6110             throws RemoteException {
6111         Parcel data = Parcel.obtain();
6112         Parcel reply = Parcel.obtain();
6113         data.writeInterfaceToken(IActivityManager.descriptor);
6114         data.writeInt(bugreportType);
6115         mRemote.transact(REQUEST_BUG_REPORT_TRANSACTION, data, reply, 0);
6116         reply.readException();
6117         data.recycle();
6118         reply.recycle();
6119     }
6120
6121     public long inputDispatchingTimedOut(int pid, boolean aboveSystem, String reason)
6122             throws RemoteException {
6123         Parcel data = Parcel.obtain();
6124         Parcel reply = Parcel.obtain();
6125         data.writeInterfaceToken(IActivityManager.descriptor);
6126         data.writeInt(pid);
6127         data.writeInt(aboveSystem ? 1 : 0);
6128         data.writeString(reason);
6129         mRemote.transact(INPUT_DISPATCHING_TIMED_OUT_TRANSACTION, data, reply, 0);
6130         reply.readException();
6131         long res = reply.readInt();
6132         data.recycle();
6133         reply.recycle();
6134         return res;
6135     }
6136
6137     public Bundle getAssistContextExtras(int requestType) throws RemoteException {
6138         Parcel data = Parcel.obtain();
6139         Parcel reply = Parcel.obtain();
6140         data.writeInterfaceToken(IActivityManager.descriptor);
6141         data.writeInt(requestType);
6142         mRemote.transact(GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION, data, reply, 0);
6143         reply.readException();
6144         Bundle res = reply.readBundle();
6145         data.recycle();
6146         reply.recycle();
6147         return res;
6148     }
6149
6150     public boolean requestAssistContextExtras(int requestType, IResultReceiver receiver,
6151             Bundle receiverExtras,
6152             IBinder activityToken, boolean focused, boolean newSessionId) throws RemoteException {
6153         Parcel data = Parcel.obtain();
6154         Parcel reply = Parcel.obtain();
6155         data.writeInterfaceToken(IActivityManager.descriptor);
6156         data.writeInt(requestType);
6157         data.writeStrongBinder(receiver.asBinder());
6158         data.writeBundle(receiverExtras);
6159         data.writeStrongBinder(activityToken);
6160         data.writeInt(focused ? 1 : 0);
6161         data.writeInt(newSessionId ? 1 : 0);
6162         mRemote.transact(REQUEST_ASSIST_CONTEXT_EXTRAS_TRANSACTION, data, reply, 0);
6163         reply.readException();
6164         boolean res = reply.readInt() != 0;
6165         data.recycle();
6166         reply.recycle();
6167         return res;
6168     }
6169
6170     public void reportAssistContextExtras(IBinder token, Bundle extras, AssistStructure structure,
6171             AssistContent content, Uri referrer) throws RemoteException {
6172         Parcel data = Parcel.obtain();
6173         Parcel reply = Parcel.obtain();
6174         data.writeInterfaceToken(IActivityManager.descriptor);
6175         data.writeStrongBinder(token);
6176         data.writeBundle(extras);
6177         structure.writeToParcel(data, 0);
6178         content.writeToParcel(data, 0);
6179         if (referrer != null) {
6180             data.writeInt(1);
6181             referrer.writeToParcel(data, 0);
6182         } else {
6183             data.writeInt(0);
6184         }
6185         mRemote.transact(REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION, data, reply, 0);
6186         reply.readException();
6187         data.recycle();
6188         reply.recycle();
6189     }
6190
6191     public boolean launchAssistIntent(Intent intent, int requestType, String hint, int userHandle,
6192             Bundle args) throws RemoteException {
6193         Parcel data = Parcel.obtain();
6194         Parcel reply = Parcel.obtain();
6195         data.writeInterfaceToken(IActivityManager.descriptor);
6196         intent.writeToParcel(data, 0);
6197         data.writeInt(requestType);
6198         data.writeString(hint);
6199         data.writeInt(userHandle);
6200         data.writeBundle(args);
6201         mRemote.transact(LAUNCH_ASSIST_INTENT_TRANSACTION, data, reply, 0);
6202         reply.readException();
6203         boolean res = reply.readInt() != 0;
6204         data.recycle();
6205         reply.recycle();
6206         return res;
6207     }
6208
6209     public boolean isAssistDataAllowedOnCurrentActivity() throws RemoteException {
6210         Parcel data = Parcel.obtain();
6211         Parcel reply = Parcel.obtain();
6212         data.writeInterfaceToken(IActivityManager.descriptor);
6213         mRemote.transact(IS_SCREEN_CAPTURE_ALLOWED_ON_CURRENT_ACTIVITY_TRANSACTION, data, reply, 0);
6214         reply.readException();
6215         boolean res = reply.readInt() != 0;
6216         data.recycle();
6217         reply.recycle();
6218         return res;
6219     }
6220
6221     public boolean showAssistFromActivity(IBinder token, Bundle args) throws RemoteException {
6222         Parcel data = Parcel.obtain();
6223         Parcel reply = Parcel.obtain();
6224         data.writeInterfaceToken(IActivityManager.descriptor);
6225         data.writeStrongBinder(token);
6226         data.writeBundle(args);
6227         mRemote.transact(SHOW_ASSIST_FROM_ACTIVITY_TRANSACTION, data, reply, 0);
6228         reply.readException();
6229         boolean res = reply.readInt() != 0;
6230         data.recycle();
6231         reply.recycle();
6232         return res;
6233     }
6234
6235     public void killUid(int appId, int userId, String reason) throws RemoteException {
6236         Parcel data = Parcel.obtain();
6237         Parcel reply = Parcel.obtain();
6238         data.writeInterfaceToken(IActivityManager.descriptor);
6239         data.writeInt(appId);
6240         data.writeInt(userId);
6241         data.writeString(reason);
6242         mRemote.transact(KILL_UID_TRANSACTION, data, reply, 0);
6243         reply.readException();
6244         data.recycle();
6245         reply.recycle();
6246     }
6247
6248     public void hang(IBinder who, boolean allowRestart) throws RemoteException {
6249         Parcel data = Parcel.obtain();
6250         Parcel reply = Parcel.obtain();
6251         data.writeInterfaceToken(IActivityManager.descriptor);
6252         data.writeStrongBinder(who);
6253         data.writeInt(allowRestart ? 1 : 0);
6254         mRemote.transact(HANG_TRANSACTION, data, reply, 0);
6255         reply.readException();
6256         data.recycle();
6257         reply.recycle();
6258     }
6259
6260     public void reportActivityFullyDrawn(IBinder token) throws RemoteException {
6261         Parcel data = Parcel.obtain();
6262         Parcel reply = Parcel.obtain();
6263         data.writeInterfaceToken(IActivityManager.descriptor);
6264         data.writeStrongBinder(token);
6265         mRemote.transact(REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION, data, reply, 0);
6266         reply.readException();
6267         data.recycle();
6268         reply.recycle();
6269     }
6270
6271     public void notifyActivityDrawn(IBinder token) throws RemoteException {
6272         Parcel data = Parcel.obtain();
6273         Parcel reply = Parcel.obtain();
6274         data.writeInterfaceToken(IActivityManager.descriptor);
6275         data.writeStrongBinder(token);
6276         mRemote.transact(NOTIFY_ACTIVITY_DRAWN_TRANSACTION, data, reply, 0);
6277         reply.readException();
6278         data.recycle();
6279         reply.recycle();
6280     }
6281
6282     public void restart() throws RemoteException {
6283         Parcel data = Parcel.obtain();
6284         Parcel reply = Parcel.obtain();
6285         data.writeInterfaceToken(IActivityManager.descriptor);
6286         mRemote.transact(RESTART_TRANSACTION, data, reply, 0);
6287         reply.readException();
6288         data.recycle();
6289         reply.recycle();
6290     }
6291
6292     public void performIdleMaintenance() throws RemoteException {
6293         Parcel data = Parcel.obtain();
6294         Parcel reply = Parcel.obtain();
6295         data.writeInterfaceToken(IActivityManager.descriptor);
6296         mRemote.transact(PERFORM_IDLE_MAINTENANCE_TRANSACTION, data, reply, 0);
6297         reply.readException();
6298         data.recycle();
6299         reply.recycle();
6300     }
6301
6302     public void sendIdleJobTrigger() throws RemoteException {
6303         Parcel data = Parcel.obtain();
6304         Parcel reply = Parcel.obtain();
6305         data.writeInterfaceToken(IActivityManager.descriptor);
6306         mRemote.transact(SEND_IDLE_JOB_TRIGGER_TRANSACTION, data, reply, 0);
6307         reply.readException();
6308         data.recycle();
6309         reply.recycle();
6310     }
6311
6312     public IActivityContainer createVirtualActivityContainer(IBinder parentActivityToken,
6313             IActivityContainerCallback callback) throws RemoteException {
6314         Parcel data = Parcel.obtain();
6315         Parcel reply = Parcel.obtain();
6316         data.writeInterfaceToken(IActivityManager.descriptor);
6317         data.writeStrongBinder(parentActivityToken);
6318         data.writeStrongBinder(callback == null ? null : callback.asBinder());
6319         mRemote.transact(CREATE_VIRTUAL_ACTIVITY_CONTAINER_TRANSACTION, data, reply, 0);
6320         reply.readException();
6321         final int result = reply.readInt();
6322         final IActivityContainer res;
6323         if (result == 1) {
6324             res = IActivityContainer.Stub.asInterface(reply.readStrongBinder());
6325         } else {
6326             res = null;
6327         }
6328         data.recycle();
6329         reply.recycle();
6330         return res;
6331     }
6332
6333     public void deleteActivityContainer(IActivityContainer activityContainer)
6334             throws RemoteException {
6335         Parcel data = Parcel.obtain();
6336         Parcel reply = Parcel.obtain();
6337         data.writeInterfaceToken(IActivityManager.descriptor);
6338         data.writeStrongBinder(activityContainer.asBinder());
6339         mRemote.transact(DELETE_ACTIVITY_CONTAINER_TRANSACTION, data, reply, 0);
6340         reply.readException();
6341         data.recycle();
6342         reply.recycle();
6343     }
6344
6345     public boolean startBinderTracking() throws RemoteException {
6346         Parcel data = Parcel.obtain();
6347         Parcel reply = Parcel.obtain();
6348         data.writeInterfaceToken(IActivityManager.descriptor);
6349         mRemote.transact(START_BINDER_TRACKING_TRANSACTION, data, reply, 0);
6350         reply.readException();
6351         boolean res = reply.readInt() != 0;
6352         reply.recycle();
6353         data.recycle();
6354         return res;
6355     }
6356
6357     public boolean stopBinderTrackingAndDump(ParcelFileDescriptor fd) throws RemoteException {
6358         Parcel data = Parcel.obtain();
6359         Parcel reply = Parcel.obtain();
6360         data.writeInterfaceToken(IActivityManager.descriptor);
6361         if (fd != null) {
6362             data.writeInt(1);
6363             fd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
6364         } else {
6365             data.writeInt(0);
6366         }
6367         mRemote.transact(STOP_BINDER_TRACKING_AND_DUMP_TRANSACTION, data, reply, 0);
6368         reply.readException();
6369         boolean res = reply.readInt() != 0;
6370         reply.recycle();
6371         data.recycle();
6372         return res;
6373     }
6374
6375     public int setVrMode(IBinder token, boolean enabled, ComponentName packageName)
6376             throws RemoteException {
6377         Parcel data = Parcel.obtain();
6378         Parcel reply = Parcel.obtain();
6379         data.writeInterfaceToken(IActivityManager.descriptor);
6380         data.writeStrongBinder(token);
6381         data.writeInt(enabled ? 1 : 0);
6382         packageName.writeToParcel(data, 0);
6383         mRemote.transact(SET_VR_MODE_TRANSACTION, data, reply, 0);
6384         reply.readException();
6385         int res = reply.readInt();
6386         data.recycle();
6387         reply.recycle();
6388         return res;
6389     }
6390
6391     public boolean isVrModePackageEnabled(ComponentName packageName)
6392             throws RemoteException {
6393         Parcel data = Parcel.obtain();
6394         Parcel reply = Parcel.obtain();
6395         data.writeInterfaceToken(IActivityManager.descriptor);
6396         packageName.writeToParcel(data, 0);
6397         mRemote.transact(IS_VR_PACKAGE_ENABLED_TRANSACTION, data, reply, 0);
6398         reply.readException();
6399         int res = reply.readInt();
6400         data.recycle();
6401         reply.recycle();
6402         return res == 1;
6403     }
6404
6405     @Override
6406     public IActivityContainer createStackOnDisplay(int displayId) throws RemoteException {
6407         Parcel data = Parcel.obtain();
6408         Parcel reply = Parcel.obtain();
6409         data.writeInterfaceToken(IActivityManager.descriptor);
6410         data.writeInt(displayId);
6411         mRemote.transact(CREATE_STACK_ON_DISPLAY, data, reply, 0);
6412         reply.readException();
6413         final int result = reply.readInt();
6414         final IActivityContainer res;
6415         if (result == 1) {
6416             res = IActivityContainer.Stub.asInterface(reply.readStrongBinder());
6417         } else {
6418             res = null;
6419         }
6420         data.recycle();
6421         reply.recycle();
6422         return res;
6423     }
6424
6425     @Override
6426     public int getActivityDisplayId(IBinder activityToken)
6427             throws RemoteException {
6428         Parcel data = Parcel.obtain();
6429         Parcel reply = Parcel.obtain();
6430         data.writeInterfaceToken(IActivityManager.descriptor);
6431         data.writeStrongBinder(activityToken);
6432         mRemote.transact(GET_ACTIVITY_DISPLAY_ID_TRANSACTION, data, reply, 0);
6433         reply.readException();
6434         final int displayId = reply.readInt();
6435         data.recycle();
6436         reply.recycle();
6437         return displayId;
6438     }
6439
6440     @Override
6441     public void startLockTaskMode(int taskId) throws RemoteException {
6442         Parcel data = Parcel.obtain();
6443         Parcel reply = Parcel.obtain();
6444         data.writeInterfaceToken(IActivityManager.descriptor);
6445         data.writeInt(taskId);
6446         mRemote.transact(START_LOCK_TASK_BY_TASK_ID_TRANSACTION, data, reply, 0);
6447         reply.readException();
6448         data.recycle();
6449         reply.recycle();
6450     }
6451
6452     @Override
6453     public void startLockTaskMode(IBinder token) throws RemoteException {
6454         Parcel data = Parcel.obtain();
6455         Parcel reply = Parcel.obtain();
6456         data.writeInterfaceToken(IActivityManager.descriptor);
6457         data.writeStrongBinder(token);
6458         mRemote.transact(START_LOCK_TASK_BY_TOKEN_TRANSACTION, data, reply, 0);
6459         reply.readException();
6460         data.recycle();
6461         reply.recycle();
6462     }
6463
6464     @Override
6465     public void startSystemLockTaskMode(int taskId) throws RemoteException {
6466         Parcel data = Parcel.obtain();
6467         Parcel reply = Parcel.obtain();
6468         data.writeInterfaceToken(IActivityManager.descriptor);
6469         data.writeInt(taskId);
6470         mRemote.transact(START_SYSTEM_LOCK_TASK_TRANSACTION, data, reply, 0);
6471         reply.readException();
6472         data.recycle();
6473         reply.recycle();
6474     }
6475
6476     @Override
6477     public void stopLockTaskMode() throws RemoteException {
6478         Parcel data = Parcel.obtain();
6479         Parcel reply = Parcel.obtain();
6480         data.writeInterfaceToken(IActivityManager.descriptor);
6481         mRemote.transact(STOP_LOCK_TASK_MODE_TRANSACTION, data, reply, 0);
6482         reply.readException();
6483         data.recycle();
6484         reply.recycle();
6485     }
6486
6487     @Override
6488     public void stopSystemLockTaskMode() throws RemoteException {
6489         Parcel data = Parcel.obtain();
6490         Parcel reply = Parcel.obtain();
6491         data.writeInterfaceToken(IActivityManager.descriptor);
6492         mRemote.transact(STOP_SYSTEM_LOCK_TASK_TRANSACTION, data, reply, 0);
6493         reply.readException();
6494         data.recycle();
6495         reply.recycle();
6496     }
6497
6498     @Override
6499     public boolean isInLockTaskMode() throws RemoteException {
6500         Parcel data = Parcel.obtain();
6501         Parcel reply = Parcel.obtain();
6502         data.writeInterfaceToken(IActivityManager.descriptor);
6503         mRemote.transact(IS_IN_LOCK_TASK_MODE_TRANSACTION, data, reply, 0);
6504         reply.readException();
6505         boolean isInLockTaskMode = reply.readInt() == 1;
6506         data.recycle();
6507         reply.recycle();
6508         return isInLockTaskMode;
6509     }
6510
6511     @Override
6512     public int getLockTaskModeState() throws RemoteException {
6513         Parcel data = Parcel.obtain();
6514         Parcel reply = Parcel.obtain();
6515         data.writeInterfaceToken(IActivityManager.descriptor);
6516         mRemote.transact(GET_LOCK_TASK_MODE_STATE_TRANSACTION, data, reply, 0);
6517         reply.readException();
6518         int lockTaskModeState = reply.readInt();
6519         data.recycle();
6520         reply.recycle();
6521         return lockTaskModeState;
6522     }
6523
6524     @Override
6525     public void showLockTaskEscapeMessage(IBinder token) throws RemoteException {
6526         Parcel data = Parcel.obtain();
6527         Parcel reply = Parcel.obtain();
6528         data.writeInterfaceToken(IActivityManager.descriptor);
6529         data.writeStrongBinder(token);
6530         mRemote.transact(SHOW_LOCK_TASK_ESCAPE_MESSAGE_TRANSACTION, data, reply,
6531                 IBinder.FLAG_ONEWAY);
6532         reply.readException();
6533         data.recycle();
6534         reply.recycle();
6535     }
6536
6537     @Override
6538     public void setTaskDescription(IBinder token, ActivityManager.TaskDescription values)
6539             throws RemoteException {
6540         Parcel data = Parcel.obtain();
6541         Parcel reply = Parcel.obtain();
6542         data.writeInterfaceToken(IActivityManager.descriptor);
6543         data.writeStrongBinder(token);
6544         values.writeToParcel(data, 0);
6545         mRemote.transact(SET_TASK_DESCRIPTION_TRANSACTION, data, reply, 0);
6546         reply.readException();
6547         data.recycle();
6548         reply.recycle();
6549     }
6550
6551     @Override
6552     public void setTaskResizeable(int taskId, int resizeableMode) throws  RemoteException {
6553         Parcel data = Parcel.obtain();
6554         Parcel reply = Parcel.obtain();
6555         data.writeInterfaceToken(IActivityManager.descriptor);
6556         data.writeInt(taskId);
6557         data.writeInt(resizeableMode);
6558         mRemote.transact(SET_TASK_RESIZEABLE_TRANSACTION, data, reply, 0);
6559         reply.readException();
6560         data.recycle();
6561         reply.recycle();
6562     }
6563
6564     @Override
6565     public void resizeTask(int taskId, Rect r, int resizeMode) throws RemoteException
6566     {
6567         Parcel data = Parcel.obtain();
6568         Parcel reply = Parcel.obtain();
6569         data.writeInterfaceToken(IActivityManager.descriptor);
6570         data.writeInt(taskId);
6571         data.writeInt(resizeMode);
6572         r.writeToParcel(data, 0);
6573         mRemote.transact(RESIZE_TASK_TRANSACTION, data, reply, 0);
6574         reply.readException();
6575         data.recycle();
6576         reply.recycle();
6577     }
6578
6579     @Override
6580     public Rect getTaskBounds(int taskId) throws RemoteException
6581     {
6582         Parcel data = Parcel.obtain();
6583         Parcel reply = Parcel.obtain();
6584         data.writeInterfaceToken(IActivityManager.descriptor);
6585         data.writeInt(taskId);
6586         mRemote.transact(GET_TASK_BOUNDS_TRANSACTION, data, reply, 0);
6587         reply.readException();
6588         Rect rect = Rect.CREATOR.createFromParcel(reply);
6589         data.recycle();
6590         reply.recycle();
6591         return rect;
6592     }
6593
6594     @Override
6595     public Bitmap getTaskDescriptionIcon(String filename, int userId) throws RemoteException {
6596         Parcel data = Parcel.obtain();
6597         Parcel reply = Parcel.obtain();
6598         data.writeInterfaceToken(IActivityManager.descriptor);
6599         data.writeString(filename);
6600         data.writeInt(userId);
6601         mRemote.transact(GET_TASK_DESCRIPTION_ICON_TRANSACTION, data, reply, 0);
6602         reply.readException();
6603         final Bitmap icon = reply.readInt() == 0 ? null : Bitmap.CREATOR.createFromParcel(reply);
6604         data.recycle();
6605         reply.recycle();
6606         return icon;
6607     }
6608
6609     @Override
6610     public void startInPlaceAnimationOnFrontMostApplication(ActivityOptions options)
6611             throws RemoteException {
6612         Parcel data = Parcel.obtain();
6613         Parcel reply = Parcel.obtain();
6614         data.writeInterfaceToken(IActivityManager.descriptor);
6615         if (options == null) {
6616             data.writeInt(0);
6617         } else {
6618             data.writeInt(1);
6619             data.writeBundle(options.toBundle());
6620         }
6621         mRemote.transact(START_IN_PLACE_ANIMATION_TRANSACTION, data, reply, 0);
6622         reply.readException();
6623         data.recycle();
6624         reply.recycle();
6625     }
6626
6627     @Override
6628     public boolean requestVisibleBehind(IBinder token, boolean visible) throws RemoteException {
6629         Parcel data = Parcel.obtain();
6630         Parcel reply = Parcel.obtain();
6631         data.writeInterfaceToken(IActivityManager.descriptor);
6632         data.writeStrongBinder(token);
6633         data.writeInt(visible ? 1 : 0);
6634         mRemote.transact(REQUEST_VISIBLE_BEHIND_TRANSACTION, data, reply, 0);
6635         reply.readException();
6636         boolean success = reply.readInt() > 0;
6637         data.recycle();
6638         reply.recycle();
6639         return success;
6640     }
6641
6642     @Override
6643     public boolean isBackgroundVisibleBehind(IBinder token) throws RemoteException {
6644         Parcel data = Parcel.obtain();
6645         Parcel reply = Parcel.obtain();
6646         data.writeInterfaceToken(IActivityManager.descriptor);
6647         data.writeStrongBinder(token);
6648         mRemote.transact(IS_BACKGROUND_VISIBLE_BEHIND_TRANSACTION, data, reply, 0);
6649         reply.readException();
6650         final boolean visible = reply.readInt() > 0;
6651         data.recycle();
6652         reply.recycle();
6653         return visible;
6654     }
6655
6656     @Override
6657     public void backgroundResourcesReleased(IBinder token) throws RemoteException {
6658         Parcel data = Parcel.obtain();
6659         Parcel reply = Parcel.obtain();
6660         data.writeInterfaceToken(IActivityManager.descriptor);
6661         data.writeStrongBinder(token);
6662         mRemote.transact(BACKGROUND_RESOURCES_RELEASED_TRANSACTION, data, reply, 0);
6663         reply.readException();
6664         data.recycle();
6665         reply.recycle();
6666     }
6667
6668     @Override
6669     public void notifyLaunchTaskBehindComplete(IBinder token) throws RemoteException {
6670         Parcel data = Parcel.obtain();
6671         Parcel reply = Parcel.obtain();
6672         data.writeInterfaceToken(IActivityManager.descriptor);
6673         data.writeStrongBinder(token);
6674         mRemote.transact(NOTIFY_LAUNCH_TASK_BEHIND_COMPLETE_TRANSACTION, data, reply, 0);
6675         reply.readException();
6676         data.recycle();
6677         reply.recycle();
6678     }
6679
6680     @Override
6681     public void notifyEnterAnimationComplete(IBinder token) throws RemoteException {
6682         Parcel data = Parcel.obtain();
6683         Parcel reply = Parcel.obtain();
6684         data.writeInterfaceToken(IActivityManager.descriptor);
6685         data.writeStrongBinder(token);
6686         mRemote.transact(NOTIFY_ENTER_ANIMATION_COMPLETE_TRANSACTION, data, reply, 0);
6687         reply.readException();
6688         data.recycle();
6689         reply.recycle();
6690     }
6691
6692     @Override
6693     public void bootAnimationComplete() throws RemoteException {
6694         Parcel data = Parcel.obtain();
6695         Parcel reply = Parcel.obtain();
6696         data.writeInterfaceToken(IActivityManager.descriptor);
6697         mRemote.transact(BOOT_ANIMATION_COMPLETE_TRANSACTION, data, reply, 0);
6698         reply.readException();
6699         data.recycle();
6700         reply.recycle();
6701     }
6702
6703     @Override
6704     public void notifyCleartextNetwork(int uid, byte[] firstPacket) throws RemoteException {
6705         Parcel data = Parcel.obtain();
6706         Parcel reply = Parcel.obtain();
6707         data.writeInterfaceToken(IActivityManager.descriptor);
6708         data.writeInt(uid);
6709         data.writeByteArray(firstPacket);
6710         mRemote.transact(NOTIFY_CLEARTEXT_NETWORK_TRANSACTION, data, reply, 0);
6711         reply.readException();
6712         data.recycle();
6713         reply.recycle();
6714     }
6715
6716     @Override
6717     public void setDumpHeapDebugLimit(String processName, int uid, long maxMemSize,
6718             String reportPackage) throws RemoteException {
6719         Parcel data = Parcel.obtain();
6720         Parcel reply = Parcel.obtain();
6721         data.writeInterfaceToken(IActivityManager.descriptor);
6722         data.writeString(processName);
6723         data.writeInt(uid);
6724         data.writeLong(maxMemSize);
6725         data.writeString(reportPackage);
6726         mRemote.transact(SET_DUMP_HEAP_DEBUG_LIMIT_TRANSACTION, data, reply, 0);
6727         reply.readException();
6728         data.recycle();
6729         reply.recycle();
6730     }
6731
6732     @Override
6733     public void dumpHeapFinished(String path) throws RemoteException {
6734         Parcel data = Parcel.obtain();
6735         Parcel reply = Parcel.obtain();
6736         data.writeInterfaceToken(IActivityManager.descriptor);
6737         data.writeString(path);
6738         mRemote.transact(DUMP_HEAP_FINISHED_TRANSACTION, data, reply, 0);
6739         reply.readException();
6740         data.recycle();
6741         reply.recycle();
6742     }
6743
6744     @Override
6745     public void setVoiceKeepAwake(IVoiceInteractionSession session, boolean keepAwake)
6746             throws RemoteException {
6747         Parcel data = Parcel.obtain();
6748         Parcel reply = Parcel.obtain();
6749         data.writeInterfaceToken(IActivityManager.descriptor);
6750         data.writeStrongBinder(session.asBinder());
6751         data.writeInt(keepAwake ? 1 : 0);
6752         mRemote.transact(SET_VOICE_KEEP_AWAKE_TRANSACTION, data, reply, 0);
6753         reply.readException();
6754         data.recycle();
6755         reply.recycle();
6756     }
6757
6758     @Override
6759     public void updateLockTaskPackages(int userId, String[] packages) throws RemoteException {
6760         Parcel data = Parcel.obtain();
6761         Parcel reply = Parcel.obtain();
6762         data.writeInterfaceToken(IActivityManager.descriptor);
6763         data.writeInt(userId);
6764         data.writeStringArray(packages);
6765         mRemote.transact(UPDATE_LOCK_TASK_PACKAGES_TRANSACTION, data, reply, 0);
6766         reply.readException();
6767         data.recycle();
6768         reply.recycle();
6769     }
6770
6771     @Override
6772     public void updateDeviceOwner(String packageName) throws RemoteException {
6773         Parcel data = Parcel.obtain();
6774         Parcel reply = Parcel.obtain();
6775         data.writeInterfaceToken(IActivityManager.descriptor);
6776         data.writeString(packageName);
6777         mRemote.transact(UPDATE_DEVICE_OWNER_TRANSACTION, data, reply, 0);
6778         reply.readException();
6779         data.recycle();
6780         reply.recycle();
6781     }
6782
6783     @Override
6784     public int getPackageProcessState(String packageName, String callingPackage)
6785             throws RemoteException {
6786         Parcel data = Parcel.obtain();
6787         Parcel reply = Parcel.obtain();
6788         data.writeInterfaceToken(IActivityManager.descriptor);
6789         data.writeString(packageName);
6790         data.writeString(callingPackage);
6791         mRemote.transact(GET_PACKAGE_PROCESS_STATE_TRANSACTION, data, reply, 0);
6792         reply.readException();
6793         int res = reply.readInt();
6794         data.recycle();
6795         reply.recycle();
6796         return res;
6797     }
6798
6799     @Override
6800     public boolean setProcessMemoryTrimLevel(String process, int userId, int level)
6801             throws RemoteException {
6802         Parcel data = Parcel.obtain();
6803         Parcel reply = Parcel.obtain();
6804         data.writeInterfaceToken(IActivityManager.descriptor);
6805         data.writeString(process);
6806         data.writeInt(userId);
6807         data.writeInt(level);
6808         mRemote.transact(SET_PROCESS_MEMORY_TRIM_TRANSACTION, data, reply, 0);
6809         reply.readException();
6810         int res = reply.readInt();
6811         data.recycle();
6812         reply.recycle();
6813         return res != 0;
6814     }
6815
6816     @Override
6817     public boolean isRootVoiceInteraction(IBinder token) throws RemoteException {
6818         Parcel data = Parcel.obtain();
6819         Parcel reply = Parcel.obtain();
6820         data.writeInterfaceToken(IActivityManager.descriptor);
6821         data.writeStrongBinder(token);
6822         mRemote.transact(IS_ROOT_VOICE_INTERACTION_TRANSACTION, data, reply, 0);
6823         reply.readException();
6824         int res = reply.readInt();
6825         data.recycle();
6826         reply.recycle();
6827         return res != 0;
6828     }
6829
6830     @Override
6831     public void exitFreeformMode(IBinder token) throws RemoteException {
6832         Parcel data = Parcel.obtain();
6833         Parcel reply = Parcel.obtain();
6834         data.writeInterfaceToken(IActivityManager.descriptor);
6835         data.writeStrongBinder(token);
6836         mRemote.transact(EXIT_FREEFORM_MODE_TRANSACTION, data, reply, 0);
6837         reply.readException();
6838         data.recycle();
6839         reply.recycle();
6840     }
6841
6842     @Override
6843     public int getActivityStackId(IBinder token) throws RemoteException {
6844         Parcel data = Parcel.obtain();
6845         Parcel reply = Parcel.obtain();
6846         data.writeInterfaceToken(IActivityManager.descriptor);
6847         data.writeStrongBinder(token);
6848         mRemote.transact(GET_ACTIVITY_STACK_ID_TRANSACTION, data, reply, 0);
6849         reply.readException();
6850         int stackId = reply.readInt();
6851         data.recycle();
6852         reply.recycle();
6853         return stackId;
6854     }
6855
6856     @Override
6857     public void reportSizeConfigurations(IBinder token, int[] horizontalSizeConfiguration,
6858             int[] verticalSizeConfigurations, int[] smallestSizeConfigurations)
6859             throws RemoteException {
6860         Parcel data = Parcel.obtain();
6861         Parcel reply = Parcel.obtain();
6862         data.writeInterfaceToken(IActivityManager.descriptor);
6863         data.writeStrongBinder(token);
6864         writeIntArray(horizontalSizeConfiguration, data);
6865         writeIntArray(verticalSizeConfigurations, data);
6866         writeIntArray(smallestSizeConfigurations, data);
6867         mRemote.transact(REPORT_SIZE_CONFIGURATIONS, data, reply, 0);
6868         reply.readException();
6869         data.recycle();
6870         reply.recycle();
6871     }
6872
6873     private static void writeIntArray(int[] array, Parcel data) {
6874         if (array == null) {
6875             data.writeInt(0);
6876         } else {
6877             data.writeInt(array.length);
6878             data.writeIntArray(array);
6879         }
6880     }
6881
6882     @Override
6883     public void suppressResizeConfigChanges(boolean suppress) throws RemoteException {
6884         Parcel data = Parcel.obtain();
6885         Parcel reply = Parcel.obtain();
6886         data.writeInterfaceToken(IActivityManager.descriptor);
6887         data.writeInt(suppress ? 1 : 0);
6888         mRemote.transact(SUPPRESS_RESIZE_CONFIG_CHANGES_TRANSACTION, data, reply, 0);
6889         reply.readException();
6890         data.recycle();
6891         reply.recycle();
6892     }
6893
6894     @Override
6895     public void moveTasksToFullscreenStack(int fromStackId, boolean onTop) throws RemoteException {
6896         Parcel data = Parcel.obtain();
6897         Parcel reply = Parcel.obtain();
6898         data.writeInterfaceToken(IActivityManager.descriptor);
6899         data.writeInt(fromStackId);
6900         data.writeInt(onTop ? 1 : 0);
6901         mRemote.transact(MOVE_TASKS_TO_FULLSCREEN_STACK_TRANSACTION, data, reply, 0);
6902         reply.readException();
6903         data.recycle();
6904         reply.recycle();
6905     }
6906
6907     @Override
6908     public int getAppStartMode(int uid, String packageName) throws RemoteException {
6909         Parcel data = Parcel.obtain();
6910         Parcel reply = Parcel.obtain();
6911         data.writeInterfaceToken(IActivityManager.descriptor);
6912         data.writeInt(uid);
6913         data.writeString(packageName);
6914         mRemote.transact(GET_APP_START_MODE_TRANSACTION, data, reply, 0);
6915         reply.readException();
6916         int res = reply.readInt();
6917         data.recycle();
6918         reply.recycle();
6919         return res;
6920     }
6921
6922     @Override
6923     public boolean isInMultiWindowMode(IBinder token) throws RemoteException {
6924         Parcel data = Parcel.obtain();
6925         Parcel reply = Parcel.obtain();
6926         data.writeInterfaceToken(IActivityManager.descriptor);
6927         data.writeStrongBinder(token);
6928         mRemote.transact(IN_MULTI_WINDOW_TRANSACTION, data, reply, 0);
6929         reply.readException();
6930         final boolean multiWindowMode = reply.readInt() == 1 ? true : false;
6931         data.recycle();
6932         reply.recycle();
6933         return multiWindowMode;
6934     }
6935
6936     @Override
6937     public boolean isInPictureInPictureMode(IBinder token) throws RemoteException {
6938         Parcel data = Parcel.obtain();
6939         Parcel reply = Parcel.obtain();
6940         data.writeInterfaceToken(IActivityManager.descriptor);
6941         data.writeStrongBinder(token);
6942         mRemote.transact(IN_PICTURE_IN_PICTURE_TRANSACTION, data, reply, 0);
6943         reply.readException();
6944         final boolean pipMode = reply.readInt() == 1 ? true : false;
6945         data.recycle();
6946         reply.recycle();
6947         return pipMode;
6948     }
6949
6950     @Override
6951     public void enterPictureInPictureMode(IBinder token) throws RemoteException {
6952         Parcel data = Parcel.obtain();
6953         Parcel reply = Parcel.obtain();
6954         data.writeInterfaceToken(IActivityManager.descriptor);
6955         data.writeStrongBinder(token);
6956         mRemote.transact(ENTER_PICTURE_IN_PICTURE_TRANSACTION, data, reply, 0);
6957         reply.readException();
6958         data.recycle();
6959         reply.recycle();
6960     }
6961
6962     @Override
6963     public boolean isAppForeground(int uid) throws RemoteException {
6964         Parcel data = Parcel.obtain();
6965         Parcel reply = Parcel.obtain();
6966         data.writeInterfaceToken(IActivityManager.descriptor);
6967         data.writeInt(uid);
6968         mRemote.transact(IS_APP_FOREGROUND_TRANSACTION, data, reply, 0);
6969         final boolean isForeground = reply.readInt() == 1 ? true : false;
6970         data.recycle();
6971         reply.recycle();
6972         return isForeground;
6973     };
6974
6975     @Override
6976     public void notifyPinnedStackAnimationEnded() throws RemoteException {
6977         Parcel data = Parcel.obtain();
6978         Parcel reply = Parcel.obtain();
6979         data.writeInterfaceToken(IActivityManager.descriptor);
6980         mRemote.transact(NOTIFY_PINNED_STACK_ANIMATION_ENDED_TRANSACTION, data, reply, 0);
6981         data.recycle();
6982         reply.recycle();
6983     };
6984
6985     @Override
6986     public void removeStack(int stackId) throws RemoteException {
6987         Parcel data = Parcel.obtain();
6988         Parcel reply = Parcel.obtain();
6989         data.writeInterfaceToken(IActivityManager.descriptor);
6990         data.writeInt(stackId);
6991         mRemote.transact(REMOVE_STACK, data, reply, 0);
6992         reply.readException();
6993         data.recycle();
6994         reply.recycle();
6995     }
6996
6997     @Override
6998     public void notifyLockedProfile(@UserIdInt int userId) throws RemoteException {
6999         Parcel data = Parcel.obtain();
7000         Parcel reply = Parcel.obtain();
7001         data.writeInterfaceToken(IActivityManager.descriptor);
7002         data.writeInt(userId);
7003         mRemote.transact(NOTIFY_LOCKED_PROFILE, data, reply, 0);
7004         reply.readException();
7005         data.recycle();
7006         reply.recycle();
7007     }
7008
7009     @Override
7010     public void startConfirmDeviceCredentialIntent(Intent intent) throws RemoteException {
7011         Parcel data = Parcel.obtain();
7012         Parcel reply = Parcel.obtain();
7013         data.writeInterfaceToken(IActivityManager.descriptor);
7014         intent.writeToParcel(data, 0);
7015         mRemote.transact(START_CONFIRM_DEVICE_CREDENTIAL_INTENT, data, reply, 0);
7016         reply.readException();
7017         data.recycle();
7018         reply.recycle();
7019     }
7020
7021     @Override
7022     public int sendIntentSender(IIntentSender target, int code, Intent intent, String resolvedType,
7023             IIntentReceiver finishedReceiver, String requiredPermission, Bundle options)
7024             throws RemoteException {
7025         Parcel data = Parcel.obtain();
7026         Parcel reply = Parcel.obtain();
7027         data.writeInterfaceToken(IActivityManager.descriptor);
7028         data.writeStrongBinder(target.asBinder());
7029         data.writeInt(code);
7030         if ((intent!=null)) {
7031             data.writeInt(1);
7032             intent.writeToParcel(data, 0);
7033         }
7034         else {
7035             data.writeInt(0);
7036         }
7037         data.writeString(resolvedType);
7038         data.writeStrongBinder((((finishedReceiver!=null))?(finishedReceiver.asBinder()):(null)));
7039         data.writeString(requiredPermission);
7040         if ((options!=null)) {
7041             data.writeInt(1);
7042             options.writeToParcel(data, 0);
7043         }
7044         else {
7045             data.writeInt(0);
7046         }
7047         mRemote.transact(SEND_INTENT_SENDER_TRANSACTION, data, reply, 0);
7048         reply.readException();
7049         final int res = reply.readInt();
7050         data.recycle();
7051         reply.recycle();
7052         return res;
7053     }
7054
7055     @Override
7056     public void setVrThread(int tid)
7057         throws RemoteException {
7058         Parcel data = Parcel.obtain();
7059         Parcel reply = Parcel.obtain();
7060         data.writeInterfaceToken(IActivityManager.descriptor);
7061         data.writeInt(tid);
7062         mRemote.transact(SET_VR_THREAD_TRANSACTION, data, reply, 0);
7063         reply.readException();
7064         data.recycle();
7065         reply.recycle();
7066         return;
7067     }
7068
7069     public void setRenderThread(int tid)
7070         throws RemoteException {
7071         Parcel data = Parcel.obtain();
7072         Parcel reply = Parcel.obtain();
7073         data.writeInterfaceToken(IActivityManager.descriptor);
7074         data.writeInt(tid);
7075         mRemote.transact(SET_RENDER_THREAD_TRANSACTION, data, reply, 0);
7076         reply.readException();
7077         data.recycle();
7078         reply.recycle();
7079         return;
7080     }
7081
7082     public void setHasTopUi(boolean hasTopUi)
7083             throws RemoteException {
7084         Parcel data = Parcel.obtain();
7085         Parcel reply = Parcel.obtain();
7086         data.writeInterfaceToken(IActivityManager.descriptor);
7087         data.writeInt(hasTopUi ? 1 : 0);
7088         mRemote.transact(SET_HAS_TOP_UI, data, reply, 0);
7089         reply.readException();
7090         data.recycle();
7091         reply.recycle();
7092         return;
7093     }
7094
7095     private IBinder mRemote;
7096 }