devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android开发者，必须知道的并且没有遇到的异常，附带简单的解决方案和异常过程、源码的分析从java层到Jni层_start_activity_as_caller

作者：知新_RL | 2024-03-15 23:33:29

赞

踩

start_activity_as_caller

在android开发的过程中异常几乎是家常小菜了，常见的异常估计就那些大家熟知的，那今天博主给大家分享一个作为一个开发者很少遇到的异常，再

此之前都不知道android系统居然还有这样的限制，今天就把这个排错的过程以及源码的分享给大家分享一下，希望大家在以后开发的过程中遇到类似

问题有一个参考！


需求的过程：

首先我把问题产生的过程大致描述一遍，我们的项目中有一个关于行车轨迹回放的功能，而这个功能的需求是这样的，当用户选择一个最近30天的日期，程序根据

该日期去服务器获取该日期的轨迹数据包，这个包通常情况下会很大，平均每天大概80000多个点，程序获取成功后会得到json数据，项目的架构是在fragment下

将数据以Intent.putExtras函数将Bundle传递给activity，activity拿到数据后，先解析json然后将轨迹数据解密，重新封装，再将封装好的数据传递给自定义的绘制控

制，让笔者自己封装的控件进行绘制轨迹线路，在用一个小车切图的marker进行移动动画展示给用户，这就是这个功能的大致实现了


问题的产生：

在fragment拿到数据后通过Bundle.putString(key,JSONObject.toString());将数据存好，在Intent.putExtras(Bundle);然后通过 getContext().startActivity跳转到我的

activity，将数据给到activity，在跳转的过程发生闪退，并且这个现象在所有的android手机上可以复现，100%复现，并且 activity onCreate()函数没被调用，我开始

觉得诡异，就怀疑是不是轨迹点有问题？我去后台查了当天的轨迹数据，发现没有任何问题，只是点太多了而已，然后继续回到程序中，检测代码，代码也没有任

何错误跟逻辑问题，我并开始怀疑是不是Intent或者是Bundle携带的数据过大导致的，我就打开Linux查看android源码，发现这这两个类的存储函数是没有大小限制

的，于是乎开始怀疑getContext().startActivity(Intent)函数,因为公司测试人员的手机没有打开开发者模式，并且属于深度定制，于是笔者将程序安装在了一个MTK方

案上的手机上，叫来了自己的同事一起来看这个问题，同事把log写到了本地，结果

发现确实是getContext().startActivity(Intent)函数引起的，由于传递的包过大导致程序进程被kill掉了


异常的log截图：



源码的分析(底层启动activity的机制)：

我们分序号来一个一个得看调用关系，这样会理得清楚一点，根据先后调用，序号递增排列

① 调用 com.android.server.am.ActivityManagerService 的 onTransact 函数，而该函数super.onTransact也就是其父类的onTransact函数，其父类 android.app.ActivityManagerNative

com.android.server.am.ActivityManagerService 的 onTransact 函数代码：

  1.     @Override
  2.     public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
  3.             throws RemoteException {
  4.         if (code == SYSPROPS_TRANSACTION) {
  5.             // We need to tell all apps about the system property change.
  6.             ArrayList<IBinder> procs = new ArrayList<IBinder>();
  7.             synchronized(this) {
  8.                 final int NP = mProcessNames.getMap().size();
  9.                 for (int ip=0; ip<NP; ip++) {
  10.                     SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip);
  11.                     final int NA = apps.size();
  12.                     for (int ia=0; ia<NA; ia++) {
  13.                         ProcessRecord app = apps.valueAt(ia);
  14.                         if (app.thread != null) {
  15.                             procs.add(app.thread.asBinder());
  16.                         }
  17.                     }
  18.                 }
  19.             }
  20.  
  21.             int N = procs.size();
  22.             for (int i=0; i<N; i++) {
  23.                 Parcel data2 = Parcel.obtain();
  24.                 try {
  25.                     procs.get(i).transact(IBinder.SYSPROPS_TRANSACTION, data2, null, 0);
  26.                 } catch (RemoteException e) {
  27.                 }
  28.                 data2.recycle();
  29.             }
  30.         }
  31.         try {
  32.             return super.onTransact(code, data, reply, flags);
  33.         } catch (RuntimeException e) {
  34.             // The activity manager only throws security exceptions, so let's
  35.             // log all others.
  36.             if (!(e instanceof SecurityException)) {
  37.                 Slog.wtf(TAG, "Activity Manager Crash", e);
  38.             }
  39.             throw e;
  40.         }
  41.     }


android.app.ActivityManagerNative 的 onTransact 函数代码：

注意：该函数代码贼长...，读者可以直接跳跃到case ATTACH_APPLICATION_TRANSACTION 那里

  1.     @Override
  2.     public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
  3.             throws RemoteException {
  4.         switch (code) {
  5.         case START_ACTIVITY_TRANSACTION:
  6.         {
  7.             data.enforceInterface(IActivityManager.descriptor);
  8.             IBinder b = data.readStrongBinder();
  9.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  10.             String callingPackage = data.readString();
  11.             Intent intent = Intent.CREATOR.createFromParcel(data);
  12.             String resolvedType = data.readString();
  13.             IBinder resultTo = data.readStrongBinder();
  14.             String resultWho = data.readString();
  15.             int requestCode = data.readInt();
  16.             int startFlags = data.readInt();
  17.             ProfilerInfo profilerInfo = data.readInt() != 0
  18.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  19.             Bundle options = data.readInt() != 0
  20.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  21.             int result = startActivity(app, callingPackage, intent, resolvedType,
  22.                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
  23.             reply.writeNoException();
  24.             reply.writeInt(result);
  25.             return true;
  26.         }
  27.  
  28.         case START_ACTIVITY_AS_USER_TRANSACTION:
  29.         {
  30.             data.enforceInterface(IActivityManager.descriptor);
  31.             IBinder b = data.readStrongBinder();
  32.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  33.             String callingPackage = data.readString();
  34.             Intent intent = Intent.CREATOR.createFromParcel(data);
  35.             String resolvedType = data.readString();
  36.             IBinder resultTo = data.readStrongBinder();
  37.             String resultWho = data.readString();
  38.             int requestCode = data.readInt();
  39.             int startFlags = data.readInt();
  40.             ProfilerInfo profilerInfo = data.readInt() != 0
  41.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  42.             Bundle options = data.readInt() != 0
  43.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  44.             int userId = data.readInt();
  45.             int result = startActivityAsUser(app, callingPackage, intent, resolvedType,
  46.                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options, userId);
  47.             reply.writeNoException();
  48.             reply.writeInt(result);
  49.             return true;
  50.         }
  51.  
  52.         case START_ACTIVITY_AS_CALLER_TRANSACTION:
  53.         {
  54.             data.enforceInterface(IActivityManager.descriptor);
  55.             IBinder b = data.readStrongBinder();
  56.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  57.             String callingPackage = data.readString();
  58.             Intent intent = Intent.CREATOR.createFromParcel(data);
  59.             String resolvedType = data.readString();
  60.             IBinder resultTo = data.readStrongBinder();
  61.             String resultWho = data.readString();
  62.             int requestCode = data.readInt();
  63.             int startFlags = data.readInt();
  64.             ProfilerInfo profilerInfo = data.readInt() != 0
  65.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  66.             Bundle options = data.readInt() != 0
  67.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  68.             boolean ignoreTargetSecurity = data.readInt() != 0;
  69.             int userId = data.readInt();
  70.             int result = startActivityAsCaller(app, callingPackage, intent, resolvedType,
  71.                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options,
  72.                     ignoreTargetSecurity, userId);
  73.             reply.writeNoException();
  74.             reply.writeInt(result);
  75.             return true;
  76.         }
  77.  
  78.         case START_ACTIVITY_AND_WAIT_TRANSACTION:
  79.         {
  80.             data.enforceInterface(IActivityManager.descriptor);
  81.             IBinder b = data.readStrongBinder();
  82.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  83.             String callingPackage = data.readString();
  84.             Intent intent = Intent.CREATOR.createFromParcel(data);
  85.             String resolvedType = data.readString();
  86.             IBinder resultTo = data.readStrongBinder();
  87.             String resultWho = data.readString();
  88.             int requestCode = data.readInt();
  89.             int startFlags = data.readInt();
  90.             ProfilerInfo profilerInfo = data.readInt() != 0
  91.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  92.             Bundle options = data.readInt() != 0
  93.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  94.             int userId = data.readInt();
  95.             WaitResult result = startActivityAndWait(app, callingPackage, intent, resolvedType,
  96.                     resultTo, resultWho, requestCode, startFlags, profilerInfo, options, userId);
  97.             reply.writeNoException();
  98.             result.writeToParcel(reply, 0);
  99.             return true;
  100.         }
  101.  
  102.         case START_ACTIVITY_WITH_CONFIG_TRANSACTION:
  103.         {
  104.             data.enforceInterface(IActivityManager.descriptor);
  105.             IBinder b = data.readStrongBinder();
  106.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  107.             String callingPackage = data.readString();
  108.             Intent intent = Intent.CREATOR.createFromParcel(data);
  109.             String resolvedType = data.readString();
  110.             IBinder resultTo = data.readStrongBinder();
  111.             String resultWho = data.readString();
  112.             int requestCode = data.readInt();
  113.             int startFlags = data.readInt();
  114.             Configuration config = Configuration.CREATOR.createFromParcel(data);
  115.             Bundle options = data.readInt() != 0
  116.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  117.             int userId = data.readInt();
  118.             int result = startActivityWithConfig(app, callingPackage, intent, resolvedType,
  119.                     resultTo, resultWho, requestCode, startFlags, config, options, userId);
  120.             reply.writeNoException();
  121.             reply.writeInt(result);
  122.             return true;
  123.         }
  124.  
  125.         case START_ACTIVITY_INTENT_SENDER_TRANSACTION:
  126.         {
  127.             data.enforceInterface(IActivityManager.descriptor);
  128.             IBinder b = data.readStrongBinder();
  129.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  130.             IntentSender intent = IntentSender.CREATOR.createFromParcel(data);
  131.             Intent fillInIntent = null;
  132.             if (data.readInt() != 0) {
  133.                 fillInIntent = Intent.CREATOR.createFromParcel(data);
  134.             }
  135.             String resolvedType = data.readString();
  136.             IBinder resultTo = data.readStrongBinder();
  137.             String resultWho = data.readString();
  138.             int requestCode = data.readInt();
  139.             int flagsMask = data.readInt();
  140.             int flagsValues = data.readInt();
  141.             Bundle options = data.readInt() != 0
  142.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  143.             int result = startActivityIntentSender(app, intent,
  144.                     fillInIntent, resolvedType, resultTo, resultWho,
  145.                     requestCode, flagsMask, flagsValues, options);
  146.             reply.writeNoException();
  147.             reply.writeInt(result);
  148.             return true;
  149.         }
  150.  
  151.         case START_VOICE_ACTIVITY_TRANSACTION:
  152.         {
  153.             data.enforceInterface(IActivityManager.descriptor);
  154.             String callingPackage = data.readString();
  155.             int callingPid = data.readInt();
  156.             int callingUid = data.readInt();
  157.             Intent intent = Intent.CREATOR.createFromParcel(data);
  158.             String resolvedType = data.readString();
  159.             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
  160.                     data.readStrongBinder());
  161.             IVoiceInteractor interactor = IVoiceInteractor.Stub.asInterface(
  162.                     data.readStrongBinder());
  163.             int startFlags = data.readInt();
  164.             ProfilerInfo profilerInfo = data.readInt() != 0
  165.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  166.             Bundle options = data.readInt() != 0
  167.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  168.             int userId = data.readInt();
  169.             int result = startVoiceActivity(callingPackage, callingPid, callingUid, intent,
  170.                     resolvedType, session, interactor, startFlags, profilerInfo, options, userId);
  171.             reply.writeNoException();
  172.             reply.writeInt(result);
  173.             return true;
  174.         }
  175.  
  176.         case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
  177.         {
  178.             data.enforceInterface(IActivityManager.descriptor);
  179.             IBinder callingActivity = data.readStrongBinder();
  180.             Intent intent = Intent.CREATOR.createFromParcel(data);
  181.             Bundle options = data.readInt() != 0
  182.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  183.             boolean result = startNextMatchingActivity(callingActivity, intent, options);
  184.             reply.writeNoException();
  185.             reply.writeInt(result ? 1 : 0);
  186.             return true;
  187.         }
  188.  
  189.         case START_ACTIVITY_FROM_RECENTS_TRANSACTION:
  190.         {
  191.             data.enforceInterface(IActivityManager.descriptor);
  192.             int taskId = data.readInt();
  193.             Bundle options = data.readInt() == 0 ? null : Bundle.CREATOR.createFromParcel(data);
  194.             int result = startActivityFromRecents(taskId, options);
  195.             reply.writeNoException();
  196.             reply.writeInt(result);
  197.             return true;
  198.         }
  199.  
  200.         case FINISH_ACTIVITY_TRANSACTION: {
  201.             data.enforceInterface(IActivityManager.descriptor);
  202.             IBinder token = data.readStrongBinder();
  203.             Intent resultData = null;
  204.             int resultCode = data.readInt();
  205.             if (data.readInt() != 0) {
  206.                 resultData = Intent.CREATOR.createFromParcel(data);
  207.             }
  208.             boolean finishTask = (data.readInt() != 0);
  209.             boolean res = finishActivity(token, resultCode, resultData, finishTask);
  210.             reply.writeNoException();
  211.             reply.writeInt(res ? 1 : 0);
  212.             return true;
  213.         }
  214.  
  215.         case FINISH_SUB_ACTIVITY_TRANSACTION: {
  216.             data.enforceInterface(IActivityManager.descriptor);
  217.             IBinder token = data.readStrongBinder();
  218.             String resultWho = data.readString();
  219.             int requestCode = data.readInt();
  220.             finishSubActivity(token, resultWho, requestCode);
  221.             reply.writeNoException();
  222.             return true;
  223.         }
  224.  
  225.         case FINISH_ACTIVITY_AFFINITY_TRANSACTION: {
  226.             data.enforceInterface(IActivityManager.descriptor);
  227.             IBinder token = data.readStrongBinder();
  228.             boolean res = finishActivityAffinity(token);
  229.             reply.writeNoException();
  230.             reply.writeInt(res ? 1 : 0);
  231.             return true;
  232.         }
  233.  
  234.         case FINISH_VOICE_TASK_TRANSACTION: {
  235.             data.enforceInterface(IActivityManager.descriptor);
  236.             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
  237.                     data.readStrongBinder());
  238.             finishVoiceTask(session);
  239.             reply.writeNoException();
  240.             return true;
  241.         }
  242.  
  243.         case RELEASE_ACTIVITY_INSTANCE_TRANSACTION: {
  244.             data.enforceInterface(IActivityManager.descriptor);
  245.             IBinder token = data.readStrongBinder();
  246.             boolean res = releaseActivityInstance(token);
  247.             reply.writeNoException();
  248.             reply.writeInt(res ? 1 : 0);
  249.             return true;
  250.         }
  251.  
  252.         case RELEASE_SOME_ACTIVITIES_TRANSACTION: {
  253.             data.enforceInterface(IActivityManager.descriptor);
  254.             IApplicationThread app = ApplicationThreadNative.asInterface(data.readStrongBinder());
  255.             releaseSomeActivities(app);
  256.             reply.writeNoException();
  257.             return true;
  258.         }
  259.  
  260.         case WILL_ACTIVITY_BE_VISIBLE_TRANSACTION: {
  261.             data.enforceInterface(IActivityManager.descriptor);
  262.             IBinder token = data.readStrongBinder();
  263.             boolean res = willActivityBeVisible(token);
  264.             reply.writeNoException();
  265.             reply.writeInt(res ? 1 : 0);
  266.             return true;
  267.         }
  268.  
  269.         case REGISTER_RECEIVER_TRANSACTION:
  270.         {
  271.             data.enforceInterface(IActivityManager.descriptor);
  272.             IBinder b = data.readStrongBinder();
  273.             IApplicationThread app =
  274.                 b != null ? ApplicationThreadNative.asInterface(b) : null;
  275.             String packageName = data.readString();
  276.             b = data.readStrongBinder();
  277.             IIntentReceiver rec
  278.                 = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
  279.             IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
  280.             String perm = data.readString();
  281.             int userId = data.readInt();
  282.             Intent intent = registerReceiver(app, packageName, rec, filter, perm, userId);
  283.             reply.writeNoException();
  284.             if (intent != null) {
  285.                 reply.writeInt(1);
  286.                 intent.writeToParcel(reply, 0);
  287.             } else {
  288.                 reply.writeInt(0);
  289.             }
  290.             return true;
  291.         }
  292.  
  293.         case UNREGISTER_RECEIVER_TRANSACTION:
  294.         {
  295.             data.enforceInterface(IActivityManager.descriptor);
  296.             IBinder b = data.readStrongBinder();
  297.             if (b == null) {
  298.                 return true;
  299.             }
  300.             IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
  301.             unregisterReceiver(rec);
  302.             reply.writeNoException();
  303.             return true;
  304.         }
  305.  
  306.         case BROADCAST_INTENT_TRANSACTION:
  307.         {
  308.             data.enforceInterface(IActivityManager.descriptor);
  309.             IBinder b = data.readStrongBinder();
  310.             IApplicationThread app =
  311.                 b != null ? ApplicationThreadNative.asInterface(b) : null;
  312.             Intent intent = Intent.CREATOR.createFromParcel(data);
  313.             String resolvedType = data.readString();
  314.             b = data.readStrongBinder();
  315.             IIntentReceiver resultTo =
  316.                 b != null ? IIntentReceiver.Stub.asInterface(b) : null;
  317.             int resultCode = data.readInt();
  318.             String resultData = data.readString();
  319.             Bundle resultExtras = data.readBundle();
  320.             String[] perms = data.readStringArray();
  321.             int appOp = data.readInt();
  322.             Bundle options = data.readBundle();
  323.             boolean serialized = data.readInt() != 0;
  324.             boolean sticky = data.readInt() != 0;
  325.             int userId = data.readInt();
  326.             int res = broadcastIntent(app, intent, resolvedType, resultTo,
  327.                     resultCode, resultData, resultExtras, perms, appOp,
  328.                     options, serialized, sticky, userId);
  329.             reply.writeNoException();
  330.             reply.writeInt(res);
  331.             return true;
  332.         }
  333.  
  334.         case UNBROADCAST_INTENT_TRANSACTION:
  335.         {
  336.             data.enforceInterface(IActivityManager.descriptor);
  337.             IBinder b = data.readStrongBinder();
  338.             IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
  339.             Intent intent = Intent.CREATOR.createFromParcel(data);
  340.             int userId = data.readInt();
  341.             unbroadcastIntent(app, intent, userId);
  342.             reply.writeNoException();
  343.             return true;
  344.         }
  345.  
  346.         case FINISH_RECEIVER_TRANSACTION: {
  347.             data.enforceInterface(IActivityManager.descriptor);
  348.             IBinder who = data.readStrongBinder();
  349.             int resultCode = data.readInt();
  350.             String resultData = data.readString();
  351.             Bundle resultExtras = data.readBundle();
  352.             boolean resultAbort = data.readInt() != 0;
  353.             int intentFlags = data.readInt();
  354.             if (who != null) {
  355.                 finishReceiver(who, resultCode, resultData, resultExtras, resultAbort, intentFlags);
  356.             }
  357.             reply.writeNoException();
  358.             return true;
  359.         }
  360.  
  361.         case ATTACH_APPLICATION_TRANSACTION: {
  362.             data.enforceInterface(IActivityManager.descriptor);
  363.             IApplicationThread app = ApplicationThreadNative.asInterface(
  364.                     data.readStrongBinder());
  365.             if (app != null) {
  366.                 attachApplication(app);
  367.             }
  368.             reply.writeNoException();
  369.             return true;
  370.         }
  371.  
  372.         case ACTIVITY_IDLE_TRANSACTION: {
  373.             data.enforceInterface(IActivityManager.descriptor);
  374.             IBinder token = data.readStrongBinder();
  375.             Configuration config = null;
  376.             if (data.readInt() != 0) {
  377.                 config = Configuration.CREATOR.createFromParcel(data);
  378.             }
  379.             boolean stopProfiling = data.readInt() != 0;
  380.             if (token != null) {
  381.                 activityIdle(token, config, stopProfiling);
  382.             }
  383.             reply.writeNoException();
  384.             return true;
  385.         }
  386.  
  387.         case ACTIVITY_RESUMED_TRANSACTION: {
  388.             data.enforceInterface(IActivityManager.descriptor);
  389.             IBinder token = data.readStrongBinder();
  390.             activityResumed(token);
  391.             reply.writeNoException();
  392.             return true;
  393.         }
  394.  
  395.         case ACTIVITY_PAUSED_TRANSACTION: {
  396.             data.enforceInterface(IActivityManager.descriptor);
  397.             IBinder token = data.readStrongBinder();
  398.             activityPaused(token);
  399.             reply.writeNoException();
  400.             return true;
  401.         }
  402.  
  403.         case ACTIVITY_STOPPED_TRANSACTION: {
  404.             data.enforceInterface(IActivityManager.descriptor);
  405.             IBinder token = data.readStrongBinder();
  406.             Bundle map = data.readBundle();
  407.             PersistableBundle persistentState = data.readPersistableBundle();
  408.             CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
  409.             activityStopped(token, map, persistentState, description);
  410.             reply.writeNoException();
  411.             return true;
  412.         }
  413.  
  414.         case ACTIVITY_SLEPT_TRANSACTION: {
  415.             data.enforceInterface(IActivityManager.descriptor);
  416.             IBinder token = data.readStrongBinder();
  417.             activitySlept(token);
  418.             reply.writeNoException();
  419.             return true;
  420.         }
  421.  
  422.         case ACTIVITY_DESTROYED_TRANSACTION: {
  423.             data.enforceInterface(IActivityManager.descriptor);
  424.             IBinder token = data.readStrongBinder();
  425.             activityDestroyed(token);
  426.             reply.writeNoException();
  427.             return true;
  428.         }
  429.  
  430.         case GET_CALLING_PACKAGE_TRANSACTION: {
  431.             data.enforceInterface(IActivityManager.descriptor);
  432.             IBinder token = data.readStrongBinder();
  433.             String res = token != null ? getCallingPackage(token) : null;
  434.             reply.writeNoException();
  435.             reply.writeString(res);
  436.             return true;
  437.         }
  438.  
  439.         case GET_CALLING_ACTIVITY_TRANSACTION: {
  440.             data.enforceInterface(IActivityManager.descriptor);
  441.             IBinder token = data.readStrongBinder();
  442.             ComponentName cn = getCallingActivity(token);
  443.             reply.writeNoException();
  444.             ComponentName.writeToParcel(cn, reply);
  445.             return true;
  446.         }
  447.  
  448.         case GET_APP_TASKS_TRANSACTION: {
  449.             data.enforceInterface(IActivityManager.descriptor);
  450.             String callingPackage = data.readString();
  451.             List<IAppTask> list = getAppTasks(callingPackage);
  452.             reply.writeNoException();
  453.             int N = list != null ? list.size() : -1;
  454.             reply.writeInt(N);
  455.             int i;
  456.             for (i=0; i<N; i++) {
  457.                 IAppTask task = list.get(i);
  458.                 reply.writeStrongBinder(task.asBinder());
  459.             }
  460.             return true;
  461.         }
  462.  
  463.         case ADD_APP_TASK_TRANSACTION: {
  464.             data.enforceInterface(IActivityManager.descriptor);
  465.             IBinder activityToken = data.readStrongBinder();
  466.             Intent intent = Intent.CREATOR.createFromParcel(data);
  467.             ActivityManager.TaskDescription descr
  468.                     = ActivityManager.TaskDescription.CREATOR.createFromParcel(data);
  469.             Bitmap thumbnail = Bitmap.CREATOR.createFromParcel(data);
  470.             int res = addAppTask(activityToken, intent, descr, thumbnail);
  471.             reply.writeNoException();
  472.             reply.writeInt(res);
  473.             return true;
  474.         }
  475.  
  476.         case GET_APP_TASK_THUMBNAIL_SIZE_TRANSACTION: {
  477.             data.enforceInterface(IActivityManager.descriptor);
  478.             Point size = getAppTaskThumbnailSize();
  479.             reply.writeNoException();
  480.             size.writeToParcel(reply, 0);
  481.             return true;
  482.         }
  483.  
  484.         case GET_TASKS_TRANSACTION: {
  485.             data.enforceInterface(IActivityManager.descriptor);
  486.             int maxNum = data.readInt();
  487.             int fl = data.readInt();
  488.             List<ActivityManager.RunningTaskInfo> list = getTasks(maxNum, fl);
  489.             reply.writeNoException();
  490.             int N = list != null ? list.size() : -1;
  491.             reply.writeInt(N);
  492.             int i;
  493.             for (i=0; i<N; i++) {
  494.                 ActivityManager.RunningTaskInfo info = list.get(i);
  495.                 info.writeToParcel(reply, 0);
  496.             }
  497.             return true;
  498.         }
  499.  
  500.         case GET_RECENT_TASKS_TRANSACTION: {
  501.             data.enforceInterface(IActivityManager.descriptor);
  502.             int maxNum = data.readInt();
  503.             int fl = data.readInt();
  504.             int userId = data.readInt();
  505.             List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
  506.                     fl, userId);
  507.             reply.writeNoException();
  508.             reply.writeTypedList(list);
  509.             return true;
  510.         }
  511.  
  512.         case GET_TASK_THUMBNAIL_TRANSACTION: {
  513.             data.enforceInterface(IActivityManager.descriptor);
  514.             int id = data.readInt();
  515.             ActivityManager.TaskThumbnail taskThumbnail = getTaskThumbnail(id);
  516.             reply.writeNoException();
  517.             if (taskThumbnail != null) {
  518.                 reply.writeInt(1);
  519.                 taskThumbnail.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  520.             } else {
  521.                 reply.writeInt(0);
  522.             }
  523.             return true;
  524.         }
  525.  
  526.         case GET_SERVICES_TRANSACTION: {
  527.             data.enforceInterface(IActivityManager.descriptor);
  528.             int maxNum = data.readInt();
  529.             int fl = data.readInt();
  530.             List<ActivityManager.RunningServiceInfo> list = getServices(maxNum, fl);
  531.             reply.writeNoException();
  532.             int N = list != null ? list.size() : -1;
  533.             reply.writeInt(N);
  534.             int i;
  535.             for (i=0; i<N; i++) {
  536.                 ActivityManager.RunningServiceInfo info = list.get(i);
  537.                 info.writeToParcel(reply, 0);
  538.             }
  539.             return true;
  540.         }
  541.  
  542.         case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION: {
  543.             data.enforceInterface(IActivityManager.descriptor);
  544.             List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
  545.             reply.writeNoException();
  546.             reply.writeTypedList(list);
  547.             return true;
  548.         }
  549.  
  550.         case GET_RUNNING_APP_PROCESSES_TRANSACTION: {
  551.             data.enforceInterface(IActivityManager.descriptor);
  552.             List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
  553.             reply.writeNoException();
  554.             reply.writeTypedList(list);
  555.             return true;
  556.         }
  557.  
  558.         case GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION: {
  559.             data.enforceInterface(IActivityManager.descriptor);
  560.             List<ApplicationInfo> list = getRunningExternalApplications();
  561.             reply.writeNoException();
  562.             reply.writeTypedList(list);
  563.             return true;
  564.         }
  565.  
  566.         case MOVE_TASK_TO_FRONT_TRANSACTION: {
  567.             data.enforceInterface(IActivityManager.descriptor);
  568.             int task = data.readInt();
  569.             int fl = data.readInt();
  570.             Bundle options = data.readInt() != 0
  571.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  572.             moveTaskToFront(task, fl, options);
  573.             reply.writeNoException();
  574.             return true;
  575.         }
  576.  
  577.         case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION: {
  578.             data.enforceInterface(IActivityManager.descriptor);
  579.             IBinder token = data.readStrongBinder();
  580.             boolean nonRoot = data.readInt() != 0;
  581.             boolean res = moveActivityTaskToBack(token, nonRoot);
  582.             reply.writeNoException();
  583.             reply.writeInt(res ? 1 : 0);
  584.             return true;
  585.         }
  586.  
  587.         case MOVE_TASK_BACKWARDS_TRANSACTION: {
  588.             data.enforceInterface(IActivityManager.descriptor);
  589.             int task = data.readInt();
  590.             moveTaskBackwards(task);
  591.             reply.writeNoException();
  592.             return true;
  593.         }
  594.  
  595.         case MOVE_TASK_TO_STACK_TRANSACTION: {
  596.             data.enforceInterface(IActivityManager.descriptor);
  597.             int taskId = data.readInt();
  598.             int stackId = data.readInt();
  599.             boolean toTop = data.readInt() != 0;
  600.             moveTaskToStack(taskId, stackId, toTop);
  601.             reply.writeNoException();
  602.             return true;
  603.         }
  604.  
  605.         case RESIZE_STACK_TRANSACTION: {
  606.             data.enforceInterface(IActivityManager.descriptor);
  607.             int stackId = data.readInt();
  608.             Rect r = Rect.CREATOR.createFromParcel(data);
  609.             resizeStack(stackId, r);
  610.             reply.writeNoException();
  611.             return true;
  612.         }
  613.  
  614.         case GET_ALL_STACK_INFOS_TRANSACTION: {
  615.             data.enforceInterface(IActivityManager.descriptor);
  616.             List<StackInfo> list = getAllStackInfos();
  617.             reply.writeNoException();
  618.             reply.writeTypedList(list);
  619.             return true;
  620.         }
  621.  
  622.         case GET_STACK_INFO_TRANSACTION: {
  623.             data.enforceInterface(IActivityManager.descriptor);
  624.             int stackId = data.readInt();
  625.             StackInfo info = getStackInfo(stackId);
  626.             reply.writeNoException();
  627.             if (info != null) {
  628.                 reply.writeInt(1);
  629.                 info.writeToParcel(reply, 0);
  630.             } else {
  631.                 reply.writeInt(0);
  632.             }
  633.             return true;
  634.         }
  635.  
  636.         case IS_IN_HOME_STACK_TRANSACTION: {
  637.             data.enforceInterface(IActivityManager.descriptor);
  638.             int taskId = data.readInt();
  639.             boolean isInHomeStack = isInHomeStack(taskId);
  640.             reply.writeNoException();
  641.             reply.writeInt(isInHomeStack ? 1 : 0);
  642.             return true;
  643.         }
  644.  
  645.         case SET_FOCUSED_STACK_TRANSACTION: {
  646.             data.enforceInterface(IActivityManager.descriptor);
  647.             int stackId = data.readInt();
  648.             setFocusedStack(stackId);
  649.             reply.writeNoException();
  650.             return true;
  651.         }
  652.  
  653.         case GET_FOCUSED_STACK_ID_TRANSACTION: {
  654.             data.enforceInterface(IActivityManager.descriptor);
  655.             int focusedStackId = getFocusedStackId();
  656.             reply.writeNoException();
  657.             reply.writeInt(focusedStackId);
  658.             return true;
  659.         }
  660.  
  661.         case REGISTER_TASK_STACK_LISTENER_TRANSACTION: {
  662.             data.enforceInterface(IActivityManager.descriptor);
  663.             IBinder token = data.readStrongBinder();
  664.             registerTaskStackListener(ITaskStackListener.Stub.asInterface(token));
  665.             reply.writeNoException();
  666.             return true;
  667.         }
  668.  
  669.         case GET_TASK_FOR_ACTIVITY_TRANSACTION: {
  670.             data.enforceInterface(IActivityManager.descriptor);
  671.             IBinder token = data.readStrongBinder();
  672.             boolean onlyRoot = data.readInt() != 0;
  673.             int res = token != null
  674.                 ? getTaskForActivity(token, onlyRoot) : -1;
  675.                 reply.writeNoException();
  676.             reply.writeInt(res);
  677.             return true;
  678.         }
  679.  
  680.         case GET_CONTENT_PROVIDER_TRANSACTION: {
  681.             data.enforceInterface(IActivityManager.descriptor);
  682.             IBinder b = data.readStrongBinder();
  683.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  684.             String name = data.readString();
  685.             int userId = data.readInt();
  686.             boolean stable = data.readInt() != 0;
  687.             ContentProviderHolder cph = getContentProvider(app, name, userId, stable);
  688.             reply.writeNoException();
  689.             if (cph != null) {
  690.                 reply.writeInt(1);
  691.                 cph.writeToParcel(reply, 0);
  692.             } else {
  693.                 reply.writeInt(0);
  694.             }
  695.             return true;
  696.         }
  697.  
  698.         case GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
  699.             data.enforceInterface(IActivityManager.descriptor);
  700.             String name = data.readString();
  701.             int userId = data.readInt();
  702.             IBinder token = data.readStrongBinder();
  703.             ContentProviderHolder cph = getContentProviderExternal(name, userId, token);
  704.             reply.writeNoException();
  705.             if (cph != null) {
  706.                 reply.writeInt(1);
  707.                 cph.writeToParcel(reply, 0);
  708.             } else {
  709.                 reply.writeInt(0);
  710.             }
  711.             return true;
  712.         }
  713.  
  714.         case PUBLISH_CONTENT_PROVIDERS_TRANSACTION: {
  715.             data.enforceInterface(IActivityManager.descriptor);
  716.             IBinder b = data.readStrongBinder();
  717.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  718.             ArrayList<ContentProviderHolder> providers =
  719.                 data.createTypedArrayList(ContentProviderHolder.CREATOR);
  720.             publishContentProviders(app, providers);
  721.             reply.writeNoException();
  722.             return true;
  723.         }
  724.  
  725.         case REF_CONTENT_PROVIDER_TRANSACTION: {
  726.             data.enforceInterface(IActivityManager.descriptor);
  727.             IBinder b = data.readStrongBinder();
  728.             int stable = data.readInt();
  729.             int unstable = data.readInt();
  730.             boolean res = refContentProvider(b, stable, unstable);
  731.             reply.writeNoException();
  732.             reply.writeInt(res ? 1 : 0);
  733.             return true;
  734.         }
  735.  
  736.         case UNSTABLE_PROVIDER_DIED_TRANSACTION: {
  737.             data.enforceInterface(IActivityManager.descriptor);
  738.             IBinder b = data.readStrongBinder();
  739.             unstableProviderDied(b);
  740.             reply.writeNoException();
  741.             return true;
  742.         }
  743.  
  744.         case APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION: {
  745.             data.enforceInterface(IActivityManager.descriptor);
  746.             IBinder b = data.readStrongBinder();
  747.             appNotRespondingViaProvider(b);
  748.             reply.writeNoException();
  749.             return true;
  750.         }
  751.  
  752.         case REMOVE_CONTENT_PROVIDER_TRANSACTION: {
  753.             data.enforceInterface(IActivityManager.descriptor);
  754.             IBinder b = data.readStrongBinder();
  755.             boolean stable = data.readInt() != 0;
  756.             removeContentProvider(b, stable);
  757.             reply.writeNoException();
  758.             return true;
  759.         }
  760.  
  761.         case REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
  762.             data.enforceInterface(IActivityManager.descriptor);
  763.             String name = data.readString();
  764.             IBinder token = data.readStrongBinder();
  765.             removeContentProviderExternal(name, token);
  766.             reply.writeNoException();
  767.             return true;
  768.         }
  769.  
  770.         case GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION: {
  771.             data.enforceInterface(IActivityManager.descriptor);
  772.             ComponentName comp = ComponentName.CREATOR.createFromParcel(data);
  773.             PendingIntent pi = getRunningServiceControlPanel(comp);
  774.             reply.writeNoException();
  775.             PendingIntent.writePendingIntentOrNullToParcel(pi, reply);
  776.             return true;
  777.         }
  778.  
  779.         case START_SERVICE_TRANSACTION: {
  780.             data.enforceInterface(IActivityManager.descriptor);
  781.             IBinder b = data.readStrongBinder();
  782.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  783.             Intent service = Intent.CREATOR.createFromParcel(data);
  784.             String resolvedType = data.readString();
  785.             String callingPackage = data.readString();
  786.             int userId = data.readInt();
  787.             ComponentName cn = startService(app, service, resolvedType, callingPackage, userId);
  788.             reply.writeNoException();
  789.             ComponentName.writeToParcel(cn, reply);
  790.             return true;
  791.         }
  792.  
  793.         case STOP_SERVICE_TRANSACTION: {
  794.             data.enforceInterface(IActivityManager.descriptor);
  795.             IBinder b = data.readStrongBinder();
  796.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  797.             Intent service = Intent.CREATOR.createFromParcel(data);
  798.             String resolvedType = data.readString();
  799.             int userId = data.readInt();
  800.             int res = stopService(app, service, resolvedType, userId);
  801.             reply.writeNoException();
  802.             reply.writeInt(res);
  803.             return true;
  804.         }
  805.  
  806.         case STOP_SERVICE_TOKEN_TRANSACTION: {
  807.             data.enforceInterface(IActivityManager.descriptor);
  808.             ComponentName className = ComponentName.readFromParcel(data);
  809.             IBinder token = data.readStrongBinder();
  810.             int startId = data.readInt();
  811.             boolean res = stopServiceToken(className, token, startId);
  812.             reply.writeNoException();
  813.             reply.writeInt(res ? 1 : 0);
  814.             return true;
  815.         }
  816.  
  817.         case SET_SERVICE_FOREGROUND_TRANSACTION: {
  818.             data.enforceInterface(IActivityManager.descriptor);
  819.             ComponentName className = ComponentName.readFromParcel(data);
  820.             IBinder token = data.readStrongBinder();
  821.             int id = data.readInt();
  822.             Notification notification = null;
  823.             if (data.readInt() != 0) {
  824.                 notification = Notification.CREATOR.createFromParcel(data);
  825.             }
  826.             boolean removeNotification = data.readInt() != 0;
  827.             setServiceForeground(className, token, id, notification, removeNotification);
  828.             reply.writeNoException();
  829.             return true;
  830.         }
  831.  
  832.         case BIND_SERVICE_TRANSACTION: {
  833.             data.enforceInterface(IActivityManager.descriptor);
  834.             IBinder b = data.readStrongBinder();
  835.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  836.             IBinder token = data.readStrongBinder();
  837.             Intent service = Intent.CREATOR.createFromParcel(data);
  838.             String resolvedType = data.readString();
  839.             b = data.readStrongBinder();
  840.             int fl = data.readInt();
  841.             String callingPackage = data.readString();
  842.             int userId = data.readInt();
  843.             IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
  844.             int res = bindService(app, token, service, resolvedType, conn, fl,
  845.                     callingPackage, userId);
  846.             reply.writeNoException();
  847.             reply.writeInt(res);
  848.             return true;
  849.         }
  850.  
  851.         case UNBIND_SERVICE_TRANSACTION: {
  852.             data.enforceInterface(IActivityManager.descriptor);
  853.             IBinder b = data.readStrongBinder();
  854.             IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
  855.             boolean res = unbindService(conn);
  856.             reply.writeNoException();
  857.             reply.writeInt(res ? 1 : 0);
  858.             return true;
  859.         }
  860.  
  861.         case PUBLISH_SERVICE_TRANSACTION: {
  862.             data.enforceInterface(IActivityManager.descriptor);
  863.             IBinder token = data.readStrongBinder();
  864.             Intent intent = Intent.CREATOR.createFromParcel(data);
  865.             IBinder service = data.readStrongBinder();
  866.             publishService(token, intent, service);
  867.             reply.writeNoException();
  868.             return true;
  869.         }
  870.  
  871.         case UNBIND_FINISHED_TRANSACTION: {
  872.             data.enforceInterface(IActivityManager.descriptor);
  873.             IBinder token = data.readStrongBinder();
  874.             Intent intent = Intent.CREATOR.createFromParcel(data);
  875.             boolean doRebind = data.readInt() != 0;
  876.             unbindFinished(token, intent, doRebind);
  877.             reply.writeNoException();
  878.             return true;
  879.         }
  880.  
  881.         case SERVICE_DONE_EXECUTING_TRANSACTION: {
  882.             data.enforceInterface(IActivityManager.descriptor);
  883.             IBinder token = data.readStrongBinder();
  884.             int type = data.readInt();
  885.             int startId = data.readInt();
  886.             int res = data.readInt();
  887.             serviceDoneExecuting(token, type, startId, res);
  888.             reply.writeNoException();
  889.             return true;
  890.         }
  891.  
  892.         case START_INSTRUMENTATION_TRANSACTION: {
  893.             data.enforceInterface(IActivityManager.descriptor);
  894.             ComponentName className = ComponentName.readFromParcel(data);
  895.             String profileFile = data.readString();
  896.             int fl = data.readInt();
  897.             Bundle arguments = data.readBundle();
  898.             IBinder b = data.readStrongBinder();
  899.             IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
  900.             b = data.readStrongBinder();
  901.             IUiAutomationConnection c = IUiAutomationConnection.Stub.asInterface(b);
  902.             int userId = data.readInt();
  903.             String abiOverride = data.readString();
  904.             boolean res = startInstrumentation(className, profileFile, fl, arguments, w, c, userId,
  905.                     abiOverride);
  906.             reply.writeNoException();
  907.             reply.writeInt(res ? 1 : 0);
  908.             return true;
  909.         }
  910.  
  911.  
  912.         case FINISH_INSTRUMENTATION_TRANSACTION: {
  913.             data.enforceInterface(IActivityManager.descriptor);
  914.             IBinder b = data.readStrongBinder();
  915.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  916.             int resultCode = data.readInt();
  917.             Bundle results = data.readBundle();
  918.             finishInstrumentation(app, resultCode, results);
  919.             reply.writeNoException();
  920.             return true;
  921.         }
  922.  
  923.         case GET_CONFIGURATION_TRANSACTION: {
  924.             data.enforceInterface(IActivityManager.descriptor);
  925.             Configuration config = getConfiguration();
  926.             reply.writeNoException();
  927.             config.writeToParcel(reply, 0);
  928.             return true;
  929.         }
  930.  
  931.         case UPDATE_CONFIGURATION_TRANSACTION: {
  932.             data.enforceInterface(IActivityManager.descriptor);
  933.             Configuration config = Configuration.CREATOR.createFromParcel(data);
  934.             updateConfiguration(config);
  935.             reply.writeNoException();
  936.             return true;
  937.         }
  938.  
  939.         case SET_REQUESTED_ORIENTATION_TRANSACTION: {
  940.             data.enforceInterface(IActivityManager.descriptor);
  941.             IBinder token = data.readStrongBinder();
  942.             int requestedOrientation = data.readInt();
  943.             setRequestedOrientation(token, requestedOrientation);
  944.             reply.writeNoException();
  945.             return true;
  946.         }
  947.  
  948.         case GET_REQUESTED_ORIENTATION_TRANSACTION: {
  949.             data.enforceInterface(IActivityManager.descriptor);
  950.             IBinder token = data.readStrongBinder();
  951.             int req = getRequestedOrientation(token);
  952.             reply.writeNoException();
  953.             reply.writeInt(req);
  954.             return true;
  955.         }
  956.  
  957.         case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION: {
  958.             data.enforceInterface(IActivityManager.descriptor);
  959.             IBinder token = data.readStrongBinder();
  960.             ComponentName cn = getActivityClassForToken(token);
  961.             reply.writeNoException();
  962.             ComponentName.writeToParcel(cn, reply);
  963.             return true;
  964.         }
  965.  
  966.         case GET_PACKAGE_FOR_TOKEN_TRANSACTION: {
  967.             data.enforceInterface(IActivityManager.descriptor);
  968.             IBinder token = data.readStrongBinder();
  969.             reply.writeNoException();
  970.             reply.writeString(getPackageForToken(token));
  971.             return true;
  972.         }
  973.  
  974.         case GET_INTENT_SENDER_TRANSACTION: {
  975.             data.enforceInterface(IActivityManager.descriptor);
  976.             int type = data.readInt();
  977.             String packageName = data.readString();
  978.             IBinder token = data.readStrongBinder();
  979.             String resultWho = data.readString();
  980.             int requestCode = data.readInt();
  981.             Intent[] requestIntents;
  982.             String[] requestResolvedTypes;
  983.             if (data.readInt() != 0) {
  984.                 requestIntents = data.createTypedArray(Intent.CREATOR);
  985.                 requestResolvedTypes = data.createStringArray();
  986.             } else {
  987.                 requestIntents = null;
  988.                 requestResolvedTypes = null;
  989.             }
  990.             int fl = data.readInt();
  991.             Bundle options = data.readInt() != 0
  992.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  993.             int userId = data.readInt();
  994.             IIntentSender res = getIntentSender(type, packageName, token,
  995.                     resultWho, requestCode, requestIntents,
  996.                     requestResolvedTypes, fl, options, userId);
  997.             reply.writeNoException();
  998.             reply.writeStrongBinder(res != null ? res.asBinder() : null);
  999.             return true;
  1000.         }
  1001.  
  1002.         case CANCEL_INTENT_SENDER_TRANSACTION: {
  1003.             data.enforceInterface(IActivityManager.descriptor);
  1004.             IIntentSender r = IIntentSender.Stub.asInterface(
  1005.                 data.readStrongBinder());
  1006.             cancelIntentSender(r);
  1007.             reply.writeNoException();
  1008.             return true;
  1009.         }
  1010.  
  1011.         case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION: {
  1012.             data.enforceInterface(IActivityManager.descriptor);
  1013.             IIntentSender r = IIntentSender.Stub.asInterface(
  1014.                 data.readStrongBinder());
  1015.             String res = getPackageForIntentSender(r);
  1016.             reply.writeNoException();
  1017.             reply.writeString(res);
  1018.             return true;
  1019.         }
  1020.  
  1021.         case GET_UID_FOR_INTENT_SENDER_TRANSACTION: {
  1022.             data.enforceInterface(IActivityManager.descriptor);
  1023.             IIntentSender r = IIntentSender.Stub.asInterface(
  1024.                 data.readStrongBinder());
  1025.             int res = getUidForIntentSender(r);
  1026.             reply.writeNoException();
  1027.             reply.writeInt(res);
  1028.             return true;
  1029.         }
  1030.  
  1031.         case HANDLE_INCOMING_USER_TRANSACTION: {
  1032.             data.enforceInterface(IActivityManager.descriptor);
  1033.             int callingPid = data.readInt();
  1034.             int callingUid = data.readInt();
  1035.             int userId = data.readInt();
  1036.             boolean allowAll = data.readInt() != 0 ;
  1037.             boolean requireFull = data.readInt() != 0;
  1038.             String name = data.readString();
  1039.             String callerPackage = data.readString();
  1040.             int res = handleIncomingUser(callingPid, callingUid, userId, allowAll,
  1041.                     requireFull, name, callerPackage);
  1042.             reply.writeNoException();
  1043.             reply.writeInt(res);
  1044.             return true;
  1045.         }
  1046.  
  1047.         case SET_PROCESS_LIMIT_TRANSACTION: {
  1048.             data.enforceInterface(IActivityManager.descriptor);
  1049.             int max = data.readInt();
  1050.             setProcessLimit(max);
  1051.             reply.writeNoException();
  1052.             return true;
  1053.         }
  1054.  
  1055.         case GET_PROCESS_LIMIT_TRANSACTION: {
  1056.             data.enforceInterface(IActivityManager.descriptor);
  1057.             int limit = getProcessLimit();
  1058.             reply.writeNoException();
  1059.             reply.writeInt(limit);
  1060.             return true;
  1061.         }
  1062.  
  1063.         case SET_PROCESS_FOREGROUND_TRANSACTION: {
  1064.             data.enforceInterface(IActivityManager.descriptor);
  1065.             IBinder token = data.readStrongBinder();
  1066.             int pid = data.readInt();
  1067.             boolean isForeground = data.readInt() != 0;
  1068.             setProcessForeground(token, pid, isForeground);
  1069.             reply.writeNoException();
  1070.             return true;
  1071.         }
  1072.  
  1073.         case CHECK_PERMISSION_TRANSACTION: {
  1074.             data.enforceInterface(IActivityManager.descriptor);
  1075.             String perm = data.readString();
  1076.             int pid = data.readInt();
  1077.             int uid = data.readInt();
  1078.             int res = checkPermission(perm, pid, uid);
  1079.             reply.writeNoException();
  1080.             reply.writeInt(res);
  1081.             return true;
  1082.         }
  1083.  
  1084.         case CHECK_PERMISSION_WITH_TOKEN_TRANSACTION: {
  1085.             data.enforceInterface(IActivityManager.descriptor);
  1086.             String perm = data.readString();
  1087.             int pid = data.readInt();
  1088.             int uid = data.readInt();
  1089.             IBinder token = data.readStrongBinder();
  1090.             int res = checkPermissionWithToken(perm, pid, uid, token);
  1091.             reply.writeNoException();
  1092.             reply.writeInt(res);
  1093.             return true;
  1094.         }
  1095.  
  1096.         case CHECK_URI_PERMISSION_TRANSACTION: {
  1097.             data.enforceInterface(IActivityManager.descriptor);
  1098.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1099.             int pid = data.readInt();
  1100.             int uid = data.readInt();
  1101.             int mode = data.readInt();
  1102.             int userId = data.readInt();
  1103.             IBinder callerToken = data.readStrongBinder();
  1104.             int res = checkUriPermission(uri, pid, uid, mode, userId, callerToken);
  1105.             reply.writeNoException();
  1106.             reply.writeInt(res);
  1107.             return true;
  1108.         }
  1109.  
  1110.         case CLEAR_APP_DATA_TRANSACTION: {
  1111.             data.enforceInterface(IActivityManager.descriptor);
  1112.             String packageName = data.readString();
  1113.             IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(
  1114.                     data.readStrongBinder());
  1115.             int userId = data.readInt();
  1116.             boolean res = clearApplicationUserData(packageName, observer, userId);
  1117.             reply.writeNoException();
  1118.             reply.writeInt(res ? 1 : 0);
  1119.             return true;
  1120.         }
  1121.  
  1122.         case GRANT_URI_PERMISSION_TRANSACTION: {
  1123.             data.enforceInterface(IActivityManager.descriptor);
  1124.             IBinder b = data.readStrongBinder();
  1125.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  1126.             String targetPkg = data.readString();
  1127.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1128.             int mode = data.readInt();
  1129.             int userId = data.readInt();
  1130.             grantUriPermission(app, targetPkg, uri, mode, userId);
  1131.             reply.writeNoException();
  1132.             return true;
  1133.         }
  1134.  
  1135.         case REVOKE_URI_PERMISSION_TRANSACTION: {
  1136.             data.enforceInterface(IActivityManager.descriptor);
  1137.             IBinder b = data.readStrongBinder();
  1138.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  1139.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1140.             int mode = data.readInt();
  1141.             int userId = data.readInt();
  1142.             revokeUriPermission(app, uri, mode, userId);
  1143.             reply.writeNoException();
  1144.             return true;
  1145.         }
  1146.  
  1147.         case TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
  1148.             data.enforceInterface(IActivityManager.descriptor);
  1149.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1150.             int mode = data.readInt();
  1151.             int userId = data.readInt();
  1152.             takePersistableUriPermission(uri, mode, userId);
  1153.             reply.writeNoException();
  1154.             return true;
  1155.         }
  1156.  
  1157.         case RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
  1158.             data.enforceInterface(IActivityManager.descriptor);
  1159.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1160.             int mode = data.readInt();
  1161.             int userId = data.readInt();
  1162.             releasePersistableUriPermission(uri, mode, userId);
  1163.             reply.writeNoException();
  1164.             return true;
  1165.         }
  1166.  
  1167.         case GET_PERSISTED_URI_PERMISSIONS_TRANSACTION: {
  1168.             data.enforceInterface(IActivityManager.descriptor);
  1169.             final String packageName = data.readString();
  1170.             final boolean incoming = data.readInt() != 0;
  1171.             final ParceledListSlice<UriPermission> perms = getPersistedUriPermissions(
  1172.                     packageName, incoming);
  1173.             reply.writeNoException();
  1174.             perms.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  1175.             return true;
  1176.         }
  1177.  
  1178.         case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: {
  1179.             data.enforceInterface(IActivityManager.descriptor);
  1180.             IBinder b = data.readStrongBinder();
  1181.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  1182.             boolean waiting = data.readInt() != 0;
  1183.             showWaitingForDebugger(app, waiting);
  1184.             reply.writeNoException();
  1185.             return true;
  1186.         }
  1187.  
  1188.         case GET_MEMORY_INFO_TRANSACTION: {
  1189.             data.enforceInterface(IActivityManager.descriptor);
  1190.             ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
  1191.             getMemoryInfo(mi);
  1192.             reply.writeNoException();
  1193.             mi.writeToParcel(reply, 0);
  1194.             return true;
  1195.         }
  1196.  
  1197.         case UNHANDLED_BACK_TRANSACTION: {
  1198.             data.enforceInterface(IActivityManager.descriptor);
  1199.             unhandledBack();
  1200.             reply.writeNoException();
  1201.             return true;
  1202.         }
  1203.  
  1204.         case OPEN_CONTENT_URI_TRANSACTION: {
  1205.             data.enforceInterface(IActivityManager.descriptor);
  1206.             Uri uri = Uri.parse(data.readString());
  1207.             ParcelFileDescriptor pfd = openContentUri(uri);
  1208.             reply.writeNoException();
  1209.             if (pfd != null) {
  1210.                 reply.writeInt(1);
  1211.                 pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  1212.             } else {
  1213.                 reply.writeInt(0);
  1214.             }
  1215.             return true;
  1216.         }
  1217.  
  1218.         case SET_LOCK_SCREEN_SHOWN_TRANSACTION: {
  1219.             data.enforceInterface(IActivityManager.descriptor);
  1220.             setLockScreenShown(data.readInt() != 0);
  1221.             reply.writeNoException();
  1222.             return true;
  1223.         }
  1224.  
  1225.         case SET_DEBUG_APP_TRANSACTION: {
  1226.             data.enforceInterface(IActivityManager.descriptor);
  1227.             String pn = data.readString();
  1228.             boolean wfd = data.readInt() != 0;
  1229.             boolean per = data.readInt() != 0;
  1230.             setDebugApp(pn, wfd, per);
  1231.             reply.writeNoException();
  1232.             return true;
  1233.         }
  1234.  
  1235.         case SET_ALWAYS_FINISH_TRANSACTION: {
  1236.             data.enforceInterface(IActivityManager.descriptor);
  1237.             boolean enabled = data.readInt() != 0;
  1238.             setAlwaysFinish(enabled);
  1239.             reply.writeNoException();
  1240.             return true;
  1241.         }
  1242.  
  1243.         case SET_ACTIVITY_CONTROLLER_TRANSACTION: {
  1244.             data.enforceInterface(IActivityManager.descriptor);
  1245.             IActivityController watcher = IActivityController.Stub.asInterface(
  1246.                     data.readStrongBinder());
  1247.             setActivityController(watcher);
  1248.             reply.writeNoException();
  1249.             return true;
  1250.         }
  1251.  
  1252.         case ENTER_SAFE_MODE_TRANSACTION: {
  1253.             data.enforceInterface(IActivityManager.descriptor);
  1254.             enterSafeMode();
  1255.             reply.writeNoException();
  1256.             return true;
  1257.         }
  1258.  
  1259.         case NOTE_WAKEUP_ALARM_TRANSACTION: {
  1260.             data.enforceInterface(IActivityManager.descriptor);
  1261.             IIntentSender is = IIntentSender.Stub.asInterface(
  1262.                     data.readStrongBinder());
  1263.             int sourceUid = data.readInt();
  1264.             String sourcePkg = data.readString();
  1265.             String tag = data.readString();
  1266.             noteWakeupAlarm(is, sourceUid, sourcePkg, tag);
  1267.             reply.writeNoException();
  1268.             return true;
  1269.         }
  1270.  
  1271.         case NOTE_ALARM_START_TRANSACTION: {
  1272.             data.enforceInterface(IActivityManager.descriptor);
  1273.             IIntentSender is = IIntentSender.Stub.asInterface(
  1274.                     data.readStrongBinder());
  1275.             int sourceUid = data.readInt();
  1276.             String tag = data.readString();
  1277.             noteAlarmStart(is, sourceUid, tag);
  1278.             reply.writeNoException();
  1279.             return true;
  1280.         }
  1281.  
  1282.         case NOTE_ALARM_FINISH_TRANSACTION: {
  1283.             data.enforceInterface(IActivityManager.descriptor);
  1284.             IIntentSender is = IIntentSender.Stub.asInterface(
  1285.                     data.readStrongBinder());
  1286.             int sourceUid = data.readInt();
  1287.             String tag = data.readString();
  1288.             noteAlarmFinish(is, sourceUid, tag);
  1289.             reply.writeNoException();
  1290.             return true;
  1291.         }
  1292.  
  1293.         case KILL_PIDS_TRANSACTION: {
  1294.             data.enforceInterface(IActivityManager.descriptor);
  1295.             int[] pids = data.createIntArray();
  1296.             String reason = data.readString();
  1297.             boolean secure = data.readInt() != 0;
  1298.             boolean res = killPids(pids, reason, secure);
  1299.             reply.writeNoException();
  1300.             reply.writeInt(res ? 1 : 0);
  1301.             return true;
  1302.         }
  1303.  
  1304.         case KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION: {
  1305.             data.enforceInterface(IActivityManager.descriptor);
  1306.             String reason = data.readString();
  1307.             boolean res = killProcessesBelowForeground(reason);
  1308.             reply.writeNoException();
  1309.             reply.writeInt(res ? 1 : 0);
  1310.             return true;
  1311.         }
  1312.  
  1313.         case HANDLE_APPLICATION_CRASH_TRANSACTION: {
  1314.             data.enforceInterface(IActivityManager.descriptor);
  1315.             IBinder app = data.readStrongBinder();
  1316.             ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
  1317.             handleApplicationCrash(app, ci);
  1318.             reply.writeNoException();
  1319.             return true;
  1320.         }
  1321.  
  1322.         case HANDLE_APPLICATION_WTF_TRANSACTION: {
  1323.             data.enforceInterface(IActivityManager.descriptor);
  1324.             IBinder app = data.readStrongBinder();
  1325.             String tag = data.readString();
  1326.             boolean system = data.readInt() != 0;
  1327.             ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
  1328.             boolean res = handleApplicationWtf(app, tag, system, ci);
  1329.             reply.writeNoException();
  1330.             reply.writeInt(res ? 1 : 0);
  1331.             return true;
  1332.         }
  1333.  
  1334.         case HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION: {
  1335.             data.enforceInterface(IActivityManager.descriptor);
  1336.             IBinder app = data.readStrongBinder();
  1337.             int violationMask = data.readInt();
  1338.             StrictMode.ViolationInfo info = new StrictMode.ViolationInfo(data);
  1339.             handleApplicationStrictModeViolation(app, violationMask, info);
  1340.             reply.writeNoException();
  1341.             return true;
  1342.         }
  1343.  
  1344.         case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION: {
  1345.             data.enforceInterface(IActivityManager.descriptor);
  1346.             int sig = data.readInt();
  1347.             signalPersistentProcesses(sig);
  1348.             reply.writeNoException();
  1349.             return true;
  1350.         }
  1351.  
  1352.         case KILL_BACKGROUND_PROCESSES_TRANSACTION: {
  1353.             data.enforceInterface(IActivityManager.descriptor);
  1354.             String packageName = data.readString();
  1355.             int userId = data.readInt();
  1356.             killBackgroundProcesses(packageName, userId);
  1357.             reply.writeNoException();
  1358.             return true;
  1359.         }
  1360.  
  1361.         case KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION: {
  1362.             data.enforceInterface(IActivityManager.descriptor);
  1363.             killAllBackgroundProcesses();
  1364.             reply.writeNoException();
  1365.             return true;
  1366.         }
  1367.  
  1368.         case FORCE_STOP_PACKAGE_TRANSACTION: {
  1369.             data.enforceInterface(IActivityManager.descriptor);
  1370.             String packageName = data.readString();
  1371.             int userId = data.readInt();
  1372.             forceStopPackage(packageName, userId);
  1373.             reply.writeNoException();
  1374.             return true;
  1375.         }
  1376.  
  1377.         case GET_MY_MEMORY_STATE_TRANSACTION: {
  1378.             data.enforceInterface(IActivityManager.descriptor);
  1379.             ActivityManager.RunningAppProcessInfo info =
  1380.                     new ActivityManager.RunningAppProcessInfo();
  1381.             getMyMemoryState(info);
  1382.             reply.writeNoException();
  1383.             info.writeToParcel(reply, 0);
  1384.             return true;
  1385.         }
  1386.  
  1387.         case GET_DEVICE_CONFIGURATION_TRANSACTION: {
  1388.             data.enforceInterface(IActivityManager.descriptor);
  1389.             ConfigurationInfo config = getDeviceConfigurationInfo();
  1390.             reply.writeNoException();
  1391.             config.writeToParcel(reply, 0);
  1392.             return true;
  1393.         }
  1394.  
  1395.         case PROFILE_CONTROL_TRANSACTION: {
  1396.             data.enforceInterface(IActivityManager.descriptor);
  1397.             String process = data.readString();
  1398.             int userId = data.readInt();
  1399.             boolean start = data.readInt() != 0;
  1400.             int profileType = data.readInt();
  1401.             ProfilerInfo profilerInfo = data.readInt() != 0
  1402.                     ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  1403.             boolean res = profileControl(process, userId, start, profilerInfo, profileType);
  1404.             reply.writeNoException();
  1405.             reply.writeInt(res ? 1 : 0);
  1406.             return true;
  1407.         }
  1408.  
  1409.         case SHUTDOWN_TRANSACTION: {
  1410.             data.enforceInterface(IActivityManager.descriptor);
  1411.             boolean res = shutdown(data.readInt());
  1412.             reply.writeNoException();
  1413.             reply.writeInt(res ? 1 : 0);
  1414.             return true;
  1415.         }
  1416.  
  1417.         case STOP_APP_SWITCHES_TRANSACTION: {
  1418.             data.enforceInterface(IActivityManager.descriptor);
  1419.             stopAppSwitches();
  1420.             reply.writeNoException();
  1421.             return true;
  1422.         }
  1423.  
  1424.         case RESUME_APP_SWITCHES_TRANSACTION: {
  1425.             data.enforceInterface(IActivityManager.descriptor);
  1426.             resumeAppSwitches();
  1427.             reply.writeNoException();
  1428.             return true;
  1429.         }
  1430.  
  1431.         case PEEK_SERVICE_TRANSACTION: {
  1432.             data.enforceInterface(IActivityManager.descriptor);
  1433.             Intent service = Intent.CREATOR.createFromParcel(data);
  1434.             String resolvedType = data.readString();
  1435.             String callingPackage = data.readString();
  1436.             IBinder binder = peekService(service, resolvedType, callingPackage);
  1437.             reply.writeNoException();
  1438.             reply.writeStrongBinder(binder);
  1439.             return true;
  1440.         }
  1441.  
  1442.         case START_BACKUP_AGENT_TRANSACTION: {
  1443.             data.enforceInterface(IActivityManager.descriptor);
  1444.             ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
  1445.             int backupRestoreMode = data.readInt();
  1446.             boolean success = bindBackupAgent(info, backupRestoreMode);
  1447.             reply.writeNoException();
  1448.             reply.writeInt(success ? 1 : 0);
  1449.             return true;
  1450.         }
  1451.  
  1452.         case BACKUP_AGENT_CREATED_TRANSACTION: {
  1453.             data.enforceInterface(IActivityManager.descriptor);
  1454.             String packageName = data.readString();
  1455.             IBinder agent = data.readStrongBinder();
  1456.             backupAgentCreated(packageName, agent);
  1457.             reply.writeNoException();
  1458.             return true;
  1459.         }
  1460.  
  1461.         case UNBIND_BACKUP_AGENT_TRANSACTION: {
  1462.             data.enforceInterface(IActivityManager.descriptor);
  1463.             ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
  1464.             unbindBackupAgent(info);
  1465.             reply.writeNoException();
  1466.             return true;
  1467.         }
  1468.  
  1469.         case ADD_PACKAGE_DEPENDENCY_TRANSACTION: {
  1470.             data.enforceInterface(IActivityManager.descriptor);
  1471.             String packageName = data.readString();
  1472.             addPackageDependency(packageName);
  1473.             reply.writeNoException();
  1474.             return true;
  1475.         }
  1476.  
  1477.         case KILL_APPLICATION_WITH_APPID_TRANSACTION: {
  1478.             data.enforceInterface(IActivityManager.descriptor);
  1479.             String pkg = data.readString();
  1480.             int appid = data.readInt();
  1481.             String reason = data.readString();
  1482.             killApplicationWithAppId(pkg, appid, reason);
  1483.             reply.writeNoException();
  1484.             return true;
  1485.         }
  1486.  
  1487.         case CLOSE_SYSTEM_DIALOGS_TRANSACTION: {
  1488.             data.enforceInterface(IActivityManager.descriptor);
  1489.             String reason = data.readString();
  1490.             closeSystemDialogs(reason);
  1491.             reply.writeNoException();
  1492.             return true;
  1493.         }
  1494.  
  1495.         case GET_PROCESS_MEMORY_INFO_TRANSACTION: {
  1496.             data.enforceInterface(IActivityManager.descriptor);
  1497.             int[] pids = data.createIntArray();
  1498.             Debug.MemoryInfo[] res =  getProcessMemoryInfo(pids);
  1499.             reply.writeNoException();
  1500.             reply.writeTypedArray(res, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  1501.             return true;
  1502.         }
  1503.  
  1504.         case KILL_APPLICATION_PROCESS_TRANSACTION: {
  1505.             data.enforceInterface(IActivityManager.descriptor);
  1506.             String processName = data.readString();
  1507.             int uid = data.readInt();
  1508.             killApplicationProcess(processName, uid);
  1509.             reply.writeNoException();
  1510.             return true;
  1511.         }
  1512.  
  1513.         case OVERRIDE_PENDING_TRANSITION_TRANSACTION: {
  1514.             data.enforceInterface(IActivityManager.descriptor);
  1515.             IBinder token = data.readStrongBinder();
  1516.             String packageName = data.readString();
  1517.             int enterAnim = data.readInt();
  1518.             int exitAnim = data.readInt();
  1519.             overridePendingTransition(token, packageName, enterAnim, exitAnim);
  1520.             reply.writeNoException();
  1521.             return true;
  1522.         }
  1523.  
  1524.         case IS_USER_A_MONKEY_TRANSACTION: {
  1525.             data.enforceInterface(IActivityManager.descriptor);
  1526.             boolean areThey = isUserAMonkey();
  1527.             reply.writeNoException();
  1528.             reply.writeInt(areThey ? 1 : 0);
  1529.             return true;
  1530.         }
  1531.  
  1532.         case SET_USER_IS_MONKEY_TRANSACTION: {
  1533.             data.enforceInterface(IActivityManager.descriptor);
  1534.             final boolean monkey = (data.readInt() == 1);
  1535.             setUserIsMonkey(monkey);
  1536.             reply.writeNoException();
  1537.             return true;
  1538.         }
  1539.  
  1540.         case FINISH_HEAVY_WEIGHT_APP_TRANSACTION: {
  1541.             data.enforceInterface(IActivityManager.descriptor);
  1542.             finishHeavyWeightApp();
  1543.             reply.writeNoException();
  1544.             return true;
  1545.         }
  1546.  
  1547.         case IS_IMMERSIVE_TRANSACTION: {
  1548.             data.enforceInterface(IActivityManager.descriptor);
  1549.             IBinder token = data.readStrongBinder();
  1550.             boolean isit = isImmersive(token);
  1551.             reply.writeNoException();
  1552.             reply.writeInt(isit ? 1 : 0);
  1553.             return true;
  1554.         }
  1555.  
  1556.         case IS_TOP_OF_TASK_TRANSACTION: {
  1557.             data.enforceInterface(IActivityManager.descriptor);
  1558.             IBinder token = data.readStrongBinder();
  1559.             final boolean isTopOfTask = isTopOfTask(token);
  1560.             reply.writeNoException();
  1561.             reply.writeInt(isTopOfTask ? 1 : 0);
  1562.             return true;
  1563.         }
  1564.  
  1565.         case CONVERT_FROM_TRANSLUCENT_TRANSACTION: {
  1566.             data.enforceInterface(IActivityManager.descriptor);
  1567.             IBinder token = data.readStrongBinder();
  1568.             boolean converted = convertFromTranslucent(token);
  1569.             reply.writeNoException();
  1570.             reply.writeInt(converted ? 1 : 0);
  1571.             return true;
  1572.         }
  1573.  
  1574.         case CONVERT_TO_TRANSLUCENT_TRANSACTION: {
  1575.             data.enforceInterface(IActivityManager.descriptor);
  1576.             IBinder token = data.readStrongBinder();
  1577.             final Bundle bundle;
  1578.             if (data.readInt() == 0) {
  1579.                 bundle = null;
  1580.             } else {
  1581.                 bundle = data.readBundle();
  1582.             }
  1583.             final ActivityOptions options = bundle == null ? null : new ActivityOptions(bundle);
  1584.             boolean converted = convertToTranslucent(token, options);
  1585.             reply.writeNoException();
  1586.             reply.writeInt(converted ? 1 : 0);
  1587.             return true;
  1588.         }
  1589.  
  1590.         case GET_ACTIVITY_OPTIONS_TRANSACTION: {
  1591.             data.enforceInterface(IActivityManager.descriptor);
  1592.             IBinder token = data.readStrongBinder();
  1593.             final ActivityOptions options = getActivityOptions(token);
  1594.             reply.writeNoException();
  1595.             reply.writeBundle(options == null ? null : options.toBundle());
  1596.             return true;
  1597.         }
  1598.  
  1599.         case SET_IMMERSIVE_TRANSACTION: {
  1600.             data.enforceInterface(IActivityManager.descriptor);
  1601.             IBinder token = data.readStrongBinder();
  1602.             boolean imm = data.readInt() == 1;
  1603.             setImmersive(token, imm);
  1604.             reply.writeNoException();
  1605.             return true;
  1606.         }
  1607.  
  1608.         case IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION: {
  1609.             data.enforceInterface(IActivityManager.descriptor);
  1610.             boolean isit = isTopActivityImmersive();
  1611.             reply.writeNoException();
  1612.             reply.writeInt(isit ? 1 : 0);
  1613.             return true;
  1614.         }
  1615.  
  1616.         case CRASH_APPLICATION_TRANSACTION: {
  1617.             data.enforceInterface(IActivityManager.descriptor);
  1618.             int uid = data.readInt();
  1619.             int initialPid = data.readInt();
  1620.             String packageName = data.readString();
  1621.             String message = data.readString();
  1622.             crashApplication(uid, initialPid, packageName, message);
  1623.             reply.writeNoException();
  1624.             return true;
  1625.         }
  1626.  
  1627.         case GET_PROVIDER_MIME_TYPE_TRANSACTION: {
  1628.             data.enforceInterface(IActivityManager.descriptor);
  1629.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1630.             int userId = data.readInt();
  1631.             String type = getProviderMimeType(uri, userId);
  1632.             reply.writeNoException();
  1633.             reply.writeString(type);
  1634.             return true;
  1635.         }
  1636.  
  1637.         case NEW_URI_PERMISSION_OWNER_TRANSACTION: {
  1638.             data.enforceInterface(IActivityManager.descriptor);
  1639.             String name = data.readString();
  1640.             IBinder perm = newUriPermissionOwner(name);
  1641.             reply.writeNoException();
  1642.             reply.writeStrongBinder(perm);
  1643.             return true;
  1644.         }
  1645.  
  1646.         case GRANT_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
  1647.             data.enforceInterface(IActivityManager.descriptor);
  1648.             IBinder owner = data.readStrongBinder();
  1649.             int fromUid = data.readInt();
  1650.             String targetPkg = data.readString();
  1651.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1652.             int mode = data.readInt();
  1653.             int sourceUserId = data.readInt();
  1654.             int targetUserId = data.readInt();
  1655.             grantUriPermissionFromOwner(owner, fromUid, targetPkg, uri, mode, sourceUserId,
  1656.                     targetUserId);
  1657.             reply.writeNoException();
  1658.             return true;
  1659.         }
  1660.  
  1661.         case REVOKE_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
  1662.             data.enforceInterface(IActivityManager.descriptor);
  1663.             IBinder owner = data.readStrongBinder();
  1664.             Uri uri = null;
  1665.             if (data.readInt() != 0) {
  1666.                 uri = Uri.CREATOR.createFromParcel(data);
  1667.             }
  1668.             int mode = data.readInt();
  1669.             int userId = data.readInt();
  1670.             revokeUriPermissionFromOwner(owner, uri, mode, userId);
  1671.             reply.writeNoException();
  1672.             return true;
  1673.         }
  1674.  
  1675.         case CHECK_GRANT_URI_PERMISSION_TRANSACTION: {
  1676.             data.enforceInterface(IActivityManager.descriptor);
  1677.             int callingUid = data.readInt();
  1678.             String targetPkg = data.readString();
  1679.             Uri uri = Uri.CREATOR.createFromParcel(data);
  1680.             int modeFlags = data.readInt();
  1681.             int userId = data.readInt();
  1682.             int res = checkGrantUriPermission(callingUid, targetPkg, uri, modeFlags, userId);
  1683.             reply.writeNoException();
  1684.             reply.writeInt(res);
  1685.             return true;
  1686.         }
  1687.  
  1688.         case DUMP_HEAP_TRANSACTION: {
  1689.             data.enforceInterface(IActivityManager.descriptor);
  1690.             String process = data.readString();
  1691.             int userId = data.readInt();
  1692.             boolean managed = data.readInt() != 0;
  1693.             String path = data.readString();
  1694.             ParcelFileDescriptor fd = data.readInt() != 0
  1695.                     ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
  1696.             boolean res = dumpHeap(process, userId, managed, path, fd);
  1697.             reply.writeNoException();
  1698.             reply.writeInt(res ? 1 : 0);
  1699.             return true;
  1700.         }
  1701.  
  1702.         case START_ACTIVITIES_TRANSACTION:
  1703.         {
  1704.             data.enforceInterface(IActivityManager.descriptor);
  1705.             IBinder b = data.readStrongBinder();
  1706.             IApplicationThread app = ApplicationThreadNative.asInterface(b);
  1707.             String callingPackage = data.readString();
  1708.             Intent[] intents = data.createTypedArray(Intent.CREATOR);
  1709.             String[] resolvedTypes = data.createStringArray();
  1710.             IBinder resultTo = data.readStrongBinder();
  1711.             Bundle options = data.readInt() != 0
  1712.                     ? Bundle.CREATOR.createFromParcel(data) : null;
  1713.             int userId = data.readInt();
  1714.             int result = startActivities(app, callingPackage, intents, resolvedTypes, resultTo,
  1715.                     options, userId);
  1716.             reply.writeNoException();
  1717.             reply.writeInt(result);
  1718.             return true;
  1719.         }
  1720.  
  1721.         case GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
  1722.         {
  1723.             data.enforceInterface(IActivityManager.descriptor);
  1724.             int mode = getFrontActivityScreenCompatMode();
  1725.             reply.writeNoException();
  1726.             reply.writeInt(mode);
  1727.             return true;
  1728.         }
  1729.  
  1730.         case SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
  1731.         {
  1732.             data.enforceInterface(IActivityManager.descriptor);
  1733.             int mode = data.readInt();
  1734.             setFrontActivityScreenCompatMode(mode);
  1735.             reply.writeNoException();
  1736.             reply.writeInt(mode);
  1737.             return true;
  1738.         }
  1739.  
  1740.         case GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
  1741.         {
  1742.             data.enforceInterface(IActivityManager.descriptor);
  1743.             String pkg = data.readString();
  1744.             int mode = getPackageScreenCompatMode(pkg);
  1745.             reply.writeNoException();
  1746.             reply.writeInt(mode);
  1747.             return true;
  1748.         }
  1749.  
  1750.         case SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
  1751.         {
  1752.             data.enforceInterface(IActivityManager.descriptor);
  1753.             String pkg = data.readString();
  1754.             int mode = data.readInt();
  1755.             setPackageScreenCompatMode(pkg, mode);
  1756.             reply.writeNoException();
  1757.             return true;
  1758.         }
  1759.  
  1760.         case SWITCH_USER_TRANSACTION: {
  1761.             data.enforceInterface(IActivityManager.descriptor);
  1762.             int userid = data.readInt();
  1763.             boolean result = switchUser(userid);
  1764.             reply.writeNoException();
  1765.             reply.writeInt(result ? 1 : 0);
  1766.             return true;
  1767.         }
  1768.  
  1769.         case START_USER_IN_BACKGROUND_TRANSACTION: {
  1770.             data.enforceInterface(IActivityManager.descriptor);
  1771.             int userid = data.readInt();
  1772.             boolean result = startUserInBackground(userid);
  1773.             reply.writeNoException();
  1774.             reply.writeInt(result ? 1 : 0);
  1775.             return true;
  1776.         }
  1777.  
  1778.         case STOP_USER_TRANSACTION: {
  1779.             data.enforceInterface(IActivityManager.descriptor);
  1780.             int userid = data.readInt();
  1781.             IStopUserCallback callback = IStopUserCallback.Stub.asInterface(
  1782.                     data.readStrongBinder());
  1783.             int result = stopUser(userid, callback);
  1784.             reply.writeNoException();
  1785.             reply.writeInt(result);
  1786.             return true;
  1787.         }
  1788.  
  1789.         case GET_CURRENT_USER_TRANSACTION: {
  1790.             data.enforceInterface(IActivityManager.descriptor);
  1791.             UserInfo userInfo = getCurrentUser();
  1792.             reply.writeNoException();
  1793.             userInfo.writeToParcel(reply, 0);
  1794.             return true;
  1795.         }
  1796.  
  1797.         case IS_USER_RUNNING_TRANSACTION: {
  1798.             data.enforceInterface(IActivityManager.descriptor);
  1799.             int userid = data.readInt();
  1800.             boolean orStopping = data.readInt() != 0;
  1801.             boolean result = isUserRunning(userid, orStopping);
  1802.             reply.writeNoException();
  1803.             reply.writeInt(result ? 1 : 0);
  1804.             return true;
  1805.         }
  1806.  
  1807.         case GET_RUNNING_USER_IDS_TRANSACTION: {
  1808.             data.enforceInterface(IActivityManager.descriptor);
  1809.             int[] result = getRunningUserIds();
  1810.             reply.writeNoException();
  1811.             reply.writeIntArray(result);
  1812.             return true;
  1813.         }
  1814.  
  1815.         case REMOVE_TASK_TRANSACTION:
  1816.         {
  1817.             data.enforceInterface(IActivityManager.descriptor);
  1818.             int taskId = data.readInt();
  1819.             boolean result = removeTask(taskId);
  1820.             reply.writeNoException();
  1821.             reply.writeInt(result ? 1 : 0);
  1822.             return true;
  1823.         }
  1824.  
  1825.         case REGISTER_PROCESS_OBSERVER_TRANSACTION: {
  1826.             data.enforceInterface(IActivityManager.descriptor);
  1827.             IProcessObserver observer = IProcessObserver.Stub.asInterface(
  1828.                     data.readStrongBinder());
  1829.             registerProcessObserver(observer);
  1830.             return true;
  1831.         }
  1832.  
  1833.         case UNREGISTER_PROCESS_OBSERVER_TRANSACTION: {
  1834.             data.enforceInterface(IActivityManager.descriptor);
  1835.             IProcessObserver observer = IProcessObserver.Stub.asInterface(
  1836.                     data.readStrongBinder());
  1837.             unregisterProcessObserver(observer);
  1838.             return true;
  1839.         }
  1840.  
  1841.         case REGISTER_UID_OBSERVER_TRANSACTION: {
  1842.             data.enforceInterface(IActivityManager.descriptor);
  1843.             IUidObserver observer = IUidObserver.Stub.asInterface(
  1844.                     data.readStrongBinder());
  1845.             registerUidObserver(observer);
  1846.             return true;
  1847.         }
  1848.  
  1849.         case UNREGISTER_UID_OBSERVER_TRANSACTION: {
  1850.             data.enforceInterface(IActivityManager.descriptor);
  1851.             IUidObserver observer = IUidObserver.Stub.asInterface(
  1852.                     data.readStrongBinder());
  1853.             unregisterUidObserver(observer);
  1854.             return true;
  1855.         }
  1856.  
  1857.         case GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
  1858.         {
  1859.             data.enforceInterface(IActivityManager.descriptor);
  1860.             String pkg = data.readString();
  1861.             boolean ask = getPackageAskScreenCompat(pkg);
  1862.             reply.writeNoException();
  1863.             reply.writeInt(ask ? 1 : 0);
  1864.             return true;
  1865.         }
  1866.  
  1867.         case SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
  1868.         {
  1869.             data.enforceInterface(IActivityManager.descriptor);
  1870.             String pkg = data.readString();
  1871.             boolean ask = data.readInt() != 0;
  1872.             setPackageAskScreenCompat(pkg, ask);
  1873.             reply.writeNoException();
  1874.             return true;
  1875.         }
  1876.  
  1877.         case IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION: {
  1878.             data.enforceInterface(IActivityManager.descriptor);
  1879.             IIntentSender r = IIntentSender.Stub.asInterface(
  1880.                     data.readStrongBinder());
  1881.             boolean res = isIntentSenderTargetedToPackage(r);
  1882.             reply.writeNoException();
  1883.             reply.writeInt(res ? 1 : 0);
  1884.             return true;
  1885.         }
  1886.  
  1887.         case IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION: {
  1888.             data.enforceInterface(IActivityManager.descriptor);
  1889.             IIntentSender r = IIntentSender.Stub.asInterface(
  1890.                 data.readStrongBinder());
  1891.             boolean res = isIntentSenderAnActivity(r);
  1892.             reply.writeNoException();
  1893.             reply.writeInt(res ? 1 : 0);
  1894.             return true;
  1895.         }
  1896.  
  1897.         case GET_INTENT_FOR_INTENT_SENDER_TRANSACTION: {
  1898.             data.enforceInterface(IActivityManager.descriptor);
  1899.             IIntentSender r = IIntentSender.Stub.asInterface(
  1900.                 data.readStrongBinder());
  1901.             Intent intent = getIntentForIntentSender(r);
  1902.             reply.writeNoException();
  1903.             if (intent != null) {
  1904.                 reply.writeInt(1);
  1905.                 intent.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  1906.             } else {
  1907.                 reply.writeInt(0);
  1908.             }
  1909.             return true;
  1910.         }
  1911.  
  1912.         case GET_TAG_FOR_INTENT_SENDER_TRANSACTION: {
  1913.             data.enforceInterface(IActivityManager.descriptor);
  1914.             IIntentSender r = IIntentSender.Stub.asInterface(
  1915.                 data.readStrongBinder());
  1916.             String prefix = data.readString();
  1917.             String tag = getTagForIntentSender(r, prefix);
  1918.             reply.writeNoException();
  1919.             reply.writeString(tag);
  1920.             return true;
  1921.         }
  1922.  
  1923.         case UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION: {
  1924.             data.enforceInterface(IActivityManager.descriptor);
  1925.             Configuration config = Configuration.CREATOR.createFromParcel(data);
  1926.             updatePersistentConfiguration(config);
  1927.             reply.writeNoException();
  1928.             return true;
  1929.         }
  1930.  
  1931.         case GET_PROCESS_PSS_TRANSACTION: {
  1932.             data.enforceInterface(IActivityManager.descriptor);
  1933.             int[] pids = data.createIntArray();
  1934.             long[] pss = getProcessPss(pids);
  1935.             reply.writeNoException();
  1936.             reply.writeLongArray(pss);
  1937.             return true;
  1938.         }
  1939.  
  1940.         case SHOW_BOOT_MESSAGE_TRANSACTION: {
  1941.             data.enforceInterface(IActivityManager.descriptor);
  1942.             CharSequence msg = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
  1943.             boolean always = data.readInt() != 0;
  1944.             showBootMessage(msg, always);
  1945.             reply.writeNoException();
  1946.             return true;
  1947.         }
  1948.  
  1949.         case KEYGUARD_WAITING_FOR_ACTIVITY_DRAWN_TRANSACTION: {
  1950.             data.enforceInterface(IActivityManager.descriptor);
  1951.             keyguardWaitingForActivityDrawn();
  1952.             reply.writeNoException();
  1953.             return true;
  1954.         }
  1955.  
  1956.         case KEYGUARD_GOING_AWAY_TRANSACTION: {
  1957.             data.enforceInterface(IActivityManager.descriptor);
  1958.             keyguardGoingAway(data.readInt() != 0, data.readInt() != 0);
  1959.             reply.writeNoException();
  1960.             return true;
  1961.         }
  1962.  
  1963.         case SHOULD_UP_RECREATE_TASK_TRANSACTION: {
  1964.             data.enforceInterface(IActivityManager.descriptor);
  1965.             IBinder token = data.readStrongBinder();
  1966.             String destAffinity = data.readString();
  1967.             boolean res = shouldUpRecreateTask(token, destAffinity);
  1968.             reply.writeNoException();
  1969.             reply.writeInt(res ? 1 : 0);
  1970.             return true;
  1971.         }
  1972.  
  1973.         case NAVIGATE_UP_TO_TRANSACTION: {
  1974.             data.enforceInterface(IActivityManager.descriptor);
  1975.             IBinder token = data.readStrongBinder();
  1976.             Intent target = Intent.CREATOR.createFromParcel(data);
  1977.             int resultCode = data.readInt();
  1978.             Intent resultData = null;
  1979.             if (data.readInt() != 0) {
  1980.                 resultData = Intent.CREATOR.createFromParcel(data);
  1981.             }
  1982.             boolean res = navigateUpTo(token, target, resultCode, resultData);
  1983.             reply.writeNoException();
  1984.             reply.writeInt(res ? 1 : 0);
  1985.             return true;
  1986.         }
  1987.  
  1988.         case GET_LAUNCHED_FROM_UID_TRANSACTION: {
  1989.             data.enforceInterface(IActivityManager.descriptor);
  1990.             IBinder token = data.readStrongBinder();
  1991.             int res = getLaunchedFromUid(token);
  1992.             reply.writeNoException();
  1993.             reply.writeInt(res);
  1994.             return true;
  1995.         }
  1996.  
  1997.         case GET_LAUNCHED_FROM_PACKAGE_TRANSACTION: {
  1998.             data.enforceInterface(IActivityManager.descriptor);
  1999.             IBinder token = data.readStrongBinder();
  2000.             String res = getLaunchedFromPackage(token);
  2001.             reply.writeNoException();
  2002.             reply.writeString(res);
  2003.             return true;
  2004.         }
  2005.  
  2006.         case REGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
  2007.             data.enforceInterface(IActivityManager.descriptor);
  2008.             IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
  2009.                     data.readStrongBinder());
  2010.             registerUserSwitchObserver(observer);
  2011.             reply.writeNoException();
  2012.             return true;
  2013.         }
  2014.  
  2015.         case UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
  2016.             data.enforceInterface(IActivityManager.descriptor);
  2017.             IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
  2018.                     data.readStrongBinder());
  2019.             unregisterUserSwitchObserver(observer);
  2020.             reply.writeNoException();
  2021.             return true;
  2022.         }
  2023.  
  2024.         case REQUEST_BUG_REPORT_TRANSACTION: {
  2025.             data.enforceInterface(IActivityManager.descriptor);
  2026.             requestBugReport();
  2027.             reply.writeNoException();
  2028.             return true;
  2029.         }
  2030.  
  2031.         case INPUT_DISPATCHING_TIMED_OUT_TRANSACTION: {
  2032.             data.enforceInterface(IActivityManager.descriptor);
  2033.             int pid = data.readInt();
  2034.             boolean aboveSystem = data.readInt() != 0;
  2035.             String reason = data.readString();
  2036.             long res = inputDispatchingTimedOut(pid, aboveSystem, reason);
  2037.             reply.writeNoException();
  2038.             reply.writeLong(res);
  2039.             return true;
  2040.         }
  2041.  
  2042.         case GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
  2043.             data.enforceInterface(IActivityManager.descriptor);
  2044.             int requestType = data.readInt();
  2045.             Bundle res = getAssistContextExtras(requestType);
  2046.             reply.writeNoException();
  2047.             reply.writeBundle(res);
  2048.             return true;
  2049.         }
  2050.  
  2051.         case REQUEST_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
  2052.             data.enforceInterface(IActivityManager.descriptor);
  2053.             int requestType = data.readInt();
  2054.             IResultReceiver receiver = IResultReceiver.Stub.asInterface(data.readStrongBinder());
  2055.             IBinder activityToken = data.readStrongBinder();
  2056.             boolean res = requestAssistContextExtras(requestType, receiver, activityToken);
  2057.             reply.writeNoException();
  2058.             reply.writeInt(res ? 1 : 0);
  2059.             return true;
  2060.         }
  2061.  
  2062.         case REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
  2063.             data.enforceInterface(IActivityManager.descriptor);
  2064.             IBinder token = data.readStrongBinder();
  2065.             Bundle extras = data.readBundle();
  2066.             AssistStructure structure = AssistStructure.CREATOR.createFromParcel(data);
  2067.             AssistContent content = AssistContent.CREATOR.createFromParcel(data);
  2068.             Uri referrer = data.readInt() != 0 ? Uri.CREATOR.createFromParcel(data) : null;
  2069.             reportAssistContextExtras(token, extras, structure, content, referrer);
  2070.             reply.writeNoException();
  2071.             return true;
  2072.         }
  2073.  
  2074.         case LAUNCH_ASSIST_INTENT_TRANSACTION: {
  2075.             data.enforceInterface(IActivityManager.descriptor);
  2076.             Intent intent = Intent.CREATOR.createFromParcel(data);
  2077.             int requestType = data.readInt();
  2078.             String hint = data.readString();
  2079.             int userHandle = data.readInt();
  2080.             Bundle args = data.readBundle();
  2081.             boolean res = launchAssistIntent(intent, requestType, hint, userHandle, args);
  2082.             reply.writeNoException();
  2083.             reply.writeInt(res ? 1 : 0);
  2084.             return true;
  2085.         }
  2086.  
  2087.         case IS_SCREEN_CAPTURE_ALLOWED_ON_CURRENT_ACTIVITY_TRANSACTION: {
  2088.             data.enforceInterface(IActivityManager.descriptor);
  2089.             boolean res = isAssistDataAllowedOnCurrentActivity();
  2090.             reply.writeNoException();
  2091.             reply.writeInt(res ? 1 : 0);
  2092.             return true;
  2093.         }
  2094.  
  2095.         case SHOW_ASSIST_FROM_ACTIVITY_TRANSACTION: {
  2096.             data.enforceInterface(IActivityManager.descriptor);
  2097.             IBinder token = data.readStrongBinder();
  2098.             Bundle args = data.readBundle();
  2099.             boolean res = showAssistFromActivity(token, args);
  2100.             reply.writeNoException();
  2101.             reply.writeInt(res ? 1 : 0);
  2102.             return true;
  2103.         }
  2104.  
  2105.         case KILL_UID_TRANSACTION: {
  2106.             data.enforceInterface(IActivityManager.descriptor);
  2107.             int appId = data.readInt();
  2108.             int userId = data.readInt();
  2109.             String reason = data.readString();
  2110.             killUid(appId, userId, reason);
  2111.             reply.writeNoException();
  2112.             return true;
  2113.         }
  2114.  
  2115.         case HANG_TRANSACTION: {
  2116.             data.enforceInterface(IActivityManager.descriptor);
  2117.             IBinder who = data.readStrongBinder();
  2118.             boolean allowRestart = data.readInt() != 0;
  2119.             hang(who, allowRestart);
  2120.             reply.writeNoException();
  2121.             return true;
  2122.         }
  2123.  
  2124.         case REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION: {
  2125.             data.enforceInterface(IActivityManager.descriptor);
  2126.             IBinder token = data.readStrongBinder();
  2127.             reportActivityFullyDrawn(token);
  2128.             reply.writeNoException();
  2129.             return true;
  2130.         }
  2131.  
  2132.         case NOTIFY_ACTIVITY_DRAWN_TRANSACTION: {
  2133.             data.enforceInterface(IActivityManager.descriptor);
  2134.             IBinder token = data.readStrongBinder();
  2135.             notifyActivityDrawn(token);
  2136.             reply.writeNoException();
  2137.             return true;
  2138.         }
  2139.  
  2140.         case RESTART_TRANSACTION: {
  2141.             data.enforceInterface(IActivityManager.descriptor);
  2142.             restart();
  2143.             reply.writeNoException();
  2144.             return true;
  2145.         }
  2146.  
  2147.         case PERFORM_IDLE_MAINTENANCE_TRANSACTION: {
  2148.             data.enforceInterface(IActivityManager.descriptor);
  2149.             performIdleMaintenance();
  2150.             reply.writeNoException();
  2151.             return true;
  2152.         }
  2153.  
  2154.         case CREATE_VIRTUAL_ACTIVITY_CONTAINER_TRANSACTION: {
  2155.             data.enforceInterface(IActivityManager.descriptor);
  2156.             IBinder parentActivityToken = data.readStrongBinder();
  2157.             IActivityContainerCallback callback =
  2158.                     IActivityContainerCallback.Stub.asInterface(data.readStrongBinder());
  2159.             IActivityContainer activityContainer =
  2160.                     createVirtualActivityContainer(parentActivityToken, callback);
  2161.             reply.writeNoException();
  2162.             if (activityContainer != null) {
  2163.                 reply.writeInt(1);
  2164.                 reply.writeStrongBinder(activityContainer.asBinder());
  2165.             } else {
  2166.                 reply.writeInt(0);
  2167.             }
  2168.             return true;
  2169.         }
  2170.  
  2171.         case DELETE_ACTIVITY_CONTAINER_TRANSACTION:  {
  2172.             data.enforceInterface(IActivityManager.descriptor);
  2173.             IActivityContainer activityContainer =
  2174.                     IActivityContainer.Stub.asInterface(data.readStrongBinder());
  2175.             deleteActivityContainer(activityContainer);
  2176.             reply.writeNoException();
  2177.             return true;
  2178.         }
  2179.  
  2180.         case CREATE_STACK_ON_DISPLAY: {
  2181.             data.enforceInterface(IActivityManager.descriptor);
  2182.             int displayId = data.readInt();
  2183.             IActivityContainer activityContainer = createStackOnDisplay(displayId);
  2184.             reply.writeNoException();
  2185.             if (activityContainer != null) {
  2186.                 reply.writeInt(1);
  2187.                 reply.writeStrongBinder(activityContainer.asBinder());
  2188.             } else {
  2189.                 reply.writeInt(0);
  2190.             }
  2191.             return true;
  2192.         }
  2193.  
  2194.         case GET_ACTIVITY_DISPLAY_ID_TRANSACTION: {
  2195.             data.enforceInterface(IActivityManager.descriptor);
  2196.             IBinder activityToken = data.readStrongBinder();
  2197.             int displayId = getActivityDisplayId(activityToken);
  2198.             reply.writeNoException();
  2199.             reply.writeInt(displayId);
  2200.             return true;
  2201.         }
  2202.  
  2203.         case START_LOCK_TASK_BY_TASK_ID_TRANSACTION: {
  2204.             data.enforceInterface(IActivityManager.descriptor);
  2205.             final int taskId = data.readInt();
  2206.             startLockTaskMode(taskId);
  2207.             reply.writeNoException();
  2208.             return true;
  2209.         }
  2210.  
  2211.         case START_LOCK_TASK_BY_TOKEN_TRANSACTION: {
  2212.             data.enforceInterface(IActivityManager.descriptor);
  2213.             IBinder token = data.readStrongBinder();
  2214.             startLockTaskMode(token);
  2215.             reply.writeNoException();
  2216.             return true;
  2217.         }
  2218.  
  2219.         case START_LOCK_TASK_BY_CURRENT_TRANSACTION: {
  2220.             data.enforceInterface(IActivityManager.descriptor);
  2221.             startLockTaskModeOnCurrent();
  2222.             reply.writeNoException();
  2223.             return true;
  2224.         }
  2225.  
  2226.         case STOP_LOCK_TASK_MODE_TRANSACTION: {
  2227.             data.enforceInterface(IActivityManager.descriptor);
  2228.             stopLockTaskMode();
  2229.             reply.writeNoException();
  2230.             return true;
  2231.         }
  2232.  
  2233.         case STOP_LOCK_TASK_BY_CURRENT_TRANSACTION: {
  2234.             data.enforceInterface(IActivityManager.descriptor);
  2235.             stopLockTaskModeOnCurrent();
  2236.             reply.writeNoException();
  2237.             return true;
  2238.         }
  2239.  
  2240.         case IS_IN_LOCK_TASK_MODE_TRANSACTION: {
  2241.             data.enforceInterface(IActivityManager.descriptor);
  2242.             final boolean isInLockTaskMode = isInLockTaskMode();
  2243.             reply.writeNoException();
  2244.             reply.writeInt(isInLockTaskMode ? 1 : 0);
  2245.             return true;
  2246.         }
  2247.  
  2248.         case GET_LOCK_TASK_MODE_STATE_TRANSACTION: {
  2249.             data.enforceInterface(IActivityManager.descriptor);
  2250.             final int lockTaskModeState = getLockTaskModeState();
  2251.             reply.writeNoException();
  2252.             reply.writeInt(lockTaskModeState);
  2253.             return true;
  2254.         }
  2255.  
  2256.         case SHOW_LOCK_TASK_ESCAPE_MESSAGE_TRANSACTION: {
  2257.             data.enforceInterface(IActivityManager.descriptor);
  2258.             final IBinder token = data.readStrongBinder();
  2259.             showLockTaskEscapeMessage(token);
  2260.             reply.writeNoException();
  2261.             return true;
  2262.         }
  2263.  
  2264.         case SET_TASK_DESCRIPTION_TRANSACTION: {
  2265.             data.enforceInterface(IActivityManager.descriptor);
  2266.             IBinder token = data.readStrongBinder();
  2267.             ActivityManager.TaskDescription values =
  2268.                     ActivityManager.TaskDescription.CREATOR.createFromParcel(data);
  2269.             setTaskDescription(token, values);
  2270.             reply.writeNoException();
  2271.             return true;
  2272.         }
  2273.  
  2274.         case SET_TASK_RESIZEABLE_TRANSACTION: {
  2275.             data.enforceInterface(IActivityManager.descriptor);
  2276.             int taskId = data.readInt();
  2277.             boolean resizeable = (data.readInt() == 1) ? true : false;
  2278.             setTaskResizeable(taskId, resizeable);
  2279.             reply.writeNoException();
  2280.             return true;
  2281.         }
  2282.  
  2283.         case RESIZE_TASK_TRANSACTION: {
  2284.             data.enforceInterface(IActivityManager.descriptor);
  2285.             int taskId = data.readInt();
  2286.             Rect r = Rect.CREATOR.createFromParcel(data);
  2287.             resizeTask(taskId, r);
  2288.             reply.writeNoException();
  2289.             return true;
  2290.         }
  2291.  
  2292.         case GET_TASK_DESCRIPTION_ICON_TRANSACTION: {
  2293.             data.enforceInterface(IActivityManager.descriptor);
  2294.             String filename = data.readString();
  2295.             Bitmap icon = getTaskDescriptionIcon(filename);
  2296.             reply.writeNoException();
  2297.             if (icon == null) {
  2298.                 reply.writeInt(0);
  2299.             } else {
  2300.                 reply.writeInt(1);
  2301.                 icon.writeToParcel(reply, 0);
  2302.             }
  2303.             return true;
  2304.         }
  2305.  
  2306.         case START_IN_PLACE_ANIMATION_TRANSACTION: {
  2307.             data.enforceInterface(IActivityManager.descriptor);
  2308.             final Bundle bundle;
  2309.             if (data.readInt() == 0) {
  2310.                 bundle = null;
  2311.             } else {
  2312.                 bundle = data.readBundle();
  2313.             }
  2314.             final ActivityOptions options = bundle == null ? null : new ActivityOptions(bundle);
  2315.             startInPlaceAnimationOnFrontMostApplication(options);
  2316.             reply.writeNoException();
  2317.             return true;
  2318.         }
  2319.  
  2320.         case REQUEST_VISIBLE_BEHIND_TRANSACTION: {
  2321.             data.enforceInterface(IActivityManager.descriptor);
  2322.             IBinder token = data.readStrongBinder();
  2323.             boolean enable = data.readInt() > 0;
  2324.             boolean success = requestVisibleBehind(token, enable);
  2325.             reply.writeNoException();
  2326.             reply.writeInt(success ? 1 : 0);
  2327.             return true;
  2328.         }
  2329.  
  2330.         case IS_BACKGROUND_VISIBLE_BEHIND_TRANSACTION: {
  2331.             data.enforceInterface(IActivityManager.descriptor);
  2332.             IBinder token = data.readStrongBinder();
  2333.             final boolean enabled = isBackgroundVisibleBehind(token);
  2334.             reply.writeNoException();
  2335.             reply.writeInt(enabled ? 1 : 0);
  2336.             return true;
  2337.         }
  2338.  
  2339.         case BACKGROUND_RESOURCES_RELEASED_TRANSACTION: {
  2340.             data.enforceInterface(IActivityManager.descriptor);
  2341.             IBinder token = data.readStrongBinder();
  2342.             backgroundResourcesReleased(token);
  2343.             reply.writeNoException();
  2344.             return true;
  2345.         }
  2346.  
  2347.         case NOTIFY_LAUNCH_TASK_BEHIND_COMPLETE_TRANSACTION: {
  2348.             data.enforceInterface(IActivityManager.descriptor);
  2349.             IBinder token = data.readStrongBinder();
  2350.             notifyLaunchTaskBehindComplete(token);
  2351.             reply.writeNoException();
  2352.             return true;
  2353.         }
  2354.  
  2355.         case NOTIFY_ENTER_ANIMATION_COMPLETE_TRANSACTION: {
  2356.             data.enforceInterface(IActivityManager.descriptor);
  2357.             IBinder token = data.readStrongBinder();
  2358.             notifyEnterAnimationComplete(token);
  2359.             reply.writeNoException();
  2360.             return true;
  2361.         }
  2362.  
  2363.         case BOOT_ANIMATION_COMPLETE_TRANSACTION: {
  2364.             data.enforceInterface(IActivityManager.descriptor);
  2365.             bootAnimationComplete();
  2366.             reply.writeNoException();
  2367.             return true;
  2368.         }
  2369.  
  2370.         case NOTIFY_CLEARTEXT_NETWORK_TRANSACTION: {
  2371.             data.enforceInterface(IActivityManager.descriptor);
  2372.             final int uid = data.readInt();
  2373.             final byte[] firstPacket = data.createByteArray();
  2374.             notifyCleartextNetwork(uid, firstPacket);
  2375.             reply.writeNoException();
  2376.             return true;
  2377.         }
  2378.  
  2379.         case SET_DUMP_HEAP_DEBUG_LIMIT_TRANSACTION: {
  2380.             data.enforceInterface(IActivityManager.descriptor);
  2381.             String procName = data.readString();
  2382.             int uid = data.readInt();
  2383.             long maxMemSize = data.readLong();
  2384.             String reportPackage = data.readString();
  2385.             setDumpHeapDebugLimit(procName, uid, maxMemSize, reportPackage);
  2386.             reply.writeNoException();
  2387.             return true;
  2388.         }
  2389.  
  2390.         case DUMP_HEAP_FINISHED_TRANSACTION: {
  2391.             data.enforceInterface(IActivityManager.descriptor);
  2392.             String path = data.readString();
  2393.             dumpHeapFinished(path);
  2394.             reply.writeNoException();
  2395.             return true;
  2396.         }
  2397.  
  2398.         case SET_VOICE_KEEP_AWAKE_TRANSACTION: {
  2399.             data.enforceInterface(IActivityManager.descriptor);
  2400.             IVoiceInteractionSession session = IVoiceInteractionSession.Stub.asInterface(
  2401.                     data.readStrongBinder());
  2402.             boolean keepAwake = data.readInt() != 0;
  2403.             setVoiceKeepAwake(session, keepAwake);
  2404.             reply.writeNoException();
  2405.             return true;
  2406.         }
  2407.  
  2408.         case UPDATE_LOCK_TASK_PACKAGES_TRANSACTION: {
  2409.             data.enforceInterface(IActivityManager.descriptor);
  2410.             int userId = data.readInt();
  2411.             String[] packages = data.readStringArray();
  2412.             updateLockTaskPackages(userId, packages);
  2413.             reply.writeNoException();
  2414.             return true;
  2415.         }
  2416.  
  2417.         case UPDATE_DEVICE_OWNER_TRANSACTION: {
  2418.             data.enforceInterface(IActivityManager.descriptor);
  2419.             String packageName = data.readString();
  2420.             updateDeviceOwner(packageName);
  2421.             reply.writeNoException();
  2422.             return true;
  2423.         }
  2424.  
  2425.         case GET_PACKAGE_PROCESS_STATE_TRANSACTION: {
  2426.             data.enforceInterface(IActivityManager.descriptor);
  2427.             String pkg = data.readString();
  2428.             String callingPackage = data.readString();
  2429.             int res = getPackageProcessState(pkg, callingPackage);
  2430.             reply.writeNoException();
  2431.             reply.writeInt(res);
  2432.             return true;
  2433.         }
  2434.  
  2435.         case SET_PROCESS_MEMORY_TRIM_TRANSACTION: {
  2436.             data.enforceInterface(IActivityManager.descriptor);
  2437.             String process = data.readString();
  2438.             int userId = data.readInt();
  2439.             int level = data.readInt();
  2440.             boolean res = setProcessMemoryTrimLevel(process, userId, level);
  2441.             reply.writeNoException();
  2442.             reply.writeInt(res ? 1 : 0);
  2443.             return true;
  2444.         }
  2445.  
  2446.         case IS_ROOT_VOICE_INTERACTION_TRANSACTION: {
  2447.             data.enforceInterface(IActivityManager.descriptor);
  2448.             IBinder token = data.readStrongBinder();
  2449.             boolean res = isRootVoiceInteraction(token);
  2450.             reply.writeNoException();
  2451.             reply.writeInt(res ? 1 : 0);
  2452.             return true;
  2453.         }
  2454.         }
  2455.  
  2456.         return super.onTransact(code, data, reply, flags);
  2457.     }


在 ATTACH_APPLICATION_TRANSACTION 这个分支，我们可以发现这几句代码： 

  1.             if (app != null) {
  2.                 attachApplication(app);
  3.             }


这个分支间接调用了一个remote方法，throws 一个 RemoteException 异常，由子类com.android.server.am.ActivityManagerService实现


② com.android.server.am.ActivityManagerService 类的 attachApplicationLocked 函数

com.android.server.am.ActivityManagerService 类的 attachApplicationLocked 函数代码：

注：只直接跳跃至下面这一段(注：我们只需要看mormalMode分支就行)：

  1.         // See if the top visible activity is waiting to run in this process...
  2. 		// 这里咱们可以抽象的理解为正常的没有问题的
  3.         if (normalMode) {
  4.             try {
  5.                 if (mStackSupervisor.attachApplicationLocked(app)) {
  6.                     didSomething = true;
  7.                 }
  8.             } catch (Exception e) {
  9.                 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
  10.                 badApp = true;
  11.             }
  12.         }
  13.  
  14.         // Find any services that should be running in this process...
  15. 		// 当然这里就是有问题的了
  16.         if (!badApp) {
  17.             try {
  18.                 didSomething |= mServices.attachApplicationLocked(app, processName);
  19.             } catch (Exception e) {
  20.                 Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
  21.                 badApp = true;
  22.             }
  23.         }


attachApplicationLocked 函数全代码：

  1.     private final boolean attachApplicationLocked(IApplicationThread thread,
  2.             int pid) {
  3.  
  4.         // Find the application record that is being attached...  either via
  5.         // the pid if we are running in multiple processes, or just pull the
  6.         // next app record if we are emulating process with anonymous threads.
  7.         ProcessRecord app;
  8.         if (pid != MY_PID && pid >= 0) {
  9.             synchronized (mPidsSelfLocked) {
  10.                 app = mPidsSelfLocked.get(pid);
  11.             }
  12.         } else {
  13.             app = null;
  14.         }
  15.  
  16.         if (app == null) {
  17.             Slog.w(TAG, "No pending application record for pid " + pid
  18.                     + " (IApplicationThread " + thread + "); dropping process");
  19.             EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid);
  20.             if (pid > 0 && pid != MY_PID) {
  21.                 Process.killProcessQuiet(pid);
  22.                 //TODO: killProcessGroup(app.info.uid, pid);
  23.             } else {
  24.                 try {
  25.                     thread.scheduleExit();
  26.                 } catch (Exception e) {
  27.                     // Ignore exceptions.
  28.                 }
  29.             }
  30.             return false;
  31.         }
  32.  
  33.         // If this application record is still attached to a previous
  34.         // process, clean it up now.
  35.         if (app.thread != null) {
  36.             handleAppDiedLocked(app, true, true);
  37.         }
  38.  
  39.         // Tell the process all about itself.
  40.  
  41.         if (DEBUG_ALL) Slog.v(
  42.                 TAG, "Binding process pid " + pid + " to record " + app);
  43.  
  44.         final String processName = app.processName;
  45.         try {
  46.             AppDeathRecipient adr = new AppDeathRecipient(
  47.                     app, pid, thread);
  48.             thread.asBinder().linkToDeath(adr, 0);
  49.             app.deathRecipient = adr;
  50.         } catch (RemoteException e) {
  51.             app.resetPackageList(mProcessStats);
  52.             startProcessLocked(app, "link fail", processName);
  53.             return false;
  54.         }
  55.  
  56.         EventLog.writeEvent(EventLogTags.AM_PROC_BOUND, app.userId, app.pid, app.processName);
  57.  
  58.         app.makeActive(thread, mProcessStats);
  59.         app.curAdj = app.setAdj = -100;
  60.         app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT;
  61.         app.forcingToForeground = null;
  62.         updateProcessForegroundLocked(app, false, false);
  63.         app.hasShownUi = false;
  64.         app.debugging = false;
  65.         app.cached = false;
  66.         app.killedByAm = false;
  67.  
  68.         mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
  69.  
  70.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
  71.         List<ProviderInfo> providers = normalMode ? generateApplicationProvidersLocked(app) : null;
  72.  
  73.         if (!normalMode) {
  74.             Slog.i(TAG, "Launching preboot mode app: " + app);
  75.         }
  76.  
  77.         if (DEBUG_ALL) Slog.v(
  78.             TAG, "New app record " + app
  79.             + " thread=" + thread.asBinder() + " pid=" + pid);
  80.         try {
  81.             int testMode = IApplicationThread.DEBUG_OFF;
  82.             if (mDebugApp != null && mDebugApp.equals(processName)) {
  83.                 testMode = mWaitForDebugger
  84.                     ? IApplicationThread.DEBUG_WAIT
  85.                     : IApplicationThread.DEBUG_ON;
  86.                 app.debugging = true;
  87.                 if (mDebugTransient) {
  88.                     mDebugApp = mOrigDebugApp;
  89.                     mWaitForDebugger = mOrigWaitForDebugger;
  90.                 }
  91.             }
  92.             String profileFile = app.instrumentationProfileFile;
  93.             ParcelFileDescriptor profileFd = null;
  94.             int samplingInterval = 0;
  95.             boolean profileAutoStop = false;
  96.             if (mProfileApp != null && mProfileApp.equals(processName)) {
  97.                 mProfileProc = app;
  98.                 profileFile = mProfileFile;
  99.                 profileFd = mProfileFd;
  100.                 samplingInterval = mSamplingInterval;
  101.                 profileAutoStop = mAutoStopProfiler;
  102.             }
  103.             boolean enableOpenGlTrace = false;
  104.             if (mOpenGlTraceApp != null && mOpenGlTraceApp.equals(processName)) {
  105.                 enableOpenGlTrace = true;
  106.                 mOpenGlTraceApp = null;
  107.             }
  108.  
  109.             // If the app is being launched for restore or full backup, set it up specially
  110.             boolean isRestrictedBackupMode = false;
  111.             if (mBackupTarget != null && mBackupAppName.equals(processName)) {
  112.                 isRestrictedBackupMode = (mBackupTarget.backupMode == BackupRecord.RESTORE)
  113.                         || (mBackupTarget.backupMode == BackupRecord.RESTORE_FULL)
  114.                         || (mBackupTarget.backupMode == BackupRecord.BACKUP_FULL);
  115.             }
  116.  
  117.             ensurePackageDexOpt(app.instrumentationInfo != null
  118.                     ? app.instrumentationInfo.packageName
  119.                     : app.info.packageName);
  120.             if (app.instrumentationClass != null) {
  121.                 ensurePackageDexOpt(app.instrumentationClass.getPackageName());
  122.             }
  123.             if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Binding proc "
  124.                     + processName + " with config " + mConfiguration);
  125.             ApplicationInfo appInfo = app.instrumentationInfo != null
  126.                     ? app.instrumentationInfo : app.info;
  127.             app.compat = compatibilityInfoForPackageLocked(appInfo);
  128.             if (profileFd != null) {
  129.                 profileFd = profileFd.dup();
  130.             }
  131.             ProfilerInfo profilerInfo = profileFile == null ? null
  132.                     : new ProfilerInfo(profileFile, profileFd, samplingInterval, profileAutoStop);
  133.             thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
  134.                     profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
  135.                     app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
  136.                     isRestrictedBackupMode || !normalMode, app.persistent,
  137.                     new Configuration(mConfiguration), app.compat,
  138.                     getCommonServicesLocked(app.isolated),
  139.                     mCoreSettingsObserver.getCoreSettingsLocked());
  140.             updateLruProcessLocked(app, false, null);
  141.             app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
  142.         } catch (Exception e) {
  143.             // todo: Yikes!  What should we do?  For now we will try to
  144.             // start another process, but that could easily get us in
  145.             // an infinite loop of restarting processes...
  146.             Slog.wtf(TAG, "Exception thrown during bind of " + app, e);
  147.  
  148.             app.resetPackageList(mProcessStats);
  149.             app.unlinkDeathRecipient();
  150.             startProcessLocked(app, "bind fail", processName);
  151.             return false;
  152.         }
  153.  
  154.         // Remove this record from the list of starting applications.
  155.         mPersistentStartingProcesses.remove(app);
  156.         if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES,
  157.                 "Attach application locked removing on hold: " + app);
  158.         mProcessesOnHold.remove(app);
  159.  
  160.         boolean badApp = false;
  161.         boolean didSomething = false;
  162.  
  163.         // See if the top visible activity is waiting to run in this process...
  164.         if (normalMode) {
  165.             try {
  166.                 if (mStackSupervisor.attachApplicationLocked(app)) {
  167.                     didSomething = true;
  168.                 }
  169.             } catch (Exception e) {
  170.                 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
  171.                 badApp = true;
  172.             }
  173.         }
  174.  
  175.         // Find any services that should be running in this process...
  176.         if (!badApp) {
  177.             try {
  178.                 didSomething |= mServices.attachApplicationLocked(app, processName);
  179.             } catch (Exception e) {
  180.                 Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
  181.                 badApp = true;
  182.             }
  183.         }
  184.  
  185.         // Check if a next-broadcast receiver is in this process...
  186.         if (!badApp && isPendingBroadcastProcessLocked(pid)) {
  187.             try {
  188.                 didSomething |= sendPendingBroadcastsLocked(app);
  189.             } catch (Exception e) {
  190.                 // If the app died trying to launch the receiver we declare it 'bad'
  191.                 Slog.wtf(TAG, "Exception thrown dispatching broadcasts in " + app, e);
  192.                 badApp = true;
  193.             }
  194.         }
  195.  
  196.         // Check whether the next backup agent is in this process...
  197.         if (!badApp && mBackupTarget != null && mBackupTarget.appInfo.uid == app.uid) {
  198.             if (DEBUG_BACKUP) Slog.v(TAG_BACKUP,
  199.                     "New app is backup target, launching agent for " + app);
  200.             ensurePackageDexOpt(mBackupTarget.appInfo.packageName);
  201.             try {
  202.                 thread.scheduleCreateBackupAgent(mBackupTarget.appInfo,
  203.                         compatibilityInfoForPackageLocked(mBackupTarget.appInfo),
  204.                         mBackupTarget.backupMode);
  205.             } catch (Exception e) {
  206.                 Slog.wtf(TAG, "Exception thrown creating backup agent in " + app, e);
  207.                 badApp = true;
  208.             }
  209.         }
  210.  
  211.         if (badApp) {
  212.             app.kill("error during init", true);
  213.             handleAppDiedLocked(app, false, true);
  214.             return false;
  215.         }
  216.  
  217.         if (!didSomething) {
  218.             updateOomAdjLocked();
  219.         }
  220.  
  221.         return true;
  222.     }

attachApplicationLocked  函数调用 com.android.server.am.ActivityStackSupervisor 类的 attachApplicationLocked 函数

③ com.android.server.am.ActivityStackSupervisor 类的 attachApplicationLocked 函数 

com.android.server.am.ActivityStackSupervisor 类的 attachApplicationLocked 函数代码：

  1.     boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
  2.         final String processName = app.processName;
  3.         boolean didSomething = false;
  4.         for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
  5.             ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
  6.             for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
  7.                 final ActivityStack stack = stacks.get(stackNdx);
  8.                 if (!isFrontStack(stack)) {
  9.                     continue;
  10.                 }
  11.                 ActivityRecord hr = stack.topRunningActivityLocked(null);
  12.                 if (hr != null) {
  13.                     if (hr.app == null && app.uid == hr.info.applicationInfo.uid
  14.                             && processName.equals(hr.processName)) {
  15.                         try {
  16.                             if (realStartActivityLocked(hr, app, true, true)) {
  17.                                 didSomething = true;
  18.                             }
  19.                         } catch (RemoteException e) {
  20.                             Slog.w(TAG, "Exception in new application when starting activity "
  21.                                   + hr.intent.getComponent().flattenToShortString(), e);
  22.                             throw e;
  23.                         }
  24.                     }
  25.                 }
  26.             }
  27.         }
  28.         if (!didSomething) {
  29.             ensureActivitiesVisibleLocked(null, 0);
  30.         }
  31.         return didSomething;
  32.     }


该函数调用了内部方法 realStartActivityLocked(hr, app, true, true)

realStartActivityLocked 函数代码：

  1.             // 可直接跳至这段代码处，app.thread.scheduleLaunchActivity 是重点，准备启动activity
  2. 			app.forceProcessStateUpTo(mService.mTopProcessState);
  3.             app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
  4.                     System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
  5.                     new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
  6.                     task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
  7.                     newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

realStartActivityLocked 函数全部代码：

  1.     final boolean realStartActivityLocked(ActivityRecord r,
  2.             ProcessRecord app, boolean andResume, boolean checkConfig)
  3.             throws RemoteException {
  4.  
  5.         if (andResume) {
  6.             r.startFreezingScreenLocked(app, 0);
  7.             mWindowManager.setAppVisibility(r.appToken, true);
  8.  
  9.             // schedule launch ticks to collect information about slow apps.
  10.             r.startLaunchTickingLocked();
  11.         }
  12.  
  13.         // Have the window manager re-evaluate the orientation of
  14.         // the screen based on the new activity order.  Note that
  15.         // as a result of this, it can call back into the activity
  16.         // manager with a new orientation.  We don't care about that,
  17.         // because the activity is not currently running so we are
  18.         // just restarting it anyway.
  19.         if (checkConfig) {
  20.             Configuration config = mWindowManager.updateOrientationFromAppTokens(
  21.                     mService.mConfiguration,
  22.                     r.mayFreezeScreenLocked(app) ? r.appToken : null);
  23.             mService.updateConfigurationLocked(config, r, false, false);
  24.         }
  25.  
  26.         r.app = app;
  27.         app.waitingToKill = null;
  28.         r.launchCount++;
  29.         r.lastLaunchTime = SystemClock.uptimeMillis();
  30.  
  31.         if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r);
  32.  
  33.         int idx = app.activities.indexOf(r);
  34.         if (idx < 0) {
  35.             app.activities.add(r);
  36.         }
  37.         mService.updateLruProcessLocked(app, true, null);
  38.         mService.updateOomAdjLocked();
  39.  
  40.         final TaskRecord task = r.task;
  41.         if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE ||
  42.                 task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) {
  43.             setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false);
  44.         }
  45.  
  46.         final ActivityStack stack = task.stack;
  47.         try {
  48.             if (app.thread == null) {
  49.                 throw new RemoteException();
  50.             }
  51.             List<ResultInfo> results = null;
  52.             List<ReferrerIntent> newIntents = null;
  53.             if (andResume) {
  54.                 results = r.results;
  55.                 newIntents = r.newIntents;
  56.             }
  57.             if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
  58.                     "Launching: " + r + " icicle=" + r.icicle + " with results=" + results
  59.                     + " newIntents=" + newIntents + " andResume=" + andResume);
  60.             if (andResume) {
  61.                 EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY,
  62.                         r.userId, System.identityHashCode(r),
  63.                         task.taskId, r.shortComponentName);
  64.             }
  65.             if (r.isHomeActivity() && r.isNotResolverActivity()) {
  66.                 // Home process is the root process of the task.
  67.                 mService.mHomeProcess = task.mActivities.get(0).app;
  68.             }
  69.             mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName());
  70.             r.sleeping = false;
  71.             r.forceNewConfig = false;
  72.             mService.showAskCompatModeDialogLocked(r);
  73.             r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);
  74.             ProfilerInfo profilerInfo = null;
  75.             if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) {
  76.                 if (mService.mProfileProc == null || mService.mProfileProc == app) {
  77.                     mService.mProfileProc = app;
  78.                     final String profileFile = mService.mProfileFile;
  79.                     if (profileFile != null) {
  80.                         ParcelFileDescriptor profileFd = mService.mProfileFd;
  81.                         if (profileFd != null) {
  82.                             try {
  83.                                 profileFd = profileFd.dup();
  84.                             } catch (IOException e) {
  85.                                 if (profileFd != null) {
  86.                                     try {
  87.                                         profileFd.close();
  88.                                     } catch (IOException o) {
  89.                                     }
  90.                                     profileFd = null;
  91.                                 }
  92.                             }
  93.                         }
  94.  
  95.                         profilerInfo = new ProfilerInfo(profileFile, profileFd,
  96.                                 mService.mSamplingInterval, mService.mAutoStopProfiler);
  97.                     }
  98.                 }
  99.             }
  100.  
  101.             if (andResume) {
  102.                 app.hasShownUi = true;
  103.                 app.pendingUiClean = true;
  104.             }
  105.             app.forceProcessStateUpTo(mService.mTopProcessState);
  106.             app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
  107.                     System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
  108.                     new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
  109.                     task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
  110.                     newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
  111.  
  112.             if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
  113.                 // This may be a heavy-weight process!  Note that the package
  114.                 // manager will ensure that only activity can run in the main
  115.                 // process of the .apk, which is the only thing that will be
  116.                 // considered heavy-weight.
  117.                 if (app.processName.equals(app.info.packageName)) {
  118.                     if (mService.mHeavyWeightProcess != null
  119.                             && mService.mHeavyWeightProcess != app) {
  120.                         Slog.w(TAG, "Starting new heavy weight process " + app
  121.                                 + " when already running "
  122.                                 + mService.mHeavyWeightProcess);
  123.                     }
  124.                     mService.mHeavyWeightProcess = app;
  125.                     Message msg = mService.mHandler.obtainMessage(
  126.                             ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG);
  127.                     msg.obj = r;
  128.                     mService.mHandler.sendMessage(msg);
  129.                 }
  130.             }
  131.  
  132.         } catch (RemoteException e) {
  133.             if (r.launchFailed) {
  134.                 // This is the second time we failed -- finish activity
  135.                 // and give up.
  136.                 Slog.e(TAG, "Second failure launching "
  137.                       + r.intent.getComponent().flattenToShortString()
  138.                       + ", giving up", e);
  139.                 mService.appDiedLocked(app);
  140.                 stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
  141.                         "2nd-crash", false);
  142.                 return false;
  143.             }
  144.  
  145.             // This is the first time we failed -- restart process and
  146.             // retry.
  147.             app.activities.remove(r);
  148.             throw e;
  149.         }
  150.  
  151.         r.launchFailed = false;
  152.         if (stack.updateLRUListLocked(r)) {
  153.             Slog.w(TAG, "Activity " + r
  154.                   + " being launched, but already in LRU list");
  155.         }
  156.  
  157.         if (andResume) {
  158.             // As part of the process of launching, ActivityThread also performs
  159.             // a resume.
  160.             stack.minimalResumeActivityLocked(r);
  161.         } else {
  162.             // This activity is not starting in the resumed state... which
  163.             // should look like we asked it to pause+stop (but remain visible),
  164.             // and it has done so and reported back the current icicle and
  165.             // other state.
  166.             if (DEBUG_STATES) Slog.v(TAG_STATES,
  167.                     "Moving to STOPPED: " + r + " (starting in stopped state)");
  168.             r.state = STOPPED;
  169.             r.stopped = true;
  170.         }
  171.  
  172.         // Launch the new version setup screen if needed.  We do this -after-
  173.         // launching the initial activity (that is, home), so that it can have
  174.         // a chance to initialize itself while in the background, making the
  175.         // switch back to it faster and look better.
  176.         if (isFrontStack(stack)) {
  177.             mService.startSetupActivityLocked();
  178.         }
  179.  
  180.         // Update any services we are bound to that might care about whether
  181.         // their client may have activities.
  182.         mService.mServices.updateServiceConnectionActivitiesLocked(r.app);
  183.  
  184.         return true;
  185.     }

下面解释 app.thread.scheduleLaunchActivity() 的来源 app 是类 com.android.server.am.ActivityStackSupervisor 中 ProcessRecord类的对象，com.android.server.am.ActivityStackSupervisor 调用 ProcessRecord类对象内部的 thread 对象，再调用 thread 对象的 scheduleLaunchActivity()  函数，下面看ProcessRecord类

④ ProcessRecord类代码：

  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 com.android.server.am;
  18.  
  19. import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
  20. import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
  21. import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
  22.  
  23. import android.util.ArraySet;
  24. import android.util.DebugUtils;
  25. import android.util.EventLog;
  26. import android.util.Slog;
  27. import com.android.internal.app.ProcessStats;
  28. import com.android.internal.os.BatteryStatsImpl;
  29.  
  30. import android.app.ActivityManager;
  31. import android.app.Dialog;
  32. import android.app.IApplicationThread;
  33. import android.app.IInstrumentationWatcher;
  34. import android.app.IUiAutomationConnection;
  35. import android.content.ComponentName;
  36. import android.content.Context;
  37. import android.content.pm.ApplicationInfo;
  38. import android.content.res.CompatibilityInfo;
  39. import android.os.Bundle;
  40. import android.os.IBinder;
  41. import android.os.Process;
  42. import android.os.SystemClock;
  43. import android.os.Trace;
  44. import android.os.UserHandle;
  45. import android.util.ArrayMap;
  46. import android.util.PrintWriterPrinter;
  47. import android.util.TimeUtils;
  48.  
  49. import java.io.PrintWriter;
  50. import java.util.ArrayList;
  51.  
  52. /**
  53.  * Full information about a particular process that
  54.  * is currently running.
  55.  */
  56. final class ProcessRecord {
  57.     private static final String TAG = TAG_WITH_CLASS_NAME ? "ProcessRecord" : TAG_AM;
  58.  
  59.     private final BatteryStatsImpl mBatteryStats; // where to collect runtime statistics
  60.     final ApplicationInfo info; // all about the first app in the process
  61.     final boolean isolated;     // true if this is a special isolated process
  62.     final int uid;              // uid of process; may be different from 'info' if isolated
  63.     final int userId;           // user of process.
  64.     final String processName;   // name of the process
  65.     // List of packages running in the process
  66.     final ArrayMap<String, ProcessStats.ProcessStateHolder> pkgList = new ArrayMap<>();
  67.     UidRecord uidRecord;        // overall state of process's uid.
  68.     ArraySet<String> pkgDeps;   // additional packages we have a dependency on
  69. 	// ProcessRecord 中的thread对象在此处定义
  70.     IApplicationThread thread;  // the actual proc...  may be null only if
  71.                                 // 'persistent' is true (in which case we
  72.                                 // are in the process of launching the app)
  73.     ProcessStats.ProcessState baseProcessTracker;
  74.     BatteryStatsImpl.Uid.Proc curProcBatteryStats;
  75.     int pid;                    // The process of this application; 0 if none
  76.     int[] gids;                 // The gids this process was launched with
  77.     String requiredAbi;         // The ABI this process was launched with
  78.     String instructionSet;      // The instruction set this process was launched with
  79.     boolean starting;           // True if the process is being started
  80.     long lastActivityTime;      // For managing the LRU list
  81.     long lastPssTime;           // Last time we retrieved PSS data
  82.     long nextPssTime;           // Next time we want to request PSS data
  83.     long lastStateTime;         // Last time setProcState changed
  84.     long initialIdlePss;        // Initial memory pss of process for idle maintenance.
  85.     long lastPss;               // Last computed memory pss.
  86.     long lastCachedPss;         // Last computed pss when in cached state.
  87.     int maxAdj;                 // Maximum OOM adjustment for this process
  88.     int curRawAdj;              // Current OOM unlimited adjustment for this process
  89.     int setRawAdj;              // Last set OOM unlimited adjustment for this process
  90.     int curAdj;                 // Current OOM adjustment for this process
  91.     int setAdj;                 // Last set OOM adjustment for this process
  92.     int curSchedGroup;          // Currently desired scheduling class
  93.     int setSchedGroup;          // Last set to background scheduling class
  94.     int trimMemoryLevel;        // Last selected memory trimming level
  95.     int curProcState = PROCESS_STATE_NONEXISTENT; // Currently computed process state
  96.     int repProcState = PROCESS_STATE_NONEXISTENT; // Last reported process state
  97.     int setProcState = PROCESS_STATE_NONEXISTENT; // Last set process state in process tracker
  98.     int pssProcState = PROCESS_STATE_NONEXISTENT; // Currently requesting pss for
  99.     boolean serviceb;           // Process currently is on the service B list
  100.     boolean serviceHighRam;     // We are forcing to service B list due to its RAM use
  101.     boolean setIsForeground;    // Running foreground UI when last set?
  102.     boolean notCachedSinceIdle; // Has this process not been in a cached state since last idle?
  103.     boolean hasClientActivities;  // Are there any client services with activities?
  104.     boolean hasStartedServices; // Are there any started services running in this process?
  105.     boolean foregroundServices; // Running any services that are foreground?
  106.     boolean foregroundActivities; // Running any activities that are foreground?
  107.     boolean repForegroundActivities; // Last reported foreground activities.
  108.     boolean systemNoUi;         // This is a system process, but not currently showing UI.
  109.     boolean hasShownUi;         // Has UI been shown in this process since it was started?
  110.     boolean pendingUiClean;     // Want to clean up resources from showing UI?
  111.     boolean hasAboveClient;     // Bound using BIND_ABOVE_CLIENT, so want to be lower
  112.     boolean treatLikeActivity;  // Bound using BIND_TREAT_LIKE_ACTIVITY
  113.     boolean bad;                // True if disabled in the bad process list
  114.     boolean killedByAm;         // True when proc has been killed by activity manager, not for RAM
  115.     boolean killed;             // True once we know the process has been killed
  116.     boolean procStateChanged;   // Keep track of whether we changed 'setAdj'.
  117.     boolean reportedInteraction;// Whether we have told usage stats about it being an interaction
  118.     long fgInteractionTime;     // When we became foreground for interaction purposes
  119.     String waitingToKill;       // Process is waiting to be killed when in the bg, and reason
  120.     IBinder forcingToForeground;// Token that is forcing this process to be foreground
  121.     int adjSeq;                 // Sequence id for identifying oom_adj assignment cycles
  122.     int lruSeq;                 // Sequence id for identifying LRU update cycles
  123.     CompatibilityInfo compat;   // last used compatibility mode
  124.     IBinder.DeathRecipient deathRecipient; // Who is watching for the death.
  125.     ComponentName instrumentationClass;// class installed to instrument app
  126.     ApplicationInfo instrumentationInfo; // the application being instrumented
  127.     String instrumentationProfileFile; // where to save profiling
  128.     IInstrumentationWatcher instrumentationWatcher; // who is waiting
  129.     IUiAutomationConnection instrumentationUiAutomationConnection; // Connection to use the UI introspection APIs.
  130.     Bundle instrumentationArguments;// as given to us
  131.     ComponentName instrumentationResultClass;// copy of instrumentationClass
  132.     boolean usingWrapper;       // Set to true when process was launched with a wrapper attached
  133.     BroadcastRecord curReceiver;// receiver currently running in the app
  134.     long lastWakeTime;          // How long proc held wake lock at last check
  135.     long lastCpuTime;           // How long proc has run CPU at last check
  136.     long curCpuTime;            // How long proc has run CPU most recently
  137.     long lastRequestedGc;       // When we last asked the app to do a gc
  138.     long lastLowMemory;         // When we last told the app that memory is low
  139.     boolean reportLowMemory;    // Set to true when waiting to report low mem
  140.     boolean empty;              // Is this an empty background process?
  141.     boolean cached;             // Is this a cached process?
  142.     String adjType;             // Debugging: primary thing impacting oom_adj.
  143.     int adjTypeCode;            // Debugging: adj code to report to app.
  144.     Object adjSource;           // Debugging: option dependent object.
  145.     int adjSourceProcState;     // Debugging: proc state of adjSource's process.
  146.     Object adjTarget;           // Debugging: target component impacting oom_adj.
  147.     Runnable crashHandler;      // Optional local handler to be invoked in the process crash.
  148.  
  149.     // all activities running in the process
  150.     final ArrayList<ActivityRecord> activities = new ArrayList<>();
  151.     // all ServiceRecord running in this process
  152.     final ArraySet<ServiceRecord> services = new ArraySet<>();
  153.     // services that are currently executing code (need to remain foreground).
  154.     final ArraySet<ServiceRecord> executingServices = new ArraySet<>();
  155.     // All ConnectionRecord this process holds
  156.     final ArraySet<ConnectionRecord> connections = new ArraySet<>();
  157.     // all IIntentReceivers that are registered from this process.
  158.     final ArraySet<ReceiverList> receivers = new ArraySet<>();
  159.     // class (String) -> ContentProviderRecord
  160.     final ArrayMap<String, ContentProviderRecord> pubProviders = new ArrayMap<>();
  161.     // All ContentProviderRecord process is using
  162.     final ArrayList<ContentProviderConnection> conProviders = new ArrayList<>();
  163.  
  164.     boolean execServicesFg;     // do we need to be executing services in the foreground?
  165.     boolean persistent;         // always keep this application running?
  166.     boolean crashing;           // are we in the process of crashing?
  167.     Dialog crashDialog;         // dialog being displayed due to crash.
  168.     boolean forceCrashReport;   // suppress normal auto-dismiss of crash dialog & report UI?
  169.     boolean notResponding;      // does the app have a not responding dialog?
  170.     Dialog anrDialog;           // dialog being displayed due to app not resp.
  171.     boolean removed;            // has app package been removed from device?
  172.     boolean debugging;          // was app launched for debugging?
  173.     boolean waitedForDebugger;  // has process show wait for debugger dialog?
  174.     Dialog waitDialog;          // current wait for debugger dialog
  175.     
  176.     String shortStringName;     // caching of toShortString() result.
  177.     String stringName;          // caching of toString() result.
  178.     
  179.     // These reports are generated & stored when an app gets into an error condition.
  180.     // They will be "null" when all is OK.
  181.     ActivityManager.ProcessErrorStateInfo crashingReport;
  182.     ActivityManager.ProcessErrorStateInfo notRespondingReport;
  183.  
  184.     // Who will be notified of the error. This is usually an activity in the
  185.     // app that installed the package.
  186.     ComponentName errorReportReceiver;
  187.  
  188.     void dump(PrintWriter pw, String prefix) {
  189.         final long now = SystemClock.uptimeMillis();
  190.  
  191.         pw.print(prefix); pw.print("user #"); pw.print(userId);
  192.                 pw.print(" uid="); pw.print(info.uid);
  193.         if (uid != info.uid) {
  194.             pw.print(" ISOLATED uid="); pw.print(uid);
  195.         }
  196.         pw.print(" gids={");
  197.         if (gids != null) {
  198.             for (int gi=0; gi<gids.length; gi++) {
  199.                 if (gi != 0) pw.print(", ");
  200.                 pw.print(gids[gi]);
  201.  
  202.             }
  203.         }
  204.         pw.println("}");
  205.         pw.print(prefix); pw.print("requiredAbi="); pw.print(requiredAbi);
  206.                 pw.print(" instructionSet="); pw.println(instructionSet);
  207.         if (info.className != null) {
  208.             pw.print(prefix); pw.print("class="); pw.println(info.className);
  209.         }
  210.         if (info.manageSpaceActivityName != null) {
  211.             pw.print(prefix); pw.print("manageSpaceActivityName=");
  212.             pw.println(info.manageSpaceActivityName);
  213.         }
  214.         pw.print(prefix); pw.print("dir="); pw.print(info.sourceDir);
  215.                 pw.print(" publicDir="); pw.print(info.publicSourceDir);
  216.                 pw.print(" data="); pw.println(info.dataDir);
  217.         pw.print(prefix); pw.print("packageList={");
  218.         for (int i=0; i<pkgList.size(); i++) {
  219.             if (i > 0) pw.print(", ");
  220.             pw.print(pkgList.keyAt(i));
  221.         }
  222.         pw.println("}");
  223.         if (pkgDeps != null) {
  224.             pw.print(prefix); pw.print("packageDependencies={");
  225.             for (int i=0; i<pkgDeps.size(); i++) {
  226.                 if (i > 0) pw.print(", ");
  227.                 pw.print(pkgDeps.valueAt(i));
  228.             }
  229.             pw.println("}");
  230.         }
  231.         pw.print(prefix); pw.print("compat="); pw.println(compat);
  232.         if (instrumentationClass != null || instrumentationProfileFile != null
  233.                 || instrumentationArguments != null) {
  234.             pw.print(prefix); pw.print("instrumentationClass=");
  235.                     pw.print(instrumentationClass);
  236.                     pw.print(" instrumentationProfileFile=");
  237.                     pw.println(instrumentationProfileFile);
  238.             pw.print(prefix); pw.print("instrumentationArguments=");
  239.                     pw.println(instrumentationArguments);
  240.             pw.print(prefix); pw.print("instrumentationInfo=");
  241.                     pw.println(instrumentationInfo);
  242.             if (instrumentationInfo != null) {
  243.                 instrumentationInfo.dump(new PrintWriterPrinter(pw), prefix + "  ");
  244.             }
  245.         }
  246.         pw.print(prefix); pw.print("thread="); pw.println(thread);
  247.         pw.print(prefix); pw.print("pid="); pw.print(pid); pw.print(" starting=");
  248.                 pw.println(starting);
  249.         pw.print(prefix); pw.print("lastActivityTime=");
  250.                 TimeUtils.formatDuration(lastActivityTime, now, pw);
  251.                 pw.print(" lastPssTime=");
  252.                 TimeUtils.formatDuration(lastPssTime, now, pw);
  253.                 pw.print(" nextPssTime=");
  254.                 TimeUtils.formatDuration(nextPssTime, now, pw);
  255.                 pw.println();
  256.         pw.print(prefix); pw.print("adjSeq="); pw.print(adjSeq);
  257.                 pw.print(" lruSeq="); pw.print(lruSeq);
  258.                 pw.print(" lastPss="); DebugUtils.printSizeValue(pw, lastPss*1024);
  259.                 pw.print(" lastCachedPss="); DebugUtils.printSizeValue(pw, lastCachedPss*1024);
  260.                 pw.println();
  261.         pw.print(prefix); pw.print("cached="); pw.print(cached);
  262.                 pw.print(" empty="); pw.println(empty);
  263.         if (serviceb) {
  264.             pw.print(prefix); pw.print("serviceb="); pw.print(serviceb);
  265.                     pw.print(" serviceHighRam="); pw.println(serviceHighRam);
  266.         }
  267.         if (notCachedSinceIdle) {
  268.             pw.print(prefix); pw.print("notCachedSinceIdle="); pw.print(notCachedSinceIdle);
  269.                     pw.print(" initialIdlePss="); pw.println(initialIdlePss);
  270.         }
  271.         pw.print(prefix); pw.print("oom: max="); pw.print(maxAdj);
  272.                 pw.print(" curRaw="); pw.print(curRawAdj);
  273.                 pw.print(" setRaw="); pw.print(setRawAdj);
  274.                 pw.print(" cur="); pw.print(curAdj);
  275.                 pw.print(" set="); pw.println(setAdj);
  276.         pw.print(prefix); pw.print("curSchedGroup="); pw.print(curSchedGroup);
  277.                 pw.print(" setSchedGroup="); pw.print(setSchedGroup);
  278.                 pw.print(" systemNoUi="); pw.print(systemNoUi);
  279.                 pw.print(" trimMemoryLevel="); pw.println(trimMemoryLevel);
  280.         pw.print(prefix); pw.print("curProcState="); pw.print(curProcState);
  281.                 pw.print(" repProcState="); pw.print(repProcState);
  282.                 pw.print(" pssProcState="); pw.print(pssProcState);
  283.                 pw.print(" setProcState="); pw.print(setProcState);
  284.                 pw.print(" lastStateTime=");
  285.                 TimeUtils.formatDuration(lastStateTime, now, pw);
  286.                 pw.println();
  287.         if (hasShownUi || pendingUiClean || hasAboveClient || treatLikeActivity) {
  288.             pw.print(prefix); pw.print("hasShownUi="); pw.print(hasShownUi);
  289.                     pw.print(" pendingUiClean="); pw.print(pendingUiClean);
  290.                     pw.print(" hasAboveClient="); pw.print(hasAboveClient);
  291.                     pw.print(" treatLikeActivity="); pw.println(treatLikeActivity);
  292.         }
  293.         if (setIsForeground || foregroundServices || forcingToForeground != null) {
  294.             pw.print(prefix); pw.print("setIsForeground="); pw.print(setIsForeground);
  295.                     pw.print(" foregroundServices="); pw.print(foregroundServices);
  296.                     pw.print(" forcingToForeground="); pw.println(forcingToForeground);
  297.         }
  298.         if (reportedInteraction || fgInteractionTime != 0) {
  299.             pw.print(prefix); pw.print("reportedInteraction=");
  300.             pw.print(reportedInteraction);
  301.             if (fgInteractionTime != 0) {
  302.                 pw.print(" fgInteractionTime=");
  303.                 TimeUtils.formatDuration(fgInteractionTime, SystemClock.elapsedRealtime(), pw);
  304.             }
  305.             pw.println();
  306.         }
  307.         if (persistent || removed) {
  308.             pw.print(prefix); pw.print("persistent="); pw.print(persistent);
  309.                     pw.print(" removed="); pw.println(removed);
  310.         }
  311.         if (hasClientActivities || foregroundActivities || repForegroundActivities) {
  312.             pw.print(prefix); pw.print("hasClientActivities="); pw.print(hasClientActivities);
  313.                     pw.print(" foregroundActivities="); pw.print(foregroundActivities);
  314.                     pw.print(" (rep="); pw.print(repForegroundActivities); pw.println(")");
  315.         }
  316.         if (hasStartedServices) {
  317.             pw.print(prefix); pw.print("hasStartedServices="); pw.println(hasStartedServices);
  318.         }
  319.         if (setProcState >= ActivityManager.PROCESS_STATE_SERVICE) {
  320.             long wtime;
  321.             synchronized (mBatteryStats) {
  322.                 wtime = mBatteryStats.getProcessWakeTime(info.uid,
  323.                         pid, SystemClock.elapsedRealtime());
  324.             }
  325.             pw.print(prefix); pw.print("lastWakeTime="); pw.print(lastWakeTime);
  326.                     pw.print(" timeUsed=");
  327.                     TimeUtils.formatDuration(wtime-lastWakeTime, pw); pw.println("");
  328.             pw.print(prefix); pw.print("lastCpuTime="); pw.print(lastCpuTime);
  329.                     pw.print(" timeUsed=");
  330.                     TimeUtils.formatDuration(curCpuTime-lastCpuTime, pw); pw.println("");
  331.         }
  332.         pw.print(prefix); pw.print("lastRequestedGc=");
  333.                 TimeUtils.formatDuration(lastRequestedGc, now, pw);
  334.                 pw.print(" lastLowMemory=");
  335.                 TimeUtils.formatDuration(lastLowMemory, now, pw);
  336.                 pw.print(" reportLowMemory="); pw.println(reportLowMemory);
  337.         if (killed || killedByAm || waitingToKill != null) {
  338.             pw.print(prefix); pw.print("killed="); pw.print(killed);
  339.                     pw.print(" killedByAm="); pw.print(killedByAm);
  340.                     pw.print(" waitingToKill="); pw.println(waitingToKill);
  341.         }
  342.         if (debugging || crashing || crashDialog != null || notResponding
  343.                 || anrDialog != null || bad) {
  344.             pw.print(prefix); pw.print("debugging="); pw.print(debugging);
  345.                     pw.print(" crashing="); pw.print(crashing);
  346.                     pw.print(" "); pw.print(crashDialog);
  347.                     pw.print(" notResponding="); pw.print(notResponding);
  348.                     pw.print(" " ); pw.print(anrDialog);
  349.                     pw.print(" bad="); pw.print(bad);
  350.  
  351.                     // crashing or notResponding is always set before errorReportReceiver
  352.                     if (errorReportReceiver != null) {
  353.                         pw.print(" errorReportReceiver=");
  354.                         pw.print(errorReportReceiver.flattenToShortString());
  355.                     }
  356.                     pw.println();
  357.         }
  358.         if (activities.size() > 0) {
  359.             pw.print(prefix); pw.println("Activities:");
  360.             for (int i=0; i<activities.size(); i++) {
  361.                 pw.print(prefix); pw.print("  - "); pw.println(activities.get(i));
  362.             }
  363.         }
  364.         if (services.size() > 0) {
  365.             pw.print(prefix); pw.println("Services:");
  366.             for (int i=0; i<services.size(); i++) {
  367.                 pw.print(prefix); pw.print("  - "); pw.println(services.valueAt(i));
  368.             }
  369.         }
  370.         if (executingServices.size() > 0) {
  371.             pw.print(prefix); pw.print("Executing Services (fg=");
  372.             pw.print(execServicesFg); pw.println(")");
  373.             for (int i=0; i<executingServices.size(); i++) {
  374.                 pw.print(prefix); pw.print("  - "); pw.println(executingServices.valueAt(i));
  375.             }
  376.         }
  377.         if (connections.size() > 0) {
  378.             pw.print(prefix); pw.println("Connections:");
  379.             for (int i=0; i<connections.size(); i++) {
  380.                 pw.print(prefix); pw.print("  - "); pw.println(connections.valueAt(i));
  381.             }
  382.         }
  383.         if (pubProviders.size() > 0) {
  384.             pw.print(prefix); pw.println("Published Providers:");
  385.             for (int i=0; i<pubProviders.size(); i++) {
  386.                 pw.print(prefix); pw.print("  - "); pw.println(pubProviders.keyAt(i));
  387.                 pw.print(prefix); pw.print("    -> "); pw.println(pubProviders.valueAt(i));
  388.             }
  389.         }
  390.         if (conProviders.size() > 0) {
  391.             pw.print(prefix); pw.println("Connected Providers:");
  392.             for (int i=0; i<conProviders.size(); i++) {
  393.                 pw.print(prefix); pw.print("  - "); pw.println(conProviders.get(i).toShortString());
  394.             }
  395.         }
  396.         if (curReceiver != null) {
  397.             pw.print(prefix); pw.print("curReceiver="); pw.println(curReceiver);
  398.         }
  399.         if (receivers.size() > 0) {
  400.             pw.print(prefix); pw.println("Receivers:");
  401.             for (int i=0; i<receivers.size(); i++) {
  402.                 pw.print(prefix); pw.print("  - "); pw.println(receivers.valueAt(i));
  403.             }
  404.         }
  405.     }
  406.     
  407.     ProcessRecord(BatteryStatsImpl _batteryStats, ApplicationInfo _info,
  408.             String _processName, int _uid) {
  409.         mBatteryStats = _batteryStats;
  410.         info = _info;
  411.         isolated = _info.uid != _uid;
  412.         uid = _uid;
  413.         userId = UserHandle.getUserId(_uid);
  414.         processName = _processName;
  415.         pkgList.put(_info.packageName, new ProcessStats.ProcessStateHolder(_info.versionCode));
  416.         maxAdj = ProcessList.UNKNOWN_ADJ;
  417.         curRawAdj = setRawAdj = -100;
  418.         curAdj = setAdj = -100;
  419.         persistent = false;
  420.         removed = false;
  421.         lastStateTime = lastPssTime = nextPssTime = SystemClock.uptimeMillis();
  422.     }
  423.  
  424.     public void setPid(int _pid) {
  425.         pid = _pid;
  426.         shortStringName = null;
  427.         stringName = null;
  428.     }
  429.  
  430.     public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
  431.         if (thread == null) {
  432.             final ProcessStats.ProcessState origBase = baseProcessTracker;
  433.             if (origBase != null) {
  434.                 origBase.setState(ProcessStats.STATE_NOTHING,
  435.                         tracker.getMemFactorLocked(), SystemClock.uptimeMillis(), pkgList);
  436.                 origBase.makeInactive();
  437.             }
  438.             baseProcessTracker = tracker.getProcessStateLocked(info.packageName, uid,
  439.                     info.versionCode, processName);
  440.             baseProcessTracker.makeActive();
  441.             for (int i=0; i<pkgList.size(); i++) {
  442.                 ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
  443.                 if (holder.state != null && holder.state != origBase) {
  444.                     holder.state.makeInactive();
  445.                 }
  446.                 holder.state = tracker.getProcessStateLocked(pkgList.keyAt(i), uid,
  447.                         info.versionCode, processName);
  448.                 if (holder.state != baseProcessTracker) {
  449.                     holder.state.makeActive();
  450.                 }
  451.             }
  452.         }
  453.         thread = _thread;
  454.     }
  455.  
  456.     public void makeInactive(ProcessStatsService tracker) {
  457.         thread = null;
  458.         final ProcessStats.ProcessState origBase = baseProcessTracker;
  459.         if (origBase != null) {
  460.             if (origBase != null) {
  461.                 origBase.setState(ProcessStats.STATE_NOTHING,
  462.                         tracker.getMemFactorLocked(), SystemClock.uptimeMillis(), pkgList);
  463.                 origBase.makeInactive();
  464.             }
  465.             baseProcessTracker = null;
  466.             for (int i=0; i<pkgList.size(); i++) {
  467.                 ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
  468.                 if (holder.state != null && holder.state != origBase) {
  469.                     holder.state.makeInactive();
  470.                 }
  471.                 holder.state = null;
  472.             }
  473.         }
  474.     }
  475.  
  476.     /**
  477.      * This method returns true if any of the activities within the process record are interesting
  478.      * to the user. See HistoryRecord.isInterestingToUserLocked()
  479.      */
  480.     public boolean isInterestingToUserLocked() {
  481.         final int size = activities.size();
  482.         for (int i = 0 ; i < size ; i++) {
  483.             ActivityRecord r = activities.get(i);
  484.             if (r.isInterestingToUserLocked()) {
  485.                 return true;
  486.             }
  487.         }
  488.         return false;
  489.     }
  490.  
  491.     public void stopFreezingAllLocked() {
  492.         int i = activities.size();
  493.         while (i > 0) {
  494.             i--;
  495.             activities.get(i).stopFreezingScreenLocked(true);
  496.         }
  497.     }
  498.  
  499.     public void unlinkDeathRecipient() {
  500.         if (deathRecipient != null && thread != null) {
  501.             thread.asBinder().unlinkToDeath(deathRecipient, 0);
  502.         }
  503.         deathRecipient = null;
  504.     }
  505.  
  506.     void updateHasAboveClientLocked() {
  507.         hasAboveClient = false;
  508.         for (int i=connections.size()-1; i>=0; i--) {
  509.             ConnectionRecord cr = connections.valueAt(i);
  510.             if ((cr.flags&Context.BIND_ABOVE_CLIENT) != 0) {
  511.                 hasAboveClient = true;
  512.                 break;
  513.             }
  514.         }
  515.     }
  516.  
  517.     int modifyRawOomAdj(int adj) {
  518.         if (hasAboveClient) {
  519.             // If this process has bound to any services with BIND_ABOVE_CLIENT,
  520.             // then we need to drop its adjustment to be lower than the service's
  521.             // in order to honor the request.  We want to drop it by one adjustment
  522.             // level...  but there is special meaning applied to various levels so
  523.             // we will skip some of them.
  524.             if (adj < ProcessList.FOREGROUND_APP_ADJ) {
  525.                 // System process will not get dropped, ever
  526.             } else if (adj < ProcessList.VISIBLE_APP_ADJ) {
  527.                 adj = ProcessList.VISIBLE_APP_ADJ;
  528.             } else if (adj < ProcessList.PERCEPTIBLE_APP_ADJ) {
  529.                 adj = ProcessList.PERCEPTIBLE_APP_ADJ;
  530.             } else if (adj < ProcessList.CACHED_APP_MIN_ADJ) {
  531.                 adj = ProcessList.CACHED_APP_MIN_ADJ;
  532.             } else if (adj < ProcessList.CACHED_APP_MAX_ADJ) {
  533.                 adj++;
  534.             }
  535.         }
  536.         return adj;
  537.     }
  538.  
  539.     void kill(String reason, boolean noisy) {
  540.         if (!killedByAm) {
  541.             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "kill");
  542.             if (noisy) {
  543.                 Slog.i(TAG, "Killing " + toShortString() + " (adj " + setAdj + "): " + reason);
  544.             }
  545.             EventLog.writeEvent(EventLogTags.AM_KILL, userId, pid, processName, setAdj, reason);
  546.             Process.killProcessQuiet(pid);
  547.             Process.killProcessGroup(info.uid, pid);
  548.             if (!persistent) {
  549.                 killed = true;
  550.                 killedByAm = true;
  551.             }
  552.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  553.         }
  554.     }
  555.  
  556.     public String toShortString() {
  557.         if (shortStringName != null) {
  558.             return shortStringName;
  559.         }
  560.         StringBuilder sb = new StringBuilder(128);
  561.         toShortString(sb);
  562.         return shortStringName = sb.toString();
  563.     }
  564.     
  565.     void toShortString(StringBuilder sb) {
  566.         sb.append(pid);
  567.         sb.append(':');
  568.         sb.append(processName);
  569.         sb.append('/');
  570.         if (info.uid < Process.FIRST_APPLICATION_UID) {
  571.             sb.append(uid);
  572.         } else {
  573.             sb.append('u');
  574.             sb.append(userId);
  575.             int appId = UserHandle.getAppId(info.uid);
  576.             if (appId >= Process.FIRST_APPLICATION_UID) {
  577.                 sb.append('a');
  578.                 sb.append(appId - Process.FIRST_APPLICATION_UID);
  579.             } else {
  580.                 sb.append('s');
  581.                 sb.append(appId);
  582.             }
  583.             if (uid != info.uid) {
  584.                 sb.append('i');
  585.                 sb.append(UserHandle.getAppId(uid) - Process.FIRST_ISOLATED_UID);
  586.             }
  587.         }
  588.     }
  589.     
  590.     public String toString() {
  591.         if (stringName != null) {
  592.             return stringName;
  593.         }
  594.         StringBuilder sb = new StringBuilder(128);
  595.         sb.append("ProcessRecord{");
  596.         sb.append(Integer.toHexString(System.identityHashCode(this)));
  597.         sb.append(' ');
  598.         toShortString(sb);
  599.         sb.append('}');
  600.         return stringName = sb.toString();
  601.     }
  602.  
  603.     public String makeAdjReason() {
  604.         if (adjSource != null || adjTarget != null) {
  605.             StringBuilder sb = new StringBuilder(128);
  606.             sb.append(' ');
  607.             if (adjTarget instanceof ComponentName) {
  608.                 sb.append(((ComponentName)adjTarget).flattenToShortString());
  609.             } else if (adjTarget != null) {
  610.                 sb.append(adjTarget.toString());
  611.             } else {
  612.                 sb.append("{null}");
  613.             }
  614.             sb.append("<=");
  615.             if (adjSource instanceof ProcessRecord) {
  616.                 sb.append("Proc{");
  617.                 sb.append(((ProcessRecord)adjSource).toShortString());
  618.                 sb.append("}");
  619.             } else if (adjSource != null) {
  620.                 sb.append(adjSource.toString());
  621.             } else {
  622.                 sb.append("{null}");
  623.             }
  624.             return sb.toString();
  625.         }
  626.         return null;
  627.     }
  628.  
  629.     /*
  630.      *  Return true if package has been added false if not
  631.      */
  632.     public boolean addPackage(String pkg, int versionCode, ProcessStatsService tracker) {
  633.         if (!pkgList.containsKey(pkg)) {
  634.             ProcessStats.ProcessStateHolder holder = new ProcessStats.ProcessStateHolder(
  635.                     versionCode);
  636.             if (baseProcessTracker != null) {
  637.                 holder.state = tracker.getProcessStateLocked(
  638.                         pkg, uid, versionCode, processName);
  639.                 pkgList.put(pkg, holder);
  640.                 if (holder.state != baseProcessTracker) {
  641.                     holder.state.makeActive();
  642.                 }
  643.             } else {
  644.                 pkgList.put(pkg, holder);
  645.             }
  646.             return true;
  647.         }
  648.         return false;
  649.     }
  650.  
  651.     public int getSetAdjWithServices() {
  652.         if (setAdj >= ProcessList.CACHED_APP_MIN_ADJ) {
  653.             if (hasStartedServices) {
  654.                 return ProcessList.SERVICE_B_ADJ;
  655.             }
  656.         }
  657.         return setAdj;
  658.     }
  659.  
  660.     public void forceProcessStateUpTo(int newState) {
  661.         if (repProcState > newState) {
  662.             curProcState = repProcState = newState;
  663.         }
  664.     }
  665.  
  666.     /*
  667.      *  Delete all packages from list except the package indicated in info
  668.      */
  669.     public void resetPackageList(ProcessStatsService tracker) {
  670.         final int N = pkgList.size();
  671.         if (baseProcessTracker != null) {
  672.             long now = SystemClock.uptimeMillis();
  673.             baseProcessTracker.setState(ProcessStats.STATE_NOTHING,
  674.                     tracker.getMemFactorLocked(), now, pkgList);
  675.             if (N != 1) {
  676.                 for (int i=0; i<N; i++) {
  677.                     ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
  678.                     if (holder.state != null && holder.state != baseProcessTracker) {
  679.                         holder.state.makeInactive();
  680.                     }
  681.  
  682.                 }
  683.                 pkgList.clear();
  684.                 ProcessStats.ProcessState ps = tracker.getProcessStateLocked(
  685.                         info.packageName, uid, info.versionCode, processName);
  686.                 ProcessStats.ProcessStateHolder holder = new ProcessStats.ProcessStateHolder(
  687.                         info.versionCode);
  688.                 holder.state = ps;
  689.                 pkgList.put(info.packageName, holder);
  690.                 if (ps != baseProcessTracker) {
  691.                     ps.makeActive();
  692.                 }
  693.             }
  694.         } else if (N != 1) {
  695.             pkgList.clear();
  696.             pkgList.put(info.packageName, new ProcessStats.ProcessStateHolder(info.versionCode));
  697.         }
  698.     }
  699.     
  700.     public String[] getPackageList() {
  701.         int size = pkgList.size();
  702.         if (size == 0) {
  703.             return null;
  704.         }
  705.         String list[] = new String[size];
  706.         for (int i=0; i<pkgList.size(); i++) {
  707.             list[i] = pkgList.keyAt(i);
  708.         }
  709.         return list;
  710.     }
  711. }


⑤ app对象中的 thread 对象即 IApplicationThread 接口对象代码： 

  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.content.ComponentName;
  20. import android.content.Intent;
  21. import android.content.IIntentReceiver;
  22. import android.content.pm.ActivityInfo;
  23. import android.content.pm.ApplicationInfo;
  24. import android.content.pm.ProviderInfo;
  25. import android.content.pm.ServiceInfo;
  26. import android.content.res.CompatibilityInfo;
  27. import android.content.res.Configuration;
  28. import android.net.Uri;
  29. import android.os.Bundle;
  30. import android.os.Debug;
  31. import android.os.ParcelFileDescriptor;
  32. import android.os.PersistableBundle;
  33. import android.os.RemoteException;
  34. import android.os.IBinder;
  35. import android.os.IInterface;
  36. import com.android.internal.app.IVoiceInteractor;
  37. import com.android.internal.content.ReferrerIntent;
  38.  
  39. import java.io.FileDescriptor;
  40. import java.util.List;
  41. import java.util.Map;
  42.  
  43. /**
  44.  * System private API for communicating with the application.  This is given to
  45.  * the activity manager by an application  when it starts up, for the activity
  46.  * manager to tell the application about things it needs to do.
  47.  * Engineer-Jsp add 
  48.  * 该interface为hide为外部不可访问，供系统内部调用
  49.  * {@hide}
  50.  */
  51. public interface IApplicationThread extends IInterface {
  52.     void schedulePauseActivity(IBinder token, boolean finished, boolean userLeaving,
  53.             int configChanges, boolean dontReport) throws RemoteException;
  54.     void scheduleStopActivity(IBinder token, boolean showWindow,
  55.             int configChanges) throws RemoteException;
  56.     void scheduleWindowVisibility(IBinder token, boolean showWindow) throws RemoteException;
  57.     void scheduleSleeping(IBinder token, boolean sleeping) throws RemoteException;
  58.     void scheduleResumeActivity(IBinder token, int procState, boolean isForward, Bundle resumeArgs)
  59.             throws RemoteException;
  60.     void scheduleSendResult(IBinder token, List<ResultInfo> results) throws RemoteException;
  61. 	
  62. 	//此处就是 com.android.server.am.ActivityStackSupervisor 调用 ProcessRecord类对象内部的 thread 对象，再调用 thread 对象的 scheduleLaunchActivity() 函数了
  63.     void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  64.             ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
  65.             CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
  66.             int procState, Bundle state, PersistableBundle persistentState,
  67.             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
  68.             boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) throws RemoteException;
  69. 			
  70.     void scheduleRelaunchActivity(IBinder token, List<ResultInfo> pendingResults,
  71.             List<ReferrerIntent> pendingNewIntents, int configChanges, boolean notResumed,
  72.             Configuration config, Configuration overrideConfig) throws RemoteException;
  73.     void scheduleNewIntent(List<ReferrerIntent> intent, IBinder token) throws RemoteException;
  74.     void scheduleDestroyActivity(IBinder token, boolean finished,
  75.             int configChanges) throws RemoteException;
  76.     void scheduleReceiver(Intent intent, ActivityInfo info, CompatibilityInfo compatInfo,
  77.             int resultCode, String data, Bundle extras, boolean sync,
  78.             int sendingUser, int processState) throws RemoteException;
  79.     static final int BACKUP_MODE_INCREMENTAL = 0;
  80.     static final int BACKUP_MODE_FULL = 1;
  81.     static final int BACKUP_MODE_RESTORE = 2;
  82.     static final int BACKUP_MODE_RESTORE_FULL = 3;
  83.     void scheduleCreateBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo,
  84.             int backupMode) throws RemoteException;
  85.     void scheduleDestroyBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo)
  86.             throws RemoteException;
  87.     void scheduleCreateService(IBinder token, ServiceInfo info,
  88.             CompatibilityInfo compatInfo, int processState) throws RemoteException;
  89.     void scheduleBindService(IBinder token,
  90.             Intent intent, boolean rebind, int processState) throws RemoteException;
  91.     void scheduleUnbindService(IBinder token,
  92.             Intent intent) throws RemoteException;
  93.     void scheduleServiceArgs(IBinder token, boolean taskRemoved, int startId,
  94.             int flags, Intent args) throws RemoteException;
  95.     void scheduleStopService(IBinder token) throws RemoteException;
  96.     static final int DEBUG_OFF = 0;
  97.     static final int DEBUG_ON = 1;
  98.     static final int DEBUG_WAIT = 2;
  99.     void bindApplication(String packageName, ApplicationInfo info, List<ProviderInfo> providers,
  100.             ComponentName testName, ProfilerInfo profilerInfo, Bundle testArguments,
  101.             IInstrumentationWatcher testWatcher, IUiAutomationConnection uiAutomationConnection,
  102.             int debugMode, boolean openGlTrace, boolean restrictedBackupMode, boolean persistent,
  103.             Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services,
  104.             Bundle coreSettings) throws RemoteException;
  105.     void scheduleExit() throws RemoteException;
  106.     void scheduleSuicide() throws RemoteException;
  107.     void scheduleConfigurationChanged(Configuration config) throws RemoteException;
  108.     void updateTimeZone() throws RemoteException;
  109.     void clearDnsCache() throws RemoteException;
  110.     void setHttpProxy(String proxy, String port, String exclList,
  111.             Uri pacFileUrl) throws RemoteException;
  112.     void processInBackground() throws RemoteException;
  113.     void dumpService(FileDescriptor fd, IBinder servicetoken, String[] args)
  114.             throws RemoteException;
  115.     void dumpProvider(FileDescriptor fd, IBinder servicetoken, String[] args)
  116.             throws RemoteException;
  117.     void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
  118.             int resultCode, String data, Bundle extras, boolean ordered,
  119.             boolean sticky, int sendingUser, int processState) throws RemoteException;
  120.     void scheduleLowMemory() throws RemoteException;
  121.     void scheduleActivityConfigurationChanged(IBinder token, Configuration overrideConfig)
  122.             throws RemoteException;
  123.     void profilerControl(boolean start, ProfilerInfo profilerInfo, int profileType)
  124.             throws RemoteException;
  125.     void dumpHeap(boolean managed, String path, ParcelFileDescriptor fd)
  126.             throws RemoteException;
  127.     void setSchedulingGroup(int group) throws RemoteException;
  128.     static final int PACKAGE_REMOVED = 0;
  129.     static final int EXTERNAL_STORAGE_UNAVAILABLE = 1;
  130.     void dispatchPackageBroadcast(int cmd, String[] packages) throws RemoteException;
  131.     void scheduleCrash(String msg) throws RemoteException;
  132.     void dumpActivity(FileDescriptor fd, IBinder servicetoken, String prefix, String[] args)
  133.             throws RemoteException;
  134.     void setCoreSettings(Bundle coreSettings) throws RemoteException;
  135.     void updatePackageCompatibilityInfo(String pkg, CompatibilityInfo info) throws RemoteException;
  136.     void scheduleTrimMemory(int level) throws RemoteException;
  137.     void dumpMemInfo(FileDescriptor fd, Debug.MemoryInfo mem, boolean checkin, boolean dumpInfo,
  138.             boolean dumpDalvik, boolean dumpSummaryOnly, String[] args) throws RemoteException;
  139.     void dumpGfxInfo(FileDescriptor fd, String[] args) throws RemoteException;
  140.     void dumpDbInfo(FileDescriptor fd, String[] args) throws RemoteException;
  141.     void unstableProviderDied(IBinder provider) throws RemoteException;
  142.     void requestAssistContextExtras(IBinder activityToken, IBinder requestToken, int requestType)
  143.             throws RemoteException;
  144.     void scheduleTranslucentConversionComplete(IBinder token, boolean timeout)
  145.             throws RemoteException;
  146.     void scheduleOnNewActivityOptions(IBinder token, ActivityOptions options)
  147.             throws RemoteException;
  148.     void setProcessState(int state) throws RemoteException;
  149.     void scheduleInstallProvider(ProviderInfo provider) throws RemoteException;
  150.     void updateTimePrefs(boolean is24Hour) throws RemoteException;
  151.     void scheduleCancelVisibleBehind(IBinder token) throws RemoteException;
  152.     void scheduleBackgroundVisibleBehindChanged(IBinder token, boolean enabled) throws RemoteException;
  153.     void scheduleEnterAnimationComplete(IBinder token) throws RemoteException;
  154.     void notifyCleartextNetwork(byte[] firstPacket) throws RemoteException;
  155.  
  156.     String descriptor = "android.app.IApplicationThread";
  157.  
  158.     int SCHEDULE_PAUSE_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
  159.     int SCHEDULE_STOP_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
  160.     int SCHEDULE_WINDOW_VISIBILITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
  161.     int SCHEDULE_RESUME_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
  162.     int SCHEDULE_SEND_RESULT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
  163.     int SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+6;
  164.     int SCHEDULE_NEW_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+7;
  165.     int SCHEDULE_FINISH_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+8;
  166.     int SCHEDULE_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+9;
  167.     int SCHEDULE_CREATE_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+10;
  168.     int SCHEDULE_STOP_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+11;
  169.     int BIND_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+12;
  170.     int SCHEDULE_EXIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+13;
  171.  
  172.     int SCHEDULE_CONFIGURATION_CHANGED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+15;
  173.     int SCHEDULE_SERVICE_ARGS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+16;
  174.     int UPDATE_TIME_ZONE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+17;
  175.     int PROCESS_IN_BACKGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+18;
  176.     int SCHEDULE_BIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+19;
  177.     int SCHEDULE_UNBIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+20;
  178.     int DUMP_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+21;
  179.     int SCHEDULE_REGISTERED_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+22;
  180.     int SCHEDULE_LOW_MEMORY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+23;
  181.     int SCHEDULE_ACTIVITY_CONFIGURATION_CHANGED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+24;
  182.     int SCHEDULE_RELAUNCH_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+25;
  183.     int SCHEDULE_SLEEPING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+26;
  184.     int PROFILER_CONTROL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+27;
  185.     int SET_SCHEDULING_GROUP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+28;
  186.     int SCHEDULE_CREATE_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+29;
  187.     int SCHEDULE_DESTROY_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+30;
  188.     int SCHEDULE_ON_NEW_ACTIVITY_OPTIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+31;
  189.     int SCHEDULE_SUICIDE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+32;
  190.     int DISPATCH_PACKAGE_BROADCAST_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+33;
  191.     int SCHEDULE_CRASH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+34;
  192.     int DUMP_HEAP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+35;
  193.     int DUMP_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+36;
  194.     int CLEAR_DNS_CACHE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+37;
  195.     int SET_HTTP_PROXY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+38;
  196.     int SET_CORE_SETTINGS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+39;
  197.     int UPDATE_PACKAGE_COMPATIBILITY_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+40;
  198.     int SCHEDULE_TRIM_MEMORY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+41;
  199.     int DUMP_MEM_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+42;
  200.     int DUMP_GFX_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+43;
  201.     int DUMP_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+44;
  202.     int DUMP_DB_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+45;
  203.     int UNSTABLE_PROVIDER_DIED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+46;
  204.     int REQUEST_ASSIST_CONTEXT_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+47;
  205.     int SCHEDULE_TRANSLUCENT_CONVERSION_COMPLETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+48;
  206.     int SET_PROCESS_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+49;
  207.     int SCHEDULE_INSTALL_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+50;
  208.     int UPDATE_TIME_PREFS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+51;
  209.     int CANCEL_VISIBLE_BEHIND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+52;
  210.     int BACKGROUND_VISIBLE_BEHIND_CHANGED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+53;
  211.     int ENTER_ANIMATION_COMPLETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+54;
  212.     int NOTIFY_CLEARTEXT_NETWORK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+55;
  213. }

⑥ IApplicationThread 由 android.app.ApplicationThreadNative 类以及其内部代理类 ApplicationThreadProxy 实现

关键调用代理代码：

  1.     /**
  2.      * Cast a Binder object into an application thread interface, generating
  3.      * a proxy if needed.
  4. 	 * Engineer-Jsp add 由此可以见，调用 android.app.ApplicationThreadNative 类的 asInterface 函数时
  5. 	 * 得到的是实现 IApplicationThread 接口的对象，该对象为 android.app.ApplicationThreadNative 内部类的代理类 ApplicationThreadProxy
  6. 	 * 参数为IBinder 对象
  7.      */
  8.     static public IApplicationThread asInterface(IBinder obj) {
  9.         if (obj == null) {
  10.             return null;
  11.         }
  12.         IApplicationThread in =
  13.             (IApplicationThread)obj.queryLocalInterface(descriptor);
  14.         if (in != null) {
  15.             return in;
  16.         }
  17.         
  18.         return new ApplicationThreadProxy(obj);
  19.     }


然后下面注意这个  scheduleLaunchActivity 函数： 

  1.     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  2.             ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
  3.             CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
  4.             int procState, Bundle state, PersistableBundle persistentState,
  5.             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
  6.             boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) throws RemoteException {
  7.         Parcel data = Parcel.obtain();
  8.         data.writeInterfaceToken(IApplicationThread.descriptor);
  9.         intent.writeToParcel(data, 0);
  10.         data.writeStrongBinder(token);
  11.         data.writeInt(ident);
  12.         info.writeToParcel(data, 0);
  13.         curConfig.writeToParcel(data, 0);
  14.         if (overrideConfig != null) {
  15.             data.writeInt(1);
  16.             overrideConfig.writeToParcel(data, 0);
  17.         } else {
  18.             data.writeInt(0);
  19.         }
  20.         compatInfo.writeToParcel(data, 0);
  21.         data.writeString(referrer);
  22.         data.writeStrongBinder(voiceInteractor != null ? voiceInteractor.asBinder() : null);
  23.         data.writeInt(procState);
  24.         data.writeBundle(state);
  25.         data.writePersistableBundle(persistentState);
  26.         data.writeTypedList(pendingResults);
  27.         data.writeTypedList(pendingNewIntents);
  28.         data.writeInt(notResumed ? 1 : 0);
  29.         data.writeInt(isForward ? 1 : 0);
  30.         if (profilerInfo != null) {
  31.             data.writeInt(1);
  32.             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  33.         } else {
  34.             data.writeInt(0);
  35.         }
  36.         mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
  37.                 IBinder.FLAG_ONEWAY);
  38.         data.recycle();
  39.     }


注意这一句代码：

  1.         mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
  2.                 IBinder.FLAG_ONEWAY);

是scheduleLaunchActivity 函数调用IBinder对象的 transact 函数，我们都知道 IBinder是一个interface，由Binder实现，所以直接看 Binder 的 transact 函数

⑦ android.os.Binder 

该类内部代理类 android.os.BinderProxy 也实现了 IBinder接口

android.os.Binder  transact 函数

  1.     public final boolean transact(int code, Parcel data, Parcel reply,
  2.             int flags) throws RemoteException {
  3.         if (false) Log.v("Binder", "Transact: " + code + " to " + this);
  4.         if (data != null) {
  5.             data.setDataPosition(0);
  6.         }
  7.         boolean r = onTransact(code, data, reply, flags);
  8.         if (reply != null) {
  9.             reply.setDataPosition(0);
  10.         }
  11.         return r;
  12.     }

android.os.BinderProxy  transact 函数

  1.     public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
  2.         Binder.checkParcel(this, code, data, "Unreasonably large binder buffer");
  3.         return transactNative(code, data, reply, flags);
  4.     }
根据异常的log,我们需要看 android.os.BinderProxy  transact 函数，因为它调用了android.os.BinderProxy 代理类 transactNative 函数

transactNative 函数代码：

  1.     public native boolean transactNative(int code, Parcel data, Parcel reply,
  2.             int flags) throws RemoteException;

走到这里的时候，发现这个已经是有底层jni来处理了，这时候我们需要查看Jni底层的代码调用了

于是乎笔者打开了Linux，查找 framework 源码，键入一条搜索命令，查找 jni 调用



一个叫 android_util_Binder.cpp 的文件调用来完成此函数，查看cpp代码，查找 transactNative 函数

vi 这个cpp，并开始查找该函数


执行 vi 搜索命令，找到 transactNative 函数


JNI 异常处理代码：

  1. void signalExceptionForError(JNIEnv* env, jobject obj, status_t err,
  2.         bool canThrowRemoteException, int parcelSize)
  3. {
  4.     switch (err) {
  5.         case UNKNOWN_ERROR:
  6.             jniThrowException(env, "java/lang/RuntimeException", "Unknown error");
  7.             break;
  8.         case NO_MEMORY:
  9.             jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
  10.             break;
  11.         case INVALID_OPERATION:
  12.             jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
  13.             break;
  14.         case BAD_VALUE:
  15.             jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
  16.             break;
  17.         case BAD_INDEX:
  18.             jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
  19.             break;
  20.         case BAD_TYPE:
  21.             jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
  22.             break;
  23.         case NAME_NOT_FOUND:
  24.             jniThrowException(env, "java/util/NoSuchElementException", NULL);
  25.             break;
  26.         case PERMISSION_DENIED:
  27.             jniThrowException(env, "java/lang/SecurityException", NULL);
  28.             break;
  29.         case NOT_ENOUGH_DATA:
  30.             jniThrowException(env, "android/os/ParcelFormatException", "Not enough data");
  31.             break;
  32.         case NO_INIT:
  33.             jniThrowException(env, "java/lang/RuntimeException", "Not initialized");
  34.             break;
  35.         case ALREADY_EXISTS:
  36.             jniThrowException(env, "java/lang/RuntimeException", "Item already exists");
  37.             break;
  38.         case DEAD_OBJECT:
  39.             // DeadObjectException is a checked exception, only throw from certain methods.
  40.             jniThrowException(env, canThrowRemoteException
  41.                     ? "android/os/DeadObjectException"
  42.                             : "java/lang/RuntimeException", NULL);
  43.             break;
  44.         case UNKNOWN_TRANSACTION:
  45.             jniThrowException(env, "java/lang/RuntimeException", "Unknown transaction code");
  46.             break;
  47.         case FAILED_TRANSACTION: {
  48.             ALOGE("!!! FAILED BINDER TRANSACTION !!!  (parcel size = %d)", parcelSize);
  49.             const char* exceptionToThrow;
  50.             char msg[128];
  51.             // TransactionTooLargeException is a checked exception, only throw from certain methods.
  52.             // FIXME: Transaction too large is the most common reason for FAILED_TRANSACTION
  53.             //        but it is not the only one.  The Binder driver can return BR_FAILED_REPLY
  54.             //        for other reasons also, such as if the transaction is malformed or
  55.             //        refers to an FD that has been closed.  We should change the driver
  56.             //        to enable us to distinguish these cases in the future.
  57. 			// 这就就是 activity 与 activity 跳转之间的过程的判断，超过限制大小时的异常处理
  58. 			// 由 jni 引用java类型 android/os/TransactionTooLargeException ，并抛出这个异常
  59. 			// parcelSize > 200*1024 ，1024为bytes，系统限制为 200*1024 字节，所以我传的 70多万的字节就会导致程序闪退了
  60. 			// 然后抛出 log data parcel size %d bytes", parcelSize 即异常后，传输包的大小了
  61.             if (canThrowRemoteException && parcelSize > 200*1024) {
  62.                 // bona fide large payload
  63.                 exceptionToThrow = "android/os/TransactionTooLargeException";
  64.                 snprintf(msg, sizeof(msg)-1, "data parcel size %d bytes", parcelSize);
  65.             } else {
  66.                 // Heuristic: a payload smaller than this threshold "shouldn't" be too
  67.                 // big, so it's probably some other, more subtle problem.  In practice
  68.                 // it seems to always mean that the remote process died while the binder
  69.                 // transaction was already in flight.
  70.                 exceptionToThrow = (canThrowRemoteException)
  71.                         ? "android/os/DeadObjectException"
  72.                         : "java/lang/RuntimeException";
  73.                 snprintf(msg, sizeof(msg)-1,
  74.                         "Transaction failed on small parcel; remote process probably died");
  75.             }
  76.             jniThrowException(env, exceptionToThrow, msg);
  77.         } break;
  78.         case FDS_NOT_ALLOWED:
  79.             jniThrowException(env, "java/lang/RuntimeException",
  80.                     "Not allowed to write file descriptors here");
  81.             break;
  82.         case -EBADF:
  83.             jniThrowException(env, "java/lang/RuntimeException",
  84.                     "Bad file descriptor");
  85.             break;
  86.         case -ENFILE:
  87.             jniThrowException(env, "java/lang/RuntimeException",
  88.                     "File table overflow");
  89.             break;
  90.         case -EMFILE:
  91.             jniThrowException(env, "java/lang/RuntimeException",
  92.                     "Too many open files");
  93.             break;
  94.         case -EFBIG:
  95.             jniThrowException(env, "java/lang/RuntimeException",
  96.                     "File too large");
  97.             break;
  98.         case -ENOSPC:
  99.             jniThrowException(env, "java/lang/RuntimeException",
  100.                     "No space left on device");
  101.             break;
  102.         case -ESPIPE:
  103.             jniThrowException(env, "java/lang/RuntimeException",
  104.                     "Illegal seek");
  105.             break;
  106.         case -EROFS:
  107.             jniThrowException(env, "java/lang/RuntimeException",
  108.                     "Read-only file system");
  109.             break;
  110.         case -EMLINK:
  111.             jniThrowException(env, "java/lang/RuntimeException",
  112.                     "Too many links");
  113.             break;
  114.         default:
  115.             ALOGE("Unknown binder error code. 0x%" PRIx32, err);
  116.             String8 msg;
  117.             msg.appendFormat("Unknown binder error code. 0x%" PRIx32, err);
  118.             // RemoteException is a checked exception, only throw from certain methods.
  119.             jniThrowException(env, canThrowRemoteException
  120.                     ? "android/os/RemoteException" : "java/lang/RuntimeException", msg.string());
  121.             break;
  122.     }
  123. }


解决方案：

产生异常代码处：

  1. 	@Override
  2. 	public void onSuccess(JSONObject object, POST type) {
  3. 		try {
  4. 			if (type == POST.SEARCH_LOCATION) {
  5. 				onSuccess2Pro(getViewController(), type);
  6. 				String location = object.getString("lat") + "_" + object.getString("lng");
  7. 				Bundle extras = new Bundle();
  8. 				extras.putString("action", "search");
  9. 				extras.putString("response", location);
  10. 				sendActivity(LocationActivity.class, extras);
  11. 			} else if (type == POST.LBS_TRACK) {
  12. 				// 闪退前的逻辑，即bug未解之前的逻辑
  13. 				Bundle extras = new Bundle();
  14. 				extras.putString("action", "track");
  15. 				extras.putString("response", object.toString());
  16. 				sendActivity(TrackActivity.class, extras);
  17. 				
  18. 				// 闪退之后的逻辑，即解决bug之后的逻辑
  19. 				new TrackAsynTask().execute(object.toString());
  20. 			}
  21. 		} catch (JSONException e) {
  22. 			e.printStackTrace();
  23. 		}
  24. 	}

解决方案的代码： 

  1. 	private class TrackAsynTask extends AsyncTask<String, Void, Boolean> {
  2. 		List<List<LatLng>> mTrackArrays = new ArrayList<List<LatLng>>();
  3.  
  4. 		@Override
  5. 		protected Boolean doInBackground(String... params) {
  6. 			try {
  7. 			// 单例调用RmtTrack将数据进行解析和解密并且重新封装，这是一个耗时的操作不能直接丢给activity处理
  8. 			// 所以处理完再丢给activity展示，避免出现卡顿、黑屏现象
  9. 				RmtTrack.getTrackManager().LBSTrack(new JSONObject(params[0]), new CarTrackListener() {
  10. 					@Override
  11. 					public void onTrackCallBack(List<LatLng> arg0) {
  12. 						// 排除点漂
  13. 						if (arg0.size() >= 2) {
  14. 						// 添加轨迹段
  15. 							mTrackArrays.add(arg0);
  16. 						}
  17. 					}
  18. 				});
  19. 			} catch (JSONException e) {
  20. 				e.printStackTrace();
  21. 				return false;
  22. 			}
  23. 			return true;
  24. 		}
  25.  
  26. 		@Override
  27. 		protected void onPostExecute(Boolean result) {
  28. 			super.onPostExecute(result);
  29. 			// 没有发生异常且全部完成
  30. 			if (result) {
  31. 			//轨迹段数据最少为1段
  32. 				if (mTrackArrays.size() > 0) {
  33. 				// 给静态函数传参，在activity onCreate之前调用就行，在绘制时判断一下是否null，activity onDestroy时在置为null
  34. 					TrackActivity.InstanceLatLngList(mTrackArrays);
  35. 					// 开始启动activity
  36. 					sendActivity(TrackActivity.class, null);
  37. 				}
  38. 				// 隐藏ProgressBar进度条
  39. 				onSuccess2Pro(getViewController(), POST.LBS_TRACK);
  40. 			}
  41. 		}
  42. 	}

解决方式简单粗暴，希望遇到与此类似问题的你们，能借此博客有所帮助，博主就心满意足了！


谢谢观博^_^！
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/245421
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号