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