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