ActivityManagerNative.java revision 7aa7601c09ab5d87cc15a0ed9a8f511d494a4cbc 
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
17package android.app;
18
19import android.app.ActivityManager.StackBoxInfo;
20import android.content.ComponentName;
21import android.content.IIntentReceiver;
22import android.content.IIntentSender;
23import android.content.Intent;
24import android.content.IntentFilter;
25import android.content.IntentSender;
26import android.content.UriPermission;
27import android.content.pm.ApplicationInfo;
28import android.content.pm.ConfigurationInfo;
29import android.content.pm.IPackageDataObserver;
30import android.content.pm.ParceledListSlice;
31import android.content.pm.UserInfo;
32import android.content.res.Configuration;
33import android.graphics.Bitmap;
34import android.net.Uri;
35import android.os.Binder;
36import android.os.Bundle;
37import android.os.Debug;
38import android.os.IBinder;
39import android.os.Parcel;
40import android.os.ParcelFileDescriptor;
41import android.os.Parcelable;
42import android.os.RemoteException;
43import android.os.ServiceManager;
44import android.os.StrictMode;
45import android.text.TextUtils;
46import android.util.Log;
47import android.util.Singleton;
48
49import java.util.ArrayList;
50import java.util.List;
51
52/** {@hide} */
53public abstract class ActivityManagerNative extends Binder implements IActivityManager
54{
55    /**
56     * Cast a Binder object into an activity manager interface, generating
57     * a proxy if needed.
58     */
59    static public IActivityManager asInterface(IBinder obj) {
60        if (obj == null) {
61            return null;
62        }
63        IActivityManager in =
64            (IActivityManager)obj.queryLocalInterface(descriptor);
65        if (in != null) {
66            return in;
67        }
68
69        return new ActivityManagerProxy(obj);
70    }
71
72    /**
73     * Retrieve the system's default/global activity manager.
74     */
75    static public IActivityManager getDefault() {
76        return gDefault.get();
77    }
78
79    /**
80     * Convenience for checking whether the system is ready.  For internal use only.
81     */
82    static public boolean isSystemReady() {
83        if (!sSystemReady) {
84            sSystemReady = getDefault().testIsSystemReady();
85        }
86        return sSystemReady;
87    }
88    static boolean sSystemReady = false;
89
90    /**
91     * Convenience for sending a sticky broadcast.  For internal use only.
92     * If you don't care about permission, use null.
93     */
94    static public void broadcastStickyIntent(Intent intent, String permission, int userId) {
95        try {
96            getDefault().broadcastIntent(
97                null, intent, null, null, Activity.RESULT_OK, null, null,
98                null /*permission*/, AppOpsManager.OP_NONE, false, true, userId);
99        } catch (RemoteException ex) {
100        }
101    }
102
103    static public void noteWakeupAlarm(PendingIntent ps) {
104        try {
105            getDefault().noteWakeupAlarm(ps.getTarget());
106        } catch (RemoteException ex) {
107        }
108    }
109
110    public ActivityManagerNative() {
111        attachInterface(this, descriptor);
112    }
113
114    @Override
115    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
116            throws RemoteException {
117        switch (code) {
118        case START_ACTIVITY_TRANSACTION:
119        {
120            data.enforceInterface(IActivityManager.descriptor);
121            IBinder b = data.readStrongBinder();
122            IApplicationThread app = ApplicationThreadNative.asInterface(b);
123            String callingPackage = data.readString();
124            Intent intent = Intent.CREATOR.createFromParcel(data);
125            String resolvedType = data.readString();
126            IBinder resultTo = data.readStrongBinder();
127            String resultWho = data.readString();
128            int requestCode = data.readInt();
129            int startFlags = data.readInt();
130            String profileFile = data.readString();
131            ParcelFileDescriptor profileFd = data.readInt() != 0
132                    ? data.readFileDescriptor() : null;
133            Bundle options = data.readInt() != 0
134                    ? Bundle.CREATOR.createFromParcel(data) : null;
135            int result = startActivity(app, callingPackage, intent, resolvedType,
136                    resultTo, resultWho, requestCode, startFlags,
137                    profileFile, profileFd, options);
138            reply.writeNoException();
139            reply.writeInt(result);
140            return true;
141        }
142
143        case START_ACTIVITY_AS_USER_TRANSACTION:
144        {
145            data.enforceInterface(IActivityManager.descriptor);
146            IBinder b = data.readStrongBinder();
147            IApplicationThread app = ApplicationThreadNative.asInterface(b);
148            String callingPackage = data.readString();
149            Intent intent = Intent.CREATOR.createFromParcel(data);
150            String resolvedType = data.readString();
151            IBinder resultTo = data.readStrongBinder();
152            String resultWho = data.readString();
153            int requestCode = data.readInt();
154            int startFlags = data.readInt();
155            String profileFile = data.readString();
156            ParcelFileDescriptor profileFd = data.readInt() != 0
157                    ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
158            Bundle options = data.readInt() != 0
159                    ? Bundle.CREATOR.createFromParcel(data) : null;
160            int userId = data.readInt();
161            int result = startActivityAsUser(app, callingPackage, intent, resolvedType,
162                    resultTo, resultWho, requestCode, startFlags,
163                    profileFile, profileFd, options, userId);
164            reply.writeNoException();
165            reply.writeInt(result);
166            return true;
167        }
168
169        case START_ACTIVITY_AND_WAIT_TRANSACTION:
170        {
171            data.enforceInterface(IActivityManager.descriptor);
172            IBinder b = data.readStrongBinder();
173            IApplicationThread app = ApplicationThreadNative.asInterface(b);
174            String callingPackage = data.readString();
175            Intent intent = Intent.CREATOR.createFromParcel(data);
176            String resolvedType = data.readString();
177            IBinder resultTo = data.readStrongBinder();
178            String resultWho = data.readString();
179            int requestCode = data.readInt();
180            int startFlags = data.readInt();
181            String profileFile = data.readString();
182            ParcelFileDescriptor profileFd = data.readInt() != 0
183                    ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
184            Bundle options = data.readInt() != 0
185                    ? Bundle.CREATOR.createFromParcel(data) : null;
186            int userId = data.readInt();
187            WaitResult result = startActivityAndWait(app, callingPackage, intent, resolvedType,
188                    resultTo, resultWho, requestCode, startFlags,
189                    profileFile, profileFd, options, userId);
190            reply.writeNoException();
191            result.writeToParcel(reply, 0);
192            return true;
193        }
194
195        case START_ACTIVITY_WITH_CONFIG_TRANSACTION:
196        {
197            data.enforceInterface(IActivityManager.descriptor);
198            IBinder b = data.readStrongBinder();
199            IApplicationThread app = ApplicationThreadNative.asInterface(b);
200            String callingPackage = data.readString();
201            Intent intent = Intent.CREATOR.createFromParcel(data);
202            String resolvedType = data.readString();
203            IBinder resultTo = data.readStrongBinder();
204            String resultWho = data.readString();
205            int requestCode = data.readInt();
206            int startFlags = data.readInt();
207            Configuration config = Configuration.CREATOR.createFromParcel(data);
208            Bundle options = data.readInt() != 0
209                    ? Bundle.CREATOR.createFromParcel(data) : null;
210            int userId = data.readInt();
211            int result = startActivityWithConfig(app, callingPackage, intent, resolvedType,
212                    resultTo, resultWho, requestCode, startFlags, config, options, userId);
213            reply.writeNoException();
214            reply.writeInt(result);
215            return true;
216        }
217
218        case START_ACTIVITY_INTENT_SENDER_TRANSACTION:
219        {
220            data.enforceInterface(IActivityManager.descriptor);
221            IBinder b = data.readStrongBinder();
222            IApplicationThread app = ApplicationThreadNative.asInterface(b);
223            IntentSender intent = IntentSender.CREATOR.createFromParcel(data);
224            Intent fillInIntent = null;
225            if (data.readInt() != 0) {
226                fillInIntent = Intent.CREATOR.createFromParcel(data);
227            }
228            String resolvedType = data.readString();
229            IBinder resultTo = data.readStrongBinder();
230            String resultWho = data.readString();
231            int requestCode = data.readInt();
232            int flagsMask = data.readInt();
233            int flagsValues = data.readInt();
234            Bundle options = data.readInt() != 0
235                    ? Bundle.CREATOR.createFromParcel(data) : null;
236            int result = startActivityIntentSender(app, intent,
237                    fillInIntent, resolvedType, resultTo, resultWho,
238                    requestCode, flagsMask, flagsValues, options);
239            reply.writeNoException();
240            reply.writeInt(result);
241            return true;
242        }
243
244        case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
245        {
246            data.enforceInterface(IActivityManager.descriptor);
247            IBinder callingActivity = data.readStrongBinder();
248            Intent intent = Intent.CREATOR.createFromParcel(data);
249            Bundle options = data.readInt() != 0
250                    ? Bundle.CREATOR.createFromParcel(data) : null;
251            boolean result = startNextMatchingActivity(callingActivity, intent, options);
252            reply.writeNoException();
253            reply.writeInt(result ? 1 : 0);
254            return true;
255        }
256
257        case FINISH_ACTIVITY_TRANSACTION: {
258            data.enforceInterface(IActivityManager.descriptor);
259            IBinder token = data.readStrongBinder();
260            Intent resultData = null;
261            int resultCode = data.readInt();
262            if (data.readInt() != 0) {
263                resultData = Intent.CREATOR.createFromParcel(data);
264            }
265            boolean res = finishActivity(token, resultCode, resultData);
266            reply.writeNoException();
267            reply.writeInt(res ? 1 : 0);
268            return true;
269        }
270
271        case FINISH_SUB_ACTIVITY_TRANSACTION: {
272            data.enforceInterface(IActivityManager.descriptor);
273            IBinder token = data.readStrongBinder();
274            String resultWho = data.readString();
275            int requestCode = data.readInt();
276            finishSubActivity(token, resultWho, requestCode);
277            reply.writeNoException();
278            return true;
279        }
280
281        case FINISH_ACTIVITY_AFFINITY_TRANSACTION: {
282            data.enforceInterface(IActivityManager.descriptor);
283            IBinder token = data.readStrongBinder();
284            boolean res = finishActivityAffinity(token);
285            reply.writeNoException();
286            reply.writeInt(res ? 1 : 0);
287            return true;
288        }
289
290        case WILL_ACTIVITY_BE_VISIBLE_TRANSACTION: {
291            data.enforceInterface(IActivityManager.descriptor);
292            IBinder token = data.readStrongBinder();
293            boolean res = willActivityBeVisible(token);
294            reply.writeNoException();
295            reply.writeInt(res ? 1 : 0);
296            return true;
297        }
298
299        case REGISTER_RECEIVER_TRANSACTION:
300        {
301            data.enforceInterface(IActivityManager.descriptor);
302            IBinder b = data.readStrongBinder();
303            IApplicationThread app =
304                b != null ? ApplicationThreadNative.asInterface(b) : null;
305            String packageName = data.readString();
306            b = data.readStrongBinder();
307            IIntentReceiver rec
308                = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
309            IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
310            String perm = data.readString();
311            int userId = data.readInt();
312            Intent intent = registerReceiver(app, packageName, rec, filter, perm, userId);
313            reply.writeNoException();
314            if (intent != null) {
315                reply.writeInt(1);
316                intent.writeToParcel(reply, 0);
317            } else {
318                reply.writeInt(0);
319            }
320            return true;
321        }
322
323        case UNREGISTER_RECEIVER_TRANSACTION:
324        {
325            data.enforceInterface(IActivityManager.descriptor);
326            IBinder b = data.readStrongBinder();
327            if (b == null) {
328                return true;
329            }
330            IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
331            unregisterReceiver(rec);
332            reply.writeNoException();
333            return true;
334        }
335
336        case BROADCAST_INTENT_TRANSACTION:
337        {
338            data.enforceInterface(IActivityManager.descriptor);
339            IBinder b = data.readStrongBinder();
340            IApplicationThread app =
341                b != null ? ApplicationThreadNative.asInterface(b) : null;
342            Intent intent = Intent.CREATOR.createFromParcel(data);
343            String resolvedType = data.readString();
344            b = data.readStrongBinder();
345            IIntentReceiver resultTo =
346                b != null ? IIntentReceiver.Stub.asInterface(b) : null;
347            int resultCode = data.readInt();
348            String resultData = data.readString();
349            Bundle resultExtras = data.readBundle();
350            String perm = data.readString();
351            int appOp = data.readInt();
352            boolean serialized = data.readInt() != 0;
353            boolean sticky = data.readInt() != 0;
354            int userId = data.readInt();
355            int res = broadcastIntent(app, intent, resolvedType, resultTo,
356                    resultCode, resultData, resultExtras, perm, appOp,
357                    serialized, sticky, userId);
358            reply.writeNoException();
359            reply.writeInt(res);
360            return true;
361        }
362
363        case UNBROADCAST_INTENT_TRANSACTION:
364        {
365            data.enforceInterface(IActivityManager.descriptor);
366            IBinder b = data.readStrongBinder();
367            IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
368            Intent intent = Intent.CREATOR.createFromParcel(data);
369            int userId = data.readInt();
370            unbroadcastIntent(app, intent, userId);
371            reply.writeNoException();
372            return true;
373        }
374
375        case FINISH_RECEIVER_TRANSACTION: {
376            data.enforceInterface(IActivityManager.descriptor);
377            IBinder who = data.readStrongBinder();
378            int resultCode = data.readInt();
379            String resultData = data.readString();
380            Bundle resultExtras = data.readBundle();
381            boolean resultAbort = data.readInt() != 0;
382            if (who != null) {
383                finishReceiver(who, resultCode, resultData, resultExtras, resultAbort);
384            }
385            reply.writeNoException();
386            return true;
387        }
388
389        case ATTACH_APPLICATION_TRANSACTION: {
390            data.enforceInterface(IActivityManager.descriptor);
391            IApplicationThread app = ApplicationThreadNative.asInterface(
392                    data.readStrongBinder());
393            if (app != null) {
394                attachApplication(app);
395            }
396            reply.writeNoException();
397            return true;
398        }
399
400        case ACTIVITY_IDLE_TRANSACTION: {
401            data.enforceInterface(IActivityManager.descriptor);
402            IBinder token = data.readStrongBinder();
403            Configuration config = null;
404            if (data.readInt() != 0) {
405                config = Configuration.CREATOR.createFromParcel(data);
406            }
407            boolean stopProfiling = data.readInt() != 0;
408            if (token != null) {
409                activityIdle(token, config, stopProfiling);
410            }
411            reply.writeNoException();
412            return true;
413        }
414
415        case ACTIVITY_RESUMED_TRANSACTION: {
416            data.enforceInterface(IActivityManager.descriptor);
417            IBinder token = data.readStrongBinder();
418            activityResumed(token);
419            reply.writeNoException();
420            return true;
421        }
422
423        case ACTIVITY_PAUSED_TRANSACTION: {
424            data.enforceInterface(IActivityManager.descriptor);
425            IBinder token = data.readStrongBinder();
426            activityPaused(token);
427            reply.writeNoException();
428            return true;
429        }
430
431        case ACTIVITY_STOPPED_TRANSACTION: {
432            data.enforceInterface(IActivityManager.descriptor);
433            IBinder token = data.readStrongBinder();
434            Bundle map = data.readBundle();
435            Bitmap thumbnail = data.readInt() != 0
436                ? Bitmap.CREATOR.createFromParcel(data) : null;
437            CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
438            activityStopped(token, map, thumbnail, description);
439            reply.writeNoException();
440            return true;
441        }
442
443        case ACTIVITY_SLEPT_TRANSACTION: {
444            data.enforceInterface(IActivityManager.descriptor);
445            IBinder token = data.readStrongBinder();
446            activitySlept(token);
447            reply.writeNoException();
448            return true;
449        }
450
451        case ACTIVITY_DESTROYED_TRANSACTION: {
452            data.enforceInterface(IActivityManager.descriptor);
453            IBinder token = data.readStrongBinder();
454            activityDestroyed(token);
455            reply.writeNoException();
456            return true;
457        }
458
459        case GET_CALLING_PACKAGE_TRANSACTION: {
460            data.enforceInterface(IActivityManager.descriptor);
461            IBinder token = data.readStrongBinder();
462            String res = token != null ? getCallingPackage(token) : null;
463            reply.writeNoException();
464            reply.writeString(res);
465            return true;
466        }
467
468        case GET_CALLING_ACTIVITY_TRANSACTION: {
469            data.enforceInterface(IActivityManager.descriptor);
470            IBinder token = data.readStrongBinder();
471            ComponentName cn = getCallingActivity(token);
472            reply.writeNoException();
473            ComponentName.writeToParcel(cn, reply);
474            return true;
475        }
476
477        case GET_TASKS_TRANSACTION: {
478            data.enforceInterface(IActivityManager.descriptor);
479            int maxNum = data.readInt();
480            int fl = data.readInt();
481            IBinder receiverBinder = data.readStrongBinder();
482            IThumbnailReceiver receiver = receiverBinder != null
483                ? IThumbnailReceiver.Stub.asInterface(receiverBinder)
484                : null;
485            List<ActivityManager.RunningTaskInfo> list = getTasks(maxNum, fl, receiver);
486            reply.writeNoException();
487            int N = list != null ? list.size() : -1;
488            reply.writeInt(N);
489            int i;
490            for (i=0; i<N; i++) {
491                ActivityManager.RunningTaskInfo info = list.get(i);
492                info.writeToParcel(reply, 0);
493            }
494            return true;
495        }
496
497        case GET_RECENT_TASKS_TRANSACTION: {
498            data.enforceInterface(IActivityManager.descriptor);
499            int maxNum = data.readInt();
500            int fl = data.readInt();
501            int userId = data.readInt();
502            List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
503                    fl, userId);
504            reply.writeNoException();
505            reply.writeTypedList(list);
506            return true;
507        }
508
509        case GET_TASK_THUMBNAILS_TRANSACTION: {
510            data.enforceInterface(IActivityManager.descriptor);
511            int id = data.readInt();
512            ActivityManager.TaskThumbnails bm = getTaskThumbnails(id);
513            reply.writeNoException();
514            if (bm != null) {
515                reply.writeInt(1);
516                bm.writeToParcel(reply, 0);
517            } else {
518                reply.writeInt(0);
519            }
520            return true;
521        }
522
523        case GET_TASK_TOP_THUMBNAIL_TRANSACTION: {
524            data.enforceInterface(IActivityManager.descriptor);
525            int id = data.readInt();
526            Bitmap bm = getTaskTopThumbnail(id);
527            reply.writeNoException();
528            if (bm != null) {
529                reply.writeInt(1);
530                bm.writeToParcel(reply, 0);
531            } else {
532                reply.writeInt(0);
533            }
534            return true;
535        }
536
537        case GET_SERVICES_TRANSACTION: {
538            data.enforceInterface(IActivityManager.descriptor);
539            int maxNum = data.readInt();
540            int fl = data.readInt();
541            List<ActivityManager.RunningServiceInfo> list = getServices(maxNum, fl);
542            reply.writeNoException();
543            int N = list != null ? list.size() : -1;
544            reply.writeInt(N);
545            int i;
546            for (i=0; i<N; i++) {
547                ActivityManager.RunningServiceInfo info = list.get(i);
548                info.writeToParcel(reply, 0);
549            }
550            return true;
551        }
552
553        case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION: {
554            data.enforceInterface(IActivityManager.descriptor);
555            List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
556            reply.writeNoException();
557            reply.writeTypedList(list);
558            return true;
559        }
560
561        case GET_RUNNING_APP_PROCESSES_TRANSACTION: {
562            data.enforceInterface(IActivityManager.descriptor);
563            List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
564            reply.writeNoException();
565            reply.writeTypedList(list);
566            return true;
567        }
568
569        case GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION: {
570            data.enforceInterface(IActivityManager.descriptor);
571            List<ApplicationInfo> list = getRunningExternalApplications();
572            reply.writeNoException();
573            reply.writeTypedList(list);
574            return true;
575        }
576
577        case MOVE_TASK_TO_FRONT_TRANSACTION: {
578            data.enforceInterface(IActivityManager.descriptor);
579            int task = data.readInt();
580            int fl = data.readInt();
581            Bundle options = data.readInt() != 0
582                    ? Bundle.CREATOR.createFromParcel(data) : null;
583            moveTaskToFront(task, fl, options);
584            reply.writeNoException();
585            return true;
586        }
587
588        case MOVE_TASK_TO_BACK_TRANSACTION: {
589            data.enforceInterface(IActivityManager.descriptor);
590            int task = data.readInt();
591            moveTaskToBack(task);
592            reply.writeNoException();
593            return true;
594        }
595
596        case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION: {
597            data.enforceInterface(IActivityManager.descriptor);
598            IBinder token = data.readStrongBinder();
599            boolean nonRoot = data.readInt() != 0;
600            boolean res = moveActivityTaskToBack(token, nonRoot);
601            reply.writeNoException();
602            reply.writeInt(res ? 1 : 0);
603            return true;
604        }
605
606        case MOVE_TASK_BACKWARDS_TRANSACTION: {
607            data.enforceInterface(IActivityManager.descriptor);
608            int task = data.readInt();
609            moveTaskBackwards(task);
610            reply.writeNoException();
611            return true;
612        }
613
614        case CREATE_STACK_TRANSACTION: {
615            data.enforceInterface(IActivityManager.descriptor);
616            int taskId = data.readInt();
617            int relativeStackId = data.readInt();
618            int position = data.readInt();
619            float weight = data.readFloat();
620            int res = createStack(taskId, relativeStackId, position, weight);
621            reply.writeNoException();
622            reply.writeInt(res);
623            return true;
624        }
625
626        case MOVE_TASK_TO_STACK_TRANSACTION: {
627            data.enforceInterface(IActivityManager.descriptor);
628            int taskId = data.readInt();
629            int stackId = data.readInt();
630            boolean toTop = data.readInt() != 0;
631            moveTaskToStack(taskId, stackId, toTop);
632            reply.writeNoException();
633            return true;
634        }
635
636        case RESIZE_STACK_TRANSACTION: {
637            data.enforceInterface(IActivityManager.descriptor);
638            int stackBoxId = data.readInt();
639            float weight = data.readFloat();
640            resizeStackBox(stackBoxId, weight);
641            reply.writeNoException();
642            return true;
643        }
644
645        case GET_STACK_BOXES_TRANSACTION: {
646            data.enforceInterface(IActivityManager.descriptor);
647            List<StackBoxInfo> list = getStackBoxes();
648            reply.writeNoException();
649            reply.writeTypedList(list);
650            return true;
651        }
652
653        case GET_STACK_BOX_INFO_TRANSACTION: {
654            data.enforceInterface(IActivityManager.descriptor);
655            int stackBoxId = data.readInt();
656            StackBoxInfo info = getStackBoxInfo(stackBoxId);
657            reply.writeNoException();
658            if (info != null) {
659                reply.writeInt(1);
660                info.writeToParcel(reply, 0);
661            } else {
662                reply.writeInt(0);
663            }
664            return true;
665        }
666
667        case SET_FOCUSED_STACK_TRANSACTION: {
668            data.enforceInterface(IActivityManager.descriptor);
669            int stackId = data.readInt();
670            setFocusedStack(stackId);
671            reply.writeNoException();
672            return true;
673        }
674
675        case GET_TASK_FOR_ACTIVITY_TRANSACTION: {
676            data.enforceInterface(IActivityManager.descriptor);
677            IBinder token = data.readStrongBinder();
678            boolean onlyRoot = data.readInt() != 0;
679            int res = token != null
680                ? getTaskForActivity(token, onlyRoot) : -1;
681                reply.writeNoException();
682            reply.writeInt(res);
683            return true;
684        }
685
686        case REPORT_THUMBNAIL_TRANSACTION: {
687            data.enforceInterface(IActivityManager.descriptor);
688            IBinder token = data.readStrongBinder();
689            Bitmap thumbnail = data.readInt() != 0
690                ? Bitmap.CREATOR.createFromParcel(data) : null;
691            CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
692            reportThumbnail(token, thumbnail, description);
693            reply.writeNoException();
694            return true;
695        }
696
697        case GET_CONTENT_PROVIDER_TRANSACTION: {
698            data.enforceInterface(IActivityManager.descriptor);
699            IBinder b = data.readStrongBinder();
700            IApplicationThread app = ApplicationThreadNative.asInterface(b);
701            String name = data.readString();
702            int userId = data.readInt();
703            boolean stable = data.readInt() != 0;
704            ContentProviderHolder cph = getContentProvider(app, name, userId, stable);
705            reply.writeNoException();
706            if (cph != null) {
707                reply.writeInt(1);
708                cph.writeToParcel(reply, 0);
709            } else {
710                reply.writeInt(0);
711            }
712            return true;
713        }
714
715        case GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
716            data.enforceInterface(IActivityManager.descriptor);
717            String name = data.readString();
718            int userId = data.readInt();
719            IBinder token = data.readStrongBinder();
720            ContentProviderHolder cph = getContentProviderExternal(name, userId, token);
721            reply.writeNoException();
722            if (cph != null) {
723                reply.writeInt(1);
724                cph.writeToParcel(reply, 0);
725            } else {
726                reply.writeInt(0);
727            }
728            return true;
729        }
730
731        case PUBLISH_CONTENT_PROVIDERS_TRANSACTION: {
732            data.enforceInterface(IActivityManager.descriptor);
733            IBinder b = data.readStrongBinder();
734            IApplicationThread app = ApplicationThreadNative.asInterface(b);
735            ArrayList<ContentProviderHolder> providers =
736                data.createTypedArrayList(ContentProviderHolder.CREATOR);
737            publishContentProviders(app, providers);
738            reply.writeNoException();
739            return true;
740        }
741
742        case REF_CONTENT_PROVIDER_TRANSACTION: {
743            data.enforceInterface(IActivityManager.descriptor);
744            IBinder b = data.readStrongBinder();
745            int stable = data.readInt();
746            int unstable = data.readInt();
747            boolean res = refContentProvider(b, stable, unstable);
748            reply.writeNoException();
749            reply.writeInt(res ? 1 : 0);
750            return true;
751        }
752
753        case UNSTABLE_PROVIDER_DIED_TRANSACTION: {
754            data.enforceInterface(IActivityManager.descriptor);
755            IBinder b = data.readStrongBinder();
756            unstableProviderDied(b);
757            reply.writeNoException();
758            return true;
759        }
760
761        case APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION: {
762            data.enforceInterface(IActivityManager.descriptor);
763            IBinder b = data.readStrongBinder();
764            appNotRespondingViaProvider(b);
765            reply.writeNoException();
766            return true;
767        }
768
769        case REMOVE_CONTENT_PROVIDER_TRANSACTION: {
770            data.enforceInterface(IActivityManager.descriptor);
771            IBinder b = data.readStrongBinder();
772            boolean stable = data.readInt() != 0;
773            removeContentProvider(b, stable);
774            reply.writeNoException();
775            return true;
776        }
777
778        case REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION: {
779            data.enforceInterface(IActivityManager.descriptor);
780            String name = data.readString();
781            IBinder token = data.readStrongBinder();
782            removeContentProviderExternal(name, token);
783            reply.writeNoException();
784            return true;
785        }
786
787        case GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION: {
788            data.enforceInterface(IActivityManager.descriptor);
789            ComponentName comp = ComponentName.CREATOR.createFromParcel(data);
790            PendingIntent pi = getRunningServiceControlPanel(comp);
791            reply.writeNoException();
792            PendingIntent.writePendingIntentOrNullToParcel(pi, reply);
793            return true;
794        }
795
796        case START_SERVICE_TRANSACTION: {
797            data.enforceInterface(IActivityManager.descriptor);
798            IBinder b = data.readStrongBinder();
799            IApplicationThread app = ApplicationThreadNative.asInterface(b);
800            Intent service = Intent.CREATOR.createFromParcel(data);
801            String resolvedType = data.readString();
802            int userId = data.readInt();
803            ComponentName cn = startService(app, service, resolvedType, userId);
804            reply.writeNoException();
805            ComponentName.writeToParcel(cn, reply);
806            return true;
807        }
808
809        case STOP_SERVICE_TRANSACTION: {
810            data.enforceInterface(IActivityManager.descriptor);
811            IBinder b = data.readStrongBinder();
812            IApplicationThread app = ApplicationThreadNative.asInterface(b);
813            Intent service = Intent.CREATOR.createFromParcel(data);
814            String resolvedType = data.readString();
815            int userId = data.readInt();
816            int res = stopService(app, service, resolvedType, userId);
817            reply.writeNoException();
818            reply.writeInt(res);
819            return true;
820        }
821
822        case STOP_SERVICE_TOKEN_TRANSACTION: {
823            data.enforceInterface(IActivityManager.descriptor);
824            ComponentName className = ComponentName.readFromParcel(data);
825            IBinder token = data.readStrongBinder();
826            int startId = data.readInt();
827            boolean res = stopServiceToken(className, token, startId);
828            reply.writeNoException();
829            reply.writeInt(res ? 1 : 0);
830            return true;
831        }
832
833        case SET_SERVICE_FOREGROUND_TRANSACTION: {
834            data.enforceInterface(IActivityManager.descriptor);
835            ComponentName className = ComponentName.readFromParcel(data);
836            IBinder token = data.readStrongBinder();
837            int id = data.readInt();
838            Notification notification = null;
839            if (data.readInt() != 0) {
840                notification = Notification.CREATOR.createFromParcel(data);
841            }
842            boolean removeNotification = data.readInt() != 0;
843            setServiceForeground(className, token, id, notification, removeNotification);
844            reply.writeNoException();
845            return true;
846        }
847
848        case BIND_SERVICE_TRANSACTION: {
849            data.enforceInterface(IActivityManager.descriptor);
850            IBinder b = data.readStrongBinder();
851            IApplicationThread app = ApplicationThreadNative.asInterface(b);
852            IBinder token = data.readStrongBinder();
853            Intent service = Intent.CREATOR.createFromParcel(data);
854            String resolvedType = data.readString();
855            b = data.readStrongBinder();
856            int fl = data.readInt();
857            int userId = data.readInt();
858            IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
859            int res = bindService(app, token, service, resolvedType, conn, fl, userId);
860            reply.writeNoException();
861            reply.writeInt(res);
862            return true;
863        }
864
865        case UNBIND_SERVICE_TRANSACTION: {
866            data.enforceInterface(IActivityManager.descriptor);
867            IBinder b = data.readStrongBinder();
868            IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
869            boolean res = unbindService(conn);
870            reply.writeNoException();
871            reply.writeInt(res ? 1 : 0);
872            return true;
873        }
874
875        case PUBLISH_SERVICE_TRANSACTION: {
876            data.enforceInterface(IActivityManager.descriptor);
877            IBinder token = data.readStrongBinder();
878            Intent intent = Intent.CREATOR.createFromParcel(data);
879            IBinder service = data.readStrongBinder();
880            publishService(token, intent, service);
881            reply.writeNoException();
882            return true;
883        }
884
885        case UNBIND_FINISHED_TRANSACTION: {
886            data.enforceInterface(IActivityManager.descriptor);
887            IBinder token = data.readStrongBinder();
888            Intent intent = Intent.CREATOR.createFromParcel(data);
889            boolean doRebind = data.readInt() != 0;
890            unbindFinished(token, intent, doRebind);
891            reply.writeNoException();
892            return true;
893        }
894
895        case SERVICE_DONE_EXECUTING_TRANSACTION: {
896            data.enforceInterface(IActivityManager.descriptor);
897            IBinder token = data.readStrongBinder();
898            int type = data.readInt();
899            int startId = data.readInt();
900            int res = data.readInt();
901            serviceDoneExecuting(token, type, startId, res);
902            reply.writeNoException();
903            return true;
904        }
905
906        case START_INSTRUMENTATION_TRANSACTION: {
907            data.enforceInterface(IActivityManager.descriptor);
908            ComponentName className = ComponentName.readFromParcel(data);
909            String profileFile = data.readString();
910            int fl = data.readInt();
911            Bundle arguments = data.readBundle();
912            IBinder b = data.readStrongBinder();
913            IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
914            b = data.readStrongBinder();
915            IUiAutomationConnection c = IUiAutomationConnection.Stub.asInterface(b);
916            int userId = data.readInt();
917            boolean res = startInstrumentation(className, profileFile, fl, arguments, w, c, userId);
918            reply.writeNoException();
919            reply.writeInt(res ? 1 : 0);
920            return true;
921        }
922
923
924        case FINISH_INSTRUMENTATION_TRANSACTION: {
925            data.enforceInterface(IActivityManager.descriptor);
926            IBinder b = data.readStrongBinder();
927            IApplicationThread app = ApplicationThreadNative.asInterface(b);
928            int resultCode = data.readInt();
929            Bundle results = data.readBundle();
930            finishInstrumentation(app, resultCode, results);
931            reply.writeNoException();
932            return true;
933        }
934
935        case GET_CONFIGURATION_TRANSACTION: {
936            data.enforceInterface(IActivityManager.descriptor);
937            Configuration config = getConfiguration();
938            reply.writeNoException();
939            config.writeToParcel(reply, 0);
940            return true;
941        }
942
943        case UPDATE_CONFIGURATION_TRANSACTION: {
944            data.enforceInterface(IActivityManager.descriptor);
945            Configuration config = Configuration.CREATOR.createFromParcel(data);
946            updateConfiguration(config);
947            reply.writeNoException();
948            return true;
949        }
950
951        case SET_REQUESTED_ORIENTATION_TRANSACTION: {
952            data.enforceInterface(IActivityManager.descriptor);
953            IBinder token = data.readStrongBinder();
954            int requestedOrientation = data.readInt();
955            setRequestedOrientation(token, requestedOrientation);
956            reply.writeNoException();
957            return true;
958        }
959
960        case GET_REQUESTED_ORIENTATION_TRANSACTION: {
961            data.enforceInterface(IActivityManager.descriptor);
962            IBinder token = data.readStrongBinder();
963            int req = getRequestedOrientation(token);
964            reply.writeNoException();
965            reply.writeInt(req);
966            return true;
967        }
968
969        case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION: {
970            data.enforceInterface(IActivityManager.descriptor);
971            IBinder token = data.readStrongBinder();
972            ComponentName cn = getActivityClassForToken(token);
973            reply.writeNoException();
974            ComponentName.writeToParcel(cn, reply);
975            return true;
976        }
977
978        case GET_PACKAGE_FOR_TOKEN_TRANSACTION: {
979            data.enforceInterface(IActivityManager.descriptor);
980            IBinder token = data.readStrongBinder();
981            reply.writeNoException();
982            reply.writeString(getPackageForToken(token));
983            return true;
984        }
985
986        case GET_INTENT_SENDER_TRANSACTION: {
987            data.enforceInterface(IActivityManager.descriptor);
988            int type = data.readInt();
989            String packageName = data.readString();
990            IBinder token = data.readStrongBinder();
991            String resultWho = data.readString();
992            int requestCode = data.readInt();
993            Intent[] requestIntents;
994            String[] requestResolvedTypes;
995            if (data.readInt() != 0) {
996                requestIntents = data.createTypedArray(Intent.CREATOR);
997                requestResolvedTypes = data.createStringArray();
998            } else {
999                requestIntents = null;
1000                requestResolvedTypes = null;
1001            }
1002            int fl = data.readInt();
1003            Bundle options = data.readInt() != 0
1004                    ? Bundle.CREATOR.createFromParcel(data) : null;
1005            int userId = data.readInt();
1006            IIntentSender res = getIntentSender(type, packageName, token,
1007                    resultWho, requestCode, requestIntents,
1008                    requestResolvedTypes, fl, options, userId);
1009            reply.writeNoException();
1010            reply.writeStrongBinder(res != null ? res.asBinder() : null);
1011            return true;
1012        }
1013
1014        case CANCEL_INTENT_SENDER_TRANSACTION: {
1015            data.enforceInterface(IActivityManager.descriptor);
1016            IIntentSender r = IIntentSender.Stub.asInterface(
1017                data.readStrongBinder());
1018            cancelIntentSender(r);
1019            reply.writeNoException();
1020            return true;
1021        }
1022
1023        case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION: {
1024            data.enforceInterface(IActivityManager.descriptor);
1025            IIntentSender r = IIntentSender.Stub.asInterface(
1026                data.readStrongBinder());
1027            String res = getPackageForIntentSender(r);
1028            reply.writeNoException();
1029            reply.writeString(res);
1030            return true;
1031        }
1032
1033        case GET_UID_FOR_INTENT_SENDER_TRANSACTION: {
1034            data.enforceInterface(IActivityManager.descriptor);
1035            IIntentSender r = IIntentSender.Stub.asInterface(
1036                data.readStrongBinder());
1037            int res = getUidForIntentSender(r);
1038            reply.writeNoException();
1039            reply.writeInt(res);
1040            return true;
1041        }
1042
1043        case HANDLE_INCOMING_USER_TRANSACTION: {
1044            data.enforceInterface(IActivityManager.descriptor);
1045            int callingPid = data.readInt();
1046            int callingUid = data.readInt();
1047            int userId = data.readInt();
1048            boolean allowAll = data.readInt() != 0 ;
1049            boolean requireFull = data.readInt() != 0;
1050            String name = data.readString();
1051            String callerPackage = data.readString();
1052            int res = handleIncomingUser(callingPid, callingUid, userId, allowAll,
1053                    requireFull, name, callerPackage);
1054            reply.writeNoException();
1055            reply.writeInt(res);
1056            return true;
1057        }
1058
1059        case SET_PROCESS_LIMIT_TRANSACTION: {
1060            data.enforceInterface(IActivityManager.descriptor);
1061            int max = data.readInt();
1062            setProcessLimit(max);
1063            reply.writeNoException();
1064            return true;
1065        }
1066
1067        case GET_PROCESS_LIMIT_TRANSACTION: {
1068            data.enforceInterface(IActivityManager.descriptor);
1069            int limit = getProcessLimit();
1070            reply.writeNoException();
1071            reply.writeInt(limit);
1072            return true;
1073        }
1074
1075        case SET_PROCESS_FOREGROUND_TRANSACTION: {
1076            data.enforceInterface(IActivityManager.descriptor);
1077            IBinder token = data.readStrongBinder();
1078            int pid = data.readInt();
1079            boolean isForeground = data.readInt() != 0;
1080            setProcessForeground(token, pid, isForeground);
1081            reply.writeNoException();
1082            return true;
1083        }
1084
1085        case CHECK_PERMISSION_TRANSACTION: {
1086            data.enforceInterface(IActivityManager.descriptor);
1087            String perm = data.readString();
1088            int pid = data.readInt();
1089            int uid = data.readInt();
1090            int res = checkPermission(perm, pid, uid);
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 res = checkUriPermission(uri, pid, uid, mode);
1103            reply.writeNoException();
1104            reply.writeInt(res);
1105            return true;
1106        }
1107
1108        case CLEAR_APP_DATA_TRANSACTION: {
1109            data.enforceInterface(IActivityManager.descriptor);
1110            String packageName = data.readString();
1111            IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(
1112                    data.readStrongBinder());
1113            int userId = data.readInt();
1114            boolean res = clearApplicationUserData(packageName, observer, userId);
1115            reply.writeNoException();
1116            reply.writeInt(res ? 1 : 0);
1117            return true;
1118        }
1119
1120        case GRANT_URI_PERMISSION_TRANSACTION: {
1121            data.enforceInterface(IActivityManager.descriptor);
1122            IBinder b = data.readStrongBinder();
1123            IApplicationThread app = ApplicationThreadNative.asInterface(b);
1124            String targetPkg = data.readString();
1125            Uri uri = Uri.CREATOR.createFromParcel(data);
1126            int mode = data.readInt();
1127            grantUriPermission(app, targetPkg, uri, mode);
1128            reply.writeNoException();
1129            return true;
1130        }
1131
1132        case REVOKE_URI_PERMISSION_TRANSACTION: {
1133            data.enforceInterface(IActivityManager.descriptor);
1134            IBinder b = data.readStrongBinder();
1135            IApplicationThread app = ApplicationThreadNative.asInterface(b);
1136            Uri uri = Uri.CREATOR.createFromParcel(data);
1137            int mode = data.readInt();
1138            revokeUriPermission(app, uri, mode);
1139            reply.writeNoException();
1140            return true;
1141        }
1142
1143        case TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
1144            data.enforceInterface(IActivityManager.descriptor);
1145            Uri uri = Uri.CREATOR.createFromParcel(data);
1146            int mode = data.readInt();
1147            takePersistableUriPermission(uri, mode);
1148            reply.writeNoException();
1149            return true;
1150        }
1151
1152        case RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION: {
1153            data.enforceInterface(IActivityManager.descriptor);
1154            Uri uri = Uri.CREATOR.createFromParcel(data);
1155            int mode = data.readInt();
1156            releasePersistableUriPermission(uri, mode);
1157            reply.writeNoException();
1158            return true;
1159        }
1160
1161        case GET_PERSISTED_URI_PERMISSIONS_TRANSACTION: {
1162            data.enforceInterface(IActivityManager.descriptor);
1163            final ParceledListSlice<UriPermission> perms = getPersistedUriPermissions();
1164            reply.writeNoException();
1165            perms.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1166            return true;
1167        }
1168
1169        case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: {
1170            data.enforceInterface(IActivityManager.descriptor);
1171            IBinder b = data.readStrongBinder();
1172            IApplicationThread app = ApplicationThreadNative.asInterface(b);
1173            boolean waiting = data.readInt() != 0;
1174            showWaitingForDebugger(app, waiting);
1175            reply.writeNoException();
1176            return true;
1177        }
1178
1179        case GET_MEMORY_INFO_TRANSACTION: {
1180            data.enforceInterface(IActivityManager.descriptor);
1181            ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
1182            getMemoryInfo(mi);
1183            reply.writeNoException();
1184            mi.writeToParcel(reply, 0);
1185            return true;
1186        }
1187
1188        case UNHANDLED_BACK_TRANSACTION: {
1189            data.enforceInterface(IActivityManager.descriptor);
1190            unhandledBack();
1191            reply.writeNoException();
1192            return true;
1193        }
1194
1195        case OPEN_CONTENT_URI_TRANSACTION: {
1196            data.enforceInterface(IActivityManager.descriptor);
1197            Uri uri = Uri.parse(data.readString());
1198            ParcelFileDescriptor pfd = openContentUri(uri);
1199            reply.writeNoException();
1200            if (pfd != null) {
1201                reply.writeInt(1);
1202                pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1203            } else {
1204                reply.writeInt(0);
1205            }
1206            return true;
1207        }
1208
1209        case GOING_TO_SLEEP_TRANSACTION: {
1210            data.enforceInterface(IActivityManager.descriptor);
1211            goingToSleep();
1212            reply.writeNoException();
1213            return true;
1214        }
1215
1216        case WAKING_UP_TRANSACTION: {
1217            data.enforceInterface(IActivityManager.descriptor);
1218            wakingUp();
1219            reply.writeNoException();
1220            return true;
1221        }
1222
1223        case SET_LOCK_SCREEN_SHOWN_TRANSACTION: {
1224            data.enforceInterface(IActivityManager.descriptor);
1225            setLockScreenShown(data.readInt() != 0);
1226            reply.writeNoException();
1227            return true;
1228        }
1229
1230        case SET_DEBUG_APP_TRANSACTION: {
1231            data.enforceInterface(IActivityManager.descriptor);
1232            String pn = data.readString();
1233            boolean wfd = data.readInt() != 0;
1234            boolean per = data.readInt() != 0;
1235            setDebugApp(pn, wfd, per);
1236            reply.writeNoException();
1237            return true;
1238        }
1239
1240        case SET_ALWAYS_FINISH_TRANSACTION: {
1241            data.enforceInterface(IActivityManager.descriptor);
1242            boolean enabled = data.readInt() != 0;
1243            setAlwaysFinish(enabled);
1244            reply.writeNoException();
1245            return true;
1246        }
1247
1248        case SET_ACTIVITY_CONTROLLER_TRANSACTION: {
1249            data.enforceInterface(IActivityManager.descriptor);
1250            IActivityController watcher = IActivityController.Stub.asInterface(
1251                    data.readStrongBinder());
1252            setActivityController(watcher);
1253            reply.writeNoException();
1254            return true;
1255        }
1256
1257        case ENTER_SAFE_MODE_TRANSACTION: {
1258            data.enforceInterface(IActivityManager.descriptor);
1259            enterSafeMode();
1260            reply.writeNoException();
1261            return true;
1262        }
1263
1264        case NOTE_WAKEUP_ALARM_TRANSACTION: {
1265            data.enforceInterface(IActivityManager.descriptor);
1266            IIntentSender is = IIntentSender.Stub.asInterface(
1267                    data.readStrongBinder());
1268            noteWakeupAlarm(is);
1269            reply.writeNoException();
1270            return true;
1271        }
1272
1273        case KILL_PIDS_TRANSACTION: {
1274            data.enforceInterface(IActivityManager.descriptor);
1275            int[] pids = data.createIntArray();
1276            String reason = data.readString();
1277            boolean secure = data.readInt() != 0;
1278            boolean res = killPids(pids, reason, secure);
1279            reply.writeNoException();
1280            reply.writeInt(res ? 1 : 0);
1281            return true;
1282        }
1283
1284        case KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION: {
1285            data.enforceInterface(IActivityManager.descriptor);
1286            String reason = data.readString();
1287            boolean res = killProcessesBelowForeground(reason);
1288            reply.writeNoException();
1289            reply.writeInt(res ? 1 : 0);
1290            return true;
1291        }
1292
1293        case START_RUNNING_TRANSACTION: {
1294            data.enforceInterface(IActivityManager.descriptor);
1295            String pkg = data.readString();
1296            String cls = data.readString();
1297            String action = data.readString();
1298            String indata = data.readString();
1299            startRunning(pkg, cls, action, indata);
1300            reply.writeNoException();
1301            return true;
1302        }
1303
1304        case HANDLE_APPLICATION_CRASH_TRANSACTION: {
1305            data.enforceInterface(IActivityManager.descriptor);
1306            IBinder app = data.readStrongBinder();
1307            ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
1308            handleApplicationCrash(app, ci);
1309            reply.writeNoException();
1310            return true;
1311        }
1312
1313        case HANDLE_APPLICATION_WTF_TRANSACTION: {
1314            data.enforceInterface(IActivityManager.descriptor);
1315            IBinder app = data.readStrongBinder();
1316            String tag = data.readString();
1317            ApplicationErrorReport.CrashInfo ci = new ApplicationErrorReport.CrashInfo(data);
1318            boolean res = handleApplicationWtf(app, tag, ci);
1319            reply.writeNoException();
1320            reply.writeInt(res ? 1 : 0);
1321            return true;
1322        }
1323
1324        case HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION: {
1325            data.enforceInterface(IActivityManager.descriptor);
1326            IBinder app = data.readStrongBinder();
1327            int violationMask = data.readInt();
1328            StrictMode.ViolationInfo info = new StrictMode.ViolationInfo(data);
1329            handleApplicationStrictModeViolation(app, violationMask, info);
1330            reply.writeNoException();
1331            return true;
1332        }
1333
1334        case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION: {
1335            data.enforceInterface(IActivityManager.descriptor);
1336            int sig = data.readInt();
1337            signalPersistentProcesses(sig);
1338            reply.writeNoException();
1339            return true;
1340        }
1341
1342        case KILL_BACKGROUND_PROCESSES_TRANSACTION: {
1343            data.enforceInterface(IActivityManager.descriptor);
1344            String packageName = data.readString();
1345            int userId = data.readInt();
1346            killBackgroundProcesses(packageName, userId);
1347            reply.writeNoException();
1348            return true;
1349        }
1350
1351        case KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION: {
1352            data.enforceInterface(IActivityManager.descriptor);
1353            killAllBackgroundProcesses();
1354            reply.writeNoException();
1355            return true;
1356        }
1357
1358        case FORCE_STOP_PACKAGE_TRANSACTION: {
1359            data.enforceInterface(IActivityManager.descriptor);
1360            String packageName = data.readString();
1361            int userId = data.readInt();
1362            forceStopPackage(packageName, userId);
1363            reply.writeNoException();
1364            return true;
1365        }
1366
1367        case GET_MY_MEMORY_STATE_TRANSACTION: {
1368            data.enforceInterface(IActivityManager.descriptor);
1369            ActivityManager.RunningAppProcessInfo info =
1370                    new ActivityManager.RunningAppProcessInfo();
1371            getMyMemoryState(info);
1372            reply.writeNoException();
1373            info.writeToParcel(reply, 0);
1374            return true;
1375        }
1376
1377        case GET_DEVICE_CONFIGURATION_TRANSACTION: {
1378            data.enforceInterface(IActivityManager.descriptor);
1379            ConfigurationInfo config = getDeviceConfigurationInfo();
1380            reply.writeNoException();
1381            config.writeToParcel(reply, 0);
1382            return true;
1383        }
1384
1385        case PROFILE_CONTROL_TRANSACTION: {
1386            data.enforceInterface(IActivityManager.descriptor);
1387            String process = data.readString();
1388            int userId = data.readInt();
1389            boolean start = data.readInt() != 0;
1390            int profileType = data.readInt();
1391            String path = data.readString();
1392            ParcelFileDescriptor fd = data.readInt() != 0
1393                    ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
1394            boolean res = profileControl(process, userId, start, path, fd, profileType);
1395            reply.writeNoException();
1396            reply.writeInt(res ? 1 : 0);
1397            return true;
1398        }
1399
1400        case SHUTDOWN_TRANSACTION: {
1401            data.enforceInterface(IActivityManager.descriptor);
1402            boolean res = shutdown(data.readInt());
1403            reply.writeNoException();
1404            reply.writeInt(res ? 1 : 0);
1405            return true;
1406        }
1407
1408        case STOP_APP_SWITCHES_TRANSACTION: {
1409            data.enforceInterface(IActivityManager.descriptor);
1410            stopAppSwitches();
1411            reply.writeNoException();
1412            return true;
1413        }
1414
1415        case RESUME_APP_SWITCHES_TRANSACTION: {
1416            data.enforceInterface(IActivityManager.descriptor);
1417            resumeAppSwitches();
1418            reply.writeNoException();
1419            return true;
1420        }
1421
1422        case PEEK_SERVICE_TRANSACTION: {
1423            data.enforceInterface(IActivityManager.descriptor);
1424            Intent service = Intent.CREATOR.createFromParcel(data);
1425            String resolvedType = data.readString();
1426            IBinder binder = peekService(service, resolvedType);
1427            reply.writeNoException();
1428            reply.writeStrongBinder(binder);
1429            return true;
1430        }
1431
1432        case START_BACKUP_AGENT_TRANSACTION: {
1433            data.enforceInterface(IActivityManager.descriptor);
1434            ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
1435            int backupRestoreMode = data.readInt();
1436            boolean success = bindBackupAgent(info, backupRestoreMode);
1437            reply.writeNoException();
1438            reply.writeInt(success ? 1 : 0);
1439            return true;
1440        }
1441
1442        case BACKUP_AGENT_CREATED_TRANSACTION: {
1443            data.enforceInterface(IActivityManager.descriptor);
1444            String packageName = data.readString();
1445            IBinder agent = data.readStrongBinder();
1446            backupAgentCreated(packageName, agent);
1447            reply.writeNoException();
1448            return true;
1449        }
1450
1451        case UNBIND_BACKUP_AGENT_TRANSACTION: {
1452            data.enforceInterface(IActivityManager.descriptor);
1453            ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
1454            unbindBackupAgent(info);
1455            reply.writeNoException();
1456            return true;
1457        }
1458
1459        case KILL_APPLICATION_WITH_APPID_TRANSACTION: {
1460            data.enforceInterface(IActivityManager.descriptor);
1461            String pkg = data.readString();
1462            int appid = data.readInt();
1463            String reason = data.readString();
1464            killApplicationWithAppId(pkg, appid, reason);
1465            reply.writeNoException();
1466            return true;
1467        }
1468
1469        case CLOSE_SYSTEM_DIALOGS_TRANSACTION: {
1470            data.enforceInterface(IActivityManager.descriptor);
1471            String reason = data.readString();
1472            closeSystemDialogs(reason);
1473            reply.writeNoException();
1474            return true;
1475        }
1476
1477        case GET_PROCESS_MEMORY_INFO_TRANSACTION: {
1478            data.enforceInterface(IActivityManager.descriptor);
1479            int[] pids = data.createIntArray();
1480            Debug.MemoryInfo[] res =  getProcessMemoryInfo(pids);
1481            reply.writeNoException();
1482            reply.writeTypedArray(res, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1483            return true;
1484        }
1485
1486        case KILL_APPLICATION_PROCESS_TRANSACTION: {
1487            data.enforceInterface(IActivityManager.descriptor);
1488            String processName = data.readString();
1489            int uid = data.readInt();
1490            killApplicationProcess(processName, uid);
1491            reply.writeNoException();
1492            return true;
1493        }
1494
1495        case OVERRIDE_PENDING_TRANSITION_TRANSACTION: {
1496            data.enforceInterface(IActivityManager.descriptor);
1497            IBinder token = data.readStrongBinder();
1498            String packageName = data.readString();
1499            int enterAnim = data.readInt();
1500            int exitAnim = data.readInt();
1501            overridePendingTransition(token, packageName, enterAnim, exitAnim);
1502            reply.writeNoException();
1503            return true;
1504        }
1505
1506        case IS_USER_A_MONKEY_TRANSACTION: {
1507            data.enforceInterface(IActivityManager.descriptor);
1508            boolean areThey = isUserAMonkey();
1509            reply.writeNoException();
1510            reply.writeInt(areThey ? 1 : 0);
1511            return true;
1512        }
1513
1514        case SET_USER_IS_MONKEY_TRANSACTION: {
1515            data.enforceInterface(IActivityManager.descriptor);
1516            final boolean monkey = (data.readInt() == 1);
1517            setUserIsMonkey(monkey);
1518            reply.writeNoException();
1519            return true;
1520        }
1521
1522        case FINISH_HEAVY_WEIGHT_APP_TRANSACTION: {
1523            data.enforceInterface(IActivityManager.descriptor);
1524            finishHeavyWeightApp();
1525            reply.writeNoException();
1526            return true;
1527        }
1528
1529        case IS_IMMERSIVE_TRANSACTION: {
1530            data.enforceInterface(IActivityManager.descriptor);
1531            IBinder token = data.readStrongBinder();
1532            boolean isit = isImmersive(token);
1533            reply.writeNoException();
1534            reply.writeInt(isit ? 1 : 0);
1535            return true;
1536        }
1537
1538        case CONVERT_FROM_TRANSLUCENT_TRANSACTION: {
1539            data.enforceInterface(IActivityManager.descriptor);
1540            IBinder token = data.readStrongBinder();
1541            boolean converted = convertFromTranslucent(token);
1542            reply.writeNoException();
1543            reply.writeInt(converted ? 1 : 0);
1544            return true;
1545        }
1546
1547        case CONVERT_TO_TRANSLUCENT_TRANSACTION: {
1548            data.enforceInterface(IActivityManager.descriptor);
1549            IBinder token = data.readStrongBinder();
1550            boolean converted = convertToTranslucent(token);
1551            reply.writeNoException();
1552            reply.writeInt(converted ? 1 : 0);
1553            return true;
1554        }
1555
1556        case SET_IMMERSIVE_TRANSACTION: {
1557            data.enforceInterface(IActivityManager.descriptor);
1558            IBinder token = data.readStrongBinder();
1559            boolean imm = data.readInt() == 1;
1560            setImmersive(token, imm);
1561            reply.writeNoException();
1562            return true;
1563        }
1564
1565        case IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION: {
1566            data.enforceInterface(IActivityManager.descriptor);
1567            boolean isit = isTopActivityImmersive();
1568            reply.writeNoException();
1569            reply.writeInt(isit ? 1 : 0);
1570            return true;
1571        }
1572
1573        case CRASH_APPLICATION_TRANSACTION: {
1574            data.enforceInterface(IActivityManager.descriptor);
1575            int uid = data.readInt();
1576            int initialPid = data.readInt();
1577            String packageName = data.readString();
1578            String message = data.readString();
1579            crashApplication(uid, initialPid, packageName, message);
1580            reply.writeNoException();
1581            return true;
1582        }
1583
1584        case GET_PROVIDER_MIME_TYPE_TRANSACTION: {
1585            data.enforceInterface(IActivityManager.descriptor);
1586            Uri uri = Uri.CREATOR.createFromParcel(data);
1587            int userId = data.readInt();
1588            String type = getProviderMimeType(uri, userId);
1589            reply.writeNoException();
1590            reply.writeString(type);
1591            return true;
1592        }
1593
1594        case NEW_URI_PERMISSION_OWNER_TRANSACTION: {
1595            data.enforceInterface(IActivityManager.descriptor);
1596            String name = data.readString();
1597            IBinder perm = newUriPermissionOwner(name);
1598            reply.writeNoException();
1599            reply.writeStrongBinder(perm);
1600            return true;
1601        }
1602
1603        case GRANT_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
1604            data.enforceInterface(IActivityManager.descriptor);
1605            IBinder owner = data.readStrongBinder();
1606            int fromUid = data.readInt();
1607            String targetPkg = data.readString();
1608            Uri uri = Uri.CREATOR.createFromParcel(data);
1609            int mode = data.readInt();
1610            grantUriPermissionFromOwner(owner, fromUid, targetPkg, uri, mode);
1611            reply.writeNoException();
1612            return true;
1613        }
1614
1615        case REVOKE_URI_PERMISSION_FROM_OWNER_TRANSACTION: {
1616            data.enforceInterface(IActivityManager.descriptor);
1617            IBinder owner = data.readStrongBinder();
1618            Uri uri = null;
1619            if (data.readInt() != 0) {
1620                Uri.CREATOR.createFromParcel(data);
1621            }
1622            int mode = data.readInt();
1623            revokeUriPermissionFromOwner(owner, uri, mode);
1624            reply.writeNoException();
1625            return true;
1626        }
1627
1628        case CHECK_GRANT_URI_PERMISSION_TRANSACTION: {
1629            data.enforceInterface(IActivityManager.descriptor);
1630            int callingUid = data.readInt();
1631            String targetPkg = data.readString();
1632            Uri uri = Uri.CREATOR.createFromParcel(data);
1633            int modeFlags = data.readInt();
1634            int res = checkGrantUriPermission(callingUid, targetPkg, uri, modeFlags);
1635            reply.writeNoException();
1636            reply.writeInt(res);
1637            return true;
1638        }
1639
1640        case DUMP_HEAP_TRANSACTION: {
1641            data.enforceInterface(IActivityManager.descriptor);
1642            String process = data.readString();
1643            int userId = data.readInt();
1644            boolean managed = data.readInt() != 0;
1645            String path = data.readString();
1646            ParcelFileDescriptor fd = data.readInt() != 0
1647                    ? ParcelFileDescriptor.CREATOR.createFromParcel(data) : null;
1648            boolean res = dumpHeap(process, userId, managed, path, fd);
1649            reply.writeNoException();
1650            reply.writeInt(res ? 1 : 0);
1651            return true;
1652        }
1653
1654        case START_ACTIVITIES_TRANSACTION:
1655        {
1656            data.enforceInterface(IActivityManager.descriptor);
1657            IBinder b = data.readStrongBinder();
1658            IApplicationThread app = ApplicationThreadNative.asInterface(b);
1659            String callingPackage = data.readString();
1660            Intent[] intents = data.createTypedArray(Intent.CREATOR);
1661            String[] resolvedTypes = data.createStringArray();
1662            IBinder resultTo = data.readStrongBinder();
1663            Bundle options = data.readInt() != 0
1664                    ? Bundle.CREATOR.createFromParcel(data) : null;
1665            int userId = data.readInt();
1666            int result = startActivities(app, callingPackage, intents, resolvedTypes, resultTo,
1667                    options, userId);
1668            reply.writeNoException();
1669            reply.writeInt(result);
1670            return true;
1671        }
1672
1673        case GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
1674        {
1675            data.enforceInterface(IActivityManager.descriptor);
1676            int mode = getFrontActivityScreenCompatMode();
1677            reply.writeNoException();
1678            reply.writeInt(mode);
1679            return true;
1680        }
1681
1682        case SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION:
1683        {
1684            data.enforceInterface(IActivityManager.descriptor);
1685            int mode = data.readInt();
1686            setFrontActivityScreenCompatMode(mode);
1687            reply.writeNoException();
1688            reply.writeInt(mode);
1689            return true;
1690        }
1691
1692        case GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
1693        {
1694            data.enforceInterface(IActivityManager.descriptor);
1695            String pkg = data.readString();
1696            int mode = getPackageScreenCompatMode(pkg);
1697            reply.writeNoException();
1698            reply.writeInt(mode);
1699            return true;
1700        }
1701
1702        case SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION:
1703        {
1704            data.enforceInterface(IActivityManager.descriptor);
1705            String pkg = data.readString();
1706            int mode = data.readInt();
1707            setPackageScreenCompatMode(pkg, mode);
1708            reply.writeNoException();
1709            return true;
1710        }
1711
1712        case SWITCH_USER_TRANSACTION: {
1713            data.enforceInterface(IActivityManager.descriptor);
1714            int userid = data.readInt();
1715            boolean result = switchUser(userid);
1716            reply.writeNoException();
1717            reply.writeInt(result ? 1 : 0);
1718            return true;
1719        }
1720
1721        case STOP_USER_TRANSACTION: {
1722            data.enforceInterface(IActivityManager.descriptor);
1723            int userid = data.readInt();
1724            IStopUserCallback callback = IStopUserCallback.Stub.asInterface(
1725                    data.readStrongBinder());
1726            int result = stopUser(userid, callback);
1727            reply.writeNoException();
1728            reply.writeInt(result);
1729            return true;
1730        }
1731
1732        case GET_CURRENT_USER_TRANSACTION: {
1733            data.enforceInterface(IActivityManager.descriptor);
1734            UserInfo userInfo = getCurrentUser();
1735            reply.writeNoException();
1736            userInfo.writeToParcel(reply, 0);
1737            return true;
1738        }
1739
1740        case IS_USER_RUNNING_TRANSACTION: {
1741            data.enforceInterface(IActivityManager.descriptor);
1742            int userid = data.readInt();
1743            boolean orStopping = data.readInt() != 0;
1744            boolean result = isUserRunning(userid, orStopping);
1745            reply.writeNoException();
1746            reply.writeInt(result ? 1 : 0);
1747            return true;
1748        }
1749
1750        case GET_RUNNING_USER_IDS_TRANSACTION: {
1751            data.enforceInterface(IActivityManager.descriptor);
1752            int[] result = getRunningUserIds();
1753            reply.writeNoException();
1754            reply.writeIntArray(result);
1755            return true;
1756        }
1757
1758        case REMOVE_SUB_TASK_TRANSACTION:
1759        {
1760            data.enforceInterface(IActivityManager.descriptor);
1761            int taskId = data.readInt();
1762            int subTaskIndex = data.readInt();
1763            boolean result = removeSubTask(taskId, subTaskIndex);
1764            reply.writeNoException();
1765            reply.writeInt(result ? 1 : 0);
1766            return true;
1767        }
1768
1769        case REMOVE_TASK_TRANSACTION:
1770        {
1771            data.enforceInterface(IActivityManager.descriptor);
1772            int taskId = data.readInt();
1773            int fl = data.readInt();
1774            boolean result = removeTask(taskId, fl);
1775            reply.writeNoException();
1776            reply.writeInt(result ? 1 : 0);
1777            return true;
1778        }
1779
1780        case REGISTER_PROCESS_OBSERVER_TRANSACTION: {
1781            data.enforceInterface(IActivityManager.descriptor);
1782            IProcessObserver observer = IProcessObserver.Stub.asInterface(
1783                    data.readStrongBinder());
1784            registerProcessObserver(observer);
1785            return true;
1786        }
1787
1788        case UNREGISTER_PROCESS_OBSERVER_TRANSACTION: {
1789            data.enforceInterface(IActivityManager.descriptor);
1790            IProcessObserver observer = IProcessObserver.Stub.asInterface(
1791                    data.readStrongBinder());
1792            unregisterProcessObserver(observer);
1793            return true;
1794        }
1795
1796        case GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
1797        {
1798            data.enforceInterface(IActivityManager.descriptor);
1799            String pkg = data.readString();
1800            boolean ask = getPackageAskScreenCompat(pkg);
1801            reply.writeNoException();
1802            reply.writeInt(ask ? 1 : 0);
1803            return true;
1804        }
1805
1806        case SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION:
1807        {
1808            data.enforceInterface(IActivityManager.descriptor);
1809            String pkg = data.readString();
1810            boolean ask = data.readInt() != 0;
1811            setPackageAskScreenCompat(pkg, ask);
1812            reply.writeNoException();
1813            return true;
1814        }
1815
1816        case IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION: {
1817            data.enforceInterface(IActivityManager.descriptor);
1818            IIntentSender r = IIntentSender.Stub.asInterface(
1819                data.readStrongBinder());
1820            boolean res = isIntentSenderTargetedToPackage(r);
1821            reply.writeNoException();
1822            reply.writeInt(res ? 1 : 0);
1823            return true;
1824        }
1825
1826        case IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION: {
1827            data.enforceInterface(IActivityManager.descriptor);
1828            IIntentSender r = IIntentSender.Stub.asInterface(
1829                data.readStrongBinder());
1830            boolean res = isIntentSenderAnActivity(r);
1831            reply.writeNoException();
1832            reply.writeInt(res ? 1 : 0);
1833            return true;
1834        }
1835
1836        case GET_INTENT_FOR_INTENT_SENDER_TRANSACTION: {
1837            data.enforceInterface(IActivityManager.descriptor);
1838            IIntentSender r = IIntentSender.Stub.asInterface(
1839                data.readStrongBinder());
1840            Intent intent = getIntentForIntentSender(r);
1841            reply.writeNoException();
1842            if (intent != null) {
1843                reply.writeInt(1);
1844                intent.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
1845            } else {
1846                reply.writeInt(0);
1847            }
1848            return true;
1849        }
1850
1851        case UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION: {
1852            data.enforceInterface(IActivityManager.descriptor);
1853            Configuration config = Configuration.CREATOR.createFromParcel(data);
1854            updatePersistentConfiguration(config);
1855            reply.writeNoException();
1856            return true;
1857        }
1858
1859        case GET_PROCESS_PSS_TRANSACTION: {
1860            data.enforceInterface(IActivityManager.descriptor);
1861            int[] pids = data.createIntArray();
1862            long[] pss = getProcessPss(pids);
1863            reply.writeNoException();
1864            reply.writeLongArray(pss);
1865            return true;
1866        }
1867
1868        case SHOW_BOOT_MESSAGE_TRANSACTION: {
1869            data.enforceInterface(IActivityManager.descriptor);
1870            CharSequence msg = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
1871            boolean always = data.readInt() != 0;
1872            showBootMessage(msg, always);
1873            reply.writeNoException();
1874            return true;
1875        }
1876
1877        case DISMISS_KEYGUARD_ON_NEXT_ACTIVITY_TRANSACTION: {
1878            data.enforceInterface(IActivityManager.descriptor);
1879            dismissKeyguardOnNextActivity();
1880            reply.writeNoException();
1881            return true;
1882        }
1883
1884        case TARGET_TASK_AFFINITY_MATCHES_ACTIVITY_TRANSACTION: {
1885            data.enforceInterface(IActivityManager.descriptor);
1886            IBinder token = data.readStrongBinder();
1887            String destAffinity = data.readString();
1888            boolean res = targetTaskAffinityMatchesActivity(token, destAffinity);
1889            reply.writeNoException();
1890            reply.writeInt(res ? 1 : 0);
1891            return true;
1892        }
1893
1894        case NAVIGATE_UP_TO_TRANSACTION: {
1895            data.enforceInterface(IActivityManager.descriptor);
1896            IBinder token = data.readStrongBinder();
1897            Intent target = Intent.CREATOR.createFromParcel(data);
1898            int resultCode = data.readInt();
1899            Intent resultData = null;
1900            if (data.readInt() != 0) {
1901                resultData = Intent.CREATOR.createFromParcel(data);
1902            }
1903            boolean res = navigateUpTo(token, target, resultCode, resultData);
1904            reply.writeNoException();
1905            reply.writeInt(res ? 1 : 0);
1906            return true;
1907        }
1908
1909        case GET_LAUNCHED_FROM_UID_TRANSACTION: {
1910            data.enforceInterface(IActivityManager.descriptor);
1911            IBinder token = data.readStrongBinder();
1912            int res = getLaunchedFromUid(token);
1913            reply.writeNoException();
1914            reply.writeInt(res);
1915            return true;
1916        }
1917
1918        case GET_LAUNCHED_FROM_PACKAGE_TRANSACTION: {
1919            data.enforceInterface(IActivityManager.descriptor);
1920            IBinder token = data.readStrongBinder();
1921            String res = getLaunchedFromPackage(token);
1922            reply.writeNoException();
1923            reply.writeString(res);
1924            return true;
1925        }
1926
1927        case REGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
1928            data.enforceInterface(IActivityManager.descriptor);
1929            IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
1930                    data.readStrongBinder());
1931            registerUserSwitchObserver(observer);
1932            reply.writeNoException();
1933            return true;
1934        }
1935
1936        case UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION: {
1937            data.enforceInterface(IActivityManager.descriptor);
1938            IUserSwitchObserver observer = IUserSwitchObserver.Stub.asInterface(
1939                    data.readStrongBinder());
1940            unregisterUserSwitchObserver(observer);
1941            reply.writeNoException();
1942            return true;
1943        }
1944
1945        case REQUEST_BUG_REPORT_TRANSACTION: {
1946            data.enforceInterface(IActivityManager.descriptor);
1947            requestBugReport();
1948            reply.writeNoException();
1949            return true;
1950        }
1951
1952        case INPUT_DISPATCHING_TIMED_OUT_TRANSACTION: {
1953            data.enforceInterface(IActivityManager.descriptor);
1954            int pid = data.readInt();
1955            boolean aboveSystem = data.readInt() != 0;
1956            String reason = data.readString();
1957            long res = inputDispatchingTimedOut(pid, aboveSystem, reason);
1958            reply.writeNoException();
1959            reply.writeLong(res);
1960            return true;
1961        }
1962
1963        case GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
1964            data.enforceInterface(IActivityManager.descriptor);
1965            int requestType = data.readInt();
1966            Bundle res = getAssistContextExtras(requestType);
1967            reply.writeNoException();
1968            reply.writeBundle(res);
1969            return true;
1970        }
1971
1972        case REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION: {
1973            data.enforceInterface(IActivityManager.descriptor);
1974            IBinder token = data.readStrongBinder();
1975            Bundle extras = data.readBundle();
1976            reportAssistContextExtras(token, extras);
1977            reply.writeNoException();
1978            return true;
1979        }
1980
1981        case KILL_UID_TRANSACTION: {
1982            data.enforceInterface(IActivityManager.descriptor);
1983            int uid = data.readInt();
1984            String reason = data.readString();
1985            killUid(uid, reason);
1986            reply.writeNoException();
1987            return true;
1988        }
1989
1990        case HANG_TRANSACTION: {
1991            data.enforceInterface(IActivityManager.descriptor);
1992            IBinder who = data.readStrongBinder();
1993            boolean allowRestart = data.readInt() != 0;
1994            hang(who, allowRestart);
1995            reply.writeNoException();
1996            return true;
1997        }
1998
1999        case REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION: {
2000            data.enforceInterface(IActivityManager.descriptor);
2001            IBinder token = data.readStrongBinder();
2002            reportActivityFullyDrawn(token);
2003            reply.writeNoException();
2004            return true;
2005        }
2006
2007        case NOTIFY_ACTIVITY_DRAWN_TRANSACTION: {
2008            data.enforceInterface(IActivityManager.descriptor);
2009            IBinder token = data.readStrongBinder();
2010            notifyActivityDrawn(token);
2011            reply.writeNoException();
2012            return true;
2013        }
2014
2015        case RESTART_TRANSACTION: {
2016            data.enforceInterface(IActivityManager.descriptor);
2017            restart();
2018            reply.writeNoException();
2019            return true;
2020        }
2021
2022        case PERFORM_IDLE_MAINTENANCE_TRANSACTION: {
2023            data.enforceInterface(IActivityManager.descriptor);
2024            performIdleMaintenance();
2025            reply.writeNoException();
2026            return true;
2027        }
2028        }
2029
2030        return super.onTransact(code, data, reply, flags);
2031    }
2032
2033    public IBinder asBinder() {
2034        return this;
2035    }
2036
2037    private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
2038        protected IActivityManager create() {
2039            IBinder b = ServiceManager.getService("activity");
2040            if (false) {
2041                Log.v("ActivityManager", "default service binder = " + b);
2042            }
2043            IActivityManager am = asInterface(b);
2044            if (false) {
2045                Log.v("ActivityManager", "default service = " + am);
2046            }
2047            return am;
2048        }
2049    };
2050}
2051
2052class ActivityManagerProxy implements IActivityManager
2053{
2054    public ActivityManagerProxy(IBinder remote)
2055    {
2056        mRemote = remote;
2057    }
2058
2059    public IBinder asBinder()
2060    {
2061        return mRemote;
2062    }
2063
2064    public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
2065            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
2066            int startFlags, String profileFile,
2067            ParcelFileDescriptor profileFd, Bundle options) throws RemoteException {
2068        Parcel data = Parcel.obtain();
2069        Parcel reply = Parcel.obtain();
2070        data.writeInterfaceToken(IActivityManager.descriptor);
2071        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2072        data.writeString(callingPackage);
2073        intent.writeToParcel(data, 0);
2074        data.writeString(resolvedType);
2075        data.writeStrongBinder(resultTo);
2076        data.writeString(resultWho);
2077        data.writeInt(requestCode);
2078        data.writeInt(startFlags);
2079        data.writeString(profileFile);
2080        if (profileFd != null) {
2081            data.writeInt(1);
2082            profileFd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
2083        } else {
2084            data.writeInt(0);
2085        }
2086        if (options != null) {
2087            data.writeInt(1);
2088            options.writeToParcel(data, 0);
2089        } else {
2090            data.writeInt(0);
2091        }
2092        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
2093        reply.readException();
2094        int result = reply.readInt();
2095        reply.recycle();
2096        data.recycle();
2097        return result;
2098    }
2099
2100    public int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent,
2101            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
2102            int startFlags, String profileFile,
2103            ParcelFileDescriptor profileFd, Bundle options, int userId) throws RemoteException {
2104        Parcel data = Parcel.obtain();
2105        Parcel reply = Parcel.obtain();
2106        data.writeInterfaceToken(IActivityManager.descriptor);
2107        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2108        data.writeString(callingPackage);
2109        intent.writeToParcel(data, 0);
2110        data.writeString(resolvedType);
2111        data.writeStrongBinder(resultTo);
2112        data.writeString(resultWho);
2113        data.writeInt(requestCode);
2114        data.writeInt(startFlags);
2115        data.writeString(profileFile);
2116        if (profileFd != null) {
2117            data.writeInt(1);
2118            profileFd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
2119        } else {
2120            data.writeInt(0);
2121        }
2122        if (options != null) {
2123            data.writeInt(1);
2124            options.writeToParcel(data, 0);
2125        } else {
2126            data.writeInt(0);
2127        }
2128        data.writeInt(userId);
2129        mRemote.transact(START_ACTIVITY_AS_USER_TRANSACTION, data, reply, 0);
2130        reply.readException();
2131        int result = reply.readInt();
2132        reply.recycle();
2133        data.recycle();
2134        return result;
2135    }
2136    public WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,
2137            Intent intent, String resolvedType, IBinder resultTo, String resultWho,
2138            int requestCode, int startFlags, String profileFile,
2139            ParcelFileDescriptor profileFd, Bundle options, int userId) throws RemoteException {
2140        Parcel data = Parcel.obtain();
2141        Parcel reply = Parcel.obtain();
2142        data.writeInterfaceToken(IActivityManager.descriptor);
2143        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2144        data.writeString(callingPackage);
2145        intent.writeToParcel(data, 0);
2146        data.writeString(resolvedType);
2147        data.writeStrongBinder(resultTo);
2148        data.writeString(resultWho);
2149        data.writeInt(requestCode);
2150        data.writeInt(startFlags);
2151        data.writeString(profileFile);
2152        if (profileFd != null) {
2153            data.writeInt(1);
2154            profileFd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
2155        } else {
2156            data.writeInt(0);
2157        }
2158        if (options != null) {
2159            data.writeInt(1);
2160            options.writeToParcel(data, 0);
2161        } else {
2162            data.writeInt(0);
2163        }
2164        data.writeInt(userId);
2165        mRemote.transact(START_ACTIVITY_AND_WAIT_TRANSACTION, data, reply, 0);
2166        reply.readException();
2167        WaitResult result = WaitResult.CREATOR.createFromParcel(reply);
2168        reply.recycle();
2169        data.recycle();
2170        return result;
2171    }
2172    public int startActivityWithConfig(IApplicationThread caller, String callingPackage,
2173            Intent intent, String resolvedType, IBinder resultTo, String resultWho,
2174            int requestCode, int startFlags, Configuration config,
2175            Bundle options, int userId) throws RemoteException {
2176        Parcel data = Parcel.obtain();
2177        Parcel reply = Parcel.obtain();
2178        data.writeInterfaceToken(IActivityManager.descriptor);
2179        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2180        data.writeString(callingPackage);
2181        intent.writeToParcel(data, 0);
2182        data.writeString(resolvedType);
2183        data.writeStrongBinder(resultTo);
2184        data.writeString(resultWho);
2185        data.writeInt(requestCode);
2186        data.writeInt(startFlags);
2187        config.writeToParcel(data, 0);
2188        if (options != null) {
2189            data.writeInt(1);
2190            options.writeToParcel(data, 0);
2191        } else {
2192            data.writeInt(0);
2193        }
2194        data.writeInt(userId);
2195        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
2196        reply.readException();
2197        int result = reply.readInt();
2198        reply.recycle();
2199        data.recycle();
2200        return result;
2201    }
2202    public int startActivityIntentSender(IApplicationThread caller,
2203            IntentSender intent, Intent fillInIntent, String resolvedType,
2204            IBinder resultTo, String resultWho, int requestCode,
2205            int flagsMask, int flagsValues, Bundle options) throws RemoteException {
2206        Parcel data = Parcel.obtain();
2207        Parcel reply = Parcel.obtain();
2208        data.writeInterfaceToken(IActivityManager.descriptor);
2209        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2210        intent.writeToParcel(data, 0);
2211        if (fillInIntent != null) {
2212            data.writeInt(1);
2213            fillInIntent.writeToParcel(data, 0);
2214        } else {
2215            data.writeInt(0);
2216        }
2217        data.writeString(resolvedType);
2218        data.writeStrongBinder(resultTo);
2219        data.writeString(resultWho);
2220        data.writeInt(requestCode);
2221        data.writeInt(flagsMask);
2222        data.writeInt(flagsValues);
2223        if (options != null) {
2224            data.writeInt(1);
2225            options.writeToParcel(data, 0);
2226        } else {
2227            data.writeInt(0);
2228        }
2229        mRemote.transact(START_ACTIVITY_INTENT_SENDER_TRANSACTION, data, reply, 0);
2230        reply.readException();
2231        int result = reply.readInt();
2232        reply.recycle();
2233        data.recycle();
2234        return result;
2235    }
2236    public boolean startNextMatchingActivity(IBinder callingActivity,
2237            Intent intent, Bundle options) throws RemoteException {
2238        Parcel data = Parcel.obtain();
2239        Parcel reply = Parcel.obtain();
2240        data.writeInterfaceToken(IActivityManager.descriptor);
2241        data.writeStrongBinder(callingActivity);
2242        intent.writeToParcel(data, 0);
2243        if (options != null) {
2244            data.writeInt(1);
2245            options.writeToParcel(data, 0);
2246        } else {
2247            data.writeInt(0);
2248        }
2249        mRemote.transact(START_NEXT_MATCHING_ACTIVITY_TRANSACTION, data, reply, 0);
2250        reply.readException();
2251        int result = reply.readInt();
2252        reply.recycle();
2253        data.recycle();
2254        return result != 0;
2255    }
2256    public boolean finishActivity(IBinder token, int resultCode, Intent resultData)
2257            throws RemoteException {
2258        Parcel data = Parcel.obtain();
2259        Parcel reply = Parcel.obtain();
2260        data.writeInterfaceToken(IActivityManager.descriptor);
2261        data.writeStrongBinder(token);
2262        data.writeInt(resultCode);
2263        if (resultData != null) {
2264            data.writeInt(1);
2265            resultData.writeToParcel(data, 0);
2266        } else {
2267            data.writeInt(0);
2268        }
2269        mRemote.transact(FINISH_ACTIVITY_TRANSACTION, data, reply, 0);
2270        reply.readException();
2271        boolean res = reply.readInt() != 0;
2272        data.recycle();
2273        reply.recycle();
2274        return res;
2275    }
2276    public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException
2277    {
2278        Parcel data = Parcel.obtain();
2279        Parcel reply = Parcel.obtain();
2280        data.writeInterfaceToken(IActivityManager.descriptor);
2281        data.writeStrongBinder(token);
2282        data.writeString(resultWho);
2283        data.writeInt(requestCode);
2284        mRemote.transact(FINISH_SUB_ACTIVITY_TRANSACTION, data, reply, 0);
2285        reply.readException();
2286        data.recycle();
2287        reply.recycle();
2288    }
2289    public boolean finishActivityAffinity(IBinder token) throws RemoteException {
2290        Parcel data = Parcel.obtain();
2291        Parcel reply = Parcel.obtain();
2292        data.writeInterfaceToken(IActivityManager.descriptor);
2293        data.writeStrongBinder(token);
2294        mRemote.transact(FINISH_ACTIVITY_AFFINITY_TRANSACTION, data, reply, 0);
2295        reply.readException();
2296        boolean res = reply.readInt() != 0;
2297        data.recycle();
2298        reply.recycle();
2299        return res;
2300    }
2301    public boolean willActivityBeVisible(IBinder token) throws RemoteException {
2302        Parcel data = Parcel.obtain();
2303        Parcel reply = Parcel.obtain();
2304        data.writeInterfaceToken(IActivityManager.descriptor);
2305        data.writeStrongBinder(token);
2306        mRemote.transact(WILL_ACTIVITY_BE_VISIBLE_TRANSACTION, data, reply, 0);
2307        reply.readException();
2308        boolean res = reply.readInt() != 0;
2309        data.recycle();
2310        reply.recycle();
2311        return res;
2312    }
2313    public Intent registerReceiver(IApplicationThread caller, String packageName,
2314            IIntentReceiver receiver,
2315            IntentFilter filter, String perm, int userId) throws RemoteException
2316    {
2317        Parcel data = Parcel.obtain();
2318        Parcel reply = Parcel.obtain();
2319        data.writeInterfaceToken(IActivityManager.descriptor);
2320        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2321        data.writeString(packageName);
2322        data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
2323        filter.writeToParcel(data, 0);
2324        data.writeString(perm);
2325        data.writeInt(userId);
2326        mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);
2327        reply.readException();
2328        Intent intent = null;
2329        int haveIntent = reply.readInt();
2330        if (haveIntent != 0) {
2331            intent = Intent.CREATOR.createFromParcel(reply);
2332        }
2333        reply.recycle();
2334        data.recycle();
2335        return intent;
2336    }
2337    public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException
2338    {
2339        Parcel data = Parcel.obtain();
2340        Parcel reply = Parcel.obtain();
2341        data.writeInterfaceToken(IActivityManager.descriptor);
2342        data.writeStrongBinder(receiver.asBinder());
2343        mRemote.transact(UNREGISTER_RECEIVER_TRANSACTION, data, reply, 0);
2344        reply.readException();
2345        data.recycle();
2346        reply.recycle();
2347    }
2348    public int broadcastIntent(IApplicationThread caller,
2349            Intent intent, String resolvedType,  IIntentReceiver resultTo,
2350            int resultCode, String resultData, Bundle map,
2351            String requiredPermission, int appOp, boolean serialized,
2352            boolean sticky, int userId) throws RemoteException
2353    {
2354        Parcel data = Parcel.obtain();
2355        Parcel reply = Parcel.obtain();
2356        data.writeInterfaceToken(IActivityManager.descriptor);
2357        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2358        intent.writeToParcel(data, 0);
2359        data.writeString(resolvedType);
2360        data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);
2361        data.writeInt(resultCode);
2362        data.writeString(resultData);
2363        data.writeBundle(map);
2364        data.writeString(requiredPermission);
2365        data.writeInt(appOp);
2366        data.writeInt(serialized ? 1 : 0);
2367        data.writeInt(sticky ? 1 : 0);
2368        data.writeInt(userId);
2369        mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
2370        reply.readException();
2371        int res = reply.readInt();
2372        reply.recycle();
2373        data.recycle();
2374        return res;
2375    }
2376    public void unbroadcastIntent(IApplicationThread caller, Intent intent, int userId)
2377            throws RemoteException
2378    {
2379        Parcel data = Parcel.obtain();
2380        Parcel reply = Parcel.obtain();
2381        data.writeInterfaceToken(IActivityManager.descriptor);
2382        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2383        intent.writeToParcel(data, 0);
2384        data.writeInt(userId);
2385        mRemote.transact(UNBROADCAST_INTENT_TRANSACTION, data, reply, 0);
2386        reply.readException();
2387        data.recycle();
2388        reply.recycle();
2389    }
2390    public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map, boolean abortBroadcast) throws RemoteException
2391    {
2392        Parcel data = Parcel.obtain();
2393        Parcel reply = Parcel.obtain();
2394        data.writeInterfaceToken(IActivityManager.descriptor);
2395        data.writeStrongBinder(who);
2396        data.writeInt(resultCode);
2397        data.writeString(resultData);
2398        data.writeBundle(map);
2399        data.writeInt(abortBroadcast ? 1 : 0);
2400        mRemote.transact(FINISH_RECEIVER_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2401        reply.readException();
2402        data.recycle();
2403        reply.recycle();
2404    }
2405    public void attachApplication(IApplicationThread app) throws RemoteException
2406    {
2407        Parcel data = Parcel.obtain();
2408        Parcel reply = Parcel.obtain();
2409        data.writeInterfaceToken(IActivityManager.descriptor);
2410        data.writeStrongBinder(app.asBinder());
2411        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
2412        reply.readException();
2413        data.recycle();
2414        reply.recycle();
2415    }
2416    public void activityIdle(IBinder token, Configuration config, boolean stopProfiling)
2417            throws RemoteException
2418    {
2419        Parcel data = Parcel.obtain();
2420        Parcel reply = Parcel.obtain();
2421        data.writeInterfaceToken(IActivityManager.descriptor);
2422        data.writeStrongBinder(token);
2423        if (config != null) {
2424            data.writeInt(1);
2425            config.writeToParcel(data, 0);
2426        } else {
2427            data.writeInt(0);
2428        }
2429        data.writeInt(stopProfiling ? 1 : 0);
2430        mRemote.transact(ACTIVITY_IDLE_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2431        reply.readException();
2432        data.recycle();
2433        reply.recycle();
2434    }
2435    public void activityResumed(IBinder token) throws RemoteException
2436    {
2437        Parcel data = Parcel.obtain();
2438        Parcel reply = Parcel.obtain();
2439        data.writeInterfaceToken(IActivityManager.descriptor);
2440        data.writeStrongBinder(token);
2441        mRemote.transact(ACTIVITY_RESUMED_TRANSACTION, data, reply, 0);
2442        reply.readException();
2443        data.recycle();
2444        reply.recycle();
2445    }
2446    public void activityPaused(IBinder token) throws RemoteException
2447    {
2448        Parcel data = Parcel.obtain();
2449        Parcel reply = Parcel.obtain();
2450        data.writeInterfaceToken(IActivityManager.descriptor);
2451        data.writeStrongBinder(token);
2452        mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
2453        reply.readException();
2454        data.recycle();
2455        reply.recycle();
2456    }
2457    public void activityStopped(IBinder token, Bundle state,
2458            Bitmap thumbnail, CharSequence description) throws RemoteException
2459    {
2460        Parcel data = Parcel.obtain();
2461        Parcel reply = Parcel.obtain();
2462        data.writeInterfaceToken(IActivityManager.descriptor);
2463        data.writeStrongBinder(token);
2464        data.writeBundle(state);
2465        if (thumbnail != null) {
2466            data.writeInt(1);
2467            thumbnail.writeToParcel(data, 0);
2468        } else {
2469            data.writeInt(0);
2470        }
2471        TextUtils.writeToParcel(description, data, 0);
2472        mRemote.transact(ACTIVITY_STOPPED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2473        reply.readException();
2474        data.recycle();
2475        reply.recycle();
2476    }
2477    public void activitySlept(IBinder token) throws RemoteException
2478    {
2479        Parcel data = Parcel.obtain();
2480        Parcel reply = Parcel.obtain();
2481        data.writeInterfaceToken(IActivityManager.descriptor);
2482        data.writeStrongBinder(token);
2483        mRemote.transact(ACTIVITY_SLEPT_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2484        reply.readException();
2485        data.recycle();
2486        reply.recycle();
2487    }
2488    public void activityDestroyed(IBinder token) throws RemoteException
2489    {
2490        Parcel data = Parcel.obtain();
2491        Parcel reply = Parcel.obtain();
2492        data.writeInterfaceToken(IActivityManager.descriptor);
2493        data.writeStrongBinder(token);
2494        mRemote.transact(ACTIVITY_DESTROYED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2495        reply.readException();
2496        data.recycle();
2497        reply.recycle();
2498    }
2499    public String getCallingPackage(IBinder token) throws RemoteException
2500    {
2501        Parcel data = Parcel.obtain();
2502        Parcel reply = Parcel.obtain();
2503        data.writeInterfaceToken(IActivityManager.descriptor);
2504        data.writeStrongBinder(token);
2505        mRemote.transact(GET_CALLING_PACKAGE_TRANSACTION, data, reply, 0);
2506        reply.readException();
2507        String res = reply.readString();
2508        data.recycle();
2509        reply.recycle();
2510        return res;
2511    }
2512    public ComponentName getCallingActivity(IBinder token)
2513            throws RemoteException {
2514        Parcel data = Parcel.obtain();
2515        Parcel reply = Parcel.obtain();
2516        data.writeInterfaceToken(IActivityManager.descriptor);
2517        data.writeStrongBinder(token);
2518        mRemote.transact(GET_CALLING_ACTIVITY_TRANSACTION, data, reply, 0);
2519        reply.readException();
2520        ComponentName res = ComponentName.readFromParcel(reply);
2521        data.recycle();
2522        reply.recycle();
2523        return res;
2524    }
2525    public List getTasks(int maxNum, int flags,
2526            IThumbnailReceiver receiver) throws RemoteException {
2527        Parcel data = Parcel.obtain();
2528        Parcel reply = Parcel.obtain();
2529        data.writeInterfaceToken(IActivityManager.descriptor);
2530        data.writeInt(maxNum);
2531        data.writeInt(flags);
2532        data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
2533        mRemote.transact(GET_TASKS_TRANSACTION, data, reply, 0);
2534        reply.readException();
2535        ArrayList list = null;
2536        int N = reply.readInt();
2537        if (N >= 0) {
2538            list = new ArrayList();
2539            while (N > 0) {
2540                ActivityManager.RunningTaskInfo info =
2541                        ActivityManager.RunningTaskInfo.CREATOR
2542                        .createFromParcel(reply);
2543                list.add(info);
2544                N--;
2545            }
2546        }
2547        data.recycle();
2548        reply.recycle();
2549        return list;
2550    }
2551    public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
2552            int flags, int userId) throws RemoteException {
2553        Parcel data = Parcel.obtain();
2554        Parcel reply = Parcel.obtain();
2555        data.writeInterfaceToken(IActivityManager.descriptor);
2556        data.writeInt(maxNum);
2557        data.writeInt(flags);
2558        data.writeInt(userId);
2559        mRemote.transact(GET_RECENT_TASKS_TRANSACTION, data, reply, 0);
2560        reply.readException();
2561        ArrayList<ActivityManager.RecentTaskInfo> list
2562            = reply.createTypedArrayList(ActivityManager.RecentTaskInfo.CREATOR);
2563        data.recycle();
2564        reply.recycle();
2565        return list;
2566    }
2567    public ActivityManager.TaskThumbnails getTaskThumbnails(int id) throws RemoteException {
2568        Parcel data = Parcel.obtain();
2569        Parcel reply = Parcel.obtain();
2570        data.writeInterfaceToken(IActivityManager.descriptor);
2571        data.writeInt(id);
2572        mRemote.transact(GET_TASK_THUMBNAILS_TRANSACTION, data, reply, 0);
2573        reply.readException();
2574        ActivityManager.TaskThumbnails bm = null;
2575        if (reply.readInt() != 0) {
2576            bm = ActivityManager.TaskThumbnails.CREATOR.createFromParcel(reply);
2577        }
2578        data.recycle();
2579        reply.recycle();
2580        return bm;
2581    }
2582    public Bitmap getTaskTopThumbnail(int id) throws RemoteException {
2583        Parcel data = Parcel.obtain();
2584        Parcel reply = Parcel.obtain();
2585        data.writeInterfaceToken(IActivityManager.descriptor);
2586        data.writeInt(id);
2587        mRemote.transact(GET_TASK_TOP_THUMBNAIL_TRANSACTION, data, reply, 0);
2588        reply.readException();
2589        Bitmap bm = null;
2590        if (reply.readInt() != 0) {
2591            bm = Bitmap.CREATOR.createFromParcel(reply);
2592        }
2593        data.recycle();
2594        reply.recycle();
2595        return bm;
2596    }
2597    public List getServices(int maxNum, int flags) throws RemoteException {
2598        Parcel data = Parcel.obtain();
2599        Parcel reply = Parcel.obtain();
2600        data.writeInterfaceToken(IActivityManager.descriptor);
2601        data.writeInt(maxNum);
2602        data.writeInt(flags);
2603        mRemote.transact(GET_SERVICES_TRANSACTION, data, reply, 0);
2604        reply.readException();
2605        ArrayList list = null;
2606        int N = reply.readInt();
2607        if (N >= 0) {
2608            list = new ArrayList();
2609            while (N > 0) {
2610                ActivityManager.RunningServiceInfo info =
2611                        ActivityManager.RunningServiceInfo.CREATOR
2612                        .createFromParcel(reply);
2613                list.add(info);
2614                N--;
2615            }
2616        }
2617        data.recycle();
2618        reply.recycle();
2619        return list;
2620    }
2621    public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState()
2622            throws RemoteException {
2623        Parcel data = Parcel.obtain();
2624        Parcel reply = Parcel.obtain();
2625        data.writeInterfaceToken(IActivityManager.descriptor);
2626        mRemote.transact(GET_PROCESSES_IN_ERROR_STATE_TRANSACTION, data, reply, 0);
2627        reply.readException();
2628        ArrayList<ActivityManager.ProcessErrorStateInfo> list
2629            = reply.createTypedArrayList(ActivityManager.ProcessErrorStateInfo.CREATOR);
2630        data.recycle();
2631        reply.recycle();
2632        return list;
2633    }
2634    public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()
2635            throws RemoteException {
2636        Parcel data = Parcel.obtain();
2637        Parcel reply = Parcel.obtain();
2638        data.writeInterfaceToken(IActivityManager.descriptor);
2639        mRemote.transact(GET_RUNNING_APP_PROCESSES_TRANSACTION, data, reply, 0);
2640        reply.readException();
2641        ArrayList<ActivityManager.RunningAppProcessInfo> list
2642        = reply.createTypedArrayList(ActivityManager.RunningAppProcessInfo.CREATOR);
2643        data.recycle();
2644        reply.recycle();
2645        return list;
2646    }
2647    public List<ApplicationInfo> getRunningExternalApplications()
2648            throws RemoteException {
2649        Parcel data = Parcel.obtain();
2650        Parcel reply = Parcel.obtain();
2651        data.writeInterfaceToken(IActivityManager.descriptor);
2652        mRemote.transact(GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION, data, reply, 0);
2653        reply.readException();
2654        ArrayList<ApplicationInfo> list
2655        = reply.createTypedArrayList(ApplicationInfo.CREATOR);
2656        data.recycle();
2657        reply.recycle();
2658        return list;
2659    }
2660    public void moveTaskToFront(int task, int flags, Bundle options) throws RemoteException
2661    {
2662        Parcel data = Parcel.obtain();
2663        Parcel reply = Parcel.obtain();
2664        data.writeInterfaceToken(IActivityManager.descriptor);
2665        data.writeInt(task);
2666        data.writeInt(flags);
2667        if (options != null) {
2668            data.writeInt(1);
2669            options.writeToParcel(data, 0);
2670        } else {
2671            data.writeInt(0);
2672        }
2673        mRemote.transact(MOVE_TASK_TO_FRONT_TRANSACTION, data, reply, 0);
2674        reply.readException();
2675        data.recycle();
2676        reply.recycle();
2677    }
2678    public void moveTaskToBack(int task) throws RemoteException
2679    {
2680        Parcel data = Parcel.obtain();
2681        Parcel reply = Parcel.obtain();
2682        data.writeInterfaceToken(IActivityManager.descriptor);
2683        data.writeInt(task);
2684        mRemote.transact(MOVE_TASK_TO_BACK_TRANSACTION, data, reply, 0);
2685        reply.readException();
2686        data.recycle();
2687        reply.recycle();
2688    }
2689    public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot)
2690            throws RemoteException {
2691        Parcel data = Parcel.obtain();
2692        Parcel reply = Parcel.obtain();
2693        data.writeInterfaceToken(IActivityManager.descriptor);
2694        data.writeStrongBinder(token);
2695        data.writeInt(nonRoot ? 1 : 0);
2696        mRemote.transact(MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION, data, reply, 0);
2697        reply.readException();
2698        boolean res = reply.readInt() != 0;
2699        data.recycle();
2700        reply.recycle();
2701        return res;
2702    }
2703    public void moveTaskBackwards(int task) throws RemoteException
2704    {
2705        Parcel data = Parcel.obtain();
2706        Parcel reply = Parcel.obtain();
2707        data.writeInterfaceToken(IActivityManager.descriptor);
2708        data.writeInt(task);
2709        mRemote.transact(MOVE_TASK_BACKWARDS_TRANSACTION, data, reply, 0);
2710        reply.readException();
2711        data.recycle();
2712        reply.recycle();
2713    }
2714    @Override
2715    public int createStack(int taskId, int relativeStackBoxId, int position, float weight)
2716            throws RemoteException
2717    {
2718        Parcel data = Parcel.obtain();
2719        Parcel reply = Parcel.obtain();
2720        data.writeInterfaceToken(IActivityManager.descriptor);
2721        data.writeInt(taskId);
2722        data.writeInt(relativeStackBoxId);
2723        data.writeInt(position);
2724        data.writeFloat(weight);
2725        mRemote.transact(CREATE_STACK_TRANSACTION, data, reply, 0);
2726        reply.readException();
2727        int res = reply.readInt();
2728        data.recycle();
2729        reply.recycle();
2730        return res;
2731    }
2732    @Override
2733    public void moveTaskToStack(int taskId, int stackId, boolean toTop) throws RemoteException
2734    {
2735        Parcel data = Parcel.obtain();
2736        Parcel reply = Parcel.obtain();
2737        data.writeInterfaceToken(IActivityManager.descriptor);
2738        data.writeInt(taskId);
2739        data.writeInt(stackId);
2740        data.writeInt(toTop ? 1 : 0);
2741        mRemote.transact(MOVE_TASK_TO_STACK_TRANSACTION, data, reply, 0);
2742        reply.readException();
2743        data.recycle();
2744        reply.recycle();
2745    }
2746    @Override
2747    public void resizeStackBox(int stackBoxId, float weight) throws RemoteException
2748    {
2749        Parcel data = Parcel.obtain();
2750        Parcel reply = Parcel.obtain();
2751        data.writeInterfaceToken(IActivityManager.descriptor);
2752        data.writeInt(stackBoxId);
2753        data.writeFloat(weight);
2754        mRemote.transact(RESIZE_STACK_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2755        reply.readException();
2756        data.recycle();
2757        reply.recycle();
2758    }
2759    @Override
2760    public List<StackBoxInfo> getStackBoxes() throws RemoteException
2761    {
2762        Parcel data = Parcel.obtain();
2763        Parcel reply = Parcel.obtain();
2764        data.writeInterfaceToken(IActivityManager.descriptor);
2765        mRemote.transact(GET_STACK_BOXES_TRANSACTION, data, reply, 0);
2766        reply.readException();
2767        ArrayList<StackBoxInfo> list = reply.createTypedArrayList(StackBoxInfo.CREATOR);
2768        data.recycle();
2769        reply.recycle();
2770        return list;
2771    }
2772    @Override
2773    public StackBoxInfo getStackBoxInfo(int stackBoxId) throws RemoteException
2774    {
2775        Parcel data = Parcel.obtain();
2776        Parcel reply = Parcel.obtain();
2777        data.writeInterfaceToken(IActivityManager.descriptor);
2778        data.writeInt(stackBoxId);
2779        mRemote.transact(GET_STACK_BOX_INFO_TRANSACTION, data, reply, 0);
2780        reply.readException();
2781        int res = reply.readInt();
2782        StackBoxInfo info = null;
2783        if (res != 0) {
2784            info = StackBoxInfo.CREATOR.createFromParcel(reply);
2785        }
2786        data.recycle();
2787        reply.recycle();
2788        return info;
2789    }
2790    @Override
2791    public void setFocusedStack(int stackId) throws RemoteException
2792    {
2793        Parcel data = Parcel.obtain();
2794        Parcel reply = Parcel.obtain();
2795        data.writeInterfaceToken(IActivityManager.descriptor);
2796        data.writeInt(stackId);
2797        mRemote.transact(SET_FOCUSED_STACK_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2798        reply.readException();
2799        data.recycle();
2800        reply.recycle();
2801    }
2802    public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException
2803    {
2804        Parcel data = Parcel.obtain();
2805        Parcel reply = Parcel.obtain();
2806        data.writeInterfaceToken(IActivityManager.descriptor);
2807        data.writeStrongBinder(token);
2808        data.writeInt(onlyRoot ? 1 : 0);
2809        mRemote.transact(GET_TASK_FOR_ACTIVITY_TRANSACTION, data, reply, 0);
2810        reply.readException();
2811        int res = reply.readInt();
2812        data.recycle();
2813        reply.recycle();
2814        return res;
2815    }
2816    public void reportThumbnail(IBinder token,
2817                                Bitmap thumbnail, CharSequence description) throws RemoteException
2818    {
2819        Parcel data = Parcel.obtain();
2820        Parcel reply = Parcel.obtain();
2821        data.writeInterfaceToken(IActivityManager.descriptor);
2822        data.writeStrongBinder(token);
2823        if (thumbnail != null) {
2824            data.writeInt(1);
2825            thumbnail.writeToParcel(data, 0);
2826        } else {
2827            data.writeInt(0);
2828        }
2829        TextUtils.writeToParcel(description, data, 0);
2830        mRemote.transact(REPORT_THUMBNAIL_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
2831        reply.readException();
2832        data.recycle();
2833        reply.recycle();
2834    }
2835    public ContentProviderHolder getContentProvider(IApplicationThread caller,
2836            String name, int userId, boolean stable) throws RemoteException {
2837        Parcel data = Parcel.obtain();
2838        Parcel reply = Parcel.obtain();
2839        data.writeInterfaceToken(IActivityManager.descriptor);
2840        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2841        data.writeString(name);
2842        data.writeInt(userId);
2843        data.writeInt(stable ? 1 : 0);
2844        mRemote.transact(GET_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
2845        reply.readException();
2846        int res = reply.readInt();
2847        ContentProviderHolder cph = null;
2848        if (res != 0) {
2849            cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
2850        }
2851        data.recycle();
2852        reply.recycle();
2853        return cph;
2854    }
2855    public ContentProviderHolder getContentProviderExternal(String name, int userId, IBinder token)
2856            throws RemoteException {
2857        Parcel data = Parcel.obtain();
2858        Parcel reply = Parcel.obtain();
2859        data.writeInterfaceToken(IActivityManager.descriptor);
2860        data.writeString(name);
2861        data.writeInt(userId);
2862        data.writeStrongBinder(token);
2863        mRemote.transact(GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION, data, reply, 0);
2864        reply.readException();
2865        int res = reply.readInt();
2866        ContentProviderHolder cph = null;
2867        if (res != 0) {
2868            cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
2869        }
2870        data.recycle();
2871        reply.recycle();
2872        return cph;
2873    }
2874    public void publishContentProviders(IApplicationThread caller,
2875            List<ContentProviderHolder> providers) throws RemoteException
2876    {
2877        Parcel data = Parcel.obtain();
2878        Parcel reply = Parcel.obtain();
2879        data.writeInterfaceToken(IActivityManager.descriptor);
2880        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2881        data.writeTypedList(providers);
2882        mRemote.transact(PUBLISH_CONTENT_PROVIDERS_TRANSACTION, data, reply, 0);
2883        reply.readException();
2884        data.recycle();
2885        reply.recycle();
2886    }
2887    public boolean refContentProvider(IBinder connection, int stable, int unstable)
2888            throws RemoteException {
2889        Parcel data = Parcel.obtain();
2890        Parcel reply = Parcel.obtain();
2891        data.writeInterfaceToken(IActivityManager.descriptor);
2892        data.writeStrongBinder(connection);
2893        data.writeInt(stable);
2894        data.writeInt(unstable);
2895        mRemote.transact(REF_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
2896        reply.readException();
2897        boolean res = reply.readInt() != 0;
2898        data.recycle();
2899        reply.recycle();
2900        return res;
2901    }
2902
2903    public void unstableProviderDied(IBinder connection) throws RemoteException {
2904        Parcel data = Parcel.obtain();
2905        Parcel reply = Parcel.obtain();
2906        data.writeInterfaceToken(IActivityManager.descriptor);
2907        data.writeStrongBinder(connection);
2908        mRemote.transact(UNSTABLE_PROVIDER_DIED_TRANSACTION, data, reply, 0);
2909        reply.readException();
2910        data.recycle();
2911        reply.recycle();
2912    }
2913
2914    @Override
2915    public void appNotRespondingViaProvider(IBinder connection) throws RemoteException {
2916        Parcel data = Parcel.obtain();
2917        Parcel reply = Parcel.obtain();
2918        data.writeInterfaceToken(IActivityManager.descriptor);
2919        data.writeStrongBinder(connection);
2920        mRemote.transact(APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION, data, reply, 0);
2921        reply.readException();
2922        data.recycle();
2923        reply.recycle();
2924    }
2925
2926    public void removeContentProvider(IBinder connection, boolean stable) throws RemoteException {
2927        Parcel data = Parcel.obtain();
2928        Parcel reply = Parcel.obtain();
2929        data.writeInterfaceToken(IActivityManager.descriptor);
2930        data.writeStrongBinder(connection);
2931        data.writeInt(stable ? 1 : 0);
2932        mRemote.transact(REMOVE_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
2933        reply.readException();
2934        data.recycle();
2935        reply.recycle();
2936    }
2937
2938    public void removeContentProviderExternal(String name, IBinder token) throws RemoteException {
2939        Parcel data = Parcel.obtain();
2940        Parcel reply = Parcel.obtain();
2941        data.writeInterfaceToken(IActivityManager.descriptor);
2942        data.writeString(name);
2943        data.writeStrongBinder(token);
2944        mRemote.transact(REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION, data, reply, 0);
2945        reply.readException();
2946        data.recycle();
2947        reply.recycle();
2948    }
2949
2950    public PendingIntent getRunningServiceControlPanel(ComponentName service)
2951            throws RemoteException
2952    {
2953        Parcel data = Parcel.obtain();
2954        Parcel reply = Parcel.obtain();
2955        data.writeInterfaceToken(IActivityManager.descriptor);
2956        service.writeToParcel(data, 0);
2957        mRemote.transact(GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION, data, reply, 0);
2958        reply.readException();
2959        PendingIntent res = PendingIntent.readPendingIntentOrNullFromParcel(reply);
2960        data.recycle();
2961        reply.recycle();
2962        return res;
2963    }
2964
2965    public ComponentName startService(IApplicationThread caller, Intent service,
2966            String resolvedType, int userId) throws RemoteException
2967    {
2968        Parcel data = Parcel.obtain();
2969        Parcel reply = Parcel.obtain();
2970        data.writeInterfaceToken(IActivityManager.descriptor);
2971        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2972        service.writeToParcel(data, 0);
2973        data.writeString(resolvedType);
2974        data.writeInt(userId);
2975        mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
2976        reply.readException();
2977        ComponentName res = ComponentName.readFromParcel(reply);
2978        data.recycle();
2979        reply.recycle();
2980        return res;
2981    }
2982    public int stopService(IApplicationThread caller, Intent service,
2983            String resolvedType, int userId) throws RemoteException
2984    {
2985        Parcel data = Parcel.obtain();
2986        Parcel reply = Parcel.obtain();
2987        data.writeInterfaceToken(IActivityManager.descriptor);
2988        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
2989        service.writeToParcel(data, 0);
2990        data.writeString(resolvedType);
2991        data.writeInt(userId);
2992        mRemote.transact(STOP_SERVICE_TRANSACTION, data, reply, 0);
2993        reply.readException();
2994        int res = reply.readInt();
2995        reply.recycle();
2996        data.recycle();
2997        return res;
2998    }
2999    public boolean stopServiceToken(ComponentName className, IBinder token,
3000            int startId) throws RemoteException {
3001        Parcel data = Parcel.obtain();
3002        Parcel reply = Parcel.obtain();
3003        data.writeInterfaceToken(IActivityManager.descriptor);
3004        ComponentName.writeToParcel(className, data);
3005        data.writeStrongBinder(token);
3006        data.writeInt(startId);
3007        mRemote.transact(STOP_SERVICE_TOKEN_TRANSACTION, data, reply, 0);
3008        reply.readException();
3009        boolean res = reply.readInt() != 0;
3010        data.recycle();
3011        reply.recycle();
3012        return res;
3013    }
3014    public void setServiceForeground(ComponentName className, IBinder token,
3015            int id, Notification notification, boolean removeNotification) throws RemoteException {
3016        Parcel data = Parcel.obtain();
3017        Parcel reply = Parcel.obtain();
3018        data.writeInterfaceToken(IActivityManager.descriptor);
3019        ComponentName.writeToParcel(className, data);
3020        data.writeStrongBinder(token);
3021        data.writeInt(id);
3022        if (notification != null) {
3023            data.writeInt(1);
3024            notification.writeToParcel(data, 0);
3025        } else {
3026            data.writeInt(0);
3027        }
3028        data.writeInt(removeNotification ? 1 : 0);
3029        mRemote.transact(SET_SERVICE_FOREGROUND_TRANSACTION, data, reply, 0);
3030        reply.readException();
3031        data.recycle();
3032        reply.recycle();
3033    }
3034    public int bindService(IApplicationThread caller, IBinder token,
3035            Intent service, String resolvedType, IServiceConnection connection,
3036            int flags, int userId) throws RemoteException {
3037        Parcel data = Parcel.obtain();
3038        Parcel reply = Parcel.obtain();
3039        data.writeInterfaceToken(IActivityManager.descriptor);
3040        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
3041        data.writeStrongBinder(token);
3042        service.writeToParcel(data, 0);
3043        data.writeString(resolvedType);
3044        data.writeStrongBinder(connection.asBinder());
3045        data.writeInt(flags);
3046        data.writeInt(userId);
3047        mRemote.transact(BIND_SERVICE_TRANSACTION, data, reply, 0);
3048        reply.readException();
3049        int res = reply.readInt();
3050        data.recycle();
3051        reply.recycle();
3052        return res;
3053    }
3054    public boolean unbindService(IServiceConnection connection) throws RemoteException
3055    {
3056        Parcel data = Parcel.obtain();
3057        Parcel reply = Parcel.obtain();
3058        data.writeInterfaceToken(IActivityManager.descriptor);
3059        data.writeStrongBinder(connection.asBinder());
3060        mRemote.transact(UNBIND_SERVICE_TRANSACTION, data, reply, 0);
3061        reply.readException();
3062        boolean res = reply.readInt() != 0;
3063        data.recycle();
3064        reply.recycle();
3065        return res;
3066    }
3067
3068    public void publishService(IBinder token,
3069            Intent intent, IBinder service) throws RemoteException {
3070        Parcel data = Parcel.obtain();
3071        Parcel reply = Parcel.obtain();
3072        data.writeInterfaceToken(IActivityManager.descriptor);
3073        data.writeStrongBinder(token);
3074        intent.writeToParcel(data, 0);
3075        data.writeStrongBinder(service);
3076        mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);
3077        reply.readException();
3078        data.recycle();
3079        reply.recycle();
3080    }
3081
3082    public void unbindFinished(IBinder token, Intent intent, boolean doRebind)
3083            throws RemoteException {
3084        Parcel data = Parcel.obtain();
3085        Parcel reply = Parcel.obtain();
3086        data.writeInterfaceToken(IActivityManager.descriptor);
3087        data.writeStrongBinder(token);
3088        intent.writeToParcel(data, 0);
3089        data.writeInt(doRebind ? 1 : 0);
3090        mRemote.transact(UNBIND_FINISHED_TRANSACTION, data, reply, 0);
3091        reply.readException();
3092        data.recycle();
3093        reply.recycle();
3094    }
3095
3096    public void serviceDoneExecuting(IBinder token, int type, int startId,
3097            int res) throws RemoteException {
3098        Parcel data = Parcel.obtain();
3099        Parcel reply = Parcel.obtain();
3100        data.writeInterfaceToken(IActivityManager.descriptor);
3101        data.writeStrongBinder(token);
3102        data.writeInt(type);
3103        data.writeInt(startId);
3104        data.writeInt(res);
3105        mRemote.transact(SERVICE_DONE_EXECUTING_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
3106        reply.readException();
3107        data.recycle();
3108        reply.recycle();
3109    }
3110
3111    public IBinder peekService(Intent service, String resolvedType) throws RemoteException {
3112        Parcel data = Parcel.obtain();
3113        Parcel reply = Parcel.obtain();
3114        data.writeInterfaceToken(IActivityManager.descriptor);
3115        service.writeToParcel(data, 0);
3116        data.writeString(resolvedType);
3117        mRemote.transact(PEEK_SERVICE_TRANSACTION, data, reply, 0);
3118        reply.readException();
3119        IBinder binder = reply.readStrongBinder();
3120        reply.recycle();
3121        data.recycle();
3122        return binder;
3123    }
3124
3125    public boolean bindBackupAgent(ApplicationInfo app, int backupRestoreMode)
3126            throws RemoteException {
3127        Parcel data = Parcel.obtain();
3128        Parcel reply = Parcel.obtain();
3129        data.writeInterfaceToken(IActivityManager.descriptor);
3130        app.writeToParcel(data, 0);
3131        data.writeInt(backupRestoreMode);
3132        mRemote.transact(START_BACKUP_AGENT_TRANSACTION, data, reply, 0);
3133        reply.readException();
3134        boolean success = reply.readInt() != 0;
3135        reply.recycle();
3136        data.recycle();
3137        return success;
3138    }
3139
3140    public void clearPendingBackup() throws RemoteException {
3141        Parcel data = Parcel.obtain();
3142        Parcel reply = Parcel.obtain();
3143        data.writeInterfaceToken(IActivityManager.descriptor);
3144        mRemote.transact(CLEAR_PENDING_BACKUP_TRANSACTION, data, reply, 0);
3145        reply.recycle();
3146        data.recycle();
3147    }
3148
3149    public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException {
3150        Parcel data = Parcel.obtain();
3151        Parcel reply = Parcel.obtain();
3152        data.writeInterfaceToken(IActivityManager.descriptor);
3153        data.writeString(packageName);
3154        data.writeStrongBinder(agent);
3155        mRemote.transact(BACKUP_AGENT_CREATED_TRANSACTION, data, reply, 0);
3156        reply.recycle();
3157        data.recycle();
3158    }
3159
3160    public void unbindBackupAgent(ApplicationInfo app) throws RemoteException {
3161        Parcel data = Parcel.obtain();
3162        Parcel reply = Parcel.obtain();
3163        data.writeInterfaceToken(IActivityManager.descriptor);
3164        app.writeToParcel(data, 0);
3165        mRemote.transact(UNBIND_BACKUP_AGENT_TRANSACTION, data, reply, 0);
3166        reply.readException();
3167        reply.recycle();
3168        data.recycle();
3169    }
3170
3171    public boolean startInstrumentation(ComponentName className, String profileFile,
3172            int flags, Bundle arguments, IInstrumentationWatcher watcher,
3173            IUiAutomationConnection connection, int userId) throws RemoteException {
3174        Parcel data = Parcel.obtain();
3175        Parcel reply = Parcel.obtain();
3176        data.writeInterfaceToken(IActivityManager.descriptor);
3177        ComponentName.writeToParcel(className, data);
3178        data.writeString(profileFile);
3179        data.writeInt(flags);
3180        data.writeBundle(arguments);
3181        data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
3182        data.writeStrongBinder(connection != null ? connection.asBinder() : null);
3183        data.writeInt(userId);
3184        mRemote.transact(START_INSTRUMENTATION_TRANSACTION, data, reply, 0);
3185        reply.readException();
3186        boolean res = reply.readInt() != 0;
3187        reply.recycle();
3188        data.recycle();
3189        return res;
3190    }
3191
3192    public void finishInstrumentation(IApplicationThread target,
3193            int resultCode, Bundle results) throws RemoteException {
3194        Parcel data = Parcel.obtain();
3195        Parcel reply = Parcel.obtain();
3196        data.writeInterfaceToken(IActivityManager.descriptor);
3197        data.writeStrongBinder(target != null ? target.asBinder() : null);
3198        data.writeInt(resultCode);
3199        data.writeBundle(results);
3200        mRemote.transact(FINISH_INSTRUMENTATION_TRANSACTION, data, reply, 0);
3201        reply.readException();
3202        data.recycle();
3203        reply.recycle();
3204    }
3205    public Configuration getConfiguration() throws RemoteException
3206    {
3207        Parcel data = Parcel.obtain();
3208        Parcel reply = Parcel.obtain();
3209        data.writeInterfaceToken(IActivityManager.descriptor);
3210        mRemote.transact(GET_CONFIGURATION_TRANSACTION, data, reply, 0);
3211        reply.readException();
3212        Configuration res = Configuration.CREATOR.createFromParcel(reply);
3213        reply.recycle();
3214        data.recycle();
3215        return res;
3216    }
3217    public void updateConfiguration(Configuration values) throws RemoteException
3218    {
3219        Parcel data = Parcel.obtain();
3220        Parcel reply = Parcel.obtain();
3221        data.writeInterfaceToken(IActivityManager.descriptor);
3222        values.writeToParcel(data, 0);
3223        mRemote.transact(UPDATE_CONFIGURATION_TRANSACTION, data, reply, 0);
3224        reply.readException();
3225        data.recycle();
3226        reply.recycle();
3227    }
3228    public void setRequestedOrientation(IBinder token, int requestedOrientation)
3229            throws RemoteException {
3230        Parcel data = Parcel.obtain();
3231        Parcel reply = Parcel.obtain();
3232        data.writeInterfaceToken(IActivityManager.descriptor);
3233        data.writeStrongBinder(token);
3234        data.writeInt(requestedOrientation);
3235        mRemote.transact(SET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
3236        reply.readException();
3237        data.recycle();
3238        reply.recycle();
3239    }
3240    public int getRequestedOrientation(IBinder token) throws RemoteException {
3241        Parcel data = Parcel.obtain();
3242        Parcel reply = Parcel.obtain();
3243        data.writeInterfaceToken(IActivityManager.descriptor);
3244        data.writeStrongBinder(token);
3245        mRemote.transact(GET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
3246        reply.readException();
3247        int res = reply.readInt();
3248        data.recycle();
3249        reply.recycle();
3250        return res;
3251    }
3252    public ComponentName getActivityClassForToken(IBinder token)
3253            throws RemoteException {
3254        Parcel data = Parcel.obtain();
3255        Parcel reply = Parcel.obtain();
3256        data.writeInterfaceToken(IActivityManager.descriptor);
3257        data.writeStrongBinder(token);
3258        mRemote.transact(GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION, data, reply, 0);
3259        reply.readException();
3260        ComponentName res = ComponentName.readFromParcel(reply);
3261        data.recycle();
3262        reply.recycle();
3263        return res;
3264    }
3265    public String getPackageForToken(IBinder token) throws RemoteException
3266    {
3267        Parcel data = Parcel.obtain();
3268        Parcel reply = Parcel.obtain();
3269        data.writeInterfaceToken(IActivityManager.descriptor);
3270        data.writeStrongBinder(token);
3271        mRemote.transact(GET_PACKAGE_FOR_TOKEN_TRANSACTION, data, reply, 0);
3272        reply.readException();
3273        String res = reply.readString();
3274        data.recycle();
3275        reply.recycle();
3276        return res;
3277    }
3278    public IIntentSender getIntentSender(int type,
3279            String packageName, IBinder token, String resultWho,
3280            int requestCode, Intent[] intents, String[] resolvedTypes, int flags,
3281            Bundle options, int userId) throws RemoteException {
3282        Parcel data = Parcel.obtain();
3283        Parcel reply = Parcel.obtain();
3284        data.writeInterfaceToken(IActivityManager.descriptor);
3285        data.writeInt(type);
3286        data.writeString(packageName);
3287        data.writeStrongBinder(token);
3288        data.writeString(resultWho);
3289        data.writeInt(requestCode);
3290        if (intents != null) {
3291            data.writeInt(1);
3292            data.writeTypedArray(intents, 0);
3293            data.writeStringArray(resolvedTypes);
3294        } else {
3295            data.writeInt(0);
3296        }
3297        data.writeInt(flags);
3298        if (options != null) {
3299            data.writeInt(1);
3300            options.writeToParcel(data, 0);
3301        } else {
3302            data.writeInt(0);
3303        }
3304        data.writeInt(userId);
3305        mRemote.transact(GET_INTENT_SENDER_TRANSACTION, data, reply, 0);
3306        reply.readException();
3307        IIntentSender res = IIntentSender.Stub.asInterface(
3308            reply.readStrongBinder());
3309        data.recycle();
3310        reply.recycle();
3311        return res;
3312    }
3313    public void cancelIntentSender(IIntentSender sender) throws RemoteException {
3314        Parcel data = Parcel.obtain();
3315        Parcel reply = Parcel.obtain();
3316        data.writeInterfaceToken(IActivityManager.descriptor);
3317        data.writeStrongBinder(sender.asBinder());
3318        mRemote.transact(CANCEL_INTENT_SENDER_TRANSACTION, data, reply, 0);
3319        reply.readException();
3320        data.recycle();
3321        reply.recycle();
3322    }
3323    public String getPackageForIntentSender(IIntentSender sender) throws RemoteException {
3324        Parcel data = Parcel.obtain();
3325        Parcel reply = Parcel.obtain();
3326        data.writeInterfaceToken(IActivityManager.descriptor);
3327        data.writeStrongBinder(sender.asBinder());
3328        mRemote.transact(GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
3329        reply.readException();
3330        String res = reply.readString();
3331        data.recycle();
3332        reply.recycle();
3333        return res;
3334    }
3335    public int getUidForIntentSender(IIntentSender sender) throws RemoteException {
3336        Parcel data = Parcel.obtain();
3337        Parcel reply = Parcel.obtain();
3338        data.writeInterfaceToken(IActivityManager.descriptor);
3339        data.writeStrongBinder(sender.asBinder());
3340        mRemote.transact(GET_UID_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
3341        reply.readException();
3342        int res = reply.readInt();
3343        data.recycle();
3344        reply.recycle();
3345        return res;
3346    }
3347    public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll,
3348            boolean requireFull, String name, String callerPackage) throws RemoteException {
3349        Parcel data = Parcel.obtain();
3350        Parcel reply = Parcel.obtain();
3351        data.writeInterfaceToken(IActivityManager.descriptor);
3352        data.writeInt(callingPid);
3353        data.writeInt(callingUid);
3354        data.writeInt(userId);
3355        data.writeInt(allowAll ? 1 : 0);
3356        data.writeInt(requireFull ? 1 : 0);
3357        data.writeString(name);
3358        data.writeString(callerPackage);
3359        mRemote.transact(HANDLE_INCOMING_USER_TRANSACTION, data, reply, 0);
3360        reply.readException();
3361        int res = reply.readInt();
3362        data.recycle();
3363        reply.recycle();
3364        return res;
3365    }
3366    public void setProcessLimit(int max) throws RemoteException
3367    {
3368        Parcel data = Parcel.obtain();
3369        Parcel reply = Parcel.obtain();
3370        data.writeInterfaceToken(IActivityManager.descriptor);
3371        data.writeInt(max);
3372        mRemote.transact(SET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
3373        reply.readException();
3374        data.recycle();
3375        reply.recycle();
3376    }
3377    public int getProcessLimit() throws RemoteException
3378    {
3379        Parcel data = Parcel.obtain();
3380        Parcel reply = Parcel.obtain();
3381        data.writeInterfaceToken(IActivityManager.descriptor);
3382        mRemote.transact(GET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
3383        reply.readException();
3384        int res = reply.readInt();
3385        data.recycle();
3386        reply.recycle();
3387        return res;
3388    }
3389    public void setProcessForeground(IBinder token, int pid,
3390            boolean isForeground) throws RemoteException {
3391        Parcel data = Parcel.obtain();
3392        Parcel reply = Parcel.obtain();
3393        data.writeInterfaceToken(IActivityManager.descriptor);
3394        data.writeStrongBinder(token);
3395        data.writeInt(pid);
3396        data.writeInt(isForeground ? 1 : 0);
3397        mRemote.transact(SET_PROCESS_FOREGROUND_TRANSACTION, data, reply, 0);
3398        reply.readException();
3399        data.recycle();
3400        reply.recycle();
3401    }
3402    public int checkPermission(String permission, int pid, int uid)
3403            throws RemoteException {
3404        Parcel data = Parcel.obtain();
3405        Parcel reply = Parcel.obtain();
3406        data.writeInterfaceToken(IActivityManager.descriptor);
3407        data.writeString(permission);
3408        data.writeInt(pid);
3409        data.writeInt(uid);
3410        mRemote.transact(CHECK_PERMISSION_TRANSACTION, data, reply, 0);
3411        reply.readException();
3412        int res = reply.readInt();
3413        data.recycle();
3414        reply.recycle();
3415        return res;
3416    }
3417    public boolean clearApplicationUserData(final String packageName,
3418            final IPackageDataObserver observer, final int userId) throws RemoteException {
3419        Parcel data = Parcel.obtain();
3420        Parcel reply = Parcel.obtain();
3421        data.writeInterfaceToken(IActivityManager.descriptor);
3422        data.writeString(packageName);
3423        data.writeStrongBinder((observer != null) ? observer.asBinder() : null);
3424        data.writeInt(userId);
3425        mRemote.transact(CLEAR_APP_DATA_TRANSACTION, data, reply, 0);
3426        reply.readException();
3427        boolean res = reply.readInt() != 0;
3428        data.recycle();
3429        reply.recycle();
3430        return res;
3431    }
3432    public int checkUriPermission(Uri uri, int pid, int uid, int mode)
3433            throws RemoteException {
3434        Parcel data = Parcel.obtain();
3435        Parcel reply = Parcel.obtain();
3436        data.writeInterfaceToken(IActivityManager.descriptor);
3437        uri.writeToParcel(data, 0);
3438        data.writeInt(pid);
3439        data.writeInt(uid);
3440        data.writeInt(mode);
3441        mRemote.transact(CHECK_URI_PERMISSION_TRANSACTION, data, reply, 0);
3442        reply.readException();
3443        int res = reply.readInt();
3444        data.recycle();
3445        reply.recycle();
3446        return res;
3447    }
3448    public void grantUriPermission(IApplicationThread caller, String targetPkg,
3449            Uri uri, int mode) throws RemoteException {
3450        Parcel data = Parcel.obtain();
3451        Parcel reply = Parcel.obtain();
3452        data.writeInterfaceToken(IActivityManager.descriptor);
3453        data.writeStrongBinder(caller.asBinder());
3454        data.writeString(targetPkg);
3455        uri.writeToParcel(data, 0);
3456        data.writeInt(mode);
3457        mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
3458        reply.readException();
3459        data.recycle();
3460        reply.recycle();
3461    }
3462    public void revokeUriPermission(IApplicationThread caller, Uri uri,
3463            int mode) throws RemoteException {
3464        Parcel data = Parcel.obtain();
3465        Parcel reply = Parcel.obtain();
3466        data.writeInterfaceToken(IActivityManager.descriptor);
3467        data.writeStrongBinder(caller.asBinder());
3468        uri.writeToParcel(data, 0);
3469        data.writeInt(mode);
3470        mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
3471        reply.readException();
3472        data.recycle();
3473        reply.recycle();
3474    }
3475
3476    @Override
3477    public void takePersistableUriPermission(Uri uri, int mode) throws RemoteException {
3478        Parcel data = Parcel.obtain();
3479        Parcel reply = Parcel.obtain();
3480        data.writeInterfaceToken(IActivityManager.descriptor);
3481        uri.writeToParcel(data, 0);
3482        data.writeInt(mode);
3483        mRemote.transact(TAKE_PERSISTABLE_URI_PERMISSION_TRANSACTION, data, reply, 0);
3484        reply.readException();
3485        data.recycle();
3486        reply.recycle();
3487    }
3488
3489    @Override
3490    public void releasePersistableUriPermission(Uri uri, int mode) throws RemoteException {
3491        Parcel data = Parcel.obtain();
3492        Parcel reply = Parcel.obtain();
3493        data.writeInterfaceToken(IActivityManager.descriptor);
3494        uri.writeToParcel(data, 0);
3495        data.writeInt(mode);
3496        mRemote.transact(RELEASE_PERSISTABLE_URI_PERMISSION_TRANSACTION, data, reply, 0);
3497        reply.readException();
3498        data.recycle();
3499        reply.recycle();
3500    }
3501
3502    @Override
3503    public ParceledListSlice<UriPermission> getPersistedUriPermissions() throws RemoteException {
3504        Parcel data = Parcel.obtain();
3505        Parcel reply = Parcel.obtain();
3506        data.writeInterfaceToken(IActivityManager.descriptor);
3507        mRemote.transact(GET_PERSISTED_URI_PERMISSIONS_TRANSACTION, data, reply, 0);
3508        reply.readException();
3509        final ParceledListSlice<UriPermission> perms = ParceledListSlice.CREATOR.createFromParcel(
3510                reply);
3511        data.recycle();
3512        reply.recycle();
3513        return perms;
3514    }
3515
3516    public void showWaitingForDebugger(IApplicationThread who, boolean waiting)
3517            throws RemoteException {
3518        Parcel data = Parcel.obtain();
3519        Parcel reply = Parcel.obtain();
3520        data.writeInterfaceToken(IActivityManager.descriptor);
3521        data.writeStrongBinder(who.asBinder());
3522        data.writeInt(waiting ? 1 : 0);
3523        mRemote.transact(SHOW_WAITING_FOR_DEBUGGER_TRANSACTION, data, reply, 0);
3524        reply.readException();
3525        data.recycle();
3526        reply.recycle();
3527    }
3528    public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException {
3529        Parcel data = Parcel.obtain();
3530        Parcel reply = Parcel.obtain();
3531        data.writeInterfaceToken(IActivityManager.descriptor);
3532        mRemote.transact(GET_MEMORY_INFO_TRANSACTION, data, reply, 0);
3533        reply.readException();
3534        outInfo.readFromParcel(reply);
3535        data.recycle();
3536        reply.recycle();
3537    }
3538    public void unhandledBack() throws RemoteException
3539    {
3540        Parcel data = Parcel.obtain();
3541        Parcel reply = Parcel.obtain();
3542        data.writeInterfaceToken(IActivityManager.descriptor);
3543        mRemote.transact(UNHANDLED_BACK_TRANSACTION, data, reply, 0);
3544        reply.readException();
3545        data.recycle();
3546        reply.recycle();
3547    }
3548    public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException
3549    {
3550        Parcel data = Parcel.obtain();
3551        Parcel reply = Parcel.obtain();
3552        data.writeInterfaceToken(IActivityManager.descriptor);
3553        mRemote.transact(OPEN_CONTENT_URI_TRANSACTION, data, reply, 0);
3554        reply.readException();
3555        ParcelFileDescriptor pfd = null;
3556        if (reply.readInt() != 0) {
3557            pfd = ParcelFileDescriptor.CREATOR.createFromParcel(reply);
3558        }
3559        data.recycle();
3560        reply.recycle();
3561        return pfd;
3562    }
3563    public void goingToSleep() throws RemoteException
3564    {
3565        Parcel data = Parcel.obtain();
3566        Parcel reply = Parcel.obtain();
3567        data.writeInterfaceToken(IActivityManager.descriptor);
3568        mRemote.transact(GOING_TO_SLEEP_TRANSACTION, data, reply, 0);
3569        reply.readException();
3570        data.recycle();
3571        reply.recycle();
3572    }
3573    public void wakingUp() throws RemoteException
3574    {
3575        Parcel data = Parcel.obtain();
3576        Parcel reply = Parcel.obtain();
3577        data.writeInterfaceToken(IActivityManager.descriptor);
3578        mRemote.transact(WAKING_UP_TRANSACTION, data, reply, 0);
3579        reply.readException();
3580        data.recycle();
3581        reply.recycle();
3582    }
3583    public void setLockScreenShown(boolean shown) throws RemoteException
3584    {
3585        Parcel data = Parcel.obtain();
3586        Parcel reply = Parcel.obtain();
3587        data.writeInterfaceToken(IActivityManager.descriptor);
3588        data.writeInt(shown ? 1 : 0);
3589        mRemote.transact(SET_LOCK_SCREEN_SHOWN_TRANSACTION, data, reply, 0);
3590        reply.readException();
3591        data.recycle();
3592        reply.recycle();
3593    }
3594    public void setDebugApp(
3595        String packageName, boolean waitForDebugger, boolean persistent)
3596        throws RemoteException
3597    {
3598        Parcel data = Parcel.obtain();
3599        Parcel reply = Parcel.obtain();
3600        data.writeInterfaceToken(IActivityManager.descriptor);
3601        data.writeString(packageName);
3602        data.writeInt(waitForDebugger ? 1 : 0);
3603        data.writeInt(persistent ? 1 : 0);
3604        mRemote.transact(SET_DEBUG_APP_TRANSACTION, data, reply, 0);
3605        reply.readException();
3606        data.recycle();
3607        reply.recycle();
3608    }
3609    public void setAlwaysFinish(boolean enabled) throws RemoteException
3610    {
3611        Parcel data = Parcel.obtain();
3612        Parcel reply = Parcel.obtain();
3613        data.writeInterfaceToken(IActivityManager.descriptor);
3614        data.writeInt(enabled ? 1 : 0);
3615        mRemote.transact(SET_ALWAYS_FINISH_TRANSACTION, data, reply, 0);
3616        reply.readException();
3617        data.recycle();
3618        reply.recycle();
3619    }
3620    public void setActivityController(IActivityController watcher) throws RemoteException
3621    {
3622        Parcel data = Parcel.obtain();
3623        Parcel reply = Parcel.obtain();
3624        data.writeInterfaceToken(IActivityManager.descriptor);
3625        data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
3626        mRemote.transact(SET_ACTIVITY_CONTROLLER_TRANSACTION, data, reply, 0);
3627        reply.readException();
3628        data.recycle();
3629        reply.recycle();
3630    }
3631    public void enterSafeMode() throws RemoteException {
3632        Parcel data = Parcel.obtain();
3633        data.writeInterfaceToken(IActivityManager.descriptor);
3634        mRemote.transact(ENTER_SAFE_MODE_TRANSACTION, data, null, 0);
3635        data.recycle();
3636    }
3637    public void noteWakeupAlarm(IIntentSender sender) throws RemoteException {
3638        Parcel data = Parcel.obtain();
3639        data.writeStrongBinder(sender.asBinder());
3640        data.writeInterfaceToken(IActivityManager.descriptor);
3641        mRemote.transact(NOTE_WAKEUP_ALARM_TRANSACTION, data, null, 0);
3642        data.recycle();
3643    }
3644    public boolean killPids(int[] pids, String reason, boolean secure) throws RemoteException {
3645        Parcel data = Parcel.obtain();
3646        Parcel reply = Parcel.obtain();
3647        data.writeInterfaceToken(IActivityManager.descriptor);
3648        data.writeIntArray(pids);
3649        data.writeString(reason);
3650        data.writeInt(secure ? 1 : 0);
3651        mRemote.transact(KILL_PIDS_TRANSACTION, data, reply, 0);
3652        reply.readException();
3653        boolean res = reply.readInt() != 0;
3654        data.recycle();
3655        reply.recycle();
3656        return res;
3657    }
3658    @Override
3659    public boolean killProcessesBelowForeground(String reason) throws RemoteException {
3660        Parcel data = Parcel.obtain();
3661        Parcel reply = Parcel.obtain();
3662        data.writeInterfaceToken(IActivityManager.descriptor);
3663        data.writeString(reason);
3664        mRemote.transact(KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION, data, reply, 0);
3665        boolean res = reply.readInt() != 0;
3666        data.recycle();
3667        reply.recycle();
3668        return res;
3669    }
3670    public void startRunning(String pkg, String cls, String action,
3671            String indata) throws RemoteException {
3672        Parcel data = Parcel.obtain();
3673        Parcel reply = Parcel.obtain();
3674        data.writeInterfaceToken(IActivityManager.descriptor);
3675        data.writeString(pkg);
3676        data.writeString(cls);
3677        data.writeString(action);
3678        data.writeString(indata);
3679        mRemote.transact(START_RUNNING_TRANSACTION, data, reply, 0);
3680        reply.readException();
3681        data.recycle();
3682        reply.recycle();
3683    }
3684    public boolean testIsSystemReady()
3685    {
3686        /* this base class version is never called */
3687        return true;
3688    }
3689    public void handleApplicationCrash(IBinder app,
3690            ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException
3691    {
3692        Parcel data = Parcel.obtain();
3693        Parcel reply = Parcel.obtain();
3694        data.writeInterfaceToken(IActivityManager.descriptor);
3695        data.writeStrongBinder(app);
3696        crashInfo.writeToParcel(data, 0);
3697        mRemote.transact(HANDLE_APPLICATION_CRASH_TRANSACTION, data, reply, 0);
3698        reply.readException();
3699        reply.recycle();
3700        data.recycle();
3701    }
3702
3703    public boolean handleApplicationWtf(IBinder app, String tag,
3704            ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException
3705    {
3706        Parcel data = Parcel.obtain();
3707        Parcel reply = Parcel.obtain();
3708        data.writeInterfaceToken(IActivityManager.descriptor);
3709        data.writeStrongBinder(app);
3710        data.writeString(tag);
3711        crashInfo.writeToParcel(data, 0);
3712        mRemote.transact(HANDLE_APPLICATION_WTF_TRANSACTION, data, reply, 0);
3713        reply.readException();
3714        boolean res = reply.readInt() != 0;
3715        reply.recycle();
3716        data.recycle();
3717        return res;
3718    }
3719
3720    public void handleApplicationStrictModeViolation(IBinder app,
3721            int violationMask,
3722            StrictMode.ViolationInfo info) throws RemoteException
3723    {
3724        Parcel data = Parcel.obtain();
3725        Parcel reply = Parcel.obtain();
3726        data.writeInterfaceToken(IActivityManager.descriptor);
3727        data.writeStrongBinder(app);
3728        data.writeInt(violationMask);
3729        info.writeToParcel(data, 0);
3730        mRemote.transact(HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION, data, reply, 0);
3731        reply.readException();
3732        reply.recycle();
3733        data.recycle();
3734    }
3735
3736    public void signalPersistentProcesses(int sig) throws RemoteException {
3737        Parcel data = Parcel.obtain();
3738        Parcel reply = Parcel.obtain();
3739        data.writeInterfaceToken(IActivityManager.descriptor);
3740        data.writeInt(sig);
3741        mRemote.transact(SIGNAL_PERSISTENT_PROCESSES_TRANSACTION, data, reply, 0);
3742        reply.readException();
3743        data.recycle();
3744        reply.recycle();
3745    }
3746
3747    public void killBackgroundProcesses(String packageName, int userId) throws RemoteException {
3748        Parcel data = Parcel.obtain();
3749        Parcel reply = Parcel.obtain();
3750        data.writeInterfaceToken(IActivityManager.descriptor);
3751        data.writeString(packageName);
3752        data.writeInt(userId);
3753        mRemote.transact(KILL_BACKGROUND_PROCESSES_TRANSACTION, data, reply, 0);
3754        reply.readException();
3755        data.recycle();
3756        reply.recycle();
3757    }
3758
3759    public void killAllBackgroundProcesses() throws RemoteException {
3760        Parcel data = Parcel.obtain();
3761        Parcel reply = Parcel.obtain();
3762        data.writeInterfaceToken(IActivityManager.descriptor);
3763        mRemote.transact(KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION, data, reply, 0);
3764        reply.readException();
3765        data.recycle();
3766        reply.recycle();
3767    }
3768
3769    public void forceStopPackage(String packageName, int userId) throws RemoteException {
3770        Parcel data = Parcel.obtain();
3771        Parcel reply = Parcel.obtain();
3772        data.writeInterfaceToken(IActivityManager.descriptor);
3773        data.writeString(packageName);
3774        data.writeInt(userId);
3775        mRemote.transact(FORCE_STOP_PACKAGE_TRANSACTION, data, reply, 0);
3776        reply.readException();
3777        data.recycle();
3778        reply.recycle();
3779    }
3780
3781    public void getMyMemoryState(ActivityManager.RunningAppProcessInfo outInfo)
3782            throws RemoteException
3783    {
3784        Parcel data = Parcel.obtain();
3785        Parcel reply = Parcel.obtain();
3786        data.writeInterfaceToken(IActivityManager.descriptor);
3787        mRemote.transact(GET_MY_MEMORY_STATE_TRANSACTION, data, reply, 0);
3788        reply.readException();
3789        outInfo.readFromParcel(reply);
3790        reply.recycle();
3791        data.recycle();
3792    }
3793
3794    public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException
3795    {
3796        Parcel data = Parcel.obtain();
3797        Parcel reply = Parcel.obtain();
3798        data.writeInterfaceToken(IActivityManager.descriptor);
3799        mRemote.transact(GET_DEVICE_CONFIGURATION_TRANSACTION, data, reply, 0);
3800        reply.readException();
3801        ConfigurationInfo res = ConfigurationInfo.CREATOR.createFromParcel(reply);
3802        reply.recycle();
3803        data.recycle();
3804        return res;
3805    }
3806
3807    public boolean profileControl(String process, int userId, boolean start,
3808            String path, ParcelFileDescriptor fd, int profileType) throws RemoteException
3809    {
3810        Parcel data = Parcel.obtain();
3811        Parcel reply = Parcel.obtain();
3812        data.writeInterfaceToken(IActivityManager.descriptor);
3813        data.writeString(process);
3814        data.writeInt(userId);
3815        data.writeInt(start ? 1 : 0);
3816        data.writeInt(profileType);
3817        data.writeString(path);
3818        if (fd != null) {
3819            data.writeInt(1);
3820            fd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
3821        } else {
3822            data.writeInt(0);
3823        }
3824        mRemote.transact(PROFILE_CONTROL_TRANSACTION, data, reply, 0);
3825        reply.readException();
3826        boolean res = reply.readInt() != 0;
3827        reply.recycle();
3828        data.recycle();
3829        return res;
3830    }
3831
3832    public boolean shutdown(int timeout) throws RemoteException
3833    {
3834        Parcel data = Parcel.obtain();
3835        Parcel reply = Parcel.obtain();
3836        data.writeInterfaceToken(IActivityManager.descriptor);
3837        data.writeInt(timeout);
3838        mRemote.transact(SHUTDOWN_TRANSACTION, data, reply, 0);
3839        reply.readException();
3840        boolean res = reply.readInt() != 0;
3841        reply.recycle();
3842        data.recycle();
3843        return res;
3844    }
3845
3846    public void stopAppSwitches() throws RemoteException {
3847        Parcel data = Parcel.obtain();
3848        Parcel reply = Parcel.obtain();
3849        data.writeInterfaceToken(IActivityManager.descriptor);
3850        mRemote.transact(STOP_APP_SWITCHES_TRANSACTION, data, reply, 0);
3851        reply.readException();
3852        reply.recycle();
3853        data.recycle();
3854    }
3855
3856    public void resumeAppSwitches() throws RemoteException {
3857        Parcel data = Parcel.obtain();
3858        Parcel reply = Parcel.obtain();
3859        data.writeInterfaceToken(IActivityManager.descriptor);
3860        mRemote.transact(RESUME_APP_SWITCHES_TRANSACTION, data, reply, 0);
3861        reply.readException();
3862        reply.recycle();
3863        data.recycle();
3864    }
3865
3866    public void killApplicationWithAppId(String pkg, int appid, String reason)
3867            throws RemoteException {
3868        Parcel data = Parcel.obtain();
3869        Parcel reply = Parcel.obtain();
3870        data.writeInterfaceToken(IActivityManager.descriptor);
3871        data.writeString(pkg);
3872        data.writeInt(appid);
3873        data.writeString(reason);
3874        mRemote.transact(KILL_APPLICATION_WITH_APPID_TRANSACTION, data, reply, 0);
3875        reply.readException();
3876        data.recycle();
3877        reply.recycle();
3878    }
3879
3880    public void closeSystemDialogs(String reason) throws RemoteException {
3881        Parcel data = Parcel.obtain();
3882        Parcel reply = Parcel.obtain();
3883        data.writeInterfaceToken(IActivityManager.descriptor);
3884        data.writeString(reason);
3885        mRemote.transact(CLOSE_SYSTEM_DIALOGS_TRANSACTION, data, reply, 0);
3886        reply.readException();
3887        data.recycle();
3888        reply.recycle();
3889    }
3890
3891    public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids)
3892            throws RemoteException {
3893        Parcel data = Parcel.obtain();
3894        Parcel reply = Parcel.obtain();
3895        data.writeInterfaceToken(IActivityManager.descriptor);
3896        data.writeIntArray(pids);
3897        mRemote.transact(GET_PROCESS_MEMORY_INFO_TRANSACTION, data, reply, 0);
3898        reply.readException();
3899        Debug.MemoryInfo[] res = reply.createTypedArray(Debug.MemoryInfo.CREATOR);
3900        data.recycle();
3901        reply.recycle();
3902        return res;
3903    }
3904
3905    public void killApplicationProcess(String processName, int uid) throws RemoteException {
3906        Parcel data = Parcel.obtain();
3907        Parcel reply = Parcel.obtain();
3908        data.writeInterfaceToken(IActivityManager.descriptor);
3909        data.writeString(processName);
3910        data.writeInt(uid);
3911        mRemote.transact(KILL_APPLICATION_PROCESS_TRANSACTION, data, reply, 0);
3912        reply.readException();
3913        data.recycle();
3914        reply.recycle();
3915    }
3916
3917    public void overridePendingTransition(IBinder token, String packageName,
3918            int enterAnim, int exitAnim) throws RemoteException {
3919        Parcel data = Parcel.obtain();
3920        Parcel reply = Parcel.obtain();
3921        data.writeInterfaceToken(IActivityManager.descriptor);
3922        data.writeStrongBinder(token);
3923        data.writeString(packageName);
3924        data.writeInt(enterAnim);
3925        data.writeInt(exitAnim);
3926        mRemote.transact(OVERRIDE_PENDING_TRANSITION_TRANSACTION, data, reply, 0);
3927        reply.readException();
3928        data.recycle();
3929        reply.recycle();
3930    }
3931
3932    public boolean isUserAMonkey() throws RemoteException {
3933        Parcel data = Parcel.obtain();
3934        Parcel reply = Parcel.obtain();
3935        data.writeInterfaceToken(IActivityManager.descriptor);
3936        mRemote.transact(IS_USER_A_MONKEY_TRANSACTION, data, reply, 0);
3937        reply.readException();
3938        boolean res = reply.readInt() != 0;
3939        data.recycle();
3940        reply.recycle();
3941        return res;
3942    }
3943
3944    public void setUserIsMonkey(boolean monkey) throws RemoteException {
3945        Parcel data = Parcel.obtain();
3946        Parcel reply = Parcel.obtain();
3947        data.writeInterfaceToken(IActivityManager.descriptor);
3948        data.writeInt(monkey ? 1 : 0);
3949        mRemote.transact(SET_USER_IS_MONKEY_TRANSACTION, data, reply, 0);
3950        reply.readException();
3951        data.recycle();
3952        reply.recycle();
3953    }
3954
3955    public void finishHeavyWeightApp() throws RemoteException {
3956        Parcel data = Parcel.obtain();
3957        Parcel reply = Parcel.obtain();
3958        data.writeInterfaceToken(IActivityManager.descriptor);
3959        mRemote.transact(FINISH_HEAVY_WEIGHT_APP_TRANSACTION, data, reply, 0);
3960        reply.readException();
3961        data.recycle();
3962        reply.recycle();
3963    }
3964
3965    public boolean convertFromTranslucent(IBinder token)
3966            throws RemoteException {
3967        Parcel data = Parcel.obtain();
3968        Parcel reply = Parcel.obtain();
3969        data.writeInterfaceToken(IActivityManager.descriptor);
3970        data.writeStrongBinder(token);
3971        mRemote.transact(CONVERT_FROM_TRANSLUCENT_TRANSACTION, data, reply, 0);
3972        reply.readException();
3973        boolean res = reply.readInt() != 0;
3974        data.recycle();
3975        reply.recycle();
3976        return res;
3977    }
3978
3979    public boolean convertToTranslucent(IBinder token)
3980            throws RemoteException {
3981        Parcel data = Parcel.obtain();
3982        Parcel reply = Parcel.obtain();
3983        data.writeInterfaceToken(IActivityManager.descriptor);
3984        data.writeStrongBinder(token);
3985        mRemote.transact(CONVERT_TO_TRANSLUCENT_TRANSACTION, data, reply, 0);
3986        reply.readException();
3987        boolean res = reply.readInt() != 0;
3988        data.recycle();
3989        reply.recycle();
3990        return res;
3991    }
3992
3993    public void setImmersive(IBinder token, boolean immersive)
3994            throws RemoteException {
3995        Parcel data = Parcel.obtain();
3996        Parcel reply = Parcel.obtain();
3997        data.writeInterfaceToken(IActivityManager.descriptor);
3998        data.writeStrongBinder(token);
3999        data.writeInt(immersive ? 1 : 0);
4000        mRemote.transact(SET_IMMERSIVE_TRANSACTION, data, reply, 0);
4001        reply.readException();
4002        data.recycle();
4003        reply.recycle();
4004    }
4005
4006    public boolean isImmersive(IBinder token)
4007            throws RemoteException {
4008        Parcel data = Parcel.obtain();
4009        Parcel reply = Parcel.obtain();
4010        data.writeInterfaceToken(IActivityManager.descriptor);
4011        data.writeStrongBinder(token);
4012        mRemote.transact(IS_IMMERSIVE_TRANSACTION, data, reply, 0);
4013        reply.readException();
4014        boolean res = reply.readInt() == 1;
4015        data.recycle();
4016        reply.recycle();
4017        return res;
4018    }
4019
4020    public boolean isTopActivityImmersive()
4021            throws RemoteException {
4022        Parcel data = Parcel.obtain();
4023        Parcel reply = Parcel.obtain();
4024        data.writeInterfaceToken(IActivityManager.descriptor);
4025        mRemote.transact(IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION, data, reply, 0);
4026        reply.readException();
4027        boolean res = reply.readInt() == 1;
4028        data.recycle();
4029        reply.recycle();
4030        return res;
4031    }
4032
4033    public void crashApplication(int uid, int initialPid, String packageName,
4034            String message) throws RemoteException {
4035        Parcel data = Parcel.obtain();
4036        Parcel reply = Parcel.obtain();
4037        data.writeInterfaceToken(IActivityManager.descriptor);
4038        data.writeInt(uid);
4039        data.writeInt(initialPid);
4040        data.writeString(packageName);
4041        data.writeString(message);
4042        mRemote.transact(CRASH_APPLICATION_TRANSACTION, data, reply, 0);
4043        reply.readException();
4044        data.recycle();
4045        reply.recycle();
4046    }
4047
4048    public String getProviderMimeType(Uri uri, int userId) throws RemoteException {
4049        Parcel data = Parcel.obtain();
4050        Parcel reply = Parcel.obtain();
4051        data.writeInterfaceToken(IActivityManager.descriptor);
4052        uri.writeToParcel(data, 0);
4053        data.writeInt(userId);
4054        mRemote.transact(GET_PROVIDER_MIME_TYPE_TRANSACTION, data, reply, 0);
4055        reply.readException();
4056        String res = reply.readString();
4057        data.recycle();
4058        reply.recycle();
4059        return res;
4060    }
4061
4062    public IBinder newUriPermissionOwner(String name)
4063            throws RemoteException {
4064        Parcel data = Parcel.obtain();
4065        Parcel reply = Parcel.obtain();
4066        data.writeInterfaceToken(IActivityManager.descriptor);
4067        data.writeString(name);
4068        mRemote.transact(NEW_URI_PERMISSION_OWNER_TRANSACTION, data, reply, 0);
4069        reply.readException();
4070        IBinder res = reply.readStrongBinder();
4071        data.recycle();
4072        reply.recycle();
4073        return res;
4074    }
4075
4076    public void grantUriPermissionFromOwner(IBinder owner, int fromUid, String targetPkg,
4077            Uri uri, int mode) throws RemoteException {
4078        Parcel data = Parcel.obtain();
4079        Parcel reply = Parcel.obtain();
4080        data.writeInterfaceToken(IActivityManager.descriptor);
4081        data.writeStrongBinder(owner);
4082        data.writeInt(fromUid);
4083        data.writeString(targetPkg);
4084        uri.writeToParcel(data, 0);
4085        data.writeInt(mode);
4086        mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
4087        reply.readException();
4088        data.recycle();
4089        reply.recycle();
4090    }
4091
4092    public void revokeUriPermissionFromOwner(IBinder owner, Uri uri,
4093            int mode) throws RemoteException {
4094        Parcel data = Parcel.obtain();
4095        Parcel reply = Parcel.obtain();
4096        data.writeInterfaceToken(IActivityManager.descriptor);
4097        data.writeStrongBinder(owner);
4098        if (uri != null) {
4099            data.writeInt(1);
4100            uri.writeToParcel(data, 0);
4101        } else {
4102            data.writeInt(0);
4103        }
4104        data.writeInt(mode);
4105        mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
4106        reply.readException();
4107        data.recycle();
4108        reply.recycle();
4109    }
4110
4111    public int checkGrantUriPermission(int callingUid, String targetPkg,
4112            Uri uri, int modeFlags) throws RemoteException {
4113        Parcel data = Parcel.obtain();
4114        Parcel reply = Parcel.obtain();
4115        data.writeInterfaceToken(IActivityManager.descriptor);
4116        data.writeInt(callingUid);
4117        data.writeString(targetPkg);
4118        uri.writeToParcel(data, 0);
4119        data.writeInt(modeFlags);
4120        mRemote.transact(CHECK_GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
4121        reply.readException();
4122        int res = reply.readInt();
4123        data.recycle();
4124        reply.recycle();
4125        return res;
4126    }
4127
4128    public boolean dumpHeap(String process, int userId, boolean managed,
4129            String path, ParcelFileDescriptor fd) throws RemoteException {
4130        Parcel data = Parcel.obtain();
4131        Parcel reply = Parcel.obtain();
4132        data.writeInterfaceToken(IActivityManager.descriptor);
4133        data.writeString(process);
4134        data.writeInt(userId);
4135        data.writeInt(managed ? 1 : 0);
4136        data.writeString(path);
4137        if (fd != null) {
4138            data.writeInt(1);
4139            fd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
4140        } else {
4141            data.writeInt(0);
4142        }
4143        mRemote.transact(DUMP_HEAP_TRANSACTION, data, reply, 0);
4144        reply.readException();
4145        boolean res = reply.readInt() != 0;
4146        reply.recycle();
4147        data.recycle();
4148        return res;
4149    }
4150
4151    public int startActivities(IApplicationThread caller, String callingPackage,
4152            Intent[] intents, String[] resolvedTypes, IBinder resultTo,
4153            Bundle options, int userId) throws RemoteException {
4154        Parcel data = Parcel.obtain();
4155        Parcel reply = Parcel.obtain();
4156        data.writeInterfaceToken(IActivityManager.descriptor);
4157        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
4158        data.writeString(callingPackage);
4159        data.writeTypedArray(intents, 0);
4160        data.writeStringArray(resolvedTypes);
4161        data.writeStrongBinder(resultTo);
4162        if (options != null) {
4163            data.writeInt(1);
4164            options.writeToParcel(data, 0);
4165        } else {
4166            data.writeInt(0);
4167        }
4168        data.writeInt(userId);
4169        mRemote.transact(START_ACTIVITIES_TRANSACTION, data, reply, 0);
4170        reply.readException();
4171        int result = reply.readInt();
4172        reply.recycle();
4173        data.recycle();
4174        return result;
4175    }
4176
4177    public int getFrontActivityScreenCompatMode() throws RemoteException {
4178        Parcel data = Parcel.obtain();
4179        Parcel reply = Parcel.obtain();
4180        data.writeInterfaceToken(IActivityManager.descriptor);
4181        mRemote.transact(GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
4182        reply.readException();
4183        int mode = reply.readInt();
4184        reply.recycle();
4185        data.recycle();
4186        return mode;
4187    }
4188
4189    public void setFrontActivityScreenCompatMode(int mode) throws RemoteException {
4190        Parcel data = Parcel.obtain();
4191        Parcel reply = Parcel.obtain();
4192        data.writeInterfaceToken(IActivityManager.descriptor);
4193        data.writeInt(mode);
4194        mRemote.transact(SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
4195        reply.readException();
4196        reply.recycle();
4197        data.recycle();
4198    }
4199
4200    public int getPackageScreenCompatMode(String packageName) throws RemoteException {
4201        Parcel data = Parcel.obtain();
4202        Parcel reply = Parcel.obtain();
4203        data.writeInterfaceToken(IActivityManager.descriptor);
4204        data.writeString(packageName);
4205        mRemote.transact(GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
4206        reply.readException();
4207        int mode = reply.readInt();
4208        reply.recycle();
4209        data.recycle();
4210        return mode;
4211    }
4212
4213    public void setPackageScreenCompatMode(String packageName, int mode)
4214            throws RemoteException {
4215        Parcel data = Parcel.obtain();
4216        Parcel reply = Parcel.obtain();
4217        data.writeInterfaceToken(IActivityManager.descriptor);
4218        data.writeString(packageName);
4219        data.writeInt(mode);
4220        mRemote.transact(SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION, data, reply, 0);
4221        reply.readException();
4222        reply.recycle();
4223        data.recycle();
4224    }
4225
4226    public boolean getPackageAskScreenCompat(String packageName) throws RemoteException {
4227        Parcel data = Parcel.obtain();
4228        Parcel reply = Parcel.obtain();
4229        data.writeInterfaceToken(IActivityManager.descriptor);
4230        data.writeString(packageName);
4231        mRemote.transact(GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION, data, reply, 0);
4232        reply.readException();
4233        boolean ask = reply.readInt() != 0;
4234        reply.recycle();
4235        data.recycle();
4236        return ask;
4237    }
4238
4239    public void setPackageAskScreenCompat(String packageName, boolean ask)
4240            throws RemoteException {
4241        Parcel data = Parcel.obtain();
4242        Parcel reply = Parcel.obtain();
4243        data.writeInterfaceToken(IActivityManager.descriptor);
4244        data.writeString(packageName);
4245        data.writeInt(ask ? 1 : 0);
4246        mRemote.transact(SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION, data, reply, 0);
4247        reply.readException();
4248        reply.recycle();
4249        data.recycle();
4250    }
4251
4252    public boolean switchUser(int userid) throws RemoteException {
4253        Parcel data = Parcel.obtain();
4254        Parcel reply = Parcel.obtain();
4255        data.writeInterfaceToken(IActivityManager.descriptor);
4256        data.writeInt(userid);
4257        mRemote.transact(SWITCH_USER_TRANSACTION, data, reply, 0);
4258        reply.readException();
4259        boolean result = reply.readInt() != 0;
4260        reply.recycle();
4261        data.recycle();
4262        return result;
4263    }
4264
4265    public int stopUser(int userid, IStopUserCallback callback) throws RemoteException {
4266        Parcel data = Parcel.obtain();
4267        Parcel reply = Parcel.obtain();
4268        data.writeInterfaceToken(IActivityManager.descriptor);
4269        data.writeInt(userid);
4270        data.writeStrongInterface(callback);
4271        mRemote.transact(STOP_USER_TRANSACTION, data, reply, 0);
4272        reply.readException();
4273        int result = reply.readInt();
4274        reply.recycle();
4275        data.recycle();
4276        return result;
4277    }
4278
4279    public UserInfo getCurrentUser() throws RemoteException {
4280        Parcel data = Parcel.obtain();
4281        Parcel reply = Parcel.obtain();
4282        data.writeInterfaceToken(IActivityManager.descriptor);
4283        mRemote.transact(GET_CURRENT_USER_TRANSACTION, data, reply, 0);
4284        reply.readException();
4285        UserInfo userInfo = UserInfo.CREATOR.createFromParcel(reply);
4286        reply.recycle();
4287        data.recycle();
4288        return userInfo;
4289    }
4290
4291    public boolean isUserRunning(int userid, boolean orStopping) throws RemoteException {
4292        Parcel data = Parcel.obtain();
4293        Parcel reply = Parcel.obtain();
4294        data.writeInterfaceToken(IActivityManager.descriptor);
4295        data.writeInt(userid);
4296        data.writeInt(orStopping ? 1 : 0);
4297        mRemote.transact(IS_USER_RUNNING_TRANSACTION, data, reply, 0);
4298        reply.readException();
4299        boolean result = reply.readInt() != 0;
4300        reply.recycle();
4301        data.recycle();
4302        return result;
4303    }
4304
4305    public int[] getRunningUserIds() throws RemoteException {
4306        Parcel data = Parcel.obtain();
4307        Parcel reply = Parcel.obtain();
4308        data.writeInterfaceToken(IActivityManager.descriptor);
4309        mRemote.transact(GET_RUNNING_USER_IDS_TRANSACTION, data, reply, 0);
4310        reply.readException();
4311        int[] result = reply.createIntArray();
4312        reply.recycle();
4313        data.recycle();
4314        return result;
4315    }
4316
4317    public boolean removeSubTask(int taskId, int subTaskIndex) throws RemoteException {
4318        Parcel data = Parcel.obtain();
4319        Parcel reply = Parcel.obtain();
4320        data.writeInterfaceToken(IActivityManager.descriptor);
4321        data.writeInt(taskId);
4322        data.writeInt(subTaskIndex);
4323        mRemote.transact(REMOVE_SUB_TASK_TRANSACTION, data, reply, 0);
4324        reply.readException();
4325        boolean result = reply.readInt() != 0;
4326        reply.recycle();
4327        data.recycle();
4328        return result;
4329    }
4330
4331    public boolean removeTask(int taskId, int flags) throws RemoteException {
4332        Parcel data = Parcel.obtain();
4333        Parcel reply = Parcel.obtain();
4334        data.writeInterfaceToken(IActivityManager.descriptor);
4335        data.writeInt(taskId);
4336        data.writeInt(flags);
4337        mRemote.transact(REMOVE_TASK_TRANSACTION, data, reply, 0);
4338        reply.readException();
4339        boolean result = reply.readInt() != 0;
4340        reply.recycle();
4341        data.recycle();
4342        return result;
4343    }
4344
4345    public void registerProcessObserver(IProcessObserver observer) throws RemoteException {
4346        Parcel data = Parcel.obtain();
4347        Parcel reply = Parcel.obtain();
4348        data.writeInterfaceToken(IActivityManager.descriptor);
4349        data.writeStrongBinder(observer != null ? observer.asBinder() : null);
4350        mRemote.transact(REGISTER_PROCESS_OBSERVER_TRANSACTION, data, reply, 0);
4351        reply.readException();
4352        data.recycle();
4353        reply.recycle();
4354    }
4355
4356    public void unregisterProcessObserver(IProcessObserver observer) throws RemoteException {
4357        Parcel data = Parcel.obtain();
4358        Parcel reply = Parcel.obtain();
4359        data.writeInterfaceToken(IActivityManager.descriptor);
4360        data.writeStrongBinder(observer != null ? observer.asBinder() : null);
4361        mRemote.transact(UNREGISTER_PROCESS_OBSERVER_TRANSACTION, data, reply, 0);
4362        reply.readException();
4363        data.recycle();
4364        reply.recycle();
4365    }
4366
4367    public boolean isIntentSenderTargetedToPackage(IIntentSender sender) throws RemoteException {
4368        Parcel data = Parcel.obtain();
4369        Parcel reply = Parcel.obtain();
4370        data.writeInterfaceToken(IActivityManager.descriptor);
4371        data.writeStrongBinder(sender.asBinder());
4372        mRemote.transact(IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION, data, reply, 0);
4373        reply.readException();
4374        boolean res = reply.readInt() != 0;
4375        data.recycle();
4376        reply.recycle();
4377        return res;
4378    }
4379
4380    public boolean isIntentSenderAnActivity(IIntentSender sender) throws RemoteException {
4381        Parcel data = Parcel.obtain();
4382        Parcel reply = Parcel.obtain();
4383        data.writeInterfaceToken(IActivityManager.descriptor);
4384        data.writeStrongBinder(sender.asBinder());
4385        mRemote.transact(IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION, data, reply, 0);
4386        reply.readException();
4387        boolean res = reply.readInt() != 0;
4388        data.recycle();
4389        reply.recycle();
4390        return res;
4391    }
4392
4393    public Intent getIntentForIntentSender(IIntentSender sender) throws RemoteException {
4394        Parcel data = Parcel.obtain();
4395        Parcel reply = Parcel.obtain();
4396        data.writeInterfaceToken(IActivityManager.descriptor);
4397        data.writeStrongBinder(sender.asBinder());
4398        mRemote.transact(GET_INTENT_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
4399        reply.readException();
4400        Intent res = reply.readInt() != 0
4401                ? Intent.CREATOR.createFromParcel(reply) : null;
4402        data.recycle();
4403        reply.recycle();
4404        return res;
4405    }
4406
4407    public void updatePersistentConfiguration(Configuration values) throws RemoteException
4408    {
4409        Parcel data = Parcel.obtain();
4410        Parcel reply = Parcel.obtain();
4411        data.writeInterfaceToken(IActivityManager.descriptor);
4412        values.writeToParcel(data, 0);
4413        mRemote.transact(UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION, data, reply, 0);
4414        reply.readException();
4415        data.recycle();
4416        reply.recycle();
4417    }
4418
4419    public long[] getProcessPss(int[] pids) throws RemoteException {
4420        Parcel data = Parcel.obtain();
4421        Parcel reply = Parcel.obtain();
4422        data.writeInterfaceToken(IActivityManager.descriptor);
4423        data.writeIntArray(pids);
4424        mRemote.transact(GET_PROCESS_PSS_TRANSACTION, data, reply, 0);
4425        reply.readException();
4426        long[] res = reply.createLongArray();
4427        data.recycle();
4428        reply.recycle();
4429        return res;
4430    }
4431
4432    public void showBootMessage(CharSequence msg, boolean always) throws RemoteException {
4433        Parcel data = Parcel.obtain();
4434        Parcel reply = Parcel.obtain();
4435        data.writeInterfaceToken(IActivityManager.descriptor);
4436        TextUtils.writeToParcel(msg, data, 0);
4437        data.writeInt(always ? 1 : 0);
4438        mRemote.transact(SHOW_BOOT_MESSAGE_TRANSACTION, data, reply, 0);
4439        reply.readException();
4440        data.recycle();
4441        reply.recycle();
4442    }
4443
4444    public void dismissKeyguardOnNextActivity() throws RemoteException {
4445        Parcel data = Parcel.obtain();
4446        Parcel reply = Parcel.obtain();
4447        data.writeInterfaceToken(IActivityManager.descriptor);
4448        mRemote.transact(DISMISS_KEYGUARD_ON_NEXT_ACTIVITY_TRANSACTION, data, reply, 0);
4449        reply.readException();
4450        data.recycle();
4451        reply.recycle();
4452    }
4453
4454    public boolean targetTaskAffinityMatchesActivity(IBinder token, String destAffinity)
4455            throws RemoteException {
4456        Parcel data = Parcel.obtain();
4457        Parcel reply = Parcel.obtain();
4458        data.writeInterfaceToken(IActivityManager.descriptor);
4459        data.writeStrongBinder(token);
4460        data.writeString(destAffinity);
4461        mRemote.transact(TARGET_TASK_AFFINITY_MATCHES_ACTIVITY_TRANSACTION, data, reply, 0);
4462        reply.readException();
4463        boolean result = reply.readInt() != 0;
4464        data.recycle();
4465        reply.recycle();
4466        return result;
4467    }
4468
4469    public boolean navigateUpTo(IBinder token, Intent target, int resultCode, Intent resultData)
4470            throws RemoteException {
4471        Parcel data = Parcel.obtain();
4472        Parcel reply = Parcel.obtain();
4473        data.writeInterfaceToken(IActivityManager.descriptor);
4474        data.writeStrongBinder(token);
4475        target.writeToParcel(data, 0);
4476        data.writeInt(resultCode);
4477        if (resultData != null) {
4478            data.writeInt(1);
4479            resultData.writeToParcel(data, 0);
4480        } else {
4481            data.writeInt(0);
4482        }
4483        mRemote.transact(NAVIGATE_UP_TO_TRANSACTION, data, reply, 0);
4484        reply.readException();
4485        boolean result = reply.readInt() != 0;
4486        data.recycle();
4487        reply.recycle();
4488        return result;
4489    }
4490
4491    public int getLaunchedFromUid(IBinder activityToken) throws RemoteException {
4492        Parcel data = Parcel.obtain();
4493        Parcel reply = Parcel.obtain();
4494        data.writeInterfaceToken(IActivityManager.descriptor);
4495        data.writeStrongBinder(activityToken);
4496        mRemote.transact(GET_LAUNCHED_FROM_UID_TRANSACTION, data, reply, 0);
4497        reply.readException();
4498        int result = reply.readInt();
4499        data.recycle();
4500        reply.recycle();
4501        return result;
4502    }
4503
4504    public String getLaunchedFromPackage(IBinder activityToken) throws RemoteException {
4505        Parcel data = Parcel.obtain();
4506        Parcel reply = Parcel.obtain();
4507        data.writeInterfaceToken(IActivityManager.descriptor);
4508        data.writeStrongBinder(activityToken);
4509        mRemote.transact(GET_LAUNCHED_FROM_PACKAGE_TRANSACTION, data, reply, 0);
4510        reply.readException();
4511        String result = reply.readString();
4512        data.recycle();
4513        reply.recycle();
4514        return result;
4515    }
4516
4517    public void registerUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException {
4518        Parcel data = Parcel.obtain();
4519        Parcel reply = Parcel.obtain();
4520        data.writeInterfaceToken(IActivityManager.descriptor);
4521        data.writeStrongBinder(observer != null ? observer.asBinder() : null);
4522        mRemote.transact(REGISTER_USER_SWITCH_OBSERVER_TRANSACTION, data, reply, 0);
4523        reply.readException();
4524        data.recycle();
4525        reply.recycle();
4526    }
4527
4528    public void unregisterUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException {
4529        Parcel data = Parcel.obtain();
4530        Parcel reply = Parcel.obtain();
4531        data.writeInterfaceToken(IActivityManager.descriptor);
4532        data.writeStrongBinder(observer != null ? observer.asBinder() : null);
4533        mRemote.transact(UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION, data, reply, 0);
4534        reply.readException();
4535        data.recycle();
4536        reply.recycle();
4537    }
4538
4539    public void requestBugReport() throws RemoteException {
4540        Parcel data = Parcel.obtain();
4541        Parcel reply = Parcel.obtain();
4542        data.writeInterfaceToken(IActivityManager.descriptor);
4543        mRemote.transact(REQUEST_BUG_REPORT_TRANSACTION, data, reply, 0);
4544        reply.readException();
4545        data.recycle();
4546        reply.recycle();
4547    }
4548
4549    public long inputDispatchingTimedOut(int pid, boolean aboveSystem, String reason)
4550            throws RemoteException {
4551        Parcel data = Parcel.obtain();
4552        Parcel reply = Parcel.obtain();
4553        data.writeInterfaceToken(IActivityManager.descriptor);
4554        data.writeInt(pid);
4555        data.writeInt(aboveSystem ? 1 : 0);
4556        data.writeString(reason);
4557        mRemote.transact(INPUT_DISPATCHING_TIMED_OUT_TRANSACTION, data, reply, 0);
4558        reply.readException();
4559        long res = reply.readInt();
4560        data.recycle();
4561        reply.recycle();
4562        return res;
4563    }
4564
4565    public Bundle getAssistContextExtras(int requestType) throws RemoteException {
4566        Parcel data = Parcel.obtain();
4567        Parcel reply = Parcel.obtain();
4568        data.writeInterfaceToken(IActivityManager.descriptor);
4569        data.writeInt(requestType);
4570        mRemote.transact(GET_ASSIST_CONTEXT_EXTRAS_TRANSACTION, data, reply, 0);
4571        reply.readException();
4572        Bundle res = reply.readBundle();
4573        data.recycle();
4574        reply.recycle();
4575        return res;
4576    }
4577
4578    public void reportAssistContextExtras(IBinder token, Bundle extras)
4579            throws RemoteException {
4580        Parcel data = Parcel.obtain();
4581        Parcel reply = Parcel.obtain();
4582        data.writeInterfaceToken(IActivityManager.descriptor);
4583        data.writeStrongBinder(token);
4584        data.writeBundle(extras);
4585        mRemote.transact(REPORT_ASSIST_CONTEXT_EXTRAS_TRANSACTION, data, reply, 0);
4586        reply.readException();
4587        data.recycle();
4588        reply.recycle();
4589    }
4590
4591    public void killUid(int uid, String reason) throws RemoteException {
4592        Parcel data = Parcel.obtain();
4593        Parcel reply = Parcel.obtain();
4594        data.writeInterfaceToken(IActivityManager.descriptor);
4595        data.writeInt(uid);
4596        data.writeString(reason);
4597        mRemote.transact(KILL_UID_TRANSACTION, data, reply, 0);
4598        reply.readException();
4599        data.recycle();
4600        reply.recycle();
4601    }
4602
4603    public void hang(IBinder who, boolean allowRestart) throws RemoteException {
4604        Parcel data = Parcel.obtain();
4605        Parcel reply = Parcel.obtain();
4606        data.writeInterfaceToken(IActivityManager.descriptor);
4607        data.writeStrongBinder(who);
4608        data.writeInt(allowRestart ? 1 : 0);
4609        mRemote.transact(HANG_TRANSACTION, data, reply, 0);
4610        reply.readException();
4611        data.recycle();
4612        reply.recycle();
4613    }
4614
4615    public void reportActivityFullyDrawn(IBinder token) throws RemoteException {
4616        Parcel data = Parcel.obtain();
4617        Parcel reply = Parcel.obtain();
4618        data.writeInterfaceToken(IActivityManager.descriptor);
4619        data.writeStrongBinder(token);
4620        mRemote.transact(REPORT_ACTIVITY_FULLY_DRAWN_TRANSACTION, data, reply, 0);
4621        reply.readException();
4622        data.recycle();
4623        reply.recycle();
4624    }
4625
4626    public void notifyActivityDrawn(IBinder token) throws RemoteException {
4627        Parcel data = Parcel.obtain();
4628        Parcel reply = Parcel.obtain();
4629        data.writeInterfaceToken(IActivityManager.descriptor);
4630        data.writeStrongBinder(token);
4631        mRemote.transact(NOTIFY_ACTIVITY_DRAWN_TRANSACTION, data, reply, 0);
4632        reply.readException();
4633        data.recycle();
4634        reply.recycle();
4635    }
4636
4637    public void restart() throws RemoteException {
4638        Parcel data = Parcel.obtain();
4639        Parcel reply = Parcel.obtain();
4640        data.writeInterfaceToken(IActivityManager.descriptor);
4641        mRemote.transact(RESTART_TRANSACTION, data, reply, 0);
4642        reply.readException();
4643        data.recycle();
4644        reply.recycle();
4645    }
4646
4647    public void performIdleMaintenance() throws RemoteException {
4648        Parcel data = Parcel.obtain();
4649        Parcel reply = Parcel.obtain();
4650        data.writeInterfaceToken(IActivityManager.descriptor);
4651        mRemote.transact(PERFORM_IDLE_MAINTENANCE_TRANSACTION, data, reply, 0);
4652        reply.readException();
4653        data.recycle();
4654        reply.recycle();
4655    }
4656
4657    private IBinder mRemote;
4658}
4659