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