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.view;
18
19import android.annotation.NonNull;
20import android.annotation.Nullable;
21import android.graphics.Rect;
22import android.graphics.Region;
23import android.hardware.display.DisplayManagerInternal;
24import android.os.IBinder;
25import android.view.animation.Animation;
26
27import java.util.List;
28
29/**
30 * Window manager local system service interface.
31 *
32 * @hide Only for use within the system server.
33 */
34public abstract class WindowManagerInternal {
35
36    /**
37     * Interface to receive a callback when the windows reported for
38     * accessibility changed.
39     */
40    public interface WindowsForAccessibilityCallback {
41
42        /**
43         * Called when the windows for accessibility changed.
44         *
45         * @param windows The windows for accessibility.
46         */
47        public void onWindowsForAccessibilityChanged(List<WindowInfo> windows);
48    }
49
50    /**
51     * Callbacks for contextual changes that affect the screen magnification
52     * feature.
53     */
54    public interface MagnificationCallbacks {
55
56        /**
57         * Called when the region where magnification operates changes. Note that this isn't the
58         * entire screen. For example, IMEs are not magnified.
59         *
60         * @param magnificationRegion the current magnification region
61         */
62        public void onMagnificationRegionChanged(Region magnificationRegion);
63
64        /**
65         * Called when an application requests a rectangle on the screen to allow
66         * the client to apply the appropriate pan and scale.
67         *
68         * @param left The rectangle left.
69         * @param top The rectangle top.
70         * @param right The rectangle right.
71         * @param bottom The rectangle bottom.
72         */
73        public void onRectangleOnScreenRequested(int left, int top, int right, int bottom);
74
75        /**
76         * Notifies that the rotation changed.
77         *
78         * @param rotation The current rotation.
79         */
80        public void onRotationChanged(int rotation);
81
82        /**
83         * Notifies that the context of the user changed. For example, an application
84         * was started.
85         */
86        public void onUserContextChanged();
87    }
88
89    /**
90     * Abstract class to be notified about {@link com.android.server.wm.AppTransition} events. Held
91     * as an abstract class so a listener only needs to implement the methods of its interest.
92     */
93    public static abstract class AppTransitionListener {
94
95        /**
96         * Called when an app transition is being setup and about to be executed.
97         */
98        public void onAppTransitionPendingLocked() {}
99
100        /**
101         * Called when a pending app transition gets cancelled.
102         *
103         * @param transit transition type indicating what kind of transition got cancelled
104         */
105        public void onAppTransitionCancelledLocked(int transit) {}
106
107        /**
108         * Called when an app transition gets started
109         *
110         * @param transit transition type indicating what kind of transition gets run, must be one
111         *                of AppTransition.TRANSIT_* values
112         * @param openToken the token for the opening app
113         * @param closeToken the token for the closing app
114         * @param openAnimation the animation for the opening app
115         * @param closeAnimation the animation for the closing app
116         *
117         * @return Return any bit set of {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_LAYOUT},
118         * {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_CONFIG},
119         * {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_WALLPAPER},
120         * or {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_ANIM}.
121         */
122        public int onAppTransitionStartingLocked(int transit, IBinder openToken, IBinder closeToken,
123                Animation openAnimation, Animation closeAnimation) {
124            return 0;
125        }
126
127        /**
128         * Called when an app transition is finished running.
129         *
130         * @param token the token for app whose transition has finished
131         */
132        public void onAppTransitionFinishedLocked(IBinder token) {}
133    }
134
135    /**
136      * An interface to be notified about hardware keyboard status.
137      */
138    public interface OnHardKeyboardStatusChangeListener {
139        public void onHardKeyboardStatusChange(boolean available);
140    }
141
142    /**
143     * Request that the window manager call
144     * {@link DisplayManagerInternal#performTraversalInTransactionFromWindowManager}
145     * within a surface transaction at a later time.
146     */
147    public abstract void requestTraversalFromDisplayManager();
148
149    /**
150     * Set by the accessibility layer to observe changes in the magnified region,
151     * rotation, and other window transformations related to display magnification
152     * as the window manager is responsible for doing the actual magnification
153     * and has access to the raw window data while the accessibility layer serves
154     * as a controller.
155     *
156     * @param callbacks The callbacks to invoke.
157     */
158    public abstract void setMagnificationCallbacks(@Nullable MagnificationCallbacks callbacks);
159
160    /**
161     * Set by the accessibility layer to specify the magnification and panning to
162     * be applied to all windows that should be magnified.
163     *
164     * @param spec The MagnficationSpec to set.
165     *
166     * @see #setMagnificationCallbacks(MagnificationCallbacks)
167     */
168    public abstract void setMagnificationSpec(MagnificationSpec spec);
169
170    /**
171     * Set by the accessibility framework to indicate whether the magnifiable regions of the display
172     * should be shown.
173     *
174     * @param show {@code true} to show magnifiable region bounds, {@code false} to hide
175     */
176    public abstract void setForceShowMagnifiableBounds(boolean show);
177
178    /**
179     * Obtains the magnification regions.
180     *
181     * @param magnificationRegion the current magnification region
182     */
183    public abstract void getMagnificationRegion(@NonNull Region magnificationRegion);
184
185    /**
186     * Gets the magnification and translation applied to a window given its token.
187     * Not all windows are magnified and the window manager policy determines which
188     * windows are magnified. The returned result also takes into account the compat
189     * scale if necessary.
190     *
191     * @param windowToken The window's token.
192     *
193     * @return The magnification spec for the window.
194     *
195     * @see #setMagnificationCallbacks(MagnificationCallbacks)
196     */
197    public abstract MagnificationSpec getCompatibleMagnificationSpecForWindow(
198            IBinder windowToken);
199
200    /**
201     * Sets a callback for observing which windows are touchable for the purposes
202     * of accessibility.
203     *
204     * @param callback The callback.
205     */
206    public abstract void setWindowsForAccessibilityCallback(
207            WindowsForAccessibilityCallback callback);
208
209    /**
210     * Sets a filter for manipulating the input event stream.
211     *
212     * @param filter The filter implementation.
213     */
214    public abstract void setInputFilter(IInputFilter filter);
215
216    /**
217     * Gets the token of the window that has input focus.
218     *
219     * @return The token.
220     */
221    public abstract IBinder getFocusedWindowToken();
222
223    /**
224     * @return Whether the keyguard is engaged.
225     */
226    public abstract boolean isKeyguardLocked();
227
228    /** @return {@code true} if the keyguard is going away. */
229    public abstract boolean isKeyguardGoingAway();
230
231    /**
232     * Gets the frame of a window given its token.
233     *
234     * @param token The token.
235     * @param outBounds The frame to populate.
236     */
237    public abstract void getWindowFrame(IBinder token, Rect outBounds);
238
239    /**
240     * Opens the global actions dialog.
241     */
242    public abstract void showGlobalActions();
243
244    /**
245     * Invalidate all visible windows. Then report back on the callback once all windows have
246     * redrawn.
247     */
248    public abstract void waitForAllWindowsDrawn(Runnable callback, long timeout);
249
250    /**
251     * Adds a window token for a given window type.
252     *
253     * @param token The token to add.
254     * @param type The window type.
255     * @param displayId The display to add the token to.
256     */
257    public abstract void addWindowToken(android.os.IBinder token, int type, int displayId);
258
259    /**
260     * Removes a window token.
261     *
262     * @param token The toke to remove.
263     * @param removeWindows Whether to also remove the windows associated with the token.
264     * @param displayId The display to remove the token from.
265     */
266    public abstract void removeWindowToken(android.os.IBinder token, boolean removeWindows,
267            int displayId);
268
269    /**
270     * Registers a listener to be notified about app transition events.
271     *
272     * @param listener The listener to register.
273     */
274    public abstract void registerAppTransitionListener(AppTransitionListener listener);
275
276    /**
277     * Retrieves a height of input method window.
278     */
279    public abstract int getInputMethodWindowVisibleHeight();
280
281    /**
282      * Saves last input method window for transition.
283      *
284      * Note that it is assumed that this method is called only by InputMethodManagerService.
285      */
286    public abstract void saveLastInputMethodWindowForTransition();
287
288    /**
289     * Clears last input method window for transition.
290     *
291     * Note that it is assumed that this method is called only by InputMethodManagerService.
292     */
293    public abstract void clearLastInputMethodWindowForTransition();
294
295    /**
296     * Notifies WindowManagerService that the current IME window status is being changed.
297     *
298     * <p>Only {@link com.android.server.InputMethodManagerService} is the expected and tested
299     * caller of this method.</p>
300     *
301     * @param imeToken token to track the active input method. Corresponding IME windows can be
302     *                 identified by checking {@link android.view.WindowManager.LayoutParams#token}.
303     *                 Note that there is no guarantee that the corresponding window is already
304     *                 created
305     * @param imeWindowVisible whether the active IME thinks that its window should be visible or
306     *                         hidden, no matter how WindowManagerService will react / has reacted
307     *                         to corresponding API calls.  Note that this state is not guaranteed
308     *                         to be synchronized with state in WindowManagerService.
309     * @param dismissImeOnBackKeyPressed {@code true} if the software keyboard is shown and the back
310     *                                   key is expected to dismiss the software keyboard.
311     * @param targetWindowToken token to identify the target window that the IME is associated with.
312     *                          {@code null} when application, system, or the IME itself decided to
313     *                          change its window visibility before being associated with any target
314     *                          window.
315     */
316    public abstract void updateInputMethodWindowStatus(@NonNull IBinder imeToken,
317            boolean imeWindowVisible, boolean dismissImeOnBackKeyPressed,
318            @Nullable IBinder targetWindowToken);
319
320    /**
321      * Returns true when the hardware keyboard is available.
322      */
323    public abstract boolean isHardKeyboardAvailable();
324
325    /**
326      * Sets the callback listener for hardware keyboard status changes.
327      *
328      * @param listener The listener to set.
329      */
330    public abstract void setOnHardKeyboardStatusChangeListener(
331        OnHardKeyboardStatusChangeListener listener);
332
333    /** Returns true if the stack with the input Id is currently visible. */
334    public abstract boolean isStackVisible(int stackId);
335
336    /**
337     * @return True if and only if the docked divider is currently in resize mode.
338     */
339    public abstract boolean isDockedDividerResizing();
340
341    /**
342     * Requests the window manager to recompute the windows for accessibility.
343     */
344    public abstract void computeWindowsForAccessibility();
345}
346