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