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