ActivityManagerNative.java revision 9c8dd55a9d829c29a3feee9469d8c2f27a9f5516 
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.pm.ApplicationInfo;
25import android.content.pm.ConfigurationInfo;
26import android.content.pm.IPackageDataObserver;
27import android.content.res.Configuration;
28import android.graphics.Bitmap;
29import android.net.Uri;
30import android.os.Binder;
31import android.os.Bundle;
32import android.os.Parcelable;
33import android.os.ParcelFileDescriptor;
34import android.os.RemoteException;
35import android.os.IBinder;
36import android.os.Parcel;
37import android.os.ServiceManager;
38import android.text.TextUtils;
39import android.util.Config;
40import android.util.Log;
41
42import java.io.FileNotFoundException;
43import java.io.FileDescriptor;
44import java.io.IOException;
45import java.util.ArrayList;
46import java.util.List;
47
48/** {@hide} */
49public abstract class ActivityManagerNative extends Binder implements IActivityManager
50{
51    /**
52     * Cast a Binder object into an activity manager interface, generating
53     * a proxy if needed.
54     */
55    static public IActivityManager asInterface(IBinder obj)
56    {
57        if (obj == null) {
58            return null;
59        }
60        IActivityManager in =
61            (IActivityManager)obj.queryLocalInterface(descriptor);
62        if (in != null) {
63            return in;
64        }
65
66        return new ActivityManagerProxy(obj);
67    }
68
69    /**
70     * Retrieve the system's default/global activity manager.
71     */
72    static public IActivityManager getDefault()
73    {
74        if (gDefault != null) {
75            //if (Config.LOGV) Log.v(
76            //    "ActivityManager", "returning cur default = " + gDefault);
77            return gDefault;
78        }
79        IBinder b = ServiceManager.getService("activity");
80        if (Config.LOGV) Log.v(
81            "ActivityManager", "default service binder = " + b);
82        gDefault = asInterface(b);
83        if (Config.LOGV) Log.v(
84            "ActivityManager", "default service = " + gDefault);
85        return gDefault;
86    }
87
88    /**
89     * Convenience for checking whether the system is ready.  For internal use only.
90     */
91    static public boolean isSystemReady() {
92        if (!sSystemReady) {
93            sSystemReady = getDefault().testIsSystemReady();
94        }
95        return sSystemReady;
96    }
97    static boolean sSystemReady = false;
98
99    /**
100     * Convenience for sending a sticky broadcast.  For internal use only.
101     * If you don't care about permission, use null.
102     */
103    static public void broadcastStickyIntent(Intent intent, String permission)
104    {
105        try {
106            getDefault().broadcastIntent(
107                null, intent, null, null, Activity.RESULT_OK, null, null,
108                null /*permission*/, false, true);
109        } catch (RemoteException ex) {
110        }
111    }
112
113    static public void noteWakeupAlarm(PendingIntent ps) {
114        try {
115            getDefault().noteWakeupAlarm(ps.getTarget());
116        } catch (RemoteException ex) {
117        }
118    }
119
120    public ActivityManagerNative()
121    {
122        attachInterface(this, descriptor);
123    }
124
125    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
126            throws RemoteException {
127        switch (code) {
128        case START_ACTIVITY_TRANSACTION:
129        {
130            data.enforceInterface(IActivityManager.descriptor);
131            IBinder b = data.readStrongBinder();
132            IApplicationThread app = ApplicationThreadNative.asInterface(b);
133            Intent intent = Intent.CREATOR.createFromParcel(data);
134            String resolvedType = data.readString();
135            Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
136            int grantedMode = data.readInt();
137            IBinder resultTo = data.readStrongBinder();
138            String resultWho = data.readString();
139            int requestCode = data.readInt();
140            boolean onlyIfNeeded = data.readInt() != 0;
141            boolean debug = data.readInt() != 0;
142            int result = startActivity(app, intent, resolvedType,
143                    grantedUriPermissions, grantedMode, resultTo, resultWho,
144                    requestCode, onlyIfNeeded, debug);
145            reply.writeNoException();
146            reply.writeInt(result);
147            return true;
148        }
149
150        case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
151        {
152            data.enforceInterface(IActivityManager.descriptor);
153            IBinder callingActivity = data.readStrongBinder();
154            Intent intent = Intent.CREATOR.createFromParcel(data);
155            boolean result = startNextMatchingActivity(callingActivity, intent);
156            reply.writeNoException();
157            reply.writeInt(result ? 1 : 0);
158            return true;
159        }
160
161        case FINISH_ACTIVITY_TRANSACTION: {
162            data.enforceInterface(IActivityManager.descriptor);
163            IBinder token = data.readStrongBinder();
164            Intent resultData = null;
165            int resultCode = data.readInt();
166            if (data.readInt() != 0) {
167                resultData = Intent.CREATOR.createFromParcel(data);
168            }
169            boolean res = finishActivity(token, resultCode, resultData);
170            reply.writeNoException();
171            reply.writeInt(res ? 1 : 0);
172            return true;
173        }
174
175        case FINISH_SUB_ACTIVITY_TRANSACTION: {
176            data.enforceInterface(IActivityManager.descriptor);
177            IBinder token = data.readStrongBinder();
178            String resultWho = data.readString();
179            int requestCode = data.readInt();
180            finishSubActivity(token, resultWho, requestCode);
181            reply.writeNoException();
182            return true;
183        }
184
185        case REGISTER_RECEIVER_TRANSACTION:
186        {
187            data.enforceInterface(IActivityManager.descriptor);
188            IBinder b = data.readStrongBinder();
189            IApplicationThread app =
190                b != null ? ApplicationThreadNative.asInterface(b) : null;
191            b = data.readStrongBinder();
192            IIntentReceiver rec
193                = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
194            IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
195            String perm = data.readString();
196            Intent intent = registerReceiver(app, rec, filter, perm);
197            reply.writeNoException();
198            if (intent != null) {
199                reply.writeInt(1);
200                intent.writeToParcel(reply, 0);
201            } else {
202                reply.writeInt(0);
203            }
204            return true;
205        }
206
207        case UNREGISTER_RECEIVER_TRANSACTION:
208        {
209            data.enforceInterface(IActivityManager.descriptor);
210            IBinder b = data.readStrongBinder();
211            if (b == null) {
212                return true;
213            }
214            IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
215            unregisterReceiver(rec);
216            reply.writeNoException();
217            return true;
218        }
219
220        case BROADCAST_INTENT_TRANSACTION:
221        {
222            data.enforceInterface(IActivityManager.descriptor);
223            IBinder b = data.readStrongBinder();
224            IApplicationThread app =
225                b != null ? ApplicationThreadNative.asInterface(b) : null;
226            Intent intent = Intent.CREATOR.createFromParcel(data);
227            String resolvedType = data.readString();
228            b = data.readStrongBinder();
229            IIntentReceiver resultTo =
230                b != null ? IIntentReceiver.Stub.asInterface(b) : null;
231            int resultCode = data.readInt();
232            String resultData = data.readString();
233            Bundle resultExtras = data.readBundle();
234            String perm = data.readString();
235            boolean serialized = data.readInt() != 0;
236            boolean sticky = data.readInt() != 0;
237            int res = broadcastIntent(app, intent, resolvedType, resultTo,
238                    resultCode, resultData, resultExtras, perm,
239                    serialized, sticky);
240            reply.writeNoException();
241            reply.writeInt(res);
242            return true;
243        }
244
245        case UNBROADCAST_INTENT_TRANSACTION:
246        {
247            data.enforceInterface(IActivityManager.descriptor);
248            IBinder b = data.readStrongBinder();
249            IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
250            Intent intent = Intent.CREATOR.createFromParcel(data);
251            unbroadcastIntent(app, intent);
252            reply.writeNoException();
253            return true;
254        }
255
256        case FINISH_RECEIVER_TRANSACTION: {
257            data.enforceInterface(IActivityManager.descriptor);
258            IBinder who = data.readStrongBinder();
259            int resultCode = data.readInt();
260            String resultData = data.readString();
261            Bundle resultExtras = data.readBundle();
262            boolean resultAbort = data.readInt() != 0;
263            if (who != null) {
264                finishReceiver(who, resultCode, resultData, resultExtras, resultAbort);
265            }
266            reply.writeNoException();
267            return true;
268        }
269
270        case SET_PERSISTENT_TRANSACTION: {
271            data.enforceInterface(IActivityManager.descriptor);
272            IBinder token = data.readStrongBinder();
273            boolean isPersistent = data.readInt() != 0;
274            if (token != null) {
275                setPersistent(token, isPersistent);
276            }
277            reply.writeNoException();
278            return true;
279        }
280
281        case ATTACH_APPLICATION_TRANSACTION: {
282            data.enforceInterface(IActivityManager.descriptor);
283            IApplicationThread app = ApplicationThreadNative.asInterface(
284                    data.readStrongBinder());
285            if (app != null) {
286                attachApplication(app);
287            }
288            reply.writeNoException();
289            return true;
290        }
291
292        case ACTIVITY_IDLE_TRANSACTION: {
293            data.enforceInterface(IActivityManager.descriptor);
294            IBinder token = data.readStrongBinder();
295            if (token != null) {
296                activityIdle(token);
297            }
298            reply.writeNoException();
299            return true;
300        }
301
302        case ACTIVITY_PAUSED_TRANSACTION: {
303            data.enforceInterface(IActivityManager.descriptor);
304            IBinder token = data.readStrongBinder();
305            Bundle map = data.readBundle();
306            activityPaused(token, map);
307            reply.writeNoException();
308            return true;
309        }
310
311        case ACTIVITY_STOPPED_TRANSACTION: {
312            data.enforceInterface(IActivityManager.descriptor);
313            IBinder token = data.readStrongBinder();
314            Bitmap thumbnail = data.readInt() != 0
315                ? Bitmap.CREATOR.createFromParcel(data) : null;
316            CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
317            activityStopped(token, thumbnail, description);
318            reply.writeNoException();
319            return true;
320        }
321
322        case ACTIVITY_DESTROYED_TRANSACTION: {
323            data.enforceInterface(IActivityManager.descriptor);
324            IBinder token = data.readStrongBinder();
325            activityDestroyed(token);
326            reply.writeNoException();
327            return true;
328        }
329
330        case GET_CALLING_PACKAGE_TRANSACTION: {
331            data.enforceInterface(IActivityManager.descriptor);
332            IBinder token = data.readStrongBinder();
333            String res = token != null ? getCallingPackage(token) : null;
334            reply.writeNoException();
335            reply.writeString(res);
336            return true;
337        }
338
339        case GET_CALLING_ACTIVITY_TRANSACTION: {
340            data.enforceInterface(IActivityManager.descriptor);
341            IBinder token = data.readStrongBinder();
342            ComponentName cn = getCallingActivity(token);
343            reply.writeNoException();
344            ComponentName.writeToParcel(cn, reply);
345            return true;
346        }
347
348        case GET_TASKS_TRANSACTION: {
349            data.enforceInterface(IActivityManager.descriptor);
350            int maxNum = data.readInt();
351            int fl = data.readInt();
352            IBinder receiverBinder = data.readStrongBinder();
353            IThumbnailReceiver receiver = receiverBinder != null
354                ? IThumbnailReceiver.Stub.asInterface(receiverBinder)
355                : null;
356            List list = getTasks(maxNum, fl, receiver);
357            reply.writeNoException();
358            int N = list != null ? list.size() : -1;
359            reply.writeInt(N);
360            int i;
361            for (i=0; i<N; i++) {
362                ActivityManager.RunningTaskInfo info =
363                        (ActivityManager.RunningTaskInfo)list.get(i);
364                info.writeToParcel(reply, 0);
365            }
366            return true;
367        }
368
369        case GET_RECENT_TASKS_TRANSACTION: {
370            data.enforceInterface(IActivityManager.descriptor);
371            int maxNum = data.readInt();
372            int fl = data.readInt();
373            List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
374                    fl);
375            reply.writeNoException();
376            reply.writeTypedList(list);
377            return true;
378        }
379
380        case GET_SERVICES_TRANSACTION: {
381            data.enforceInterface(IActivityManager.descriptor);
382            int maxNum = data.readInt();
383            int fl = data.readInt();
384            List list = getServices(maxNum, fl);
385            reply.writeNoException();
386            int N = list != null ? list.size() : -1;
387            reply.writeInt(N);
388            int i;
389            for (i=0; i<N; i++) {
390                ActivityManager.RunningServiceInfo info =
391                        (ActivityManager.RunningServiceInfo)list.get(i);
392                info.writeToParcel(reply, 0);
393            }
394            return true;
395        }
396
397        case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION: {
398            data.enforceInterface(IActivityManager.descriptor);
399            List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
400            reply.writeNoException();
401            reply.writeTypedList(list);
402            return true;
403        }
404
405        case GET_RUNNING_APP_PROCESSES_TRANSACTION: {
406            data.enforceInterface(IActivityManager.descriptor);
407            List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
408            reply.writeNoException();
409            reply.writeTypedList(list);
410            return true;
411        }
412
413        case MOVE_TASK_TO_FRONT_TRANSACTION: {
414            data.enforceInterface(IActivityManager.descriptor);
415            int task = data.readInt();
416            moveTaskToFront(task);
417            reply.writeNoException();
418            return true;
419        }
420
421        case MOVE_TASK_TO_BACK_TRANSACTION: {
422            data.enforceInterface(IActivityManager.descriptor);
423            int task = data.readInt();
424            moveTaskToBack(task);
425            reply.writeNoException();
426            return true;
427        }
428
429        case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION: {
430            data.enforceInterface(IActivityManager.descriptor);
431            IBinder token = data.readStrongBinder();
432            boolean nonRoot = data.readInt() != 0;
433            boolean res = moveActivityTaskToBack(token, nonRoot);
434            reply.writeNoException();
435            reply.writeInt(res ? 1 : 0);
436            return true;
437        }
438
439        case MOVE_TASK_BACKWARDS_TRANSACTION: {
440            data.enforceInterface(IActivityManager.descriptor);
441            int task = data.readInt();
442            moveTaskBackwards(task);
443            reply.writeNoException();
444            return true;
445        }
446
447        case GET_TASK_FOR_ACTIVITY_TRANSACTION: {
448            data.enforceInterface(IActivityManager.descriptor);
449            IBinder token = data.readStrongBinder();
450            boolean onlyRoot = data.readInt() != 0;
451            int res = token != null
452                ? getTaskForActivity(token, onlyRoot) : -1;
453                reply.writeNoException();
454            reply.writeInt(res);
455            return true;
456        }
457
458        case FINISH_OTHER_INSTANCES_TRANSACTION: {
459            data.enforceInterface(IActivityManager.descriptor);
460            IBinder token = data.readStrongBinder();
461            ComponentName className = ComponentName.readFromParcel(data);
462            finishOtherInstances(token, className);
463            reply.writeNoException();
464            return true;
465        }
466
467        case REPORT_THUMBNAIL_TRANSACTION: {
468            data.enforceInterface(IActivityManager.descriptor);
469            IBinder token = data.readStrongBinder();
470            Bitmap thumbnail = data.readInt() != 0
471                ? Bitmap.CREATOR.createFromParcel(data) : null;
472            CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
473            reportThumbnail(token, thumbnail, description);
474            reply.writeNoException();
475            return true;
476        }
477
478        case GET_CONTENT_PROVIDER_TRANSACTION: {
479            data.enforceInterface(IActivityManager.descriptor);
480            IBinder b = data.readStrongBinder();
481            IApplicationThread app = ApplicationThreadNative.asInterface(b);
482            String name = data.readString();
483            ContentProviderHolder cph = getContentProvider(app, name);
484            reply.writeNoException();
485            if (cph != null) {
486                reply.writeInt(1);
487                cph.writeToParcel(reply, 0);
488            } else {
489                reply.writeInt(0);
490            }
491            return true;
492        }
493
494        case PUBLISH_CONTENT_PROVIDERS_TRANSACTION: {
495            data.enforceInterface(IActivityManager.descriptor);
496            IBinder b = data.readStrongBinder();
497            IApplicationThread app = ApplicationThreadNative.asInterface(b);
498            ArrayList<ContentProviderHolder> providers =
499                data.createTypedArrayList(ContentProviderHolder.CREATOR);
500            publishContentProviders(app, providers);
501            reply.writeNoException();
502            return true;
503        }
504
505        case REMOVE_CONTENT_PROVIDER_TRANSACTION: {
506            data.enforceInterface(IActivityManager.descriptor);
507            IBinder b = data.readStrongBinder();
508            IApplicationThread app = ApplicationThreadNative.asInterface(b);
509            String name = data.readString();
510            removeContentProvider(app, name);
511            reply.writeNoException();
512            return true;
513        }
514
515        case START_SERVICE_TRANSACTION: {
516            data.enforceInterface(IActivityManager.descriptor);
517            IBinder b = data.readStrongBinder();
518            IApplicationThread app = ApplicationThreadNative.asInterface(b);
519            Intent service = Intent.CREATOR.createFromParcel(data);
520            String resolvedType = data.readString();
521            ComponentName cn = startService(app, service, resolvedType);
522            reply.writeNoException();
523            ComponentName.writeToParcel(cn, reply);
524            return true;
525        }
526
527        case STOP_SERVICE_TRANSACTION: {
528            data.enforceInterface(IActivityManager.descriptor);
529            IBinder b = data.readStrongBinder();
530            IApplicationThread app = ApplicationThreadNative.asInterface(b);
531            Intent service = Intent.CREATOR.createFromParcel(data);
532            String resolvedType = data.readString();
533            int res = stopService(app, service, resolvedType);
534            reply.writeNoException();
535            reply.writeInt(res);
536            return true;
537        }
538
539        case STOP_SERVICE_TOKEN_TRANSACTION: {
540            data.enforceInterface(IActivityManager.descriptor);
541            ComponentName className = ComponentName.readFromParcel(data);
542            IBinder token = data.readStrongBinder();
543            int startId = data.readInt();
544            boolean res = stopServiceToken(className, token, startId);
545            reply.writeNoException();
546            reply.writeInt(res ? 1 : 0);
547            return true;
548        }
549
550        case SET_SERVICE_FOREGROUND_TRANSACTION: {
551            data.enforceInterface(IActivityManager.descriptor);
552            ComponentName className = ComponentName.readFromParcel(data);
553            IBinder token = data.readStrongBinder();
554            boolean isForeground = data.readInt() != 0;
555            setServiceForeground(className, token, isForeground);
556            reply.writeNoException();
557            return true;
558        }
559
560        case BIND_SERVICE_TRANSACTION: {
561            data.enforceInterface(IActivityManager.descriptor);
562            IBinder b = data.readStrongBinder();
563            IApplicationThread app = ApplicationThreadNative.asInterface(b);
564            IBinder token = data.readStrongBinder();
565            Intent service = Intent.CREATOR.createFromParcel(data);
566            String resolvedType = data.readString();
567            b = data.readStrongBinder();
568            int fl = data.readInt();
569            IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
570            int res = bindService(app, token, service, resolvedType, conn, fl);
571            reply.writeNoException();
572            reply.writeInt(res);
573            return true;
574        }
575
576        case UNBIND_SERVICE_TRANSACTION: {
577            data.enforceInterface(IActivityManager.descriptor);
578            IBinder b = data.readStrongBinder();
579            IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
580            boolean res = unbindService(conn);
581            reply.writeNoException();
582            reply.writeInt(res ? 1 : 0);
583            return true;
584        }
585
586        case PUBLISH_SERVICE_TRANSACTION: {
587            data.enforceInterface(IActivityManager.descriptor);
588            IBinder token = data.readStrongBinder();
589            Intent intent = Intent.CREATOR.createFromParcel(data);
590            IBinder service = data.readStrongBinder();
591            publishService(token, intent, service);
592            reply.writeNoException();
593            return true;
594        }
595
596        case UNBIND_FINISHED_TRANSACTION: {
597            data.enforceInterface(IActivityManager.descriptor);
598            IBinder token = data.readStrongBinder();
599            Intent intent = Intent.CREATOR.createFromParcel(data);
600            boolean doRebind = data.readInt() != 0;
601            unbindFinished(token, intent, doRebind);
602            reply.writeNoException();
603            return true;
604        }
605
606        case SERVICE_DONE_EXECUTING_TRANSACTION: {
607            data.enforceInterface(IActivityManager.descriptor);
608            IBinder token = data.readStrongBinder();
609            serviceDoneExecuting(token);
610            reply.writeNoException();
611            return true;
612        }
613
614        case START_INSTRUMENTATION_TRANSACTION: {
615            data.enforceInterface(IActivityManager.descriptor);
616            ComponentName className = ComponentName.readFromParcel(data);
617            String profileFile = data.readString();
618            int fl = data.readInt();
619            Bundle arguments = data.readBundle();
620            IBinder b = data.readStrongBinder();
621            IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
622            boolean res = startInstrumentation(className, profileFile, fl, arguments, w);
623            reply.writeNoException();
624            reply.writeInt(res ? 1 : 0);
625            return true;
626        }
627
628
629        case FINISH_INSTRUMENTATION_TRANSACTION: {
630            data.enforceInterface(IActivityManager.descriptor);
631            IBinder b = data.readStrongBinder();
632            IApplicationThread app = ApplicationThreadNative.asInterface(b);
633            int resultCode = data.readInt();
634            Bundle results = data.readBundle();
635            finishInstrumentation(app, resultCode, results);
636            reply.writeNoException();
637            return true;
638        }
639
640        case GET_CONFIGURATION_TRANSACTION: {
641            data.enforceInterface(IActivityManager.descriptor);
642            Configuration config = getConfiguration();
643            reply.writeNoException();
644            config.writeToParcel(reply, 0);
645            return true;
646        }
647
648        case UPDATE_CONFIGURATION_TRANSACTION: {
649            data.enforceInterface(IActivityManager.descriptor);
650            Configuration config = Configuration.CREATOR.createFromParcel(data);
651            updateConfiguration(config);
652            reply.writeNoException();
653            return true;
654        }
655
656        case SET_REQUESTED_ORIENTATION_TRANSACTION: {
657            data.enforceInterface(IActivityManager.descriptor);
658            IBinder token = data.readStrongBinder();
659            int requestedOrientation = data.readInt();
660            setRequestedOrientation(token, requestedOrientation);
661            reply.writeNoException();
662            return true;
663        }
664
665        case GET_REQUESTED_ORIENTATION_TRANSACTION: {
666            data.enforceInterface(IActivityManager.descriptor);
667            IBinder token = data.readStrongBinder();
668            int req = getRequestedOrientation(token);
669            reply.writeNoException();
670            reply.writeInt(req);
671            return true;
672        }
673
674        case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION: {
675            data.enforceInterface(IActivityManager.descriptor);
676            IBinder token = data.readStrongBinder();
677            ComponentName cn = getActivityClassForToken(token);
678            reply.writeNoException();
679            ComponentName.writeToParcel(cn, reply);
680            return true;
681        }
682
683        case GET_PACKAGE_FOR_TOKEN_TRANSACTION: {
684            data.enforceInterface(IActivityManager.descriptor);
685            IBinder token = data.readStrongBinder();
686            reply.writeNoException();
687            reply.writeString(getPackageForToken(token));
688            return true;
689        }
690
691        case GET_INTENT_SENDER_TRANSACTION: {
692            data.enforceInterface(IActivityManager.descriptor);
693            int type = data.readInt();
694            String packageName = data.readString();
695            IBinder token = data.readStrongBinder();
696            String resultWho = data.readString();
697            int requestCode = data.readInt();
698            Intent requestIntent = data.readInt() != 0
699                    ? Intent.CREATOR.createFromParcel(data) : null;
700            String requestResolvedType = data.readString();
701            int fl = data.readInt();
702            IIntentSender res = getIntentSender(type, packageName, token,
703                    resultWho, requestCode, requestIntent,
704                    requestResolvedType, fl);
705            reply.writeNoException();
706            reply.writeStrongBinder(res != null ? res.asBinder() : null);
707            return true;
708        }
709
710        case CANCEL_INTENT_SENDER_TRANSACTION: {
711            data.enforceInterface(IActivityManager.descriptor);
712            IIntentSender r = IIntentSender.Stub.asInterface(
713                data.readStrongBinder());
714            cancelIntentSender(r);
715            reply.writeNoException();
716            return true;
717        }
718
719        case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION: {
720            data.enforceInterface(IActivityManager.descriptor);
721            IIntentSender r = IIntentSender.Stub.asInterface(
722                data.readStrongBinder());
723            String res = getPackageForIntentSender(r);
724            reply.writeNoException();
725            reply.writeString(res);
726            return true;
727        }
728
729        case SET_PROCESS_LIMIT_TRANSACTION: {
730            data.enforceInterface(IActivityManager.descriptor);
731            int max = data.readInt();
732            setProcessLimit(max);
733            reply.writeNoException();
734            return true;
735        }
736
737        case GET_PROCESS_LIMIT_TRANSACTION: {
738            data.enforceInterface(IActivityManager.descriptor);
739            int limit = getProcessLimit();
740            reply.writeNoException();
741            reply.writeInt(limit);
742            return true;
743        }
744
745        case SET_PROCESS_FOREGROUND_TRANSACTION: {
746            data.enforceInterface(IActivityManager.descriptor);
747            IBinder token = data.readStrongBinder();
748            int pid = data.readInt();
749            boolean isForeground = data.readInt() != 0;
750            setProcessForeground(token, pid, isForeground);
751            reply.writeNoException();
752            return true;
753        }
754
755        case CHECK_PERMISSION_TRANSACTION: {
756            data.enforceInterface(IActivityManager.descriptor);
757            String perm = data.readString();
758            int pid = data.readInt();
759            int uid = data.readInt();
760            int res = checkPermission(perm, pid, uid);
761            reply.writeNoException();
762            reply.writeInt(res);
763            return true;
764        }
765
766        case CHECK_URI_PERMISSION_TRANSACTION: {
767            data.enforceInterface(IActivityManager.descriptor);
768            Uri uri = Uri.CREATOR.createFromParcel(data);
769            int pid = data.readInt();
770            int uid = data.readInt();
771            int mode = data.readInt();
772            int res = checkUriPermission(uri, pid, uid, mode);
773            reply.writeNoException();
774            reply.writeInt(res);
775            return true;
776        }
777
778        case CLEAR_APP_DATA_TRANSACTION: {
779            data.enforceInterface(IActivityManager.descriptor);
780            String packageName = data.readString();
781            IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(
782                    data.readStrongBinder());
783            boolean res = clearApplicationUserData(packageName, observer);
784            reply.writeNoException();
785            reply.writeInt(res ? 1 : 0);
786            return true;
787        }
788
789        case GRANT_URI_PERMISSION_TRANSACTION: {
790            data.enforceInterface(IActivityManager.descriptor);
791            IBinder b = data.readStrongBinder();
792            IApplicationThread app = ApplicationThreadNative.asInterface(b);
793            String targetPkg = data.readString();
794            Uri uri = Uri.CREATOR.createFromParcel(data);
795            int mode = data.readInt();
796            grantUriPermission(app, targetPkg, uri, mode);
797            reply.writeNoException();
798            return true;
799        }
800
801        case REVOKE_URI_PERMISSION_TRANSACTION: {
802            data.enforceInterface(IActivityManager.descriptor);
803            IBinder b = data.readStrongBinder();
804            IApplicationThread app = ApplicationThreadNative.asInterface(b);
805            Uri uri = Uri.CREATOR.createFromParcel(data);
806            int mode = data.readInt();
807            revokeUriPermission(app, uri, mode);
808            reply.writeNoException();
809            return true;
810        }
811
812        case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: {
813            data.enforceInterface(IActivityManager.descriptor);
814            IBinder b = data.readStrongBinder();
815            IApplicationThread app = ApplicationThreadNative.asInterface(b);
816            boolean waiting = data.readInt() != 0;
817            showWaitingForDebugger(app, waiting);
818            reply.writeNoException();
819            return true;
820        }
821
822        case GET_MEMORY_INFO_TRANSACTION: {
823            data.enforceInterface(IActivityManager.descriptor);
824            ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
825            getMemoryInfo(mi);
826            reply.writeNoException();
827            mi.writeToParcel(reply, 0);
828            return true;
829        }
830
831        case UNHANDLED_BACK_TRANSACTION: {
832            data.enforceInterface(IActivityManager.descriptor);
833            unhandledBack();
834            reply.writeNoException();
835            return true;
836        }
837
838        case OPEN_CONTENT_URI_TRANSACTION: {
839            data.enforceInterface(IActivityManager.descriptor);
840            Uri uri = Uri.parse(data.readString());
841            ParcelFileDescriptor pfd = openContentUri(uri);
842            reply.writeNoException();
843            if (pfd != null) {
844                reply.writeInt(1);
845                pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
846            } else {
847                reply.writeInt(0);
848            }
849            return true;
850        }
851
852        case GOING_TO_SLEEP_TRANSACTION: {
853            data.enforceInterface(IActivityManager.descriptor);
854            goingToSleep();
855            reply.writeNoException();
856            return true;
857        }
858
859        case WAKING_UP_TRANSACTION: {
860            data.enforceInterface(IActivityManager.descriptor);
861            wakingUp();
862            reply.writeNoException();
863            return true;
864        }
865
866        case SET_DEBUG_APP_TRANSACTION: {
867            data.enforceInterface(IActivityManager.descriptor);
868            String pn = data.readString();
869            boolean wfd = data.readInt() != 0;
870            boolean per = data.readInt() != 0;
871            setDebugApp(pn, wfd, per);
872            reply.writeNoException();
873            return true;
874        }
875
876        case SET_ALWAYS_FINISH_TRANSACTION: {
877            data.enforceInterface(IActivityManager.descriptor);
878            boolean enabled = data.readInt() != 0;
879            setAlwaysFinish(enabled);
880            reply.writeNoException();
881            return true;
882        }
883
884        case SET_ACTIVITY_WATCHER_TRANSACTION: {
885            data.enforceInterface(IActivityManager.descriptor);
886            IActivityWatcher watcher = IActivityWatcher.Stub.asInterface(
887                    data.readStrongBinder());
888            setActivityWatcher(watcher);
889            return true;
890        }
891
892        case ENTER_SAFE_MODE_TRANSACTION: {
893            data.enforceInterface(IActivityManager.descriptor);
894            enterSafeMode();
895            reply.writeNoException();
896            return true;
897        }
898
899        case NOTE_WAKEUP_ALARM_TRANSACTION: {
900            data.enforceInterface(IActivityManager.descriptor);
901            IIntentSender is = IIntentSender.Stub.asInterface(
902                    data.readStrongBinder());
903            noteWakeupAlarm(is);
904            reply.writeNoException();
905            return true;
906        }
907
908        case KILL_PIDS_FOR_MEMORY_TRANSACTION: {
909            data.enforceInterface(IActivityManager.descriptor);
910            int[] pids = data.createIntArray();
911            boolean res = killPidsForMemory(pids);
912            reply.writeNoException();
913            reply.writeInt(res ? 1 : 0);
914            return true;
915        }
916
917        case REPORT_PSS_TRANSACTION: {
918            data.enforceInterface(IActivityManager.descriptor);
919            IBinder b = data.readStrongBinder();
920            IApplicationThread app = ApplicationThreadNative.asInterface(b);
921            int pss = data.readInt();
922            reportPss(app, pss);
923            reply.writeNoException();
924            return true;
925        }
926
927        case START_RUNNING_TRANSACTION: {
928            data.enforceInterface(IActivityManager.descriptor);
929            String pkg = data.readString();
930            String cls = data.readString();
931            String action = data.readString();
932            String indata = data.readString();
933            startRunning(pkg, cls, action, indata);
934            reply.writeNoException();
935            return true;
936        }
937
938        case SYSTEM_READY_TRANSACTION: {
939            data.enforceInterface(IActivityManager.descriptor);
940            systemReady();
941            reply.writeNoException();
942            return true;
943        }
944
945        case HANDLE_APPLICATION_ERROR_TRANSACTION: {
946            data.enforceInterface(IActivityManager.descriptor);
947            IBinder app = data.readStrongBinder();
948            int fl = data.readInt();
949            String tag = data.readString();
950            String shortMsg = data.readString();
951            String longMsg = data.readString();
952            byte[] crashData = data.createByteArray();
953            int res = handleApplicationError(app, fl, tag, shortMsg, longMsg,
954                    crashData);
955            reply.writeNoException();
956            reply.writeInt(res);
957            return true;
958        }
959
960        case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION: {
961            data.enforceInterface(IActivityManager.descriptor);
962            int sig = data.readInt();
963            signalPersistentProcesses(sig);
964            reply.writeNoException();
965            return true;
966        }
967
968        case RESTART_PACKAGE_TRANSACTION: {
969            data.enforceInterface(IActivityManager.descriptor);
970            String packageName = data.readString();
971            restartPackage(packageName);
972            reply.writeNoException();
973            return true;
974        }
975
976        case GET_DEVICE_CONFIGURATION_TRANSACTION: {
977            data.enforceInterface(IActivityManager.descriptor);
978            ConfigurationInfo config = getDeviceConfigurationInfo();
979            reply.writeNoException();
980            config.writeToParcel(reply, 0);
981            return true;
982        }
983
984        case PROFILE_CONTROL_TRANSACTION: {
985            data.enforceInterface(IActivityManager.descriptor);
986            String process = data.readString();
987            boolean start = data.readInt() != 0;
988            String path = data.readString();
989            ParcelFileDescriptor fd = data.readInt() != 0
990                    ? data.readFileDescriptor() : null;
991            boolean res = profileControl(process, start, path, fd);
992            reply.writeNoException();
993            reply.writeInt(res ? 1 : 0);
994            return true;
995        }
996
997        case SHUTDOWN_TRANSACTION: {
998            data.enforceInterface(IActivityManager.descriptor);
999            boolean res = shutdown(data.readInt());
1000            reply.writeNoException();
1001            reply.writeInt(res ? 1 : 0);
1002            return true;
1003        }
1004
1005        case STOP_APP_SWITCHES_TRANSACTION: {
1006            data.enforceInterface(IActivityManager.descriptor);
1007            stopAppSwitches();
1008            reply.writeNoException();
1009            return true;
1010        }
1011
1012        case RESUME_APP_SWITCHES_TRANSACTION: {
1013            data.enforceInterface(IActivityManager.descriptor);
1014            resumeAppSwitches();
1015            reply.writeNoException();
1016            return true;
1017        }
1018
1019        case PEEK_SERVICE_TRANSACTION: {
1020            data.enforceInterface(IActivityManager.descriptor);
1021            Intent service = Intent.CREATOR.createFromParcel(data);
1022            String resolvedType = data.readString();
1023            IBinder binder = peekService(service, resolvedType);
1024            reply.writeNoException();
1025            reply.writeStrongBinder(binder);
1026            return true;
1027        }
1028
1029        case START_BACKUP_AGENT_TRANSACTION: {
1030            data.enforceInterface(IActivityManager.descriptor);
1031            ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
1032            int backupRestoreMode = data.readInt();
1033            boolean success = bindBackupAgent(info, backupRestoreMode);
1034            reply.writeNoException();
1035            reply.writeInt(success ? 1 : 0);
1036            return true;
1037        }
1038
1039        case BACKUP_AGENT_CREATED_TRANSACTION: {
1040            data.enforceInterface(IActivityManager.descriptor);
1041            String packageName = data.readString();
1042            IBinder agent = data.readStrongBinder();
1043            backupAgentCreated(packageName, agent);
1044            reply.writeNoException();
1045            return true;
1046        }
1047
1048        case UNBIND_BACKUP_AGENT_TRANSACTION: {
1049            data.enforceInterface(IActivityManager.descriptor);
1050            ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
1051            unbindBackupAgent(info);
1052            reply.writeNoException();
1053            return true;
1054        }
1055        }
1056
1057        return super.onTransact(code, data, reply, flags);
1058    }
1059
1060    public IBinder asBinder()
1061    {
1062        return this;
1063    }
1064
1065    private static IActivityManager gDefault;
1066}
1067
1068class ActivityManagerProxy implements IActivityManager
1069{
1070    public ActivityManagerProxy(IBinder remote)
1071    {
1072        mRemote = remote;
1073    }
1074
1075    public IBinder asBinder()
1076    {
1077        return mRemote;
1078    }
1079
1080    public int startActivity(IApplicationThread caller, Intent intent,
1081            String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
1082            IBinder resultTo, String resultWho,
1083            int requestCode, boolean onlyIfNeeded,
1084            boolean debug) throws RemoteException {
1085        Parcel data = Parcel.obtain();
1086        Parcel reply = Parcel.obtain();
1087        data.writeInterfaceToken(IActivityManager.descriptor);
1088        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1089        intent.writeToParcel(data, 0);
1090        data.writeString(resolvedType);
1091        data.writeTypedArray(grantedUriPermissions, 0);
1092        data.writeInt(grantedMode);
1093        data.writeStrongBinder(resultTo);
1094        data.writeString(resultWho);
1095        data.writeInt(requestCode);
1096        data.writeInt(onlyIfNeeded ? 1 : 0);
1097        data.writeInt(debug ? 1 : 0);
1098        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
1099        reply.readException();
1100        int result = reply.readInt();
1101        reply.recycle();
1102        data.recycle();
1103        return result;
1104    }
1105    public boolean startNextMatchingActivity(IBinder callingActivity,
1106            Intent intent) throws RemoteException {
1107        Parcel data = Parcel.obtain();
1108        Parcel reply = Parcel.obtain();
1109        data.writeInterfaceToken(IActivityManager.descriptor);
1110        data.writeStrongBinder(callingActivity);
1111        intent.writeToParcel(data, 0);
1112        mRemote.transact(START_NEXT_MATCHING_ACTIVITY_TRANSACTION, data, reply, 0);
1113        reply.readException();
1114        int result = reply.readInt();
1115        reply.recycle();
1116        data.recycle();
1117        return result != 0;
1118    }
1119    public boolean finishActivity(IBinder token, int resultCode, Intent resultData)
1120            throws RemoteException {
1121        Parcel data = Parcel.obtain();
1122        Parcel reply = Parcel.obtain();
1123        data.writeInterfaceToken(IActivityManager.descriptor);
1124        data.writeStrongBinder(token);
1125        data.writeInt(resultCode);
1126        if (resultData != null) {
1127            data.writeInt(1);
1128            resultData.writeToParcel(data, 0);
1129        } else {
1130            data.writeInt(0);
1131        }
1132        mRemote.transact(FINISH_ACTIVITY_TRANSACTION, data, reply, 0);
1133        reply.readException();
1134        boolean res = reply.readInt() != 0;
1135        data.recycle();
1136        reply.recycle();
1137        return res;
1138    }
1139    public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException
1140    {
1141        Parcel data = Parcel.obtain();
1142        Parcel reply = Parcel.obtain();
1143        data.writeInterfaceToken(IActivityManager.descriptor);
1144        data.writeStrongBinder(token);
1145        data.writeString(resultWho);
1146        data.writeInt(requestCode);
1147        mRemote.transact(FINISH_SUB_ACTIVITY_TRANSACTION, data, reply, 0);
1148        reply.readException();
1149        data.recycle();
1150        reply.recycle();
1151    }
1152    public Intent registerReceiver(IApplicationThread caller,
1153            IIntentReceiver receiver,
1154            IntentFilter filter, String perm) throws RemoteException
1155    {
1156        Parcel data = Parcel.obtain();
1157        Parcel reply = Parcel.obtain();
1158        data.writeInterfaceToken(IActivityManager.descriptor);
1159        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1160        data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
1161        filter.writeToParcel(data, 0);
1162        data.writeString(perm);
1163        mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);
1164        reply.readException();
1165        Intent intent = null;
1166        int haveIntent = reply.readInt();
1167        if (haveIntent != 0) {
1168            intent = Intent.CREATOR.createFromParcel(reply);
1169        }
1170        reply.recycle();
1171        data.recycle();
1172        return intent;
1173    }
1174    public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException
1175    {
1176        Parcel data = Parcel.obtain();
1177        Parcel reply = Parcel.obtain();
1178        data.writeInterfaceToken(IActivityManager.descriptor);
1179        data.writeStrongBinder(receiver.asBinder());
1180        mRemote.transact(UNREGISTER_RECEIVER_TRANSACTION, data, reply, 0);
1181        reply.readException();
1182        data.recycle();
1183        reply.recycle();
1184    }
1185    public int broadcastIntent(IApplicationThread caller,
1186            Intent intent, String resolvedType,  IIntentReceiver resultTo,
1187            int resultCode, String resultData, Bundle map,
1188            String requiredPermission, boolean serialized,
1189            boolean sticky) throws RemoteException
1190    {
1191        Parcel data = Parcel.obtain();
1192        Parcel reply = Parcel.obtain();
1193        data.writeInterfaceToken(IActivityManager.descriptor);
1194        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1195        intent.writeToParcel(data, 0);
1196        data.writeString(resolvedType);
1197        data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);
1198        data.writeInt(resultCode);
1199        data.writeString(resultData);
1200        data.writeBundle(map);
1201        data.writeString(requiredPermission);
1202        data.writeInt(serialized ? 1 : 0);
1203        data.writeInt(sticky ? 1 : 0);
1204        mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
1205        reply.readException();
1206        int res = reply.readInt();
1207        reply.recycle();
1208        data.recycle();
1209        return res;
1210    }
1211    public void unbroadcastIntent(IApplicationThread caller, Intent intent) throws RemoteException
1212    {
1213        Parcel data = Parcel.obtain();
1214        Parcel reply = Parcel.obtain();
1215        data.writeInterfaceToken(IActivityManager.descriptor);
1216        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1217        intent.writeToParcel(data, 0);
1218        mRemote.transact(UNBROADCAST_INTENT_TRANSACTION, data, reply, 0);
1219        reply.readException();
1220        data.recycle();
1221        reply.recycle();
1222    }
1223    public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map, boolean abortBroadcast) throws RemoteException
1224    {
1225        Parcel data = Parcel.obtain();
1226        Parcel reply = Parcel.obtain();
1227        data.writeInterfaceToken(IActivityManager.descriptor);
1228        data.writeStrongBinder(who);
1229        data.writeInt(resultCode);
1230        data.writeString(resultData);
1231        data.writeBundle(map);
1232        data.writeInt(abortBroadcast ? 1 : 0);
1233        mRemote.transact(FINISH_RECEIVER_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1234        reply.readException();
1235        data.recycle();
1236        reply.recycle();
1237    }
1238    public void setPersistent(IBinder token, boolean isPersistent) throws RemoteException
1239    {
1240        Parcel data = Parcel.obtain();
1241        Parcel reply = Parcel.obtain();
1242        data.writeInterfaceToken(IActivityManager.descriptor);
1243        data.writeStrongBinder(token);
1244        data.writeInt(isPersistent ? 1 : 0);
1245        mRemote.transact(SET_PERSISTENT_TRANSACTION, data, reply, 0);
1246        reply.readException();
1247        data.recycle();
1248        reply.recycle();
1249    }
1250    public void attachApplication(IApplicationThread app) throws RemoteException
1251    {
1252        Parcel data = Parcel.obtain();
1253        Parcel reply = Parcel.obtain();
1254        data.writeInterfaceToken(IActivityManager.descriptor);
1255        data.writeStrongBinder(app.asBinder());
1256        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
1257        reply.readException();
1258        data.recycle();
1259        reply.recycle();
1260    }
1261    public void activityIdle(IBinder token) throws RemoteException
1262    {
1263        Parcel data = Parcel.obtain();
1264        Parcel reply = Parcel.obtain();
1265        data.writeInterfaceToken(IActivityManager.descriptor);
1266        data.writeStrongBinder(token);
1267        mRemote.transact(ACTIVITY_IDLE_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1268        reply.readException();
1269        data.recycle();
1270        reply.recycle();
1271    }
1272    public void activityPaused(IBinder token, Bundle state) throws RemoteException
1273    {
1274        Parcel data = Parcel.obtain();
1275        Parcel reply = Parcel.obtain();
1276        data.writeInterfaceToken(IActivityManager.descriptor);
1277        data.writeStrongBinder(token);
1278        data.writeBundle(state);
1279        mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
1280        reply.readException();
1281        data.recycle();
1282        reply.recycle();
1283    }
1284    public void activityStopped(IBinder token,
1285                                Bitmap thumbnail, CharSequence description) throws RemoteException
1286    {
1287        Parcel data = Parcel.obtain();
1288        Parcel reply = Parcel.obtain();
1289        data.writeInterfaceToken(IActivityManager.descriptor);
1290        data.writeStrongBinder(token);
1291        if (thumbnail != null) {
1292            data.writeInt(1);
1293            thumbnail.writeToParcel(data, 0);
1294        } else {
1295            data.writeInt(0);
1296        }
1297        TextUtils.writeToParcel(description, data, 0);
1298        mRemote.transact(ACTIVITY_STOPPED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1299        reply.readException();
1300        data.recycle();
1301        reply.recycle();
1302    }
1303    public void activityDestroyed(IBinder token) throws RemoteException
1304    {
1305        Parcel data = Parcel.obtain();
1306        Parcel reply = Parcel.obtain();
1307        data.writeInterfaceToken(IActivityManager.descriptor);
1308        data.writeStrongBinder(token);
1309        mRemote.transact(ACTIVITY_DESTROYED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1310        reply.readException();
1311        data.recycle();
1312        reply.recycle();
1313    }
1314    public String getCallingPackage(IBinder token) throws RemoteException
1315    {
1316        Parcel data = Parcel.obtain();
1317        Parcel reply = Parcel.obtain();
1318        data.writeInterfaceToken(IActivityManager.descriptor);
1319        data.writeStrongBinder(token);
1320        mRemote.transact(GET_CALLING_PACKAGE_TRANSACTION, data, reply, 0);
1321        reply.readException();
1322        String res = reply.readString();
1323        data.recycle();
1324        reply.recycle();
1325        return res;
1326    }
1327    public ComponentName getCallingActivity(IBinder token)
1328            throws RemoteException {
1329        Parcel data = Parcel.obtain();
1330        Parcel reply = Parcel.obtain();
1331        data.writeInterfaceToken(IActivityManager.descriptor);
1332        data.writeStrongBinder(token);
1333        mRemote.transact(GET_CALLING_ACTIVITY_TRANSACTION, data, reply, 0);
1334        reply.readException();
1335        ComponentName res = ComponentName.readFromParcel(reply);
1336        data.recycle();
1337        reply.recycle();
1338        return res;
1339    }
1340    public List getTasks(int maxNum, int flags,
1341            IThumbnailReceiver receiver) throws RemoteException {
1342        Parcel data = Parcel.obtain();
1343        Parcel reply = Parcel.obtain();
1344        data.writeInterfaceToken(IActivityManager.descriptor);
1345        data.writeInt(maxNum);
1346        data.writeInt(flags);
1347        data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
1348        mRemote.transact(GET_TASKS_TRANSACTION, data, reply, 0);
1349        reply.readException();
1350        ArrayList list = null;
1351        int N = reply.readInt();
1352        if (N >= 0) {
1353            list = new ArrayList();
1354            while (N > 0) {
1355                ActivityManager.RunningTaskInfo info =
1356                        ActivityManager.RunningTaskInfo.CREATOR
1357                        .createFromParcel(reply);
1358                list.add(info);
1359                N--;
1360            }
1361        }
1362        data.recycle();
1363        reply.recycle();
1364        return list;
1365    }
1366    public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
1367            int flags) throws RemoteException {
1368        Parcel data = Parcel.obtain();
1369        Parcel reply = Parcel.obtain();
1370        data.writeInterfaceToken(IActivityManager.descriptor);
1371        data.writeInt(maxNum);
1372        data.writeInt(flags);
1373        mRemote.transact(GET_RECENT_TASKS_TRANSACTION, data, reply, 0);
1374        reply.readException();
1375        ArrayList<ActivityManager.RecentTaskInfo> list
1376            = reply.createTypedArrayList(ActivityManager.RecentTaskInfo.CREATOR);
1377        data.recycle();
1378        reply.recycle();
1379        return list;
1380    }
1381    public List getServices(int maxNum, int flags) throws RemoteException {
1382        Parcel data = Parcel.obtain();
1383        Parcel reply = Parcel.obtain();
1384        data.writeInterfaceToken(IActivityManager.descriptor);
1385        data.writeInt(maxNum);
1386        data.writeInt(flags);
1387        mRemote.transact(GET_SERVICES_TRANSACTION, data, reply, 0);
1388        reply.readException();
1389        ArrayList list = null;
1390        int N = reply.readInt();
1391        if (N >= 0) {
1392            list = new ArrayList();
1393            while (N > 0) {
1394                ActivityManager.RunningServiceInfo info =
1395                        ActivityManager.RunningServiceInfo.CREATOR
1396                        .createFromParcel(reply);
1397                list.add(info);
1398                N--;
1399            }
1400        }
1401        data.recycle();
1402        reply.recycle();
1403        return list;
1404    }
1405    public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState()
1406            throws RemoteException {
1407        Parcel data = Parcel.obtain();
1408        Parcel reply = Parcel.obtain();
1409        data.writeInterfaceToken(IActivityManager.descriptor);
1410        mRemote.transact(GET_PROCESSES_IN_ERROR_STATE_TRANSACTION, data, reply, 0);
1411        reply.readException();
1412        ArrayList<ActivityManager.ProcessErrorStateInfo> list
1413            = reply.createTypedArrayList(ActivityManager.ProcessErrorStateInfo.CREATOR);
1414        data.recycle();
1415        reply.recycle();
1416        return list;
1417    }
1418    public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()
1419            throws RemoteException {
1420        Parcel data = Parcel.obtain();
1421        Parcel reply = Parcel.obtain();
1422        data.writeInterfaceToken(IActivityManager.descriptor);
1423        mRemote.transact(GET_RUNNING_APP_PROCESSES_TRANSACTION, data, reply, 0);
1424        reply.readException();
1425        ArrayList<ActivityManager.RunningAppProcessInfo> list
1426        = reply.createTypedArrayList(ActivityManager.RunningAppProcessInfo.CREATOR);
1427        data.recycle();
1428        reply.recycle();
1429        return list;
1430    }
1431    public void moveTaskToFront(int task) throws RemoteException
1432    {
1433        Parcel data = Parcel.obtain();
1434        Parcel reply = Parcel.obtain();
1435        data.writeInterfaceToken(IActivityManager.descriptor);
1436        data.writeInt(task);
1437        mRemote.transact(MOVE_TASK_TO_FRONT_TRANSACTION, data, reply, 0);
1438        reply.readException();
1439        data.recycle();
1440        reply.recycle();
1441    }
1442    public void moveTaskToBack(int task) throws RemoteException
1443    {
1444        Parcel data = Parcel.obtain();
1445        Parcel reply = Parcel.obtain();
1446        data.writeInterfaceToken(IActivityManager.descriptor);
1447        data.writeInt(task);
1448        mRemote.transact(MOVE_TASK_TO_BACK_TRANSACTION, data, reply, 0);
1449        reply.readException();
1450        data.recycle();
1451        reply.recycle();
1452    }
1453    public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot)
1454            throws RemoteException {
1455        Parcel data = Parcel.obtain();
1456        Parcel reply = Parcel.obtain();
1457        data.writeInterfaceToken(IActivityManager.descriptor);
1458        data.writeStrongBinder(token);
1459        data.writeInt(nonRoot ? 1 : 0);
1460        mRemote.transact(MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION, data, reply, 0);
1461        reply.readException();
1462        boolean res = reply.readInt() != 0;
1463        data.recycle();
1464        reply.recycle();
1465        return res;
1466    }
1467    public void moveTaskBackwards(int task) throws RemoteException
1468    {
1469        Parcel data = Parcel.obtain();
1470        Parcel reply = Parcel.obtain();
1471        data.writeInterfaceToken(IActivityManager.descriptor);
1472        data.writeInt(task);
1473        mRemote.transact(MOVE_TASK_BACKWARDS_TRANSACTION, data, reply, 0);
1474        reply.readException();
1475        data.recycle();
1476        reply.recycle();
1477    }
1478    public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException
1479    {
1480        Parcel data = Parcel.obtain();
1481        Parcel reply = Parcel.obtain();
1482        data.writeInterfaceToken(IActivityManager.descriptor);
1483        data.writeStrongBinder(token);
1484        data.writeInt(onlyRoot ? 1 : 0);
1485        mRemote.transact(GET_TASK_FOR_ACTIVITY_TRANSACTION, data, reply, 0);
1486        reply.readException();
1487        int res = reply.readInt();
1488        data.recycle();
1489        reply.recycle();
1490        return res;
1491    }
1492    public void finishOtherInstances(IBinder token, ComponentName className) throws RemoteException
1493    {
1494        Parcel data = Parcel.obtain();
1495        Parcel reply = Parcel.obtain();
1496        data.writeInterfaceToken(IActivityManager.descriptor);
1497        data.writeStrongBinder(token);
1498        ComponentName.writeToParcel(className, data);
1499        mRemote.transact(FINISH_OTHER_INSTANCES_TRANSACTION, data, reply, 0);
1500        reply.readException();
1501        data.recycle();
1502        reply.recycle();
1503    }
1504    public void reportThumbnail(IBinder token,
1505                                Bitmap thumbnail, CharSequence description) throws RemoteException
1506    {
1507        Parcel data = Parcel.obtain();
1508        Parcel reply = Parcel.obtain();
1509        data.writeInterfaceToken(IActivityManager.descriptor);
1510        data.writeStrongBinder(token);
1511        if (thumbnail != null) {
1512            data.writeInt(1);
1513            thumbnail.writeToParcel(data, 0);
1514        } else {
1515            data.writeInt(0);
1516        }
1517        TextUtils.writeToParcel(description, data, 0);
1518        mRemote.transact(REPORT_THUMBNAIL_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1519        reply.readException();
1520        data.recycle();
1521        reply.recycle();
1522    }
1523    public ContentProviderHolder getContentProvider(IApplicationThread caller,
1524                                                    String name) throws RemoteException
1525    {
1526        Parcel data = Parcel.obtain();
1527        Parcel reply = Parcel.obtain();
1528        data.writeInterfaceToken(IActivityManager.descriptor);
1529        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1530        data.writeString(name);
1531        mRemote.transact(GET_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
1532        reply.readException();
1533        int res = reply.readInt();
1534        ContentProviderHolder cph = null;
1535        if (res != 0) {
1536            cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
1537        }
1538        data.recycle();
1539        reply.recycle();
1540        return cph;
1541    }
1542    public void publishContentProviders(IApplicationThread caller,
1543                                        List<ContentProviderHolder> providers) throws RemoteException
1544    {
1545        Parcel data = Parcel.obtain();
1546        Parcel reply = Parcel.obtain();
1547        data.writeInterfaceToken(IActivityManager.descriptor);
1548        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1549        data.writeTypedList(providers);
1550        mRemote.transact(PUBLISH_CONTENT_PROVIDERS_TRANSACTION, data, reply, 0);
1551        reply.readException();
1552        data.recycle();
1553        reply.recycle();
1554    }
1555
1556    public void removeContentProvider(IApplicationThread caller,
1557            String name) throws RemoteException {
1558        Parcel data = Parcel.obtain();
1559        Parcel reply = Parcel.obtain();
1560        data.writeInterfaceToken(IActivityManager.descriptor);
1561        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1562        data.writeString(name);
1563        mRemote.transact(REMOVE_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
1564        reply.readException();
1565        data.recycle();
1566        reply.recycle();
1567    }
1568
1569    public ComponentName startService(IApplicationThread caller, Intent service,
1570            String resolvedType) throws RemoteException
1571    {
1572        Parcel data = Parcel.obtain();
1573        Parcel reply = Parcel.obtain();
1574        data.writeInterfaceToken(IActivityManager.descriptor);
1575        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1576        service.writeToParcel(data, 0);
1577        data.writeString(resolvedType);
1578        mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
1579        reply.readException();
1580        ComponentName res = ComponentName.readFromParcel(reply);
1581        data.recycle();
1582        reply.recycle();
1583        return res;
1584    }
1585    public int stopService(IApplicationThread caller, Intent service,
1586            String resolvedType) throws RemoteException
1587    {
1588        Parcel data = Parcel.obtain();
1589        Parcel reply = Parcel.obtain();
1590        data.writeInterfaceToken(IActivityManager.descriptor);
1591        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1592        service.writeToParcel(data, 0);
1593        data.writeString(resolvedType);
1594        mRemote.transact(STOP_SERVICE_TRANSACTION, data, reply, 0);
1595        reply.readException();
1596        int res = reply.readInt();
1597        reply.recycle();
1598        data.recycle();
1599        return res;
1600    }
1601    public boolean stopServiceToken(ComponentName className, IBinder token,
1602            int startId) throws RemoteException {
1603        Parcel data = Parcel.obtain();
1604        Parcel reply = Parcel.obtain();
1605        data.writeInterfaceToken(IActivityManager.descriptor);
1606        ComponentName.writeToParcel(className, data);
1607        data.writeStrongBinder(token);
1608        data.writeInt(startId);
1609        mRemote.transact(STOP_SERVICE_TOKEN_TRANSACTION, data, reply, 0);
1610        reply.readException();
1611        boolean res = reply.readInt() != 0;
1612        data.recycle();
1613        reply.recycle();
1614        return res;
1615    }
1616    public void setServiceForeground(ComponentName className, IBinder token,
1617            boolean isForeground) throws RemoteException {
1618        Parcel data = Parcel.obtain();
1619        Parcel reply = Parcel.obtain();
1620        data.writeInterfaceToken(IActivityManager.descriptor);
1621        ComponentName.writeToParcel(className, data);
1622        data.writeStrongBinder(token);
1623        data.writeInt(isForeground ? 1 : 0);
1624        mRemote.transact(SET_SERVICE_FOREGROUND_TRANSACTION, data, reply, 0);
1625        reply.readException();
1626        data.recycle();
1627        reply.recycle();
1628    }
1629    public int bindService(IApplicationThread caller, IBinder token,
1630            Intent service, String resolvedType, IServiceConnection connection,
1631            int flags) throws RemoteException {
1632        Parcel data = Parcel.obtain();
1633        Parcel reply = Parcel.obtain();
1634        data.writeInterfaceToken(IActivityManager.descriptor);
1635        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
1636        data.writeStrongBinder(token);
1637        service.writeToParcel(data, 0);
1638        data.writeString(resolvedType);
1639        data.writeStrongBinder(connection.asBinder());
1640        data.writeInt(flags);
1641        mRemote.transact(BIND_SERVICE_TRANSACTION, data, reply, 0);
1642        reply.readException();
1643        int res = reply.readInt();
1644        data.recycle();
1645        reply.recycle();
1646        return res;
1647    }
1648    public boolean unbindService(IServiceConnection connection) throws RemoteException
1649    {
1650        Parcel data = Parcel.obtain();
1651        Parcel reply = Parcel.obtain();
1652        data.writeInterfaceToken(IActivityManager.descriptor);
1653        data.writeStrongBinder(connection.asBinder());
1654        mRemote.transact(UNBIND_SERVICE_TRANSACTION, data, reply, 0);
1655        reply.readException();
1656        boolean res = reply.readInt() != 0;
1657        data.recycle();
1658        reply.recycle();
1659        return res;
1660    }
1661
1662    public void publishService(IBinder token,
1663            Intent intent, IBinder service) throws RemoteException {
1664        Parcel data = Parcel.obtain();
1665        Parcel reply = Parcel.obtain();
1666        data.writeInterfaceToken(IActivityManager.descriptor);
1667        data.writeStrongBinder(token);
1668        intent.writeToParcel(data, 0);
1669        data.writeStrongBinder(service);
1670        mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);
1671        reply.readException();
1672        data.recycle();
1673        reply.recycle();
1674    }
1675
1676    public void unbindFinished(IBinder token, Intent intent, boolean doRebind)
1677            throws RemoteException {
1678        Parcel data = Parcel.obtain();
1679        Parcel reply = Parcel.obtain();
1680        data.writeInterfaceToken(IActivityManager.descriptor);
1681        data.writeStrongBinder(token);
1682        intent.writeToParcel(data, 0);
1683        data.writeInt(doRebind ? 1 : 0);
1684        mRemote.transact(UNBIND_FINISHED_TRANSACTION, data, reply, 0);
1685        reply.readException();
1686        data.recycle();
1687        reply.recycle();
1688    }
1689
1690    public void serviceDoneExecuting(IBinder token) throws RemoteException {
1691        Parcel data = Parcel.obtain();
1692        Parcel reply = Parcel.obtain();
1693        data.writeInterfaceToken(IActivityManager.descriptor);
1694        data.writeStrongBinder(token);
1695        mRemote.transact(SERVICE_DONE_EXECUTING_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
1696        reply.readException();
1697        data.recycle();
1698        reply.recycle();
1699    }
1700
1701    public IBinder peekService(Intent service, String resolvedType) throws RemoteException {
1702        Parcel data = Parcel.obtain();
1703        Parcel reply = Parcel.obtain();
1704        data.writeInterfaceToken(IActivityManager.descriptor);
1705        service.writeToParcel(data, 0);
1706        data.writeString(resolvedType);
1707        mRemote.transact(PEEK_SERVICE_TRANSACTION, data, reply, 0);
1708        reply.readException();
1709        IBinder binder = reply.readStrongBinder();
1710        reply.recycle();
1711        data.recycle();
1712        return binder;
1713    }
1714
1715    public boolean bindBackupAgent(ApplicationInfo app, int backupRestoreMode)
1716            throws RemoteException {
1717        Parcel data = Parcel.obtain();
1718        Parcel reply = Parcel.obtain();
1719        data.writeInterfaceToken(IActivityManager.descriptor);
1720        app.writeToParcel(data, 0);
1721        data.writeInt(backupRestoreMode);
1722        mRemote.transact(START_BACKUP_AGENT_TRANSACTION, data, reply, 0);
1723        reply.readException();
1724        boolean success = reply.readInt() != 0;
1725        reply.recycle();
1726        data.recycle();
1727        return success;
1728    }
1729
1730    public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException {
1731        Parcel data = Parcel.obtain();
1732        Parcel reply = Parcel.obtain();
1733        data.writeInterfaceToken(IActivityManager.descriptor);
1734        data.writeString(packageName);
1735        data.writeStrongBinder(agent);
1736        mRemote.transact(BACKUP_AGENT_CREATED_TRANSACTION, data, reply, 0);
1737        reply.recycle();
1738        data.recycle();
1739    }
1740
1741    public void unbindBackupAgent(ApplicationInfo app) throws RemoteException {
1742        Parcel data = Parcel.obtain();
1743        Parcel reply = Parcel.obtain();
1744        data.writeInterfaceToken(IActivityManager.descriptor);
1745        app.writeToParcel(data, 0);
1746        mRemote.transact(UNBIND_BACKUP_AGENT_TRANSACTION, data, reply, 0);
1747        reply.readException();
1748        reply.recycle();
1749        data.recycle();
1750    }
1751
1752    public boolean startInstrumentation(ComponentName className, String profileFile,
1753            int flags, Bundle arguments, IInstrumentationWatcher watcher)
1754            throws RemoteException {
1755        Parcel data = Parcel.obtain();
1756        Parcel reply = Parcel.obtain();
1757        data.writeInterfaceToken(IActivityManager.descriptor);
1758        ComponentName.writeToParcel(className, data);
1759        data.writeString(profileFile);
1760        data.writeInt(flags);
1761        data.writeBundle(arguments);
1762        data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
1763        mRemote.transact(START_INSTRUMENTATION_TRANSACTION, data, reply, 0);
1764        reply.readException();
1765        boolean res = reply.readInt() != 0;
1766        reply.recycle();
1767        data.recycle();
1768        return res;
1769    }
1770
1771    public void finishInstrumentation(IApplicationThread target,
1772            int resultCode, Bundle results) throws RemoteException {
1773        Parcel data = Parcel.obtain();
1774        Parcel reply = Parcel.obtain();
1775        data.writeInterfaceToken(IActivityManager.descriptor);
1776        data.writeStrongBinder(target != null ? target.asBinder() : null);
1777        data.writeInt(resultCode);
1778        data.writeBundle(results);
1779        mRemote.transact(FINISH_INSTRUMENTATION_TRANSACTION, data, reply, 0);
1780        reply.readException();
1781        data.recycle();
1782        reply.recycle();
1783    }
1784    public Configuration getConfiguration() throws RemoteException
1785    {
1786        Parcel data = Parcel.obtain();
1787        Parcel reply = Parcel.obtain();
1788        data.writeInterfaceToken(IActivityManager.descriptor);
1789        mRemote.transact(GET_CONFIGURATION_TRANSACTION, data, reply, 0);
1790        reply.readException();
1791        Configuration res = Configuration.CREATOR.createFromParcel(reply);
1792        reply.recycle();
1793        data.recycle();
1794        return res;
1795    }
1796    public void updateConfiguration(Configuration values) throws RemoteException
1797    {
1798        Parcel data = Parcel.obtain();
1799        Parcel reply = Parcel.obtain();
1800        data.writeInterfaceToken(IActivityManager.descriptor);
1801        values.writeToParcel(data, 0);
1802        mRemote.transact(UPDATE_CONFIGURATION_TRANSACTION, data, reply, 0);
1803        reply.readException();
1804        data.recycle();
1805        reply.recycle();
1806    }
1807    public void setRequestedOrientation(IBinder token, int requestedOrientation)
1808            throws RemoteException {
1809        Parcel data = Parcel.obtain();
1810        Parcel reply = Parcel.obtain();
1811        data.writeInterfaceToken(IActivityManager.descriptor);
1812        data.writeStrongBinder(token);
1813        data.writeInt(requestedOrientation);
1814        mRemote.transact(SET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
1815        reply.readException();
1816        data.recycle();
1817        reply.recycle();
1818    }
1819    public int getRequestedOrientation(IBinder token) throws RemoteException {
1820        Parcel data = Parcel.obtain();
1821        Parcel reply = Parcel.obtain();
1822        data.writeInterfaceToken(IActivityManager.descriptor);
1823        data.writeStrongBinder(token);
1824        mRemote.transact(GET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
1825        reply.readException();
1826        int res = reply.readInt();
1827        data.recycle();
1828        reply.recycle();
1829        return res;
1830    }
1831    public ComponentName getActivityClassForToken(IBinder token)
1832            throws RemoteException {
1833        Parcel data = Parcel.obtain();
1834        Parcel reply = Parcel.obtain();
1835        data.writeInterfaceToken(IActivityManager.descriptor);
1836        data.writeStrongBinder(token);
1837        mRemote.transact(GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION, data, reply, 0);
1838        reply.readException();
1839        ComponentName res = ComponentName.readFromParcel(reply);
1840        data.recycle();
1841        reply.recycle();
1842        return res;
1843    }
1844    public String getPackageForToken(IBinder token) throws RemoteException
1845    {
1846        Parcel data = Parcel.obtain();
1847        Parcel reply = Parcel.obtain();
1848        data.writeInterfaceToken(IActivityManager.descriptor);
1849        data.writeStrongBinder(token);
1850        mRemote.transact(GET_PACKAGE_FOR_TOKEN_TRANSACTION, data, reply, 0);
1851        reply.readException();
1852        String res = reply.readString();
1853        data.recycle();
1854        reply.recycle();
1855        return res;
1856    }
1857    public IIntentSender getIntentSender(int type,
1858            String packageName, IBinder token, String resultWho,
1859            int requestCode, Intent intent, String resolvedType, int flags)
1860            throws RemoteException {
1861        Parcel data = Parcel.obtain();
1862        Parcel reply = Parcel.obtain();
1863        data.writeInterfaceToken(IActivityManager.descriptor);
1864        data.writeInt(type);
1865        data.writeString(packageName);
1866        data.writeStrongBinder(token);
1867        data.writeString(resultWho);
1868        data.writeInt(requestCode);
1869        if (intent != null) {
1870            data.writeInt(1);
1871            intent.writeToParcel(data, 0);
1872        } else {
1873            data.writeInt(0);
1874        }
1875        data.writeString(resolvedType);
1876        data.writeInt(flags);
1877        mRemote.transact(GET_INTENT_SENDER_TRANSACTION, data, reply, 0);
1878        reply.readException();
1879        IIntentSender res = IIntentSender.Stub.asInterface(
1880            reply.readStrongBinder());
1881        data.recycle();
1882        reply.recycle();
1883        return res;
1884    }
1885    public void cancelIntentSender(IIntentSender sender) throws RemoteException {
1886        Parcel data = Parcel.obtain();
1887        Parcel reply = Parcel.obtain();
1888        data.writeInterfaceToken(IActivityManager.descriptor);
1889        data.writeStrongBinder(sender.asBinder());
1890        mRemote.transact(CANCEL_INTENT_SENDER_TRANSACTION, data, reply, 0);
1891        reply.readException();
1892        data.recycle();
1893        reply.recycle();
1894    }
1895    public String getPackageForIntentSender(IIntentSender sender) throws RemoteException {
1896        Parcel data = Parcel.obtain();
1897        Parcel reply = Parcel.obtain();
1898        data.writeInterfaceToken(IActivityManager.descriptor);
1899        data.writeStrongBinder(sender.asBinder());
1900        mRemote.transact(GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
1901        reply.readException();
1902        String res = reply.readString();
1903        data.recycle();
1904        reply.recycle();
1905        return res;
1906    }
1907    public void setProcessLimit(int max) throws RemoteException
1908    {
1909        Parcel data = Parcel.obtain();
1910        Parcel reply = Parcel.obtain();
1911        data.writeInterfaceToken(IActivityManager.descriptor);
1912        data.writeInt(max);
1913        mRemote.transact(SET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
1914        reply.readException();
1915        data.recycle();
1916        reply.recycle();
1917    }
1918    public int getProcessLimit() throws RemoteException
1919    {
1920        Parcel data = Parcel.obtain();
1921        Parcel reply = Parcel.obtain();
1922        data.writeInterfaceToken(IActivityManager.descriptor);
1923        mRemote.transact(GET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
1924        reply.readException();
1925        int res = reply.readInt();
1926        data.recycle();
1927        reply.recycle();
1928        return res;
1929    }
1930    public void setProcessForeground(IBinder token, int pid,
1931            boolean isForeground) throws RemoteException {
1932        Parcel data = Parcel.obtain();
1933        Parcel reply = Parcel.obtain();
1934        data.writeInterfaceToken(IActivityManager.descriptor);
1935        data.writeStrongBinder(token);
1936        data.writeInt(pid);
1937        data.writeInt(isForeground ? 1 : 0);
1938        mRemote.transact(SET_PROCESS_FOREGROUND_TRANSACTION, data, reply, 0);
1939        reply.readException();
1940        data.recycle();
1941        reply.recycle();
1942    }
1943    public int checkPermission(String permission, int pid, int uid)
1944            throws RemoteException {
1945        Parcel data = Parcel.obtain();
1946        Parcel reply = Parcel.obtain();
1947        data.writeInterfaceToken(IActivityManager.descriptor);
1948        data.writeString(permission);
1949        data.writeInt(pid);
1950        data.writeInt(uid);
1951        mRemote.transact(CHECK_PERMISSION_TRANSACTION, data, reply, 0);
1952        reply.readException();
1953        int res = reply.readInt();
1954        data.recycle();
1955        reply.recycle();
1956        return res;
1957    }
1958    public boolean clearApplicationUserData(final String packageName,
1959            final IPackageDataObserver observer) throws RemoteException {
1960        Parcel data = Parcel.obtain();
1961        Parcel reply = Parcel.obtain();
1962        data.writeInterfaceToken(IActivityManager.descriptor);
1963        data.writeString(packageName);
1964        data.writeStrongBinder(observer.asBinder());
1965        mRemote.transact(CLEAR_APP_DATA_TRANSACTION, data, reply, 0);
1966        reply.readException();
1967        boolean res = reply.readInt() != 0;
1968        data.recycle();
1969        reply.recycle();
1970        return res;
1971    }
1972    public int checkUriPermission(Uri uri, int pid, int uid, int mode)
1973            throws RemoteException {
1974        Parcel data = Parcel.obtain();
1975        Parcel reply = Parcel.obtain();
1976        data.writeInterfaceToken(IActivityManager.descriptor);
1977        uri.writeToParcel(data, 0);
1978        data.writeInt(pid);
1979        data.writeInt(uid);
1980        data.writeInt(mode);
1981        mRemote.transact(CHECK_URI_PERMISSION_TRANSACTION, data, reply, 0);
1982        reply.readException();
1983        int res = reply.readInt();
1984        data.recycle();
1985        reply.recycle();
1986        return res;
1987    }
1988    public void grantUriPermission(IApplicationThread caller, String targetPkg,
1989            Uri uri, int mode) throws RemoteException {
1990        Parcel data = Parcel.obtain();
1991        Parcel reply = Parcel.obtain();
1992        data.writeInterfaceToken(IActivityManager.descriptor);
1993        data.writeStrongBinder(caller.asBinder());
1994        data.writeString(targetPkg);
1995        uri.writeToParcel(data, 0);
1996        data.writeInt(mode);
1997        mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
1998        reply.readException();
1999        data.recycle();
2000        reply.recycle();
2001    }
2002    public void revokeUriPermission(IApplicationThread caller, Uri uri,
2003            int mode) throws RemoteException {
2004        Parcel data = Parcel.obtain();
2005        Parcel reply = Parcel.obtain();
2006        data.writeInterfaceToken(IActivityManager.descriptor);
2007        data.writeStrongBinder(caller.asBinder());
2008        uri.writeToParcel(data, 0);
2009        data.writeInt(mode);
2010        mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
2011        reply.readException();
2012        data.recycle();
2013        reply.recycle();
2014    }
2015    public void showWaitingForDebugger(IApplicationThread who, boolean waiting)
2016            throws RemoteException {
2017        Parcel data = Parcel.obtain();
2018        Parcel reply = Parcel.obtain();
2019        data.writeInterfaceToken(IActivityManager.descriptor);
2020        data.writeStrongBinder(who.asBinder());
2021        data.writeInt(waiting ? 1 : 0);
2022        mRemote.transact(SHOW_WAITING_FOR_DEBUGGER_TRANSACTION, data, reply, 0);
2023        reply.readException();
2024        data.recycle();
2025        reply.recycle();
2026    }
2027    public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException {
2028        Parcel data = Parcel.obtain();
2029        Parcel reply = Parcel.obtain();
2030        data.writeInterfaceToken(IActivityManager.descriptor);
2031        mRemote.transact(GET_MEMORY_INFO_TRANSACTION, data, reply, 0);
2032        reply.readException();
2033        outInfo.readFromParcel(reply);
2034        data.recycle();
2035        reply.recycle();
2036    }
2037    public void unhandledBack() throws RemoteException
2038    {
2039        Parcel data = Parcel.obtain();
2040        Parcel reply = Parcel.obtain();
2041        data.writeInterfaceToken(IActivityManager.descriptor);
2042        mRemote.transact(UNHANDLED_BACK_TRANSACTION, data, reply, 0);
2043        reply.readException();
2044        data.recycle();
2045        reply.recycle();
2046    }
2047    public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException
2048    {
2049        Parcel data = Parcel.obtain();
2050        Parcel reply = Parcel.obtain();
2051        data.writeInterfaceToken(IActivityManager.descriptor);
2052        mRemote.transact(OPEN_CONTENT_URI_TRANSACTION, data, reply, 0);
2053        reply.readException();
2054        ParcelFileDescriptor pfd = null;
2055        if (reply.readInt() != 0) {
2056            pfd = ParcelFileDescriptor.CREATOR.createFromParcel(reply);
2057        }
2058        data.recycle();
2059        reply.recycle();
2060        return pfd;
2061    }
2062    public void goingToSleep() throws RemoteException
2063    {
2064        Parcel data = Parcel.obtain();
2065        Parcel reply = Parcel.obtain();
2066        data.writeInterfaceToken(IActivityManager.descriptor);
2067        mRemote.transact(GOING_TO_SLEEP_TRANSACTION, data, reply, 0);
2068        reply.readException();
2069        data.recycle();
2070        reply.recycle();
2071    }
2072    public void wakingUp() throws RemoteException
2073    {
2074        Parcel data = Parcel.obtain();
2075        Parcel reply = Parcel.obtain();
2076        data.writeInterfaceToken(IActivityManager.descriptor);
2077        mRemote.transact(WAKING_UP_TRANSACTION, data, reply, 0);
2078        reply.readException();
2079        data.recycle();
2080        reply.recycle();
2081    }
2082    public void setDebugApp(
2083        String packageName, boolean waitForDebugger, boolean persistent)
2084        throws RemoteException
2085    {
2086        Parcel data = Parcel.obtain();
2087        Parcel reply = Parcel.obtain();
2088        data.writeInterfaceToken(IActivityManager.descriptor);
2089        data.writeString(packageName);
2090        data.writeInt(waitForDebugger ? 1 : 0);
2091        data.writeInt(persistent ? 1 : 0);
2092        mRemote.transact(SET_DEBUG_APP_TRANSACTION, data, reply, 0);
2093        reply.readException();
2094        data.recycle();
2095        reply.recycle();
2096    }
2097    public void setAlwaysFinish(boolean enabled) throws RemoteException
2098    {
2099        Parcel data = Parcel.obtain();
2100        Parcel reply = Parcel.obtain();
2101        data.writeInterfaceToken(IActivityManager.descriptor);
2102        data.writeInt(enabled ? 1 : 0);
2103        mRemote.transact(SET_ALWAYS_FINISH_TRANSACTION, data, reply, 0);
2104        reply.readException();
2105        data.recycle();
2106        reply.recycle();
2107    }
2108    public void setActivityWatcher(IActivityWatcher watcher) throws RemoteException
2109    {
2110        Parcel data = Parcel.obtain();
2111        Parcel reply = Parcel.obtain();
2112        data.writeInterfaceToken(IActivityManager.descriptor);
2113        data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
2114        mRemote.transact(SET_ACTIVITY_WATCHER_TRANSACTION, data, reply, 0);
2115        reply.readException();
2116        data.recycle();
2117        reply.recycle();
2118    }
2119    public void enterSafeMode() throws RemoteException {
2120        Parcel data = Parcel.obtain();
2121        data.writeInterfaceToken(IActivityManager.descriptor);
2122        mRemote.transact(ENTER_SAFE_MODE_TRANSACTION, data, null, 0);
2123        data.recycle();
2124    }
2125    public void noteWakeupAlarm(IIntentSender sender) throws RemoteException {
2126        Parcel data = Parcel.obtain();
2127        data.writeStrongBinder(sender.asBinder());
2128        data.writeInterfaceToken(IActivityManager.descriptor);
2129        mRemote.transact(NOTE_WAKEUP_ALARM_TRANSACTION, data, null, 0);
2130        data.recycle();
2131    }
2132    public boolean killPidsForMemory(int[] pids) throws RemoteException {
2133        Parcel data = Parcel.obtain();
2134        Parcel reply = Parcel.obtain();
2135        data.writeInterfaceToken(IActivityManager.descriptor);
2136        data.writeIntArray(pids);
2137        mRemote.transact(KILL_PIDS_FOR_MEMORY_TRANSACTION, data, reply, 0);
2138        boolean res = reply.readInt() != 0;
2139        data.recycle();
2140        reply.recycle();
2141        return res;
2142    }
2143    public void reportPss(IApplicationThread caller, int pss) throws RemoteException {
2144        Parcel data = Parcel.obtain();
2145        data.writeInterfaceToken(IActivityManager.descriptor);
2146        data.writeStrongBinder(caller.asBinder());
2147        data.writeInt(pss);
2148        mRemote.transact(REPORT_PSS_TRANSACTION, data, null, 0);
2149        data.recycle();
2150    }
2151    public void startRunning(String pkg, String cls, String action,
2152            String indata) throws RemoteException {
2153        Parcel data = Parcel.obtain();
2154        Parcel reply = Parcel.obtain();
2155        data.writeInterfaceToken(IActivityManager.descriptor);
2156        data.writeString(pkg);
2157        data.writeString(cls);
2158        data.writeString(action);
2159        data.writeString(indata);
2160        mRemote.transact(START_RUNNING_TRANSACTION, data, reply, 0);
2161        reply.readException();
2162        data.recycle();
2163        reply.recycle();
2164    }
2165    public void systemReady() throws RemoteException
2166    {
2167        Parcel data = Parcel.obtain();
2168        Parcel reply = Parcel.obtain();
2169        data.writeInterfaceToken(IActivityManager.descriptor);
2170        mRemote.transact(SYSTEM_READY_TRANSACTION, data, reply, 0);
2171        reply.readException();
2172        data.recycle();
2173        reply.recycle();
2174    }
2175    public boolean testIsSystemReady()
2176    {
2177        /* this base class version is never called */
2178        return true;
2179    }
2180    public int handleApplicationError(IBinder app, int flags,
2181            String tag, String shortMsg, String longMsg,
2182            byte[] crashData) throws RemoteException
2183    {
2184        Parcel data = Parcel.obtain();
2185        Parcel reply = Parcel.obtain();
2186        data.writeInterfaceToken(IActivityManager.descriptor);
2187        data.writeStrongBinder(app);
2188        data.writeInt(flags);
2189        data.writeString(tag);
2190        data.writeString(shortMsg);
2191        data.writeString(longMsg);
2192        data.writeByteArray(crashData);
2193        mRemote.transact(HANDLE_APPLICATION_ERROR_TRANSACTION, data, reply, 0);
2194        reply.readException();
2195        int res = reply.readInt();
2196        reply.recycle();
2197        data.recycle();
2198        return res;
2199    }
2200
2201    public void signalPersistentProcesses(int sig) throws RemoteException {
2202        Parcel data = Parcel.obtain();
2203        Parcel reply = Parcel.obtain();
2204        data.writeInterfaceToken(IActivityManager.descriptor);
2205        data.writeInt(sig);
2206        mRemote.transact(SIGNAL_PERSISTENT_PROCESSES_TRANSACTION, data, reply, 0);
2207        reply.readException();
2208        data.recycle();
2209        reply.recycle();
2210    }
2211
2212    public void restartPackage(String packageName) throws RemoteException {
2213        Parcel data = Parcel.obtain();
2214        Parcel reply = Parcel.obtain();
2215        data.writeInterfaceToken(IActivityManager.descriptor);
2216        data.writeString(packageName);
2217        mRemote.transact(RESTART_PACKAGE_TRANSACTION, data, reply, 0);
2218        reply.readException();
2219        data.recycle();
2220        reply.recycle();
2221    }
2222
2223    public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException
2224    {
2225        Parcel data = Parcel.obtain();
2226        Parcel reply = Parcel.obtain();
2227        data.writeInterfaceToken(IActivityManager.descriptor);
2228        mRemote.transact(GET_DEVICE_CONFIGURATION_TRANSACTION, data, reply, 0);
2229        reply.readException();
2230        ConfigurationInfo res = ConfigurationInfo.CREATOR.createFromParcel(reply);
2231        reply.recycle();
2232        data.recycle();
2233        return res;
2234    }
2235
2236    public boolean profileControl(String process, boolean start,
2237            String path, ParcelFileDescriptor fd) throws RemoteException
2238    {
2239        Parcel data = Parcel.obtain();
2240        Parcel reply = Parcel.obtain();
2241        data.writeInterfaceToken(IActivityManager.descriptor);
2242        data.writeString(process);
2243        data.writeInt(start ? 1 : 0);
2244        data.writeString(path);
2245        if (fd != null) {
2246            data.writeInt(1);
2247            fd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
2248        } else {
2249            data.writeInt(0);
2250        }
2251        mRemote.transact(PROFILE_CONTROL_TRANSACTION, data, reply, 0);
2252        reply.readException();
2253        boolean res = reply.readInt() != 0;
2254        reply.recycle();
2255        data.recycle();
2256        return res;
2257    }
2258
2259    public boolean shutdown(int timeout) throws RemoteException
2260    {
2261        Parcel data = Parcel.obtain();
2262        Parcel reply = Parcel.obtain();
2263        data.writeInterfaceToken(IActivityManager.descriptor);
2264        data.writeInt(timeout);
2265        mRemote.transact(SHUTDOWN_TRANSACTION, data, reply, 0);
2266        reply.readException();
2267        boolean res = reply.readInt() != 0;
2268        reply.recycle();
2269        data.recycle();
2270        return res;
2271    }
2272
2273    public void stopAppSwitches() throws RemoteException {
2274        Parcel data = Parcel.obtain();
2275        Parcel reply = Parcel.obtain();
2276        data.writeInterfaceToken(IActivityManager.descriptor);
2277        mRemote.transact(STOP_APP_SWITCHES_TRANSACTION, data, reply, 0);
2278        reply.readException();
2279        reply.recycle();
2280        data.recycle();
2281    }
2282
2283    public void resumeAppSwitches() throws RemoteException {
2284        Parcel data = Parcel.obtain();
2285        Parcel reply = Parcel.obtain();
2286        data.writeInterfaceToken(IActivityManager.descriptor);
2287        mRemote.transact(RESUME_APP_SWITCHES_TRANSACTION, data, reply, 0);
2288        reply.readException();
2289        reply.recycle();
2290        data.recycle();
2291    }
2292
2293    private IBinder mRemote;
2294}
2295