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