1 /* 2 * Copyright (C) 2010 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 com.android.server.wm; 18 19 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_DRAG; 20 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS_LIGHT; 21 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_INPUT; 22 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_POSITIONING; 23 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM; 24 25 import android.app.ActivityManagerNative; 26 import android.graphics.Rect; 27 import android.os.Debug; 28 import android.os.RemoteException; 29 import android.util.Log; 30 import android.util.Slog; 31 import android.view.Display; 32 import android.view.InputChannel; 33 import android.view.KeyEvent; 34 import android.view.WindowManager; 35 36 import com.android.server.input.InputApplicationHandle; 37 import com.android.server.input.InputManagerService; 38 import com.android.server.input.InputWindowHandle; 39 40 import java.io.PrintWriter; 41 import java.util.Arrays; 42 43 final class InputMonitor implements InputManagerService.WindowManagerCallbacks { 44 private final WindowManagerService mService; 45 46 // Current window with input focus for keys and other non-touch events. May be null. 47 private WindowState mInputFocus; 48 49 // When true, prevents input dispatch from proceeding until set to false again. 50 private boolean mInputDispatchFrozen; 51 52 // The reason the input is currently frozen or null if the input isn't frozen. 53 private String mInputFreezeReason = null; 54 55 // When true, input dispatch proceeds normally. Otherwise all events are dropped. 56 // Initially false, so that input does not get dispatched until boot is finished at 57 // which point the ActivityManager will enable dispatching. 58 private boolean mInputDispatchEnabled; 59 60 // When true, need to call updateInputWindowsLw(). 61 private boolean mUpdateInputWindowsNeeded = true; 62 63 // Array of window handles to provide to the input dispatcher. 64 private InputWindowHandle[] mInputWindowHandles; 65 private int mInputWindowHandleCount; 66 67 // Set to true when the first input device configuration change notification 68 // is received to indicate that the input devices are ready. 69 private final Object mInputDevicesReadyMonitor = new Object(); 70 private boolean mInputDevicesReady; 71 72 public InputMonitor(WindowManagerService service) { 73 mService = service; 74 } 75 76 /* Notifies the window manager about a broken input channel. 77 * 78 * Called by the InputManager. 79 */ 80 @Override 81 public void notifyInputChannelBroken(InputWindowHandle inputWindowHandle) { 82 if (inputWindowHandle == null) { 83 return; 84 } 85 86 synchronized (mService.mWindowMap) { 87 WindowState windowState = (WindowState) inputWindowHandle.windowState; 88 if (windowState != null) { 89 Slog.i(TAG_WM, "WINDOW DIED " + windowState); 90 mService.removeWindowLocked(windowState); 91 } 92 } 93 } 94 95 /* Notifies the window manager about an application that is not responding. 96 * Returns a new timeout to continue waiting in nanoseconds, or 0 to abort dispatch. 97 * 98 * Called by the InputManager. 99 */ 100 @Override 101 public long notifyANR(InputApplicationHandle inputApplicationHandle, 102 InputWindowHandle inputWindowHandle, String reason) { 103 AppWindowToken appWindowToken = null; 104 WindowState windowState = null; 105 boolean aboveSystem = false; 106 synchronized (mService.mWindowMap) { 107 if (inputWindowHandle != null) { 108 windowState = (WindowState) inputWindowHandle.windowState; 109 if (windowState != null) { 110 appWindowToken = windowState.mAppToken; 111 } 112 } 113 if (appWindowToken == null && inputApplicationHandle != null) { 114 appWindowToken = (AppWindowToken)inputApplicationHandle.appWindowToken; 115 } 116 117 if (windowState != null) { 118 Slog.i(TAG_WM, "Input event dispatching timed out " 119 + "sending to " + windowState.mAttrs.getTitle() 120 + ". Reason: " + reason); 121 // Figure out whether this window is layered above system windows. 122 // We need to do this here to help the activity manager know how to 123 // layer its ANR dialog. 124 int systemAlertLayer = mService.mPolicy.windowTypeToLayerLw( 125 WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); 126 aboveSystem = windowState.mBaseLayer > systemAlertLayer; 127 } else if (appWindowToken != null) { 128 Slog.i(TAG_WM, "Input event dispatching timed out " 129 + "sending to application " + appWindowToken.stringName 130 + ". Reason: " + reason); 131 } else { 132 Slog.i(TAG_WM, "Input event dispatching timed out " 133 + ". Reason: " + reason); 134 } 135 136 mService.saveANRStateLocked(appWindowToken, windowState, reason); 137 } 138 139 if (appWindowToken != null && appWindowToken.appToken != null) { 140 try { 141 // Notify the activity manager about the timeout and let it decide whether 142 // to abort dispatching or keep waiting. 143 boolean abort = appWindowToken.appToken.keyDispatchingTimedOut(reason); 144 if (! abort) { 145 // The activity manager declined to abort dispatching. 146 // Wait a bit longer and timeout again later. 147 return appWindowToken.inputDispatchingTimeoutNanos; 148 } 149 } catch (RemoteException ex) { 150 } 151 } else if (windowState != null) { 152 try { 153 // Notify the activity manager about the timeout and let it decide whether 154 // to abort dispatching or keep waiting. 155 long timeout = ActivityManagerNative.getDefault().inputDispatchingTimedOut( 156 windowState.mSession.mPid, aboveSystem, reason); 157 if (timeout >= 0) { 158 // The activity manager declined to abort dispatching. 159 // Wait a bit longer and timeout again later. 160 return timeout * 1000000L; // nanoseconds 161 } 162 } catch (RemoteException ex) { 163 } 164 } 165 return 0; // abort dispatching 166 } 167 168 private void addInputWindowHandleLw(final InputWindowHandle windowHandle) { 169 if (mInputWindowHandles == null) { 170 mInputWindowHandles = new InputWindowHandle[16]; 171 } 172 if (mInputWindowHandleCount >= mInputWindowHandles.length) { 173 mInputWindowHandles = Arrays.copyOf(mInputWindowHandles, 174 mInputWindowHandleCount * 2); 175 } 176 mInputWindowHandles[mInputWindowHandleCount++] = windowHandle; 177 } 178 179 private void addInputWindowHandleLw(final InputWindowHandle inputWindowHandle, 180 final WindowState child, int flags, final int type, final boolean isVisible, 181 final boolean hasFocus, final boolean hasWallpaper) { 182 // Add a window to our list of input windows. 183 inputWindowHandle.name = child.toString(); 184 flags = child.getTouchableRegion(inputWindowHandle.touchableRegion, flags); 185 inputWindowHandle.layoutParamsFlags = flags; 186 inputWindowHandle.layoutParamsType = type; 187 inputWindowHandle.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos(); 188 inputWindowHandle.visible = isVisible; 189 inputWindowHandle.canReceiveKeys = child.canReceiveKeys(); 190 inputWindowHandle.hasFocus = hasFocus; 191 inputWindowHandle.hasWallpaper = hasWallpaper; 192 inputWindowHandle.paused = child.mAppToken != null ? child.mAppToken.paused : false; 193 inputWindowHandle.layer = child.mLayer; 194 inputWindowHandle.ownerPid = child.mSession.mPid; 195 inputWindowHandle.ownerUid = child.mSession.mUid; 196 inputWindowHandle.inputFeatures = child.mAttrs.inputFeatures; 197 198 final Rect frame = child.mFrame; 199 inputWindowHandle.frameLeft = frame.left; 200 inputWindowHandle.frameTop = frame.top; 201 inputWindowHandle.frameRight = frame.right; 202 inputWindowHandle.frameBottom = frame.bottom; 203 204 if (child.isDockedInEffect()) { 205 // Adjust to account for non-resizeable tasks that's scrolled 206 inputWindowHandle.frameLeft += child.mXOffset; 207 inputWindowHandle.frameTop += child.mYOffset; 208 inputWindowHandle.frameRight += child.mXOffset; 209 inputWindowHandle.frameBottom += child.mYOffset; 210 } 211 212 if (child.mGlobalScale != 1) { 213 // If we are scaling the window, input coordinates need 214 // to be inversely scaled to map from what is on screen 215 // to what is actually being touched in the UI. 216 inputWindowHandle.scaleFactor = 1.0f/child.mGlobalScale; 217 } else { 218 inputWindowHandle.scaleFactor = 1; 219 } 220 221 if (DEBUG_INPUT) { 222 Slog.d(TAG_WM, "addInputWindowHandle: " 223 + child + ", " + inputWindowHandle); 224 } 225 addInputWindowHandleLw(inputWindowHandle); 226 } 227 228 private void clearInputWindowHandlesLw() { 229 while (mInputWindowHandleCount != 0) { 230 mInputWindowHandles[--mInputWindowHandleCount] = null; 231 } 232 } 233 234 public void setUpdateInputWindowsNeededLw() { 235 mUpdateInputWindowsNeeded = true; 236 } 237 238 /* Updates the cached window information provided to the input dispatcher. */ 239 public void updateInputWindowsLw(boolean force) { 240 if (!force && !mUpdateInputWindowsNeeded) { 241 return; 242 } 243 mUpdateInputWindowsNeeded = false; 244 245 if (false) Slog.d(TAG_WM, ">>>>>> ENTERED updateInputWindowsLw"); 246 247 // Populate the input window list with information about all of the windows that 248 // could potentially receive input. 249 // As an optimization, we could try to prune the list of windows but this turns 250 // out to be difficult because only the native code knows for sure which window 251 // currently has touch focus. 252 boolean disableWallpaperTouchEvents = false; 253 254 // If there's a drag in flight, provide a pseudowindow to catch drag input 255 final boolean inDrag = (mService.mDragState != null); 256 if (inDrag) { 257 if (DEBUG_DRAG) { 258 Log.d(TAG_WM, "Inserting drag window"); 259 } 260 final InputWindowHandle dragWindowHandle = mService.mDragState.mDragWindowHandle; 261 if (dragWindowHandle != null) { 262 addInputWindowHandleLw(dragWindowHandle); 263 } else { 264 Slog.w(TAG_WM, "Drag is in progress but there is no " 265 + "drag window handle."); 266 } 267 } 268 269 final boolean inPositioning = (mService.mTaskPositioner != null); 270 if (inPositioning) { 271 if (DEBUG_TASK_POSITIONING) { 272 Log.d(TAG_WM, "Inserting window handle for repositioning"); 273 } 274 final InputWindowHandle dragWindowHandle = mService.mTaskPositioner.mDragWindowHandle; 275 if (dragWindowHandle != null) { 276 addInputWindowHandleLw(dragWindowHandle); 277 } else { 278 Slog.e(TAG_WM, 279 "Repositioning is in progress but there is no drag window handle."); 280 } 281 } 282 283 boolean addInputConsumerHandle = mService.mInputConsumer != null; 284 285 boolean addWallpaperInputConsumerHandle = mService.mWallpaperInputConsumer != null; 286 287 // Add all windows on the default display. 288 final int numDisplays = mService.mDisplayContents.size(); 289 final WallpaperController wallpaperController = mService.mWallpaperControllerLocked; 290 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 291 final DisplayContent displayContent = mService.mDisplayContents.valueAt(displayNdx); 292 final WindowList windows = displayContent.getWindowList(); 293 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) { 294 final WindowState child = windows.get(winNdx); 295 final InputChannel inputChannel = child.mInputChannel; 296 final InputWindowHandle inputWindowHandle = child.mInputWindowHandle; 297 if (inputChannel == null || inputWindowHandle == null || child.mRemoved 298 || child.isAdjustedForMinimizedDock()) { 299 // Skip this window because it cannot possibly receive input. 300 continue; 301 } 302 if (addInputConsumerHandle 303 && inputWindowHandle.layer <= mService.mInputConsumer.mWindowHandle.layer) { 304 addInputWindowHandleLw(mService.mInputConsumer.mWindowHandle); 305 addInputConsumerHandle = false; 306 } 307 308 if (addWallpaperInputConsumerHandle) { 309 if (child.mAttrs.type == WindowManager.LayoutParams.TYPE_WALLPAPER) { 310 // Add the wallpaper input consumer above the first wallpaper window. 311 addInputWindowHandleLw(mService.mWallpaperInputConsumer.mWindowHandle); 312 addWallpaperInputConsumerHandle = false; 313 } 314 } 315 316 final int flags = child.mAttrs.flags; 317 final int privateFlags = child.mAttrs.privateFlags; 318 final int type = child.mAttrs.type; 319 320 final boolean hasFocus = (child == mInputFocus); 321 final boolean isVisible = child.isVisibleLw(); 322 if ((privateFlags 323 & WindowManager.LayoutParams.PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS) 324 != 0) { 325 disableWallpaperTouchEvents = true; 326 } 327 final boolean hasWallpaper = wallpaperController.isWallpaperTarget(child) 328 && (privateFlags & WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD) == 0 329 && !disableWallpaperTouchEvents; 330 final boolean onDefaultDisplay = (child.getDisplayId() == Display.DEFAULT_DISPLAY); 331 332 // If there's a drag in progress and 'child' is a potential drop target, 333 // make sure it's been told about the drag 334 if (inDrag && isVisible && onDefaultDisplay) { 335 mService.mDragState.sendDragStartedIfNeededLw(child); 336 } 337 338 addInputWindowHandleLw( 339 inputWindowHandle, child, flags, type, isVisible, hasFocus, hasWallpaper); 340 } 341 } 342 343 if (addWallpaperInputConsumerHandle) { 344 // No wallpaper found, add the wallpaper input consumer at the end. 345 addInputWindowHandleLw(mService.mWallpaperInputConsumer.mWindowHandle); 346 } 347 348 // Send windows to native code. 349 mService.mInputManager.setInputWindows(mInputWindowHandles); 350 351 // Clear the list in preparation for the next round. 352 clearInputWindowHandlesLw(); 353 354 if (false) Slog.d(TAG_WM, "<<<<<<< EXITED updateInputWindowsLw"); 355 } 356 357 /* Notifies that the input device configuration has changed. */ 358 @Override 359 public void notifyConfigurationChanged() { 360 mService.sendNewConfiguration(); 361 362 synchronized (mInputDevicesReadyMonitor) { 363 if (!mInputDevicesReady) { 364 mInputDevicesReady = true; 365 mInputDevicesReadyMonitor.notifyAll(); 366 } 367 } 368 } 369 370 /* Waits until the built-in input devices have been configured. */ 371 public boolean waitForInputDevicesReady(long timeoutMillis) { 372 synchronized (mInputDevicesReadyMonitor) { 373 if (!mInputDevicesReady) { 374 try { 375 mInputDevicesReadyMonitor.wait(timeoutMillis); 376 } catch (InterruptedException ex) { 377 } 378 } 379 return mInputDevicesReady; 380 } 381 } 382 383 /* Notifies that the lid switch changed state. */ 384 @Override 385 public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen) { 386 mService.mPolicy.notifyLidSwitchChanged(whenNanos, lidOpen); 387 } 388 389 /* Notifies that the camera lens cover state has changed. */ 390 @Override 391 public void notifyCameraLensCoverSwitchChanged(long whenNanos, boolean lensCovered) { 392 mService.mPolicy.notifyCameraLensCoverSwitchChanged(whenNanos, lensCovered); 393 } 394 395 /* Provides an opportunity for the window manager policy to intercept early key 396 * processing as soon as the key has been read from the device. */ 397 @Override 398 public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) { 399 return mService.mPolicy.interceptKeyBeforeQueueing(event, policyFlags); 400 } 401 402 /* Provides an opportunity for the window manager policy to intercept early motion event 403 * processing when the device is in a non-interactive state since these events are normally 404 * dropped. */ 405 @Override 406 public int interceptMotionBeforeQueueingNonInteractive(long whenNanos, int policyFlags) { 407 return mService.mPolicy.interceptMotionBeforeQueueingNonInteractive( 408 whenNanos, policyFlags); 409 } 410 411 /* Provides an opportunity for the window manager policy to process a key before 412 * ordinary dispatch. */ 413 @Override 414 public long interceptKeyBeforeDispatching( 415 InputWindowHandle focus, KeyEvent event, int policyFlags) { 416 WindowState windowState = focus != null ? (WindowState) focus.windowState : null; 417 return mService.mPolicy.interceptKeyBeforeDispatching(windowState, event, policyFlags); 418 } 419 420 /* Provides an opportunity for the window manager policy to process a key that 421 * the application did not handle. */ 422 @Override 423 public KeyEvent dispatchUnhandledKey( 424 InputWindowHandle focus, KeyEvent event, int policyFlags) { 425 WindowState windowState = focus != null ? (WindowState) focus.windowState : null; 426 return mService.mPolicy.dispatchUnhandledKey(windowState, event, policyFlags); 427 } 428 429 /* Callback to get pointer layer. */ 430 @Override 431 public int getPointerLayer() { 432 return mService.mPolicy.windowTypeToLayerLw(WindowManager.LayoutParams.TYPE_POINTER) 433 * WindowManagerService.TYPE_LAYER_MULTIPLIER 434 + WindowManagerService.TYPE_LAYER_OFFSET; 435 } 436 437 /* Called when the current input focus changes. 438 * Layer assignment is assumed to be complete by the time this is called. 439 */ 440 public void setInputFocusLw(WindowState newWindow, boolean updateInputWindows) { 441 if (DEBUG_FOCUS_LIGHT || DEBUG_INPUT) { 442 Slog.d(TAG_WM, "Input focus has changed to " + newWindow); 443 } 444 445 if (newWindow != mInputFocus) { 446 if (newWindow != null && newWindow.canReceiveKeys()) { 447 // Displaying a window implicitly causes dispatching to be unpaused. 448 // This is to protect against bugs if someone pauses dispatching but 449 // forgets to resume. 450 newWindow.mToken.paused = false; 451 } 452 453 mInputFocus = newWindow; 454 setUpdateInputWindowsNeededLw(); 455 456 if (updateInputWindows) { 457 updateInputWindowsLw(false /*force*/); 458 } 459 } 460 } 461 462 public void setFocusedAppLw(AppWindowToken newApp) { 463 // Focused app has changed. 464 if (newApp == null) { 465 mService.mInputManager.setFocusedApplication(null); 466 } else { 467 final InputApplicationHandle handle = newApp.mInputApplicationHandle; 468 handle.name = newApp.toString(); 469 handle.dispatchingTimeoutNanos = newApp.inputDispatchingTimeoutNanos; 470 471 mService.mInputManager.setFocusedApplication(handle); 472 } 473 } 474 475 public void pauseDispatchingLw(WindowToken window) { 476 if (! window.paused) { 477 if (DEBUG_INPUT) { 478 Slog.v(TAG_WM, "Pausing WindowToken " + window); 479 } 480 481 window.paused = true; 482 updateInputWindowsLw(true /*force*/); 483 } 484 } 485 486 public void resumeDispatchingLw(WindowToken window) { 487 if (window.paused) { 488 if (DEBUG_INPUT) { 489 Slog.v(TAG_WM, "Resuming WindowToken " + window); 490 } 491 492 window.paused = false; 493 updateInputWindowsLw(true /*force*/); 494 } 495 } 496 497 public void freezeInputDispatchingLw() { 498 if (!mInputDispatchFrozen) { 499 if (DEBUG_INPUT) { 500 Slog.v(TAG_WM, "Freezing input dispatching"); 501 } 502 503 mInputDispatchFrozen = true; 504 505 if (DEBUG_INPUT || true) { 506 mInputFreezeReason = Debug.getCallers(6); 507 } 508 updateInputDispatchModeLw(); 509 } 510 } 511 512 public void thawInputDispatchingLw() { 513 if (mInputDispatchFrozen) { 514 if (DEBUG_INPUT) { 515 Slog.v(TAG_WM, "Thawing input dispatching"); 516 } 517 518 mInputDispatchFrozen = false; 519 mInputFreezeReason = null; 520 updateInputDispatchModeLw(); 521 } 522 } 523 524 public void setEventDispatchingLw(boolean enabled) { 525 if (mInputDispatchEnabled != enabled) { 526 if (DEBUG_INPUT) { 527 Slog.v(TAG_WM, "Setting event dispatching to " + enabled); 528 } 529 530 mInputDispatchEnabled = enabled; 531 updateInputDispatchModeLw(); 532 } 533 } 534 535 private void updateInputDispatchModeLw() { 536 mService.mInputManager.setInputDispatchMode(mInputDispatchEnabled, mInputDispatchFrozen); 537 } 538 539 void dump(PrintWriter pw, String prefix) { 540 if (mInputFreezeReason != null) { 541 pw.println(prefix + "mInputFreezeReason=" + mInputFreezeReason); 542 } 543 } 544 } 545