core/java/android/view/WindowManagerInternal.java

   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
  17 package android.view;
  18
  19 import android.annotation.NonNull;
  20 import android.annotation.Nullable;
  21 import android.graphics.Rect;
  22 import android.graphics.Region;
  23 import android.hardware.display.DisplayManagerInternal;
  24 import android.os.IBinder;
  25 import android.view.animation.Animation;
  26
  27 import java.util.List;
  28
  29 /**
  30  * Window manager local system service interface.
  31  *
  32  * @hide Only for use within the system server.
  33  */
  34 public 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      * Obtains the magnification regions.
 172      *
 173      * @param magnificationRegion the current magnification region
 174      */
 175     public abstract void getMagnificationRegion(@NonNull Region magnificationRegion);
 176
 177     /**
 178      * Gets the magnification and translation applied to a window given its token.
 179      * Not all windows are magnified and the window manager policy determines which
 180      * windows are magnified. The returned result also takes into account the compat
 181      * scale if necessary.
 182      *
 183      * @param windowToken The window's token.
 184      *
 185      * @return The magnification spec for the window.
 186      *
 187      * @see #setMagnificationCallbacks(MagnificationCallbacks)
 188      */
 189     public abstract MagnificationSpec getCompatibleMagnificationSpecForWindow(
 190             IBinder windowToken);
 191
 192     /**
 193      * Sets a callback for observing which windows are touchable for the purposes
 194      * of accessibility.
 195      *
 196      * @param callback The callback.
 197      */
 198     public abstract void setWindowsForAccessibilityCallback(
 199             WindowsForAccessibilityCallback callback);
 200
 201     /**
 202      * Sets a filter for manipulating the input event stream.
 203      *
 204      * @param filter The filter implementation.
 205      */
 206     public abstract void setInputFilter(IInputFilter filter);
 207
 208     /**
 209      * Gets the token of the window that has input focus.
 210      *
 211      * @return The token.
 212      */
 213     public abstract IBinder getFocusedWindowToken();
 214
 215     /**
 216      * @return Whether the keyguard is engaged.
 217      */
 218     public abstract boolean isKeyguardLocked();
 219
 220     /**
 221      * Gets the frame of a window given its token.
 222      *
 223      * @param token The token.
 224      * @param outBounds The frame to populate.
 225      */
 226     public abstract void getWindowFrame(IBinder token, Rect outBounds);
 227
 228     /**
 229      * Opens the global actions dialog.
 230      */
 231     public abstract void showGlobalActions();
 232
 233     /**
 234      * Invalidate all visible windows. Then report back on the callback once all windows have
 235      * redrawn.
 236      */
 237     public abstract void waitForAllWindowsDrawn(Runnable callback, long timeout);
 238
 239     /**
 240      * Adds a window token for a given window type.
 241      *
 242      * @param token The token to add.
 243      * @param type The window type.
 244      * @param displayId The display to add the token to.
 245      */
 246     public abstract void addWindowToken(android.os.IBinder token, int type, int displayId);
 247
 248     /**
 249      * Removes a window token.
 250      *
 251      * @param token The toke to remove.
 252      * @param removeWindows Whether to also remove the windows associated with the token.
 253      * @param displayId The display to remove the token from.
 254      */
 255     public abstract void removeWindowToken(android.os.IBinder token, boolean removeWindows,
 256             int displayId);
 257
 258     /**
 259      * Registers a listener to be notified about app transition events.
 260      *
 261      * @param listener The listener to register.
 262      */
 263     public abstract void registerAppTransitionListener(AppTransitionListener listener);
 264
 265     /**
 266      * Retrieves a height of input method window.
 267      */
 268     public abstract int getInputMethodWindowVisibleHeight();
 269
 270     /**
 271       * Saves last input method window for transition.
 272       *
 273       * Note that it is assumed that this method is called only by InputMethodManagerService.
 274       */
 275     public abstract void saveLastInputMethodWindowForTransition();
 276
 277     /**
 278      * Clears last input method window for transition.
 279      *
 280      * Note that it is assumed that this method is called only by InputMethodManagerService.
 281      */
 282     public abstract void clearLastInputMethodWindowForTransition();
 283
 284     /**
 285      * Notifies WindowManagerService that the current IME window status is being changed.
 286      *
 287      * <p>Only {@link com.android.server.InputMethodManagerService} is the expected and tested
 288      * caller of this method.</p>
 289      *
 290      * @param imeToken token to track the active input method. Corresponding IME windows can be
 291      *                 identified by checking {@link android.view.WindowManager.LayoutParams#token}.
 292      *                 Note that there is no guarantee that the corresponding window is already
 293      *                 created
 294      * @param imeWindowVisible whether the active IME thinks that its window should be visible or
 295      *                         hidden, no matter how WindowManagerService will react / has reacted
 296      *                         to corresponding API calls.  Note that this state is not guaranteed
 297      *                         to be synchronized with state in WindowManagerService.
 298      * @param targetWindowToken token to identify the target window that the IME is associated with.
 299      */
 300     public abstract void updateInputMethodWindowStatus(IBinder imeToken, boolean imeWindowVisible,
 301             IBinder targetWindowToken);
 302
 303     /**
 304       * Returns true when the hardware keyboard is available.
 305       */
 306     public abstract boolean isHardKeyboardAvailable();
 307
 308     /**
 309       * Sets the callback listener for hardware keyboard status changes.
 310       *
 311       * @param listener The listener to set.
 312       */
 313     public abstract void setOnHardKeyboardStatusChangeListener(
 314         OnHardKeyboardStatusChangeListener listener);
 315
 316     /** Returns true if the stack with the input Id is currently visible. */
 317     public abstract boolean isStackVisible(int stackId);
 318
 319     /**
 320      * @return True if and only if the docked divider is currently in resize mode.
 321      */
 322     public abstract boolean isDockedDividerResizing();
 323
 324     /**
 325      * Requests the window manager to recompute the windows for accessibility.
 326      */
 327     public abstract void computeWindowsForAccessibility();
 328 }