• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.view;
18 
19 import android.content.Context;
20 import android.content.res.CompatibilityInfo;
21 import android.content.res.Configuration;
22 import android.graphics.Rect;
23 import android.graphics.RectF;
24 import android.os.IBinder;
25 import android.os.LocalPowerManager;
26 import android.os.Looper;
27 import android.view.animation.Animation;
28 
29 import java.io.FileDescriptor;
30 import java.io.PrintWriter;
31 
32 /**
33  * This interface supplies all UI-specific behavior of the window manager.  An
34  * instance of it is created by the window manager when it starts up, and allows
35  * customization of window layering, special window types, key dispatching, and
36  * layout.
37  *
38  * <p>Because this provides deep interaction with the system window manager,
39  * specific methods on this interface can be called from a variety of contexts
40  * with various restrictions on what they can do.  These are encoded through
41  * a suffixes at the end of a method encoding the thread the method is called
42  * from and any locks that are held when it is being called; if no suffix
43  * is attached to a method, then it is not called with any locks and may be
44  * called from the main window manager thread or another thread calling into
45  * the window manager.
46  *
47  * <p>The current suffixes are:
48  *
49  * <dl>
50  * <dt> Ti <dd> Called from the input thread.  This is the thread that
51  * collects pending input events and dispatches them to the appropriate window.
52  * It may block waiting for events to be processed, so that the input stream is
53  * properly serialized.
54  * <dt> Tq <dd> Called from the low-level input queue thread.  This is the
55  * thread that reads events out of the raw input devices and places them
56  * into the global input queue that is read by the <var>Ti</var> thread.
57  * This thread should not block for a long period of time on anything but the
58  * key driver.
59  * <dt> Lw <dd> Called with the main window manager lock held.  Because the
60  * window manager is a very low-level system service, there are few other
61  * system services you can call with this lock held.  It is explicitly okay to
62  * make calls into the package manager and power manager; it is explicitly not
63  * okay to make calls into the activity manager or most other services.  Note that
64  * {@link android.content.Context#checkPermission(String, int, int)} and
65  * variations require calling into the activity manager.
66  * <dt> Li <dd> Called with the input thread lock held.  This lock can be
67  * acquired by the window manager while it holds the window lock, so this is
68  * even more restrictive than <var>Lw</var>.
69  * </dl>
70  *
71  * @hide
72  */
73 public interface WindowManagerPolicy {
74     // Policy flags.  These flags are also defined in frameworks/base/include/ui/Input.h.
75     public final static int FLAG_WAKE = 0x00000001;
76     public final static int FLAG_WAKE_DROPPED = 0x00000002;
77     public final static int FLAG_SHIFT = 0x00000004;
78     public final static int FLAG_CAPS_LOCK = 0x00000008;
79     public final static int FLAG_ALT = 0x00000010;
80     public final static int FLAG_ALT_GR = 0x00000020;
81     public final static int FLAG_MENU = 0x00000040;
82     public final static int FLAG_LAUNCHER = 0x00000080;
83     public final static int FLAG_VIRTUAL = 0x00000100;
84 
85     public final static int FLAG_INJECTED = 0x01000000;
86     public final static int FLAG_TRUSTED = 0x02000000;
87     public final static int FLAG_FILTERED = 0x04000000;
88     public final static int FLAG_DISABLE_KEY_REPEAT = 0x08000000;
89 
90     public final static int FLAG_WOKE_HERE = 0x10000000;
91     public final static int FLAG_BRIGHT_HERE = 0x20000000;
92     public final static int FLAG_PASS_TO_USER = 0x40000000;
93 
94     public final static boolean WATCH_POINTER = false;
95 
96     /**
97      * Sticky broadcast of the current HDMI plugged state.
98      */
99     public final static String ACTION_HDMI_PLUGGED = "android.intent.action.HDMI_PLUGGED";
100 
101     /**
102      * Extra in {@link #ACTION_HDMI_PLUGGED} indicating the state: true if
103      * plugged in to HDMI, false if not.
104      */
105     public final static String EXTRA_HDMI_PLUGGED_STATE = "state";
106 
107     /**
108      * Pass this event to the user / app.  To be returned from
109      * {@link #interceptKeyBeforeQueueing}.
110      */
111     public final static int ACTION_PASS_TO_USER = 0x00000001;
112 
113     /**
114      * This key event should extend the user activity timeout and turn the lights on.
115      * To be returned from {@link #interceptKeyBeforeQueueing}.
116      * Do not return this and {@link #ACTION_GO_TO_SLEEP} or {@link #ACTION_PASS_TO_USER}.
117      */
118     public final static int ACTION_POKE_USER_ACTIVITY = 0x00000002;
119 
120     /**
121      * This key event should put the device to sleep (and engage keyguard if necessary)
122      * To be returned from {@link #interceptKeyBeforeQueueing}.
123      * Do not return this and {@link #ACTION_POKE_USER_ACTIVITY} or {@link #ACTION_PASS_TO_USER}.
124      */
125     public final static int ACTION_GO_TO_SLEEP = 0x00000004;
126 
127     /**
128      * Interface to the Window Manager state associated with a particular
129      * window.  You can hold on to an instance of this interface from the call
130      * to prepareAddWindow() until removeWindow().
131      */
132     public interface WindowState {
133         /**
134          * Perform standard frame computation.  The result can be obtained with
135          * getFrame() if so desired.  Must be called with the window manager
136          * lock held.
137          *
138          * @param parentFrame The frame of the parent container this window
139          * is in, used for computing its basic position.
140          * @param displayFrame The frame of the overall display in which this
141          * window can appear, used for constraining the overall dimensions
142          * of the window.
143          * @param contentFrame The frame within the display in which we would
144          * like active content to appear.  This will cause windows behind to
145          * be resized to match the given content frame.
146          * @param visibleFrame The frame within the display that the window
147          * is actually visible, used for computing its visible insets to be
148          * given to windows behind.
149          * This can be used as a hint for scrolling (avoiding resizing)
150          * the window to make certain that parts of its content
151          * are visible.
152          */
computeFrameLw(Rect parentFrame, Rect displayFrame, Rect contentFrame, Rect visibleFrame)153         public void computeFrameLw(Rect parentFrame, Rect displayFrame,
154                 Rect contentFrame, Rect visibleFrame);
155 
156         /**
157          * Retrieve the current frame of the window that has been assigned by
158          * the window manager.  Must be called with the window manager lock held.
159          *
160          * @return Rect The rectangle holding the window frame.
161          */
getFrameLw()162         public Rect getFrameLw();
163 
164         /**
165          * Retrieve the current frame of the window that is actually shown.
166          * Must be called with the window manager lock held.
167          *
168          * @return Rect The rectangle holding the shown window frame.
169          */
getShownFrameLw()170         public RectF getShownFrameLw();
171 
172         /**
173          * Retrieve the frame of the display that this window was last
174          * laid out in.  Must be called with the
175          * window manager lock held.
176          *
177          * @return Rect The rectangle holding the display frame.
178          */
getDisplayFrameLw()179         public Rect getDisplayFrameLw();
180 
181         /**
182          * Retrieve the frame of the content area that this window was last
183          * laid out in.  This is the area in which the content of the window
184          * should be placed.  It will be smaller than the display frame to
185          * account for screen decorations such as a status bar or soft
186          * keyboard.  Must be called with the
187          * window manager lock held.
188          *
189          * @return Rect The rectangle holding the content frame.
190          */
getContentFrameLw()191         public Rect getContentFrameLw();
192 
193         /**
194          * Retrieve the frame of the visible area that this window was last
195          * laid out in.  This is the area of the screen in which the window
196          * will actually be fully visible.  It will be smaller than the
197          * content frame to account for transient UI elements blocking it
198          * such as an input method's candidates UI.  Must be called with the
199          * window manager lock held.
200          *
201          * @return Rect The rectangle holding the visible frame.
202          */
getVisibleFrameLw()203         public Rect getVisibleFrameLw();
204 
205         /**
206          * Returns true if this window is waiting to receive its given
207          * internal insets from the client app, and so should not impact the
208          * layout of other windows.
209          */
getGivenInsetsPendingLw()210         public boolean getGivenInsetsPendingLw();
211 
212         /**
213          * Retrieve the insets given by this window's client for the content
214          * area of windows behind it.  Must be called with the
215          * window manager lock held.
216          *
217          * @return Rect The left, top, right, and bottom insets, relative
218          * to the window's frame, of the actual contents.
219          */
getGivenContentInsetsLw()220         public Rect getGivenContentInsetsLw();
221 
222         /**
223          * Retrieve the insets given by this window's client for the visible
224          * area of windows behind it.  Must be called with the
225          * window manager lock held.
226          *
227          * @return Rect The left, top, right, and bottom insets, relative
228          * to the window's frame, of the actual visible area.
229          */
getGivenVisibleInsetsLw()230         public Rect getGivenVisibleInsetsLw();
231 
232         /**
233          * Retrieve the current LayoutParams of the window.
234          *
235          * @return WindowManager.LayoutParams The window's internal LayoutParams
236          *         instance.
237          */
getAttrs()238         public WindowManager.LayoutParams getAttrs();
239 
240         /**
241          * Retrieve the current system UI visibility flags associated with
242          * this window.
243          */
getSystemUiVisibility()244         public int getSystemUiVisibility();
245 
246         /**
247          * Get the layer at which this window's surface will be Z-ordered.
248          */
getSurfaceLayer()249         public int getSurfaceLayer();
250 
251         /**
252          * Return the token for the application (actually activity) that owns
253          * this window.  May return null for system windows.
254          *
255          * @return An IApplicationToken identifying the owning activity.
256          */
getAppToken()257         public IApplicationToken getAppToken();
258 
259         /**
260          * Return true if, at any point, the application token associated with
261          * this window has actually displayed any windows.  This is most useful
262          * with the "starting up" window to determine if any windows were
263          * displayed when it is closed.
264          *
265          * @return Returns true if one or more windows have been displayed,
266          *         else false.
267          */
hasAppShownWindows()268         public boolean hasAppShownWindows();
269 
270         /**
271          * Is this window visible?  It is not visible if there is no
272          * surface, or we are in the process of running an exit animation
273          * that will remove the surface.
274          */
isVisibleLw()275         boolean isVisibleLw();
276 
277         /**
278          * Like {@link #isVisibleLw}, but also counts a window that is currently
279          * "hidden" behind the keyguard as visible.  This allows us to apply
280          * things like window flags that impact the keyguard.
281          */
isVisibleOrBehindKeyguardLw()282         boolean isVisibleOrBehindKeyguardLw();
283 
284         /**
285          * Is this window currently visible to the user on-screen?  It is
286          * displayed either if it is visible or it is currently running an
287          * animation before no longer being visible.  Must be called with the
288          * window manager lock held.
289          */
isDisplayedLw()290         boolean isDisplayedLw();
291 
292         /**
293          * Returns true if this window has been shown on screen at some time in
294          * the past.  Must be called with the window manager lock held.
295          *
296          * @return boolean
297          */
hasDrawnLw()298         public boolean hasDrawnLw();
299 
300         /**
301          * Can be called by the policy to force a window to be hidden,
302          * regardless of whether the client or window manager would like
303          * it shown.  Must be called with the window manager lock held.
304          * Returns true if {@link #showLw} was last called for the window.
305          */
hideLw(boolean doAnimation)306         public boolean hideLw(boolean doAnimation);
307 
308         /**
309          * Can be called to undo the effect of {@link #hideLw}, allowing a
310          * window to be shown as long as the window manager and client would
311          * also like it to be shown.  Must be called with the window manager
312          * lock held.
313          * Returns true if {@link #hideLw} was last called for the window.
314          */
showLw(boolean doAnimation)315         public boolean showLw(boolean doAnimation);
316     }
317 
318     /**
319      * Representation of a "fake window" that the policy has added to the
320      * window manager to consume events.
321      */
322     public interface FakeWindow {
323         /**
324          * Remove the fake window from the window manager.
325          */
dismiss()326         void dismiss();
327     }
328 
329     /**
330      * Interface for calling back in to the window manager that is private
331      * between it and the policy.
332      */
333     public interface WindowManagerFuncs {
334         /**
335          * Ask the window manager to re-evaluate the system UI flags.
336          */
reevaluateStatusBarVisibility()337         public void reevaluateStatusBarVisibility();
338 
339         /**
340          * Add a fake window to the window manager.  This window sits
341          * at the top of the other windows and consumes events.
342          */
addFakeWindow(Looper looper, InputHandler inputHandler, String name, int windowType, int layoutParamsFlags, boolean canReceiveKeys, boolean hasFocus, boolean touchFullscreen)343         public FakeWindow addFakeWindow(Looper looper, InputHandler inputHandler,
344                 String name, int windowType, int layoutParamsFlags, boolean canReceiveKeys,
345                 boolean hasFocus, boolean touchFullscreen);
346     }
347 
348     /**
349      * Bit mask that is set for all enter transition.
350      */
351     public final int TRANSIT_ENTER_MASK = 0x1000;
352 
353     /**
354      * Bit mask that is set for all exit transitions.
355      */
356     public final int TRANSIT_EXIT_MASK = 0x2000;
357 
358     /** Not set up for a transition. */
359     public final int TRANSIT_UNSET = -1;
360     /** No animation for transition. */
361     public final int TRANSIT_NONE = 0;
362     /** Window has been added to the screen. */
363     public final int TRANSIT_ENTER = 1 | TRANSIT_ENTER_MASK;
364     /** Window has been removed from the screen. */
365     public final int TRANSIT_EXIT = 2 | TRANSIT_EXIT_MASK;
366     /** Window has been made visible. */
367     public final int TRANSIT_SHOW = 3 | TRANSIT_ENTER_MASK;
368     /** Window has been made invisible. */
369     public final int TRANSIT_HIDE = 4 | TRANSIT_EXIT_MASK;
370     /** The "application starting" preview window is no longer needed, and will
371      * animate away to show the real window. */
372     public final int TRANSIT_PREVIEW_DONE = 5;
373     /** A window in a new activity is being opened on top of an existing one
374      * in the same task. */
375     public final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK;
376     /** The window in the top-most activity is being closed to reveal the
377      * previous activity in the same task. */
378     public final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK;
379     /** A window in a new task is being opened on top of an existing one
380      * in another activity's task. */
381     public final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK;
382     /** A window in the top-most activity is being closed to reveal the
383      * previous activity in a different task. */
384     public final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK;
385     /** A window in an existing task is being displayed on top of an existing one
386      * in another activity's task. */
387     public final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK;
388     /** A window in an existing task is being put below all other tasks. */
389     public final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK;
390     /** A window in a new activity that doesn't have a wallpaper is being
391      * opened on top of one that does, effectively closing the wallpaper. */
392     public final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK;
393     /** A window in a new activity that does have a wallpaper is being
394      * opened on one that didn't, effectively opening the wallpaper. */
395     public final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK;
396     /** A window in a new activity is being opened on top of an existing one,
397      * and both are on top of the wallpaper. */
398     public final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK;
399     /** The window in the top-most activity is being closed to reveal the
400      * previous activity, and both are on top of he wallpaper. */
401     public final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK;
402 
403     // NOTE: screen off reasons are in order of significance, with more
404     // important ones lower than less important ones.
405 
406     /** Screen turned off because of a device admin */
407     public final int OFF_BECAUSE_OF_ADMIN = 1;
408     /** Screen turned off because of power button */
409     public final int OFF_BECAUSE_OF_USER = 2;
410     /** Screen turned off because of timeout */
411     public final int OFF_BECAUSE_OF_TIMEOUT = 3;
412     /** Screen turned off because of proximity sensor */
413     public final int OFF_BECAUSE_OF_PROX_SENSOR = 4;
414 
415     /** When not otherwise specified by the activity's screenOrientation, rotation should be
416      * determined by the system (that is, using sensors). */
417     public final int USER_ROTATION_FREE = 0;
418     /** When not otherwise specified by the activity's screenOrientation, rotation is set by
419      * the user. */
420     public final int USER_ROTATION_LOCKED = 1;
421 
422     /**
423      * Perform initialization of the policy.
424      *
425      * @param context The system context we are running in.
426      * @param powerManager
427      */
init(Context context, IWindowManager windowManager, WindowManagerFuncs windowManagerFuncs, LocalPowerManager powerManager)428     public void init(Context context, IWindowManager windowManager,
429             WindowManagerFuncs windowManagerFuncs,
430             LocalPowerManager powerManager);
431 
432     /**
433      * Called by window manager once it has the initial, default native
434      * display dimensions.
435      */
setInitialDisplaySize(int width, int height)436     public void setInitialDisplaySize(int width, int height);
437 
438     /**
439      * Check permissions when adding a window.
440      *
441      * @param attrs The window's LayoutParams.
442      *
443      * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed;
444      *      else an error code, usually
445      *      {@link WindowManagerImpl#ADD_PERMISSION_DENIED}, to abort the add.
446      */
checkAddPermission(WindowManager.LayoutParams attrs)447     public int checkAddPermission(WindowManager.LayoutParams attrs);
448 
449     /**
450      * Sanitize the layout parameters coming from a client.  Allows the policy
451      * to do things like ensure that windows of a specific type can't take
452      * input focus.
453      *
454      * @param attrs The window layout parameters to be modified.  These values
455      * are modified in-place.
456      */
adjustWindowParamsLw(WindowManager.LayoutParams attrs)457     public void adjustWindowParamsLw(WindowManager.LayoutParams attrs);
458 
459     /**
460      * After the window manager has computed the current configuration based
461      * on its knowledge of the display and input devices, it gives the policy
462      * a chance to adjust the information contained in it.  If you want to
463      * leave it as-is, simply do nothing.
464      *
465      * <p>This method may be called by any thread in the window manager, but
466      * no internal locks in the window manager will be held.
467      *
468      * @param config The Configuration being computed, for you to change as
469      * desired.
470      */
adjustConfigurationLw(Configuration config)471     public void adjustConfigurationLw(Configuration config);
472 
473     /**
474      * Assign a window type to a layer.  Allows you to control how different
475      * kinds of windows are ordered on-screen.
476      *
477      * @param type The type of window being assigned.
478      *
479      * @return int An arbitrary integer used to order windows, with lower
480      *         numbers below higher ones.
481      */
windowTypeToLayerLw(int type)482     public int windowTypeToLayerLw(int type);
483 
484     /**
485      * Return how to Z-order sub-windows in relation to the window they are
486      * attached to.  Return positive to have them ordered in front, negative for
487      * behind.
488      *
489      * @param type The sub-window type code.
490      *
491      * @return int Layer in relation to the attached window, where positive is
492      *         above and negative is below.
493      */
subWindowTypeToLayerLw(int type)494     public int subWindowTypeToLayerLw(int type);
495 
496     /**
497      * Get the highest layer (actually one more than) that the wallpaper is
498      * allowed to be in.
499      */
getMaxWallpaperLayer()500     public int getMaxWallpaperLayer();
501 
502     /**
503      * Return true if the policy allows the status bar to hide.  Otherwise,
504      * it is a tablet-style system bar.
505      */
canStatusBarHide()506     public boolean canStatusBarHide();
507 
508     /**
509      * Return the display width available after excluding any screen
510      * decorations that can never be removed.  That is, system bar or
511      * button bar.
512      */
getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation)513     public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation);
514 
515     /**
516      * Return the display height available after excluding any screen
517      * decorations that can never be removed.  That is, system bar or
518      * button bar.
519      */
getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation)520     public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation);
521 
522     /**
523      * Return the available screen width that we should report for the
524      * configuration.  This must be no larger than
525      * {@link #getNonDecorDisplayWidth(int, int)}; it may be smaller than
526      * that to account for more transient decoration like a status bar.
527      */
getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation)528     public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation);
529 
530     /**
531      * Return the available screen height that we should report for the
532      * configuration.  This must be no larger than
533      * {@link #getNonDecorDisplayHeight(int, int)}; it may be smaller than
534      * that to account for more transient decoration like a status bar.
535      */
getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation)536     public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation);
537 
538     /**
539      * Return whether the given window should forcibly hide everything
540      * behind it.  Typically returns true for the keyguard.
541      */
doesForceHide(WindowState win, WindowManager.LayoutParams attrs)542     public boolean doesForceHide(WindowState win, WindowManager.LayoutParams attrs);
543 
544     /**
545      * Determine if a window that is behind one that is force hiding
546      * (as determined by {@link #doesForceHide}) should actually be hidden.
547      * For example, typically returns false for the status bar.  Be careful
548      * to return false for any window that you may hide yourself, since this
549      * will conflict with what you set.
550      */
canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs)551     public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs);
552 
553     /**
554      * Called when the system would like to show a UI to indicate that an
555      * application is starting.  You can use this to add a
556      * APPLICATION_STARTING_TYPE window with the given appToken to the window
557      * manager (using the normal window manager APIs) that will be shown until
558      * the application displays its own window.  This is called without the
559      * window manager locked so that you can call back into it.
560      *
561      * @param appToken Token of the application being started.
562      * @param packageName The name of the application package being started.
563      * @param theme Resource defining the application's overall visual theme.
564      * @param nonLocalizedLabel The default title label of the application if
565      *        no data is found in the resource.
566      * @param labelRes The resource ID the application would like to use as its name.
567      * @param icon The resource ID the application would like to use as its icon.
568      * @param windowFlags Window layout flags.
569      *
570      * @return Optionally you can return the View that was used to create the
571      *         window, for easy removal in removeStartingWindow.
572      *
573      * @see #removeStartingWindow
574      */
addStartingWindow(IBinder appToken, String packageName, int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes, int icon, int windowFlags)575     public View addStartingWindow(IBinder appToken, String packageName,
576             int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel,
577             int labelRes, int icon, int windowFlags);
578 
579     /**
580      * Called when the first window of an application has been displayed, while
581      * {@link #addStartingWindow} has created a temporary initial window for
582      * that application.  You should at this point remove the window from the
583      * window manager.  This is called without the window manager locked so
584      * that you can call back into it.
585      *
586      * <p>Note: due to the nature of these functions not being called with the
587      * window manager locked, you must be prepared for this function to be
588      * called multiple times and/or an initial time with a null View window
589      * even if you previously returned one.
590      *
591      * @param appToken Token of the application that has started.
592      * @param window Window View that was returned by createStartingWindow.
593      *
594      * @see #addStartingWindow
595      */
removeStartingWindow(IBinder appToken, View window)596     public void removeStartingWindow(IBinder appToken, View window);
597 
598     /**
599      * Prepare for a window being added to the window manager.  You can throw an
600      * exception here to prevent the window being added, or do whatever setup
601      * you need to keep track of the window.
602      *
603      * @param win The window being added.
604      * @param attrs The window's LayoutParams.
605      *
606      * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed, else an
607      *         error code to abort the add.
608      */
prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs)609     public int prepareAddWindowLw(WindowState win,
610             WindowManager.LayoutParams attrs);
611 
612     /**
613      * Called when a window is being removed from a window manager.  Must not
614      * throw an exception -- clean up as much as possible.
615      *
616      * @param win The window being removed.
617      */
removeWindowLw(WindowState win)618     public void removeWindowLw(WindowState win);
619 
620     /**
621      * Control the animation to run when a window's state changes.  Return a
622      * non-0 number to force the animation to a specific resource ID, or 0
623      * to use the default animation.
624      *
625      * @param win The window that is changing.
626      * @param transit What is happening to the window: {@link #TRANSIT_ENTER},
627      *                {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or
628      *                {@link #TRANSIT_HIDE}.
629      *
630      * @return Resource ID of the actual animation to use, or 0 for none.
631      */
selectAnimationLw(WindowState win, int transit)632     public int selectAnimationLw(WindowState win, int transit);
633 
634     /**
635      * Create and return an animation to re-display a force hidden window.
636      */
createForceHideEnterAnimation()637     public Animation createForceHideEnterAnimation();
638 
639     /**
640      * Called from the input reader thread before a key is enqueued.
641      *
642      * <p>There are some actions that need to be handled here because they
643      * affect the power state of the device, for example, the power keys.
644      * Generally, it's best to keep as little as possible in the queue thread
645      * because it's the most fragile.
646      * @param event The key event.
647      * @param policyFlags The policy flags associated with the key.
648      * @param isScreenOn True if the screen is already on
649      *
650      * @return The bitwise or of the {@link #ACTION_PASS_TO_USER},
651      *          {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags.
652      */
interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn)653     public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn);
654 
655     /**
656      * Called from the input reader thread before a motion is enqueued when the screen is off.
657      *
658      * <p>There are some actions that need to be handled here because they
659      * affect the power state of the device, for example, waking on motions.
660      * Generally, it's best to keep as little as possible in the queue thread
661      * because it's the most fragile.
662      * @param policyFlags The policy flags associated with the motion.
663      *
664      * @return The bitwise or of the {@link #ACTION_PASS_TO_USER},
665      *          {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags.
666      */
interceptMotionBeforeQueueingWhenScreenOff(int policyFlags)667     public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags);
668 
669     /**
670      * Called from the input dispatcher thread before a key is dispatched to a window.
671      *
672      * <p>Allows you to define
673      * behavior for keys that can not be overridden by applications.
674      * This method is called from the input thread, with no locks held.
675      *
676      * @param win The window that currently has focus.  This is where the key
677      *            event will normally go.
678      * @param event The key event.
679      * @param policyFlags The policy flags associated with the key.
680      * @return 0 if the key should be dispatched immediately, -1 if the key should
681      * not be dispatched ever, or a positive value indicating the number of
682      * milliseconds by which the key dispatch should be delayed before trying
683      * again.
684      */
interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags)685     public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags);
686 
687     /**
688      * Called from the input dispatcher thread when an application did not handle
689      * a key that was dispatched to it.
690      *
691      * <p>Allows you to define default global behavior for keys that were not handled
692      * by applications.  This method is called from the input thread, with no locks held.
693      *
694      * @param win The window that currently has focus.  This is where the key
695      *            event will normally go.
696      * @param event The key event.
697      * @param policyFlags The policy flags associated with the key.
698      * @return Returns an alternate key event to redispatch as a fallback, or null to give up.
699      * The caller is responsible for recycling the key event.
700      */
dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags)701     public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags);
702 
703     /**
704      * Called when layout of the windows is about to start.
705      *
706      * @param displayWidth The current full width of the screen.
707      * @param displayHeight The current full height of the screen.
708      * @param displayRotation The current rotation being applied to the base
709      * window.
710      */
beginLayoutLw(int displayWidth, int displayHeight, int displayRotation)711     public void beginLayoutLw(int displayWidth, int displayHeight, int displayRotation);
712 
713     /**
714      * Called for each window attached to the window manager as layout is
715      * proceeding.  The implementation of this function must take care of
716      * setting the window's frame, either here or in finishLayout().
717      *
718      * @param win The window being positioned.
719      * @param attrs The LayoutParams of the window.
720      * @param attached For sub-windows, the window it is attached to; this
721      *                 window will already have had layoutWindow() called on it
722      *                 so you can use its Rect.  Otherwise null.
723      */
layoutWindowLw(WindowState win, WindowManager.LayoutParams attrs, WindowState attached)724     public void layoutWindowLw(WindowState win,
725             WindowManager.LayoutParams attrs, WindowState attached);
726 
727 
728     /**
729      * Return the insets for the areas covered by system windows. These values
730      * are computed on the most recent layout, so they are not guaranteed to
731      * be correct.
732      *
733      * @param attrs The LayoutParams of the window.
734      * @param contentInset The areas covered by system windows, expressed as positive insets
735      *
736      */
getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset)737     public void getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset);
738 
739     /**
740      * Called when layout of the windows is finished.  After this function has
741      * returned, all windows given to layoutWindow() <em>must</em> have had a
742      * frame assigned.
743      *
744      * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT},
745      * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER},
746      * or {@link #FINISH_LAYOUT_REDO_ANIM}.
747      */
finishLayoutLw()748     public int finishLayoutLw();
749 
750     /** Layout state may have changed (so another layout will be performed) */
751     static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001;
752     /** Configuration state may have changed */
753     static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002;
754     /** Wallpaper may need to move */
755     static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004;
756     /** Need to recompute animations */
757     static final int FINISH_LAYOUT_REDO_ANIM = 0x0008;
758 
759     /**
760      * Called when animation of the windows is about to start.
761      *
762      * @param displayWidth The current full width of the screen.
763      * @param displayHeight The current full height of the screen.
764      */
beginAnimationLw(int displayWidth, int displayHeight)765     public void beginAnimationLw(int displayWidth, int displayHeight);
766 
767     /**
768      * Called each time a window is animating.
769      *
770      * @param win The window being positioned.
771      * @param attrs The LayoutParams of the window.
772      */
animatingWindowLw(WindowState win, WindowManager.LayoutParams attrs)773     public void animatingWindowLw(WindowState win,
774             WindowManager.LayoutParams attrs);
775 
776     /**
777      * Called when animation of the windows is finished.  If in this function you do
778      * something that may have modified the animation state of another window,
779      * be sure to return true in order to perform another animation frame.
780      *
781      * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT},
782      * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER},
783      * or {@link #FINISH_LAYOUT_REDO_ANIM}.
784      */
finishAnimationLw()785     public int finishAnimationLw();
786 
787     /**
788      * Return true if it is okay to perform animations for an app transition
789      * that is about to occur.  You may return false for this if, for example,
790      * the lock screen is currently displayed so the switch should happen
791      * immediately.
792      */
allowAppAnimationsLw()793     public boolean allowAppAnimationsLw();
794 
795 
796     /**
797      * A new window has been focused.
798      */
focusChangedLw(WindowState lastFocus, WindowState newFocus)799     public int focusChangedLw(WindowState lastFocus, WindowState newFocus);
800 
801     /**
802      * Called after the screen turns off.
803      *
804      * @param why {@link #OFF_BECAUSE_OF_USER} or
805      * {@link #OFF_BECAUSE_OF_TIMEOUT}.
806      */
screenTurnedOff(int why)807     public void screenTurnedOff(int why);
808 
809     public interface ScreenOnListener {
onScreenOn()810         void onScreenOn();
811     };
812 
813     /**
814      * Called when the power manager would like to turn the screen on.
815      * Must call back on the listener to tell it when the higher-level system
816      * is ready for the screen to go on (i.e. the lock screen is shown).
817      */
screenTurningOn(ScreenOnListener screenOnListener)818     public void screenTurningOn(ScreenOnListener screenOnListener);
819 
820     /**
821      * Return whether the screen is about to turn on or is currently on.
822      */
isScreenOnEarly()823     public boolean isScreenOnEarly();
824 
825     /**
826      * Return whether the screen is fully turned on.
827      */
isScreenOnFully()828     public boolean isScreenOnFully();
829 
830     /**
831      * Tell the policy that the lid switch has changed state.
832      * @param whenNanos The time when the change occurred in uptime nanoseconds.
833      * @param lidOpen True if the lid is now open.
834      */
notifyLidSwitchChanged(long whenNanos, boolean lidOpen)835     public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen);
836 
837     /**
838      * Tell the policy if anyone is requesting that keyguard not come on.
839      *
840      * @param enabled Whether keyguard can be on or not.  does not actually
841      * turn it on, unless it was previously disabled with this function.
842      *
843      * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard()
844      * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard()
845      */
enableKeyguard(boolean enabled)846     public void enableKeyguard(boolean enabled);
847 
848     /**
849      * Callback used by {@link WindowManagerPolicy#exitKeyguardSecurely}
850      */
851     interface OnKeyguardExitResult {
onKeyguardExitResult(boolean success)852         void onKeyguardExitResult(boolean success);
853     }
854 
855     /**
856      * Tell the policy if anyone is requesting the keyguard to exit securely
857      * (this would be called after the keyguard was disabled)
858      * @param callback Callback to send the result back.
859      * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult)
860      */
exitKeyguardSecurely(OnKeyguardExitResult callback)861     void exitKeyguardSecurely(OnKeyguardExitResult callback);
862 
863     /**
864      * isKeyguardLocked
865      *
866      * Return whether the keyguard is currently locked.
867      *
868      * @return true if in keyguard is locked.
869      */
isKeyguardLocked()870     public boolean isKeyguardLocked();
871 
872     /**
873      * isKeyguardSecure
874      *
875      * Return whether the keyguard requires a password to unlock.
876      *
877      * @return true if in keyguard is secure.
878      */
isKeyguardSecure()879     public boolean isKeyguardSecure();
880 
881     /**
882      * inKeyguardRestrictedKeyInputMode
883      *
884      * if keyguard screen is showing or in restricted key input mode (i.e. in
885      * keyguard password emergency screen). When in such mode, certain keys,
886      * such as the Home key and the right soft keys, don't work.
887      *
888      * @return true if in keyguard restricted input mode.
889      */
inKeyguardRestrictedKeyInputMode()890     public boolean inKeyguardRestrictedKeyInputMode();
891 
892     /**
893      * Ask the policy to dismiss the keyguard, if it is currently shown.
894      */
dismissKeyguardLw()895     public void dismissKeyguardLw();
896 
897     /**
898      * Given an orientation constant, returns the appropriate surface rotation,
899      * taking into account sensors, docking mode, rotation lock, and other factors.
900      *
901      * @param orientation An orientation constant, such as
902      * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}.
903      * @param lastRotation The most recently used rotation.
904      * @return The surface rotation to use.
905      */
rotationForOrientationLw(int orientation, int lastRotation)906     public int rotationForOrientationLw(int orientation, int lastRotation);
907 
908     /**
909      * Given an orientation constant and a rotation, returns true if the rotation
910      * has compatible metrics to the requested orientation.  For example, if
911      * the application requested landscape and got seascape, then the rotation
912      * has compatible metrics; if the application requested portrait and got landscape,
913      * then the rotation has incompatible metrics; if the application did not specify
914      * a preference, then anything goes.
915      *
916      * @param orientation An orientation constant, such as
917      * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}.
918      * @param rotation The rotation to check.
919      * @return True if the rotation is compatible with the requested orientation.
920      */
rotationHasCompatibleMetricsLw(int orientation, int rotation)921     public boolean rotationHasCompatibleMetricsLw(int orientation, int rotation);
922 
923     /**
924      * Called by the window manager when the rotation changes.
925      *
926      * @param rotation The new rotation.
927      */
setRotationLw(int rotation)928     public void setRotationLw(int rotation);
929 
930     /**
931      * Called when the system is mostly done booting to determine whether
932      * the system should go into safe mode.
933      */
detectSafeMode()934     public boolean detectSafeMode();
935 
936     /**
937      * Called when the system is mostly done booting.
938      */
systemReady()939     public void systemReady();
940 
941     /**
942      * Called when the system is done booting to the point where the
943      * user can start interacting with it.
944      */
systemBooted()945     public void systemBooted();
946 
947     /**
948      * Show boot time message to the user.
949      */
showBootMessage(final CharSequence msg, final boolean always)950     public void showBootMessage(final CharSequence msg, final boolean always);
951 
952     /**
953      * Hide the UI for showing boot messages, never to be displayed again.
954      */
hideBootMessages()955     public void hideBootMessages();
956 
957     /**
958      * Called when userActivity is signalled in the power manager.
959      * This is safe to call from any thread, with any window manager locks held or not.
960      */
userActivity()961     public void userActivity();
962 
963     /**
964      * Called when we have finished booting and can now display the home
965      * screen to the user.  This wilWl happen after systemReady(), and at
966      * this point the display is active.
967      */
enableScreenAfterBoot()968     public void enableScreenAfterBoot();
969 
setCurrentOrientationLw(int newOrientation)970     public void setCurrentOrientationLw(int newOrientation);
971 
972     /**
973      * Call from application to perform haptic feedback on its window.
974      */
performHapticFeedbackLw(WindowState win, int effectId, boolean always)975     public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always);
976 
977     /**
978      * Called when we have started keeping the screen on because a window
979      * requesting this has become visible.
980      */
screenOnStartedLw()981     public void screenOnStartedLw();
982 
983     /**
984      * Called when we have stopped keeping the screen on because the last window
985      * requesting this is no longer visible.
986      */
screenOnStoppedLw()987     public void screenOnStoppedLw();
988 
989     /**
990      * Return false to disable key repeat events from being generated.
991      */
allowKeyRepeat()992     public boolean allowKeyRepeat();
993 
994     /**
995      * Inform the policy that the user has chosen a preferred orientation ("rotation lock").
996      *
997      * @param mode One of {@link WindowManagerPolicy#USER_ROTATION_LOCKED} or
998      *             {@link * WindowManagerPolicy#USER_ROTATION_FREE}.
999      * @param rotation One of {@link Surface#ROTATION_0}, {@link Surface#ROTATION_90},
1000      *                 {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}.
1001      */
setUserRotationMode(int mode, int rotation)1002     public void setUserRotationMode(int mode, int rotation);
1003 
1004     /**
1005      * Called when a new system UI visibility is being reported, allowing
1006      * the policy to adjust what is actually reported.
1007      * @param visibility The raw visiblity reported by the status bar.
1008      * @return The new desired visibility.
1009      */
adjustSystemUiVisibilityLw(int visibility)1010     public int adjustSystemUiVisibilityLw(int visibility);
1011 
1012     /**
1013      * Specifies whether there is an on-screen navigation bar separate from the status bar.
1014      */
hasNavigationBar()1015     public boolean hasNavigationBar();
1016 
1017     /**
1018      * Print the WindowManagerPolicy's state into the given stream.
1019      *
1020      * @param prefix Text to print at the front of each line.
1021      * @param fd The raw file descriptor that the dump is being sent to.
1022      * @param writer The PrintWriter to which you should dump your state.  This will be
1023      * closed for you after you return.
1024      * @param args additional arguments to the dump request.
1025      */
dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args)1026     public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args);
1027 }
1028