auto import from //depot/cupcake/@135843
diff --git a/core/java/android/app/ActivityManagerNative.java b/core/java/android/app/ActivityManagerNative.java
new file mode 100644
index 0000000..f11dbec
--- /dev/null
+++ b/core/java/android/app/ActivityManagerNative.java
@@ -0,0 +1,2135 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.app;
+
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ConfigurationInfo;
+import android.content.pm.IPackageDataObserver;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.ServiceManager;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+import java.io.FileNotFoundException;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/** {@hide} */
+public abstract class ActivityManagerNative extends Binder implements IActivityManager
+{
+ /**
+ * Cast a Binder object into an activity manager interface, generating
+ * a proxy if needed.
+ */
+ static public IActivityManager asInterface(IBinder obj)
+ {
+ if (obj == null) {
+ return null;
+ }
+ IActivityManager in =
+ (IActivityManager)obj.queryLocalInterface(descriptor);
+ if (in != null) {
+ return in;
+ }
+
+ return new ActivityManagerProxy(obj);
+ }
+
+ /**
+ * Retrieve the system's default/global activity manager.
+ */
+ static public IActivityManager getDefault()
+ {
+ if (gDefault != null) {
+ //if (Config.LOGV) Log.v(
+ // "ActivityManager", "returning cur default = " + gDefault);
+ return gDefault;
+ }
+ IBinder b = ServiceManager.getService("activity");
+ if (Config.LOGV) Log.v(
+ "ActivityManager", "default service binder = " + b);
+ gDefault = asInterface(b);
+ if (Config.LOGV) Log.v(
+ "ActivityManager", "default service = " + gDefault);
+ return gDefault;
+ }
+
+ /**
+ * Convenience for checking whether the system is ready. For internal use only.
+ */
+ static public boolean isSystemReady() {
+ if (!sSystemReady) {
+ sSystemReady = getDefault().testIsSystemReady();
+ }
+ return sSystemReady;
+ }
+ static boolean sSystemReady = false;
+
+ /**
+ * Convenience for sending a sticky broadcast. For internal use only.
+ * If you don't care about permission, use null.
+ */
+ static public void broadcastStickyIntent(Intent intent, String permission)
+ {
+ try {
+ getDefault().broadcastIntent(
+ null, intent, null, null, Activity.RESULT_OK, null, null,
+ null /*permission*/, false, true);
+ } catch (RemoteException ex) {
+ }
+ }
+
+ static public void noteWakeupAlarm(PendingIntent ps) {
+ try {
+ getDefault().noteWakeupAlarm(ps.getTarget());
+ } catch (RemoteException ex) {
+ }
+ }
+
+ public ActivityManagerNative()
+ {
+ attachInterface(this, descriptor);
+ }
+
+ public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
+ throws RemoteException {
+ switch (code) {
+ case START_ACTIVITY_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
+ int grantedMode = data.readInt();
+ IBinder resultTo = data.readStrongBinder();
+ String resultWho = data.readString();
+ int requestCode = data.readInt();
+ boolean onlyIfNeeded = data.readInt() != 0;
+ boolean debug = data.readInt() != 0;
+ int result = startActivity(app, intent, resolvedType,
+ grantedUriPermissions, grantedMode, resultTo, resultWho,
+ requestCode, onlyIfNeeded, debug);
+ reply.writeNoException();
+ reply.writeInt(result);
+ return true;
+ }
+
+ case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder callingActivity = data.readStrongBinder();
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ boolean result = startNextMatchingActivity(callingActivity, intent);
+ reply.writeNoException();
+ reply.writeInt(result ? 1 : 0);
+ return true;
+ }
+
+ case FINISH_ACTIVITY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Intent resultData = null;
+ int resultCode = data.readInt();
+ if (data.readInt() != 0) {
+ resultData = Intent.CREATOR.createFromParcel(data);
+ }
+ boolean res = finishActivity(token, resultCode, resultData);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case FINISH_SUB_ACTIVITY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ String resultWho = data.readString();
+ int requestCode = data.readInt();
+ finishSubActivity(token, resultWho, requestCode);
+ reply.writeNoException();
+ return true;
+ }
+
+ case REGISTER_RECEIVER_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app =
+ b != null ? ApplicationThreadNative.asInterface(b) : null;
+ b = data.readStrongBinder();
+ IIntentReceiver rec
+ = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
+ IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
+ String perm = data.readString();
+ Intent intent = registerReceiver(app, rec, filter, perm);
+ reply.writeNoException();
+ if (intent != null) {
+ reply.writeInt(1);
+ intent.writeToParcel(reply, 0);
+ } else {
+ reply.writeInt(0);
+ }
+ return true;
+ }
+
+ case UNREGISTER_RECEIVER_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ if (b == null) {
+ return true;
+ }
+ IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
+ unregisterReceiver(rec);
+ reply.writeNoException();
+ return true;
+ }
+
+ case BROADCAST_INTENT_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app =
+ b != null ? ApplicationThreadNative.asInterface(b) : null;
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ b = data.readStrongBinder();
+ IIntentReceiver resultTo =
+ b != null ? IIntentReceiver.Stub.asInterface(b) : null;
+ int resultCode = data.readInt();
+ String resultData = data.readString();
+ Bundle resultExtras = data.readBundle();
+ String perm = data.readString();
+ boolean serialized = data.readInt() != 0;
+ boolean sticky = data.readInt() != 0;
+ int res = broadcastIntent(app, intent, resolvedType, resultTo,
+ resultCode, resultData, resultExtras, perm,
+ serialized, sticky);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case UNBROADCAST_INTENT_TRANSACTION:
+ {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ unbroadcastIntent(app, intent);
+ reply.writeNoException();
+ return true;
+ }
+
+ case FINISH_RECEIVER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder who = data.readStrongBinder();
+ int resultCode = data.readInt();
+ String resultData = data.readString();
+ Bundle resultExtras = data.readBundle();
+ boolean resultAbort = data.readInt() != 0;
+ if (who != null) {
+ finishReceiver(who, resultCode, resultData, resultExtras, resultAbort);
+ }
+ reply.writeNoException();
+ return true;
+ }
+
+ case SET_PERSISTENT_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ boolean isPersistent = data.readInt() != 0;
+ if (token != null) {
+ setPersistent(token, isPersistent);
+ }
+ reply.writeNoException();
+ return true;
+ }
+
+ case ATTACH_APPLICATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IApplicationThread app = ApplicationThreadNative.asInterface(
+ data.readStrongBinder());
+ if (app != null) {
+ attachApplication(app);
+ }
+ reply.writeNoException();
+ return true;
+ }
+
+ case ACTIVITY_IDLE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ if (token != null) {
+ activityIdle(token);
+ }
+ reply.writeNoException();
+ return true;
+ }
+
+ case ACTIVITY_PAUSED_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Bundle map = data.readBundle();
+ activityPaused(token, map);
+ reply.writeNoException();
+ return true;
+ }
+
+ case ACTIVITY_STOPPED_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Bitmap thumbnail = data.readInt() != 0
+ ? Bitmap.CREATOR.createFromParcel(data) : null;
+ CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
+ activityStopped(token, thumbnail, description);
+ reply.writeNoException();
+ return true;
+ }
+
+ case ACTIVITY_DESTROYED_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ activityDestroyed(token);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_CALLING_PACKAGE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ String res = token != null ? getCallingPackage(token) : null;
+ reply.writeNoException();
+ reply.writeString(res);
+ return true;
+ }
+
+ case GET_CALLING_ACTIVITY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ ComponentName cn = getCallingActivity(token);
+ reply.writeNoException();
+ ComponentName.writeToParcel(cn, reply);
+ return true;
+ }
+
+ case GET_TASKS_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int maxNum = data.readInt();
+ int fl = data.readInt();
+ IBinder receiverBinder = data.readStrongBinder();
+ IThumbnailReceiver receiver = receiverBinder != null
+ ? IThumbnailReceiver.Stub.asInterface(receiverBinder)
+ : null;
+ List list = getTasks(maxNum, fl, receiver);
+ reply.writeNoException();
+ int N = list != null ? list.size() : -1;
+ reply.writeInt(N);
+ int i;
+ for (i=0; i<N; i++) {
+ ActivityManager.RunningTaskInfo info =
+ (ActivityManager.RunningTaskInfo)list.get(i);
+ info.writeToParcel(reply, 0);
+ }
+ return true;
+ }
+
+ case GET_RECENT_TASKS_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int maxNum = data.readInt();
+ int fl = data.readInt();
+ List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
+ fl);
+ reply.writeNoException();
+ reply.writeTypedList(list);
+ return true;
+ }
+
+ case GET_SERVICES_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int maxNum = data.readInt();
+ int fl = data.readInt();
+ List list = getServices(maxNum, fl);
+ reply.writeNoException();
+ int N = list != null ? list.size() : -1;
+ reply.writeInt(N);
+ int i;
+ for (i=0; i<N; i++) {
+ ActivityManager.RunningServiceInfo info =
+ (ActivityManager.RunningServiceInfo)list.get(i);
+ info.writeToParcel(reply, 0);
+ }
+ return true;
+ }
+
+ case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
+ reply.writeNoException();
+ reply.writeTypedList(list);
+ return true;
+ }
+
+ case GET_RUNNING_APP_PROCESSES_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
+ reply.writeNoException();
+ reply.writeTypedList(list);
+ return true;
+ }
+
+ case MOVE_TASK_TO_FRONT_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int task = data.readInt();
+ moveTaskToFront(task);
+ reply.writeNoException();
+ return true;
+ }
+
+ case MOVE_TASK_TO_BACK_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int task = data.readInt();
+ moveTaskToBack(task);
+ reply.writeNoException();
+ return true;
+ }
+
+ case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ boolean nonRoot = data.readInt() != 0;
+ boolean res = moveActivityTaskToBack(token, nonRoot);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case MOVE_TASK_BACKWARDS_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int task = data.readInt();
+ moveTaskBackwards(task);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_TASK_FOR_ACTIVITY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ boolean onlyRoot = data.readInt() != 0;
+ int res = token != null
+ ? getTaskForActivity(token, onlyRoot) : -1;
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case FINISH_OTHER_INSTANCES_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ ComponentName className = ComponentName.readFromParcel(data);
+ finishOtherInstances(token, className);
+ reply.writeNoException();
+ return true;
+ }
+
+ case REPORT_THUMBNAIL_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Bitmap thumbnail = data.readInt() != 0
+ ? Bitmap.CREATOR.createFromParcel(data) : null;
+ CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
+ reportThumbnail(token, thumbnail, description);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_CONTENT_PROVIDER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ String name = data.readString();
+ ContentProviderHolder cph = getContentProvider(app, name);
+ reply.writeNoException();
+ if (cph != null) {
+ reply.writeInt(1);
+ cph.writeToParcel(reply, 0);
+ } else {
+ reply.writeInt(0);
+ }
+ return true;
+ }
+
+ case PUBLISH_CONTENT_PROVIDERS_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ ArrayList<ContentProviderHolder> providers =
+ data.createTypedArrayList(ContentProviderHolder.CREATOR);
+ publishContentProviders(app, providers);
+ reply.writeNoException();
+ return true;
+ }
+
+ case REMOVE_CONTENT_PROVIDER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ String name = data.readString();
+ removeContentProvider(app, name);
+ reply.writeNoException();
+ return true;
+ }
+
+ case START_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ Intent service = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ ComponentName cn = startService(app, service, resolvedType);
+ reply.writeNoException();
+ ComponentName.writeToParcel(cn, reply);
+ return true;
+ }
+
+ case STOP_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ Intent service = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ int res = stopService(app, service, resolvedType);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case STOP_SERVICE_TOKEN_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ ComponentName className = ComponentName.readFromParcel(data);
+ IBinder token = data.readStrongBinder();
+ int startId = data.readInt();
+ boolean res = stopServiceToken(className, token, startId);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case SET_SERVICE_FOREGROUND_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ ComponentName className = ComponentName.readFromParcel(data);
+ IBinder token = data.readStrongBinder();
+ boolean isForeground = data.readInt() != 0;
+ setServiceForeground(className, token, isForeground);
+ reply.writeNoException();
+ return true;
+ }
+
+ case BIND_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ IBinder token = data.readStrongBinder();
+ Intent service = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ b = data.readStrongBinder();
+ int fl = data.readInt();
+ IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
+ int res = bindService(app, token, service, resolvedType, conn, fl);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case UNBIND_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
+ boolean res = unbindService(conn);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case PUBLISH_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ IBinder service = data.readStrongBinder();
+ publishService(token, intent, service);
+ reply.writeNoException();
+ return true;
+ }
+
+ case UNBIND_FINISHED_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ Intent intent = Intent.CREATOR.createFromParcel(data);
+ boolean doRebind = data.readInt() != 0;
+ unbindFinished(token, intent, doRebind);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SERVICE_DONE_EXECUTING_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ serviceDoneExecuting(token);
+ reply.writeNoException();
+ return true;
+ }
+
+ case START_INSTRUMENTATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ ComponentName className = ComponentName.readFromParcel(data);
+ String profileFile = data.readString();
+ int fl = data.readInt();
+ Bundle arguments = data.readBundle();
+ IBinder b = data.readStrongBinder();
+ IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
+ boolean res = startInstrumentation(className, profileFile, fl, arguments, w);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+
+ case FINISH_INSTRUMENTATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ int resultCode = data.readInt();
+ Bundle results = data.readBundle();
+ finishInstrumentation(app, resultCode, results);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_CONFIGURATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ Configuration config = getConfiguration();
+ reply.writeNoException();
+ config.writeToParcel(reply, 0);
+ return true;
+ }
+
+ case UPDATE_CONFIGURATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ Configuration config = Configuration.CREATOR.createFromParcel(data);
+ updateConfiguration(config);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SET_REQUESTED_ORIENTATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ int requestedOrientation = data.readInt();
+ setRequestedOrientation(token, requestedOrientation);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_REQUESTED_ORIENTATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ int req = getRequestedOrientation(token);
+ reply.writeNoException();
+ reply.writeInt(req);
+ return true;
+ }
+
+ case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ ComponentName cn = getActivityClassForToken(token);
+ reply.writeNoException();
+ ComponentName.writeToParcel(cn, reply);
+ return true;
+ }
+
+ case GET_PACKAGE_FOR_TOKEN_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ reply.writeNoException();
+ reply.writeString(getPackageForToken(token));
+ return true;
+ }
+
+ case GET_INTENT_SENDER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int type = data.readInt();
+ String packageName = data.readString();
+ IBinder token = data.readStrongBinder();
+ String resultWho = data.readString();
+ int requestCode = data.readInt();
+ Intent requestIntent = data.readInt() != 0
+ ? Intent.CREATOR.createFromParcel(data) : null;
+ String requestResolvedType = data.readString();
+ int fl = data.readInt();
+ IIntentSender res = getIntentSender(type, packageName, token,
+ resultWho, requestCode, requestIntent,
+ requestResolvedType, fl);
+ reply.writeNoException();
+ reply.writeStrongBinder(res != null ? res.asBinder() : null);
+ return true;
+ }
+
+ case CANCEL_INTENT_SENDER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IIntentSender r = IIntentSender.Stub.asInterface(
+ data.readStrongBinder());
+ cancelIntentSender(r);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IIntentSender r = IIntentSender.Stub.asInterface(
+ data.readStrongBinder());
+ String res = getPackageForIntentSender(r);
+ reply.writeNoException();
+ reply.writeString(res);
+ return true;
+ }
+
+ case SET_PROCESS_LIMIT_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int max = data.readInt();
+ setProcessLimit(max);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_PROCESS_LIMIT_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int limit = getProcessLimit();
+ reply.writeNoException();
+ reply.writeInt(limit);
+ return true;
+ }
+
+ case SET_PROCESS_FOREGROUND_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder token = data.readStrongBinder();
+ int pid = data.readInt();
+ boolean isForeground = data.readInt() != 0;
+ setProcessForeground(token, pid, isForeground);
+ reply.writeNoException();
+ return true;
+ }
+
+ case CHECK_PERMISSION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ String perm = data.readString();
+ int pid = data.readInt();
+ int uid = data.readInt();
+ int res = checkPermission(perm, pid, uid);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case CHECK_URI_PERMISSION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ Uri uri = Uri.CREATOR.createFromParcel(data);
+ int pid = data.readInt();
+ int uid = data.readInt();
+ int mode = data.readInt();
+ int res = checkUriPermission(uri, pid, uid, mode);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case CLEAR_APP_DATA_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ String packageName = data.readString();
+ IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(
+ data.readStrongBinder());
+ boolean res = clearApplicationUserData(packageName, observer);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case GRANT_URI_PERMISSION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ String targetPkg = data.readString();
+ Uri uri = Uri.CREATOR.createFromParcel(data);
+ int mode = data.readInt();
+ grantUriPermission(app, targetPkg, uri, mode);
+ reply.writeNoException();
+ return true;
+ }
+
+ case REVOKE_URI_PERMISSION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ Uri uri = Uri.CREATOR.createFromParcel(data);
+ int mode = data.readInt();
+ revokeUriPermission(app, uri, mode);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ boolean waiting = data.readInt() != 0;
+ showWaitingForDebugger(app, waiting);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_MEMORY_INFO_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
+ getMemoryInfo(mi);
+ reply.writeNoException();
+ mi.writeToParcel(reply, 0);
+ return true;
+ }
+
+ case UNHANDLED_BACK_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ unhandledBack();
+ reply.writeNoException();
+ return true;
+ }
+
+ case OPEN_CONTENT_URI_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ Uri uri = Uri.parse(data.readString());
+ ParcelFileDescriptor pfd = openContentUri(uri);
+ reply.writeNoException();
+ if (pfd != null) {
+ reply.writeInt(1);
+ pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
+ } else {
+ reply.writeInt(0);
+ }
+ return true;
+ }
+
+ case GOING_TO_SLEEP_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ goingToSleep();
+ reply.writeNoException();
+ return true;
+ }
+
+ case WAKING_UP_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ wakingUp();
+ reply.writeNoException();
+ return true;
+ }
+
+ case SET_DEBUG_APP_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ String pn = data.readString();
+ boolean wfd = data.readInt() != 0;
+ boolean per = data.readInt() != 0;
+ setDebugApp(pn, wfd, per);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SET_ALWAYS_FINISH_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ boolean enabled = data.readInt() != 0;
+ setAlwaysFinish(enabled);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SET_ACTIVITY_WATCHER_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IActivityWatcher watcher = IActivityWatcher.Stub.asInterface(
+ data.readStrongBinder());
+ setActivityWatcher(watcher);
+ return true;
+ }
+
+ case ENTER_SAFE_MODE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ enterSafeMode();
+ reply.writeNoException();
+ return true;
+ }
+
+ case NOTE_WAKEUP_ALARM_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IIntentSender is = IIntentSender.Stub.asInterface(
+ data.readStrongBinder());
+ noteWakeupAlarm(is);
+ reply.writeNoException();
+ return true;
+ }
+
+ case KILL_PIDS_FOR_MEMORY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int[] pids = data.createIntArray();
+ boolean res = killPidsForMemory(pids);
+ reply.writeNoException();
+ reply.writeInt(res ? 1 : 0);
+ return true;
+ }
+
+ case REPORT_PSS_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder b = data.readStrongBinder();
+ IApplicationThread app = ApplicationThreadNative.asInterface(b);
+ int pss = data.readInt();
+ reportPss(app, pss);
+ reply.writeNoException();
+ return true;
+ }
+
+ case START_RUNNING_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ String pkg = data.readString();
+ String cls = data.readString();
+ String action = data.readString();
+ String indata = data.readString();
+ startRunning(pkg, cls, action, indata);
+ reply.writeNoException();
+ return true;
+ }
+
+ case SYSTEM_READY_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ systemReady();
+ reply.writeNoException();
+ return true;
+ }
+
+ case HANDLE_APPLICATION_ERROR_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ IBinder app = data.readStrongBinder();
+ int fl = data.readInt();
+ String tag = data.readString();
+ String shortMsg = data.readString();
+ String longMsg = data.readString();
+ byte[] crashData = data.createByteArray();
+ int res = handleApplicationError(app, fl, tag, shortMsg, longMsg,
+ crashData);
+ reply.writeNoException();
+ reply.writeInt(res);
+ return true;
+ }
+
+ case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ int sig = data.readInt();
+ signalPersistentProcesses(sig);
+ reply.writeNoException();
+ return true;
+ }
+
+ case RESTART_PACKAGE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ String packageName = data.readString();
+ restartPackage(packageName);
+ reply.writeNoException();
+ return true;
+ }
+
+ case GET_DEVICE_CONFIGURATION_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ ConfigurationInfo config = getDeviceConfigurationInfo();
+ reply.writeNoException();
+ config.writeToParcel(reply, 0);
+ return true;
+ }
+
+ case PEEK_SERVICE_TRANSACTION: {
+ data.enforceInterface(IActivityManager.descriptor);
+ Intent service = Intent.CREATOR.createFromParcel(data);
+ String resolvedType = data.readString();
+ IBinder binder = peekService(service, resolvedType);
+ reply.writeNoException();
+ reply.writeStrongBinder(binder);
+ return true;
+ }
+ }
+
+ return super.onTransact(code, data, reply, flags);
+ }
+
+ public IBinder asBinder()
+ {
+ return this;
+ }
+
+ private static IActivityManager gDefault;
+}
+
+class ActivityManagerProxy implements IActivityManager
+{
+ public ActivityManagerProxy(IBinder remote)
+ {
+ mRemote = remote;
+ }
+
+ public IBinder asBinder()
+ {
+ return mRemote;
+ }
+
+ public int startActivity(IApplicationThread caller, Intent intent,
+ String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
+ IBinder resultTo, String resultWho,
+ int requestCode, boolean onlyIfNeeded,
+ boolean debug) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ intent.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ data.writeTypedArray(grantedUriPermissions, 0);
+ data.writeInt(grantedMode);
+ data.writeStrongBinder(resultTo);
+ data.writeString(resultWho);
+ data.writeInt(requestCode);
+ data.writeInt(onlyIfNeeded ? 1 : 0);
+ data.writeInt(debug ? 1 : 0);
+ mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int result = reply.readInt();
+ reply.recycle();
+ data.recycle();
+ return result;
+ }
+ public boolean startNextMatchingActivity(IBinder callingActivity,
+ Intent intent) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(callingActivity);
+ intent.writeToParcel(data, 0);
+ mRemote.transact(START_NEXT_MATCHING_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int result = reply.readInt();
+ reply.recycle();
+ data.recycle();
+ return result != 0;
+ }
+ public boolean finishActivity(IBinder token, int resultCode, Intent resultData)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(resultCode);
+ if (resultData != null) {
+ data.writeInt(1);
+ resultData.writeToParcel(data, 0);
+ } else {
+ data.writeInt(0);
+ }
+ mRemote.transact(FINISH_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeString(resultWho);
+ data.writeInt(requestCode);
+ mRemote.transact(FINISH_SUB_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public Intent registerReceiver(IApplicationThread caller,
+ IIntentReceiver receiver,
+ IntentFilter filter, String perm) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
+ filter.writeToParcel(data, 0);
+ data.writeString(perm);
+ mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ Intent intent = null;
+ int haveIntent = reply.readInt();
+ if (haveIntent != 0) {
+ intent = Intent.CREATOR.createFromParcel(reply);
+ }
+ reply.recycle();
+ data.recycle();
+ return intent;
+ }
+ public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(receiver.asBinder());
+ mRemote.transact(UNREGISTER_RECEIVER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int broadcastIntent(IApplicationThread caller,
+ Intent intent, String resolvedType, IIntentReceiver resultTo,
+ int resultCode, String resultData, Bundle map,
+ String requiredPermission, boolean serialized,
+ boolean sticky) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ intent.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);
+ data.writeInt(resultCode);
+ data.writeString(resultData);
+ data.writeBundle(map);
+ data.writeString(requiredPermission);
+ data.writeInt(serialized ? 1 : 0);
+ data.writeInt(sticky ? 1 : 0);
+ mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+ public void unbroadcastIntent(IApplicationThread caller, Intent intent) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ intent.writeToParcel(data, 0);
+ mRemote.transact(UNBROADCAST_INTENT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map, boolean abortBroadcast) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(who);
+ data.writeInt(resultCode);
+ data.writeString(resultData);
+ data.writeBundle(map);
+ data.writeInt(abortBroadcast ? 1 : 0);
+ mRemote.transact(FINISH_RECEIVER_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void setPersistent(IBinder token, boolean isPersistent) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(isPersistent ? 1 : 0);
+ mRemote.transact(SET_PERSISTENT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void attachApplication(IApplicationThread app) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(app.asBinder());
+ mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void activityIdle(IBinder token) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(ACTIVITY_IDLE_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void activityPaused(IBinder token, Bundle state) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeBundle(state);
+ mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void activityStopped(IBinder token,
+ Bitmap thumbnail, CharSequence description) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ if (thumbnail != null) {
+ data.writeInt(1);
+ thumbnail.writeToParcel(data, 0);
+ } else {
+ data.writeInt(0);
+ }
+ TextUtils.writeToParcel(description, data, 0);
+ mRemote.transact(ACTIVITY_STOPPED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void activityDestroyed(IBinder token) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(ACTIVITY_DESTROYED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public String getCallingPackage(IBinder token) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(GET_CALLING_PACKAGE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ String res = reply.readString();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public ComponentName getCallingActivity(IBinder token)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(GET_CALLING_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ComponentName res = ComponentName.readFromParcel(reply);
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public List getTasks(int maxNum, int flags,
+ IThumbnailReceiver receiver) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(maxNum);
+ data.writeInt(flags);
+ data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
+ mRemote.transact(GET_TASKS_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ArrayList list = null;
+ int N = reply.readInt();
+ if (N >= 0) {
+ list = new ArrayList();
+ while (N > 0) {
+ ActivityManager.RunningTaskInfo info =
+ ActivityManager.RunningTaskInfo.CREATOR
+ .createFromParcel(reply);
+ list.add(info);
+ N--;
+ }
+ }
+ data.recycle();
+ reply.recycle();
+ return list;
+ }
+ public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
+ int flags) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(maxNum);
+ data.writeInt(flags);
+ mRemote.transact(GET_RECENT_TASKS_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ArrayList<ActivityManager.RecentTaskInfo> list
+ = reply.createTypedArrayList(ActivityManager.RecentTaskInfo.CREATOR);
+ data.recycle();
+ reply.recycle();
+ return list;
+ }
+ public List getServices(int maxNum, int flags) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(maxNum);
+ data.writeInt(flags);
+ mRemote.transact(GET_SERVICES_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ArrayList list = null;
+ int N = reply.readInt();
+ if (N >= 0) {
+ list = new ArrayList();
+ while (N > 0) {
+ ActivityManager.RunningServiceInfo info =
+ ActivityManager.RunningServiceInfo.CREATOR
+ .createFromParcel(reply);
+ list.add(info);
+ N--;
+ }
+ }
+ data.recycle();
+ reply.recycle();
+ return list;
+ }
+ public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState()
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_PROCESSES_IN_ERROR_STATE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ArrayList<ActivityManager.ProcessErrorStateInfo> list
+ = reply.createTypedArrayList(ActivityManager.ProcessErrorStateInfo.CREATOR);
+ data.recycle();
+ reply.recycle();
+ return list;
+ }
+ public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_RUNNING_APP_PROCESSES_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ArrayList<ActivityManager.RunningAppProcessInfo> list
+ = reply.createTypedArrayList(ActivityManager.RunningAppProcessInfo.CREATOR);
+ data.recycle();
+ reply.recycle();
+ return list;
+ }
+ public void moveTaskToFront(int task) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(task);
+ mRemote.transact(MOVE_TASK_TO_FRONT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void moveTaskToBack(int task) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(task);
+ mRemote.transact(MOVE_TASK_TO_BACK_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(nonRoot ? 1 : 0);
+ mRemote.transact(MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void moveTaskBackwards(int task) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(task);
+ mRemote.transact(MOVE_TASK_BACKWARDS_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(onlyRoot ? 1 : 0);
+ mRemote.transact(GET_TASK_FOR_ACTIVITY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void finishOtherInstances(IBinder token, ComponentName className) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ ComponentName.writeToParcel(className, data);
+ mRemote.transact(FINISH_OTHER_INSTANCES_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void reportThumbnail(IBinder token,
+ Bitmap thumbnail, CharSequence description) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ if (thumbnail != null) {
+ data.writeInt(1);
+ thumbnail.writeToParcel(data, 0);
+ } else {
+ data.writeInt(0);
+ }
+ TextUtils.writeToParcel(description, data, 0);
+ mRemote.transact(REPORT_THUMBNAIL_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public ContentProviderHolder getContentProvider(IApplicationThread caller,
+ String name) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ data.writeString(name);
+ mRemote.transact(GET_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ ContentProviderHolder cph = null;
+ if (res != 0) {
+ cph = ContentProviderHolder.CREATOR.createFromParcel(reply);
+ }
+ data.recycle();
+ reply.recycle();
+ return cph;
+ }
+ public void publishContentProviders(IApplicationThread caller,
+ List<ContentProviderHolder> providers) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ data.writeTypedList(providers);
+ mRemote.transact(PUBLISH_CONTENT_PROVIDERS_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public void removeContentProvider(IApplicationThread caller,
+ String name) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ data.writeString(name);
+ mRemote.transact(REMOVE_CONTENT_PROVIDER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public ComponentName startService(IApplicationThread caller, Intent service,
+ String resolvedType) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ service.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ComponentName res = ComponentName.readFromParcel(reply);
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public int stopService(IApplicationThread caller, Intent service,
+ String resolvedType) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ service.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ mRemote.transact(STOP_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+ public boolean stopServiceToken(ComponentName className, IBinder token,
+ int startId) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ ComponentName.writeToParcel(className, data);
+ data.writeStrongBinder(token);
+ data.writeInt(startId);
+ mRemote.transact(STOP_SERVICE_TOKEN_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void setServiceForeground(ComponentName className, IBinder token,
+ boolean isForeground) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ ComponentName.writeToParcel(className, data);
+ data.writeStrongBinder(token);
+ data.writeInt(isForeground ? 1 : 0);
+ mRemote.transact(SET_SERVICE_FOREGROUND_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int bindService(IApplicationThread caller, IBinder token,
+ Intent service, String resolvedType, IServiceConnection connection,
+ int flags) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+ data.writeStrongBinder(token);
+ service.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ data.writeStrongBinder(connection.asBinder());
+ data.writeInt(flags);
+ mRemote.transact(BIND_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public boolean unbindService(IServiceConnection connection) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(connection.asBinder());
+ mRemote.transact(UNBIND_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+
+ public void publishService(IBinder token,
+ Intent intent, IBinder service) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ intent.writeToParcel(data, 0);
+ data.writeStrongBinder(service);
+ mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public void unbindFinished(IBinder token, Intent intent, boolean doRebind)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ intent.writeToParcel(data, 0);
+ data.writeInt(doRebind ? 1 : 0);
+ mRemote.transact(UNBIND_FINISHED_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public void serviceDoneExecuting(IBinder token) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(SERVICE_DONE_EXECUTING_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public IBinder peekService(Intent service, String resolvedType) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ service.writeToParcel(data, 0);
+ data.writeString(resolvedType);
+ mRemote.transact(PEEK_SERVICE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ IBinder binder = reply.readStrongBinder();
+ reply.recycle();
+ data.recycle();
+ return binder;
+ }
+
+ public boolean startInstrumentation(ComponentName className, String profileFile,
+ int flags, Bundle arguments, IInstrumentationWatcher watcher)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ ComponentName.writeToParcel(className, data);
+ data.writeString(profileFile);
+ data.writeInt(flags);
+ data.writeBundle(arguments);
+ data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
+ mRemote.transact(START_INSTRUMENTATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+
+ public void finishInstrumentation(IApplicationThread target,
+ int resultCode, Bundle results) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(target != null ? target.asBinder() : null);
+ data.writeInt(resultCode);
+ data.writeBundle(results);
+ mRemote.transact(FINISH_INSTRUMENTATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public Configuration getConfiguration() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_CONFIGURATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ Configuration res = Configuration.CREATOR.createFromParcel(reply);
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+ public void updateConfiguration(Configuration values) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ values.writeToParcel(data, 0);
+ mRemote.transact(UPDATE_CONFIGURATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void setRequestedOrientation(IBinder token, int requestedOrientation)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(requestedOrientation);
+ mRemote.transact(SET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int getRequestedOrientation(IBinder token) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(GET_REQUESTED_ORIENTATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public ComponentName getActivityClassForToken(IBinder token)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ComponentName res = ComponentName.readFromParcel(reply);
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public String getPackageForToken(IBinder token) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ mRemote.transact(GET_PACKAGE_FOR_TOKEN_TRANSACTION, data, reply, 0);
+ reply.readException();
+ String res = reply.readString();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public IIntentSender getIntentSender(int type,
+ String packageName, IBinder token, String resultWho,
+ int requestCode, Intent intent, String resolvedType, int flags)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(type);
+ data.writeString(packageName);
+ data.writeStrongBinder(token);
+ data.writeString(resultWho);
+ data.writeInt(requestCode);
+ if (intent != null) {
+ data.writeInt(1);
+ intent.writeToParcel(data, 0);
+ } else {
+ data.writeInt(0);
+ }
+ data.writeString(resolvedType);
+ data.writeInt(flags);
+ mRemote.transact(GET_INTENT_SENDER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ IIntentSender res = IIntentSender.Stub.asInterface(
+ reply.readStrongBinder());
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void cancelIntentSender(IIntentSender sender) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(sender.asBinder());
+ mRemote.transact(CANCEL_INTENT_SENDER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public String getPackageForIntentSender(IIntentSender sender) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(sender.asBinder());
+ mRemote.transact(GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ String res = reply.readString();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void setProcessLimit(int max) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(max);
+ mRemote.transact(SET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int getProcessLimit() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_PROCESS_LIMIT_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void setProcessForeground(IBinder token, int pid,
+ boolean isForeground) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(token);
+ data.writeInt(pid);
+ data.writeInt(isForeground ? 1 : 0);
+ mRemote.transact(SET_PROCESS_FOREGROUND_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public int checkPermission(String permission, int pid, int uid)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeString(permission);
+ data.writeInt(pid);
+ data.writeInt(uid);
+ mRemote.transact(CHECK_PERMISSION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public boolean clearApplicationUserData(final String packageName,
+ final IPackageDataObserver observer) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeString(packageName);
+ data.writeStrongBinder(observer.asBinder());
+ mRemote.transact(CLEAR_APP_DATA_TRANSACTION, data, reply, 0);
+ reply.readException();
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public int checkUriPermission(Uri uri, int pid, int uid, int mode)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ uri.writeToParcel(data, 0);
+ data.writeInt(pid);
+ data.writeInt(uid);
+ data.writeInt(mode);
+ mRemote.transact(CHECK_URI_PERMISSION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void grantUriPermission(IApplicationThread caller, String targetPkg,
+ Uri uri, int mode) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller.asBinder());
+ data.writeString(targetPkg);
+ uri.writeToParcel(data, 0);
+ data.writeInt(mode);
+ mRemote.transact(GRANT_URI_PERMISSION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void revokeUriPermission(IApplicationThread caller, Uri uri,
+ int mode) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller.asBinder());
+ uri.writeToParcel(data, 0);
+ data.writeInt(mode);
+ mRemote.transact(REVOKE_URI_PERMISSION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void showWaitingForDebugger(IApplicationThread who, boolean waiting)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(who.asBinder());
+ data.writeInt(waiting ? 1 : 0);
+ mRemote.transact(SHOW_WAITING_FOR_DEBUGGER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_MEMORY_INFO_TRANSACTION, data, reply, 0);
+ reply.readException();
+ outInfo.readFromParcel(reply);
+ data.recycle();
+ reply.recycle();
+ }
+ public void unhandledBack() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(UNHANDLED_BACK_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(OPEN_CONTENT_URI_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ParcelFileDescriptor pfd = null;
+ if (reply.readInt() != 0) {
+ pfd = ParcelFileDescriptor.CREATOR.createFromParcel(reply);
+ }
+ data.recycle();
+ reply.recycle();
+ return pfd;
+ }
+ public void goingToSleep() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GOING_TO_SLEEP_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void wakingUp() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(WAKING_UP_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void setDebugApp(
+ String packageName, boolean waitForDebugger, boolean persistent)
+ throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeString(packageName);
+ data.writeInt(waitForDebugger ? 1 : 0);
+ data.writeInt(persistent ? 1 : 0);
+ mRemote.transact(SET_DEBUG_APP_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void setAlwaysFinish(boolean enabled) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(enabled ? 1 : 0);
+ mRemote.transact(SET_ALWAYS_FINISH_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void setActivityWatcher(IActivityWatcher watcher) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(watcher != null ? watcher.asBinder() : null);
+ mRemote.transact(SET_ACTIVITY_WATCHER_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void enterSafeMode() throws RemoteException {
+ Parcel data = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(ENTER_SAFE_MODE_TRANSACTION, data, null, 0);
+ data.recycle();
+ }
+ public void noteWakeupAlarm(IIntentSender sender) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ data.writeStrongBinder(sender.asBinder());
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(NOTE_WAKEUP_ALARM_TRANSACTION, data, null, 0);
+ data.recycle();
+ }
+ public boolean killPidsForMemory(int[] pids) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeIntArray(pids);
+ mRemote.transact(KILL_PIDS_FOR_MEMORY_TRANSACTION, data, reply, 0);
+ boolean res = reply.readInt() != 0;
+ data.recycle();
+ reply.recycle();
+ return res;
+ }
+ public void reportPss(IApplicationThread caller, int pss) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(caller.asBinder());
+ data.writeInt(pss);
+ mRemote.transact(REPORT_PSS_TRANSACTION, data, null, 0);
+ data.recycle();
+ }
+ public void startRunning(String pkg, String cls, String action,
+ String indata) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeString(pkg);
+ data.writeString(cls);
+ data.writeString(action);
+ data.writeString(indata);
+ mRemote.transact(START_RUNNING_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public void systemReady() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(SYSTEM_READY_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+ public boolean testIsSystemReady()
+ {
+ /* this base class version is never called */
+ return true;
+ }
+ public int handleApplicationError(IBinder app, int flags,
+ String tag, String shortMsg, String longMsg,
+ byte[] crashData) throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeStrongBinder(app);
+ data.writeInt(flags);
+ data.writeString(tag);
+ data.writeString(shortMsg);
+ data.writeString(longMsg);
+ data.writeByteArray(crashData);
+ mRemote.transact(HANDLE_APPLICATION_ERROR_TRANSACTION, data, reply, 0);
+ reply.readException();
+ int res = reply.readInt();
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+
+ public void signalPersistentProcesses(int sig) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeInt(sig);
+ mRemote.transact(SIGNAL_PERSISTENT_PROCESSES_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public void restartPackage(String packageName) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ data.writeString(packageName);
+ mRemote.transact(RESTART_PACKAGE_TRANSACTION, data, reply, 0);
+ reply.readException();
+ data.recycle();
+ reply.recycle();
+ }
+
+ public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException
+ {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ data.writeInterfaceToken(IActivityManager.descriptor);
+ mRemote.transact(GET_DEVICE_CONFIGURATION_TRANSACTION, data, reply, 0);
+ reply.readException();
+ ConfigurationInfo res = ConfigurationInfo.CREATOR.createFromParcel(reply);
+ reply.recycle();
+ data.recycle();
+ return res;
+ }
+ private IBinder mRemote;
+}