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