ActivityManagerInternal.java revision af8ff4f2afdfa1acfc7acf73f934434cac97b7a3 
1/*
2 * Copyright (C) 2014 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.annotation.NonNull;
20import android.annotation.Nullable;
21import android.content.ComponentName;
22import android.content.IIntentSender;
23import android.content.Intent;
24import android.content.res.Configuration;
25import android.os.Bundle;
26import android.os.IBinder;
27import android.os.SystemClock;
28import android.service.voice.IVoiceInteractionSession;
29import android.util.SparseIntArray;
30import android.view.RemoteAnimationAdapter;
31
32import com.android.internal.app.IVoiceInteractor;
33
34import java.util.List;
35
36/**
37 * Activity manager local system service interface.
38 *
39 * @hide Only for use within the system server.
40 */
41public abstract class ActivityManagerInternal {
42
43    /**
44     * Type for {@link #notifyAppTransitionStarting}: The transition was started because we drew
45     * the splash screen.
46     */
47    public static final int APP_TRANSITION_SPLASH_SCREEN =
48              AppProtoEnums.APP_TRANSITION_SPLASH_SCREEN; // 1
49
50    /**
51     * Type for {@link #notifyAppTransitionStarting}: The transition was started because we all
52     * app windows were drawn
53     */
54    public static final int APP_TRANSITION_WINDOWS_DRAWN =
55              AppProtoEnums.APP_TRANSITION_WINDOWS_DRAWN; // 2
56
57    /**
58     * Type for {@link #notifyAppTransitionStarting}: The transition was started because of a
59     * timeout.
60     */
61    public static final int APP_TRANSITION_TIMEOUT =
62              AppProtoEnums.APP_TRANSITION_TIMEOUT; // 3
63
64    /**
65     * Type for {@link #notifyAppTransitionStarting}: The transition was started because of a
66     * we drew a task snapshot.
67     */
68    public static final int APP_TRANSITION_SNAPSHOT =
69              AppProtoEnums.APP_TRANSITION_SNAPSHOT; // 4
70
71    /**
72     * Type for {@link #notifyAppTransitionStarting}: The transition was started because it was a
73     * recents animation and we only needed to wait on the wallpaper.
74     */
75    public static final int APP_TRANSITION_RECENTS_ANIM =
76            AppProtoEnums.APP_TRANSITION_RECENTS_ANIM; // 5
77
78    /**
79     * The bundle key to extract the assist data.
80     */
81    public static final String ASSIST_KEY_DATA = "data";
82
83    /**
84     * The bundle key to extract the assist structure.
85     */
86    public static final String ASSIST_KEY_STRUCTURE = "structure";
87
88    /**
89     * The bundle key to extract the assist content.
90     */
91    public static final String ASSIST_KEY_CONTENT = "content";
92
93    /**
94     * The bundle key to extract the assist receiver extras.
95     */
96    public static final String ASSIST_KEY_RECEIVER_EXTRAS = "receiverExtras";
97
98
99    /**
100     * Grant Uri permissions from one app to another. This method only extends
101     * permission grants if {@code callingUid} has permission to them.
102     */
103    public abstract void grantUriPermissionFromIntent(int callingUid, String targetPkg,
104            Intent intent, int targetUserId);
105
106    /**
107     * Verify that calling app has access to the given provider.
108     */
109    public abstract String checkContentProviderAccess(String authority, int userId);
110
111    // Called by the power manager.
112    public abstract void onWakefulnessChanged(int wakefulness);
113
114    /**
115     * @return {@code true} if process start is successful, {@code false} otherwise.
116     */
117    public abstract boolean startIsolatedProcess(String entryPoint, String[] mainArgs,
118            String processName, String abiOverride, int uid, Runnable crashHandler);
119
120    /**
121     * Acquires a sleep token for the specified display with the specified tag.
122     *
123     * @param tag A string identifying the purpose of the token (eg. "Dream").
124     * @param displayId The display to apply the sleep token to.
125     */
126    public abstract SleepToken acquireSleepToken(@NonNull String tag, int displayId);
127
128    /**
129     * Sleep tokens cause the activity manager to put the top activity to sleep.
130     * They are used by components such as dreams that may hide and block interaction
131     * with underlying activities.
132     */
133    public static abstract class SleepToken {
134
135        /**
136         * Releases the sleep token.
137         */
138        public abstract void release();
139    }
140
141    /**
142     * Returns home activity for the specified user.
143     *
144     * @param userId ID of the user or {@link android.os.UserHandle#USER_ALL}
145     */
146    public abstract ComponentName getHomeActivityForUser(int userId);
147
148    /**
149     * Called when a user has been deleted. This can happen during normal device usage
150     * or just at startup, when partially removed users are purged. Any state persisted by the
151     * ActivityManager should be purged now.
152     *
153     * @param userId The user being cleaned up.
154     */
155    public abstract void onUserRemoved(int userId);
156
157    public abstract void onLocalVoiceInteractionStarted(IBinder callingActivity,
158            IVoiceInteractionSession mSession,
159            IVoiceInteractor mInteractor);
160
161    /**
162     * Callback for window manager to let activity manager know that we are finally starting the
163     * app transition;
164     *
165     * @param reasons A map from windowing mode to a reason integer why the transition was started,
166     *                which must be one of the APP_TRANSITION_* values.
167     * @param timestamp The time at which the app transition started in
168     *                  {@link SystemClock#uptimeMillis()} timebase.
169     */
170    public abstract void notifyAppTransitionStarting(SparseIntArray reasons, long timestamp);
171
172    /**
173     * Callback for window manager to let activity manager know that the app transition was
174     * cancelled.
175     */
176    public abstract void notifyAppTransitionCancelled();
177
178    /**
179     * Callback for window manager to let activity manager know that the app transition is finished.
180     */
181    public abstract void notifyAppTransitionFinished();
182
183    /**
184     * Returns the top activity from each of the currently visible stacks. The first entry will be
185     * the focused activity.
186     */
187    public abstract List<IBinder> getTopVisibleActivities();
188
189    /**
190     * Callback for window manager to let activity manager know that docked stack changes its
191     * minimized state.
192     */
193    public abstract void notifyDockedStackMinimizedChanged(boolean minimized);
194
195    /**
196     * Kill foreground apps from the specified user.
197     */
198    public abstract void killForegroundAppsForUser(int userHandle);
199
200    /**
201     *  Sets how long a {@link PendingIntent} can be temporarily whitelist to by bypass restrictions
202     *  such as Power Save mode.
203     */
204    public abstract void setPendingIntentWhitelistDuration(IIntentSender target,
205            IBinder whitelistToken, long duration);
206
207    /**
208     * Allow DeviceIdleController to tell us about what apps are whitelisted.
209     */
210    public abstract void setDeviceIdleWhitelist(int[] allAppids, int[] exceptIdleAppids);
211
212    /**
213     * Update information about which app IDs are on the temp whitelist.
214     */
215    public abstract void updateDeviceIdleTempWhitelist(int[] appids, int changingAppId,
216            boolean adding);
217
218    /**
219     * Updates and persists the {@link Configuration} for a given user.
220     *
221     * @param values the configuration to update
222     * @param userId the user to update the configuration for
223     */
224    public abstract void updatePersistentConfigurationForUser(@NonNull Configuration values,
225            int userId);
226
227    /**
228     * Start activity {@code intents} as if {@code packageName} on user {@code userId} did it.
229     *
230     * - DO NOT call it with the calling UID cleared.
231     * - All the necessary caller permission checks must be done at callsites.
232     *
233     * @return error codes used by {@link IActivityManager#startActivity} and its siblings.
234     */
235    public abstract int startActivitiesAsPackage(String packageName,
236            int userId, Intent[] intents, Bundle bOptions);
237
238    /**
239     * Start activity {@code intent} without calling user-id check.
240     *
241     * - DO NOT call it with the calling UID cleared.
242     * - The caller must do the calling user ID check.
243     *
244     * @return error codes used by {@link IActivityManager#startActivity} and its siblings.
245     */
246    public abstract int startActivityAsUser(IApplicationThread caller, String callingPackage,
247            Intent intent, @Nullable Bundle options, int userId);
248
249    /**
250     * Get the procstate for the UID.  The return value will be between
251     * {@link ActivityManager#MIN_PROCESS_STATE} and {@link ActivityManager#MAX_PROCESS_STATE}.
252     * Note if the UID doesn't exist, it'll return {@link ActivityManager#PROCESS_STATE_NONEXISTENT}
253     * (-1).
254     */
255    public abstract int getUidProcessState(int uid);
256
257    /**
258     * Called when Keyguard flags might have changed.
259     *
260     * @param callback Callback to run after activity visibilities have been reevaluated. This can
261     *                 be used from window manager so that when the callback is called, it's
262     *                 guaranteed that all apps have their visibility updated accordingly.
263     */
264    public abstract void notifyKeyguardFlagsChanged(@Nullable Runnable callback);
265
266    /**
267     * @return {@code true} if system is ready, {@code false} otherwise.
268     */
269    public abstract boolean isSystemReady();
270
271    /**
272     * Called when the trusted state of Keyguard has changed.
273     */
274    public abstract void notifyKeyguardTrustedChanged();
275
276    /**
277     * Sets if the given pid has an overlay UI or not.
278     *
279     * @param pid The pid we are setting overlay UI for.
280     * @param hasOverlayUi True if the process has overlay UI.
281     * @see android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY
282     */
283    public abstract void setHasOverlayUi(int pid, boolean hasOverlayUi);
284
285    /**
286     * Sets if the given pid is currently running a remote animation, which is taken a signal for
287     * determining oom adjustment and scheduling behavior.
288     *
289     * @param pid The pid we are setting overlay UI for.
290     * @param runningRemoteAnimation True if the process is running a remote animation, false
291     *                               otherwise.
292     * @see RemoteAnimationAdapter
293     */
294    public abstract void setRunningRemoteAnimation(int pid, boolean runningRemoteAnimation);
295
296    /**
297     * Called after the network policy rules are updated by
298     * {@link com.android.server.net.NetworkPolicyManagerService} for a specific {@param uid} and
299     * {@param procStateSeq}.
300     */
301    public abstract void notifyNetworkPolicyRulesUpdated(int uid, long procStateSeq);
302
303    /**
304     * Called after the voice interaction service has changed.
305     */
306    public abstract void notifyActiveVoiceInteractionServiceChanged(ComponentName component);
307
308    /**
309     * Called after virtual display Id is updated by
310     * {@link com.android.server.vr.Vr2dDisplay} with a specific
311     * {@param vr2dDisplayId}.
312     */
313    public abstract void setVr2dDisplayId(int vr2dDisplayId);
314
315    /**
316     * Saves the current activity manager state and includes the saved state in the next dump of
317     * activity manager.
318     */
319    public abstract void saveANRState(String reason);
320
321    /**
322     * Clears the previously saved activity manager ANR state.
323     */
324    public abstract void clearSavedANRState();
325
326    /**
327     * Set focus on an activity.
328     * @param token The IApplicationToken for the activity
329     */
330    public abstract void setFocusedActivity(IBinder token);
331
332    /**
333     * Set a uid that is allowed to bypass stopped app switches, launching an app
334     * whenever it wants.
335     *
336     * @param type Type of the caller -- unique string the caller supplies to identify itself
337     * and disambiguate with other calles.
338     * @param uid The uid of the app to be allowed, or -1 to clear the uid for this type.
339     * @param userId The user it is allowed for.
340     */
341    public abstract void setAllowAppSwitches(@NonNull String type, int uid, int userId);
342
343    /**
344     * @return true if runtime was restarted, false if it's normal boot
345     */
346    public abstract boolean isRuntimeRestarted();
347
348    /**
349     * Returns {@code true} if {@code uid} is running an activity from {@code packageName}.
350     */
351    public abstract boolean hasRunningActivity(int uid, @Nullable String packageName);
352
353    public interface ScreenObserver {
354        public void onAwakeStateChanged(boolean isAwake);
355        public void onKeyguardStateChanged(boolean isShowing);
356    }
357
358    public abstract void registerScreenObserver(ScreenObserver observer);
359
360    /**
361     * Returns if more users can be started without stopping currently running users.
362     */
363    public abstract boolean canStartMoreUsers();
364
365    /**
366     * Sets the user switcher message for switching from {@link android.os.UserHandle#SYSTEM}.
367     */
368    public abstract void setSwitchingFromSystemUserMessage(String switchingFromSystemUserMessage);
369
370    /**
371     * Sets the user switcher message for switching to {@link android.os.UserHandle#SYSTEM}.
372     */
373    public abstract void setSwitchingToSystemUserMessage(String switchingToSystemUserMessage);
374
375    /**
376     * Returns maximum number of users that can run simultaneously.
377     */
378    public abstract int getMaxRunningUsers();
379
380    /**
381     * Returns is the caller has the same uid as the Recents component
382     */
383    public abstract boolean isCallerRecents(int callingUid);
384
385    /**
386     * Returns whether the recents component is the home activity for the given user.
387     */
388    public abstract boolean isRecentsComponentHomeActivity(int userId);
389
390    /**
391     * Cancels any currently running recents animation.
392     */
393    public abstract void cancelRecentsAnimation(boolean restoreHomeStackPosition);
394
395    /**
396     * Whether an UID is active or idle.
397     */
398    public abstract boolean isUidActive(int uid);
399
400    /**
401     * Returns a list that contains the memory stats for currently running processes.
402     */
403    public abstract List<ProcessMemoryState> getMemoryStateForProcesses();
404
405    /**
406     * This enforces {@code func} can only be called if either the caller is Recents activity or
407     * has {@code permission}.
408     */
409    public abstract void enforceCallerIsRecentsOrHasPermission(String permission, String func);
410}
411