ActivityManagerShellCommand.java revision 09a88f5f3e7d4a3bbfce04ac06594ac590c67d27 
1/*
2 * Copyright (C) 2015 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 com.android.server.am;
18
19import android.app.IActivityManager;
20import android.os.RemoteException;
21import android.os.ShellCommand;
22import android.os.UserHandle;
23
24import com.android.internal.util.ArrayUtils;
25
26import java.io.PrintWriter;
27
28class ActivityManagerShellCommand extends ShellCommand {
29    // IPC interface to activity manager -- don't need to do additional security checks.
30    final IActivityManager mInterface;
31
32    // Internal service impl -- must perform security checks before touching.
33    final ActivityManagerService mInternal;
34
35    final boolean mDumping;
36
37    ActivityManagerShellCommand(ActivityManagerService service, boolean dumping) {
38        mInterface = service;
39        mInternal = service;
40        mDumping = dumping;
41    }
42
43    @Override
44    public int onCommand(String cmd) {
45        if (cmd == null) {
46            return handleDefaultCommands(cmd);
47        }
48        PrintWriter pw = getOutPrintWriter();
49        try {
50            switch (cmd) {
51                case "force-stop":
52                    return runForceStop(pw);
53                case "kill":
54                    return runKill(pw);
55                case "kill-all":
56                    return runKillAll(pw);
57                case "write":
58                    return runWrite(pw);
59                case "track-associations":
60                    return runTrackAssociations(pw);
61                case "untrack-associations":
62                    return runUntrackAssociations(pw);
63                case "is-user-stopped":
64                    return runIsUserStopped(pw);
65                default:
66                    return handleDefaultCommands(cmd);
67            }
68        } catch (RemoteException e) {
69            pw.println("Remote exception: " + e);
70        }
71        return -1;
72    }
73
74    int runIsUserStopped(PrintWriter pw) {
75        int userId = UserHandle.parseUserArg(getNextArgRequired());
76        boolean stopped = mInternal.isUserStopped(userId);
77        pw.println(stopped);
78        return 0;
79    }
80
81    int runForceStop(PrintWriter pw) throws RemoteException {
82        int userId = UserHandle.USER_ALL;
83
84        String opt;
85        while ((opt = getNextOption()) != null) {
86            if (opt.equals("--user")) {
87                userId = UserHandle.parseUserArg(getNextArgRequired());
88            } else {
89                pw.println("Error: Unknown option: " + opt);
90                return -1;
91            }
92        }
93        mInterface.forceStopPackage(getNextArgRequired(), userId);
94        return 0;
95    }
96
97    int runKill(PrintWriter pw) throws RemoteException {
98        int userId = UserHandle.USER_ALL;
99
100        String opt;
101        while ((opt=getNextOption()) != null) {
102            if (opt.equals("--user")) {
103                userId = UserHandle.parseUserArg(getNextArgRequired());
104            } else {
105                pw.println("Error: Unknown option: " + opt);
106                return -1;
107            }
108        }
109        mInterface.killBackgroundProcesses(getNextArgRequired(), userId);
110        return 0;
111    }
112
113    int runKillAll(PrintWriter pw) throws RemoteException {
114        mInterface.killAllBackgroundProcesses();
115        return 0;
116    }
117
118    int runWrite(PrintWriter pw) {
119        mInternal.enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER,
120                "registerUidObserver()");
121        mInternal.mRecentTasks.flush();
122        pw.println("All tasks persisted.");
123        return 0;
124    }
125
126    int runTrackAssociations(PrintWriter pw) {
127        mInternal.enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER,
128                "registerUidObserver()");
129        synchronized (mInternal) {
130            if (!mInternal.mTrackingAssociations) {
131                mInternal.mTrackingAssociations = true;
132                pw.println("Association tracking started.");
133            } else {
134                pw.println("Association tracking already enabled.");
135            }
136        }
137        return 0;
138    }
139
140    int runUntrackAssociations(PrintWriter pw) {
141        mInternal.enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER,
142                "registerUidObserver()");
143        synchronized (mInternal) {
144            if (mInternal.mTrackingAssociations) {
145                mInternal.mTrackingAssociations = false;
146                mInternal.mAssociations.clear();
147                pw.println("Association tracking stopped.");
148            } else {
149                pw.println("Association tracking not running.");
150            }
151        }
152        return 0;
153    }
154
155    @Override
156    public void onHelp() {
157        PrintWriter pw = getOutPrintWriter();
158        dumpHelp(pw, mDumping);
159    }
160
161    static void dumpHelp(PrintWriter pw, boolean dumping) {
162        if (dumping) {
163            pw.println("Activity manager dump options:");
164            pw.println("  [-a] [-c] [-p PACKAGE] [-h] [WHAT] ...");
165            pw.println("  WHAT may be one of:");
166            pw.println("    a[ctivities]: activity stack state");
167            pw.println("    r[recents]: recent activities state");
168            pw.println("    b[roadcasts] [PACKAGE_NAME] [history [-s]]: broadcast state");
169            pw.println("    i[ntents] [PACKAGE_NAME]: pending intent state");
170            pw.println("    p[rocesses] [PACKAGE_NAME]: process state");
171            pw.println("    o[om]: out of memory management");
172            pw.println("    perm[issions]: URI permission grant state");
173            pw.println("    prov[iders] [COMP_SPEC ...]: content provider state");
174            pw.println("    provider [COMP_SPEC]: provider client-side state");
175            pw.println("    s[ervices] [COMP_SPEC ...]: service state");
176            pw.println("    as[sociations]: tracked app associations");
177            pw.println("    service [COMP_SPEC]: service client-side state");
178            pw.println("    package [PACKAGE_NAME]: all state related to given package");
179            pw.println("    all: dump all activities");
180            pw.println("    top: dump the top activity");
181            pw.println("  WHAT may also be a COMP_SPEC to dump activities.");
182            pw.println("  COMP_SPEC may be a component name (com.foo/.myApp),");
183            pw.println("    a partial substring in a component name, a");
184            pw.println("    hex object identifier.");
185            pw.println("  -a: include all available server state.");
186            pw.println("  -c: include client state.");
187            pw.println("  -p: limit output to given package.");
188        } else {
189            pw.println("Activity manager (activity) commands:");
190            pw.println("  help");
191            pw.println("    Print this help text.");
192            pw.println("  force-stop [--user <USER_ID> | all | current] <PACKAGE>");
193            pw.println("    Complete stop the given application package.");
194            pw.println("  kill [--user <USER_ID> | all | current] <PACKAGE>");
195            pw.println("    Kill all processes associated with the given application.");
196            pw.println("  kill-all");
197            pw.println("    Kill all processes that are safe to kill (cached, etc)");
198            pw.println("  write");
199            pw.println("    Write all pending state to storage.");
200            pw.println("  track-associations");
201            pw.println("    Enable association tracking.");
202            pw.println("  untrack-associations");
203            pw.println("    Disable and clear association tracking.");
204            pw.println("  is-user-stopped <USER_ID>");
205            pw.println("    returns whether <USER_ID> has been stopped or not");
206        }
207    }
208}
209