services/core/java/com/android/server/wm/InputMonitor.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.wm;

 import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;
 import static android.view.WindowManager.INPUT_CONSUMER_NAVIGATION;
 import static android.view.WindowManager.INPUT_CONSUMER_PIP;
 import static android.view.WindowManager.INPUT_CONSUMER_RECENTS_ANIMATION;
 import static android.view.WindowManager.INPUT_CONSUMER_WALLPAPER;
 import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS;
 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
 import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;

 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS_LIGHT;
 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_INPUT;
 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_POSITIONING;
 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;

 import android.graphics.Rect;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Process;
 import android.os.Trace;
 import android.os.UserHandle;
 import android.util.ArrayMap;
 import android.util.Log;
 import android.util.Slog;
 import android.view.InputApplicationHandle;
 import android.view.InputChannel;
 import android.view.InputEventReceiver;
 import android.view.InputWindowHandle;
 import android.view.SurfaceControl;

 import com.android.server.AnimationThread;
 import com.android.server.policy.WindowManagerPolicy;

 import java.io.PrintWriter;
 import java.util.Set;
 import java.util.function.Consumer;

 final class InputMonitor {
     private final WindowManagerService mService;

     // Current window with input focus for keys and other non-touch events.  May be null.
     private WindowState mInputFocus;

     // When true, need to call updateInputWindowsLw().
     private boolean mUpdateInputWindowsNeeded = true;
     private boolean mUpdateInputWindowsPending;
     private boolean mApplyImmediately;

     // Currently focused input window handle.
     private InputWindowHandle mFocusedInputWindowHandle;

     private boolean mDisableWallpaperTouchEvents;
     private final Rect mTmpRect = new Rect();
     private final UpdateInputForAllWindowsConsumer mUpdateInputForAllWindowsConsumer;

     private final int mDisplayId;
     private final DisplayContent mDisplayContent;
     private boolean mDisplayRemoved;

     private final SurfaceControl.Transaction mInputTransaction;
     private final Handler mHandler;

     /**
      * The set of input consumer added to the window manager by name, which consumes input events
      * for the windows below it.
      */
     private final ArrayMap<String, InputConsumerImpl> mInputConsumers = new ArrayMap();

     private static final class EventReceiverInputConsumer extends InputConsumerImpl
             implements WindowManagerPolicy.InputConsumer {
         private InputMonitor mInputMonitor;
         private final InputEventReceiver mInputEventReceiver;

         EventReceiverInputConsumer(WindowManagerService service, InputMonitor monitor,
                                    Looper looper, String name,
                                    InputEventReceiver.Factory inputEventReceiverFactory,
                                    int clientPid, UserHandle clientUser, int displayId) {
             super(service, null /* token */, name, null /* inputChannel */, clientPid, clientUser,
                     displayId);
             mInputMonitor = monitor;
             mInputEventReceiver = inputEventReceiverFactory.createInputEventReceiver(
                     mClientChannel, looper);
         }

         @Override
         public void dismiss() {
             synchronized (mService.mGlobalLock) {
                 if (mInputMonitor.destroyInputConsumer(mWindowHandle.name)) {
                     mInputEventReceiver.dispose();
                 }
             }
         }
     }

     private final Runnable mUpdateInputWindows = new Runnable() {
         @Override
         public void run() {
             synchronized (mService.mGlobalLock) {
                 mUpdateInputWindowsPending = false;
                 mUpdateInputWindowsNeeded = false;

                 if (mDisplayRemoved) {
                     return;
                 }

                 // Populate the input window list with information about all of the windows that
                 // could potentially receive input.
                 // As an optimization, we could try to prune the list of windows but this turns
                 // out to be difficult because only the native code knows for sure which window
                 // currently has touch focus.

                 // If there's a drag in flight, provide a pseudo-window to catch drag input
                 final boolean inDrag = mService.mDragDropController.dragDropActiveLocked();
                 final boolean inPositioning =
                         mService.mTaskPositioningController.isPositioningLocked();
                 if (inPositioning) {
                     if (DEBUG_TASK_POSITIONING) {
                         Log.d(TAG_WM, "Inserting window handle for repositioning");
                     }
                     mService.mTaskPositioningController.showInputSurface(mInputTransaction,
                             mDisplayId);
                 } else {
                     mService.mTaskPositioningController.hideInputSurface(mInputTransaction,
                             mDisplayId);
                 }

                 // Add all windows on the default display.
                 mUpdateInputForAllWindowsConsumer.updateInputWindows(inDrag);
             }
         }
     };

     public InputMonitor(WindowManagerService service, int displayId) {
         mService = service;
         mDisplayContent = mService.mRoot.getDisplayContent(displayId);
         mDisplayId = displayId;
         mInputTransaction = mService.mTransactionFactory.make();
         mHandler = AnimationThread.getHandler();
         mUpdateInputForAllWindowsConsumer = new UpdateInputForAllWindowsConsumer();
     }

     void onDisplayRemoved() {
         mHandler.removeCallbacks(mUpdateInputWindows);
         mService.mInputManager.onDisplayRemoved(mDisplayId);
         mDisplayRemoved = true;
     }

     private void addInputConsumer(String name, InputConsumerImpl consumer) {
         mInputConsumers.put(name, consumer);
         consumer.linkToDeathRecipient();
         updateInputWindowsLw(true /* force */);
     }

     boolean destroyInputConsumer(String name) {
         if (disposeInputConsumer(mInputConsumers.remove(name))) {
             updateInputWindowsLw(true /* force */);
             return true;
         }
         return false;
     }

     private boolean disposeInputConsumer(InputConsumerImpl consumer) {
         if (consumer != null) {
             consumer.disposeChannelsLw();
             consumer.hide(mInputTransaction);
             return true;
         }
         return false;
     }

     InputConsumerImpl getInputConsumer(String name) {
         return mInputConsumers.get(name);
     }

     void layoutInputConsumers(int dw, int dh) {
         try {
             Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "layoutInputConsumer");
             for (int i = mInputConsumers.size() - 1; i >= 0; i--) {
                 mInputConsumers.valueAt(i).layout(mInputTransaction, dw, dh);
             }
         } finally {
             Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
         }
     }

     // The visibility of the input consumers is recomputed each time we
     // update the input windows. We use a model where consumers begin invisible
     // (set so by this function) and must meet some condition for visibility on each update.
     void resetInputConsumers(SurfaceControl.Transaction t) {
         for (int i = mInputConsumers.size() - 1; i >= 0; i--) {
             mInputConsumers.valueAt(i).hide(t);
         }
     }

     WindowManagerPolicy.InputConsumer createInputConsumer(Looper looper, String name,
             InputEventReceiver.Factory inputEventReceiverFactory) {
         if (mInputConsumers.containsKey(name)) {
             throw new IllegalStateException("Existing input consumer found with name: " + name
                     + ", display: " + mDisplayId);
         }
         final EventReceiverInputConsumer consumer = new EventReceiverInputConsumer(mService,
                 this, looper, name, inputEventReceiverFactory, Process.myPid(),
                 UserHandle.SYSTEM, mDisplayId);
         addInputConsumer(name, consumer);
         return consumer;
     }

     void createInputConsumer(IBinder token, String name, InputChannel inputChannel, int clientPid,
             UserHandle clientUser) {
         if (mInputConsumers.containsKey(name)) {
             throw new IllegalStateException("Existing input consumer found with name: " + name
                     + ", display: " + mDisplayId);
         }

         final InputConsumerImpl consumer = new InputConsumerImpl(mService, token, name,
                 inputChannel, clientPid, clientUser, mDisplayId);
         switch (name) {
             case INPUT_CONSUMER_WALLPAPER:
                 consumer.mWindowHandle.hasWallpaper = true;
                 break;
             case INPUT_CONSUMER_PIP:
                 // The touchable region of the Pip input window is cropped to the bounds of the
                 // stack, and we need FLAG_NOT_TOUCH_MODAL to ensure other events fall through
                 consumer.mWindowHandle.layoutParamsFlags |= FLAG_NOT_TOUCH_MODAL;
                 break;
         }
         addInputConsumer(name, consumer);
     }


     void populateInputWindowHandle(final InputWindowHandle inputWindowHandle,
             final WindowState child, int flags, final int type, final boolean isVisible,
             final boolean hasFocus, final boolean hasWallpaper) {
         // Add a window to our list of input windows.
         inputWindowHandle.name = child.toString();
         flags = child.getSurfaceTouchableRegion(inputWindowHandle, flags);
         inputWindowHandle.layoutParamsFlags = flags;
         inputWindowHandle.layoutParamsType = type;
         inputWindowHandle.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos();
         inputWindowHandle.visible = isVisible;
         inputWindowHandle.canReceiveKeys = child.canReceiveKeys();
         inputWindowHandle.hasFocus = hasFocus;
         inputWindowHandle.hasWallpaper = hasWallpaper;
         inputWindowHandle.paused = child.mAppToken != null ? child.mAppToken.paused : false;
         inputWindowHandle.layer = child.mLayer;
         inputWindowHandle.ownerPid = child.mSession.mPid;
         inputWindowHandle.ownerUid = child.mSession.mUid;
         inputWindowHandle.inputFeatures = child.mAttrs.inputFeatures;
         inputWindowHandle.displayId = child.getDisplayId();

         final Rect frame = child.getFrameLw();
         inputWindowHandle.frameLeft = frame.left;
         inputWindowHandle.frameTop = frame.top;
         inputWindowHandle.frameRight = frame.right;
         inputWindowHandle.frameBottom = frame.bottom;

         // Surface insets are hardcoded to be the same in all directions
         // and we could probably deprecate the "left/right/top/bottom" concept.
         // we avoid reintroducing this concept by just choosing one of them here.
         inputWindowHandle.surfaceInset = child.getAttrs().surfaceInsets.left;

         if (child.mGlobalScale != 1) {
             // If we are scaling the window, input coordinates need
             // to be inversely scaled to map from what is on screen
             // to what is actually being touched in the UI.
             inputWindowHandle.scaleFactor = 1.0f/child.mGlobalScale;
         } else {
             inputWindowHandle.scaleFactor = 1;
         }

         if (DEBUG_INPUT) {
             Slog.d(TAG_WM, "addInputWindowHandle: "
                     + child + ", " + inputWindowHandle);
         }

         if (hasFocus) {
             mFocusedInputWindowHandle = inputWindowHandle;
         }
     }

     void setUpdateInputWindowsNeededLw() {
         mUpdateInputWindowsNeeded = true;
     }

     /* Updates the cached window information provided to the input dispatcher. */
     void updateInputWindowsLw(boolean force) {
         if (!force && !mUpdateInputWindowsNeeded) {
             return;
         }
         scheduleUpdateInputWindows();
     }

     private void scheduleUpdateInputWindows() {
         if (mDisplayRemoved) {
             return;
         }

         if (!mUpdateInputWindowsPending) {
             mUpdateInputWindowsPending = true;
             mHandler.post(mUpdateInputWindows);
         }
     }

     void updateInputWindowsImmediately() {
         if (mUpdateInputWindowsPending) {
             mApplyImmediately = true;
             mUpdateInputWindows.run();
             mApplyImmediately = false;
         }
     }

     /* Called when the current input focus changes.
      * Layer assignment is assumed to be complete by the time this is called.
      */
     public void setInputFocusLw(WindowState newWindow, boolean updateInputWindows) {
         if (DEBUG_FOCUS_LIGHT || DEBUG_INPUT) {
             Slog.d(TAG_WM, "Input focus has changed to " + newWindow);
         }

         if (newWindow != mInputFocus) {
             if (newWindow != null && newWindow.canReceiveKeys()) {
                 // Displaying a window implicitly causes dispatching to be unpaused.
                 // This is to protect against bugs if someone pauses dispatching but
                 // forgets to resume.
                 newWindow.mToken.paused = false;
             }

             mInputFocus = newWindow;
             setUpdateInputWindowsNeededLw();

             if (updateInputWindows) {
                 updateInputWindowsLw(false /*force*/);
             }
         }
     }

     public void setFocusedAppLw(AppWindowToken newApp) {
         // Focused app has changed.
         if (newApp == null) {
             mService.mInputManager.setFocusedApplication(mDisplayId, null);
         } else {
             final InputApplicationHandle handle = newApp.mInputApplicationHandle;
             handle.name = newApp.toString();
             handle.dispatchingTimeoutNanos = newApp.mInputDispatchingTimeoutNanos;

             mService.mInputManager.setFocusedApplication(mDisplayId, handle);
         }
     }

     public void pauseDispatchingLw(WindowToken window) {
         if (! window.paused) {
             if (DEBUG_INPUT) {
                 Slog.v(TAG_WM, "Pausing WindowToken " + window);
             }

             window.paused = true;
             updateInputWindowsLw(true /*force*/);
         }
     }

     public void resumeDispatchingLw(WindowToken window) {
         if (window.paused) {
             if (DEBUG_INPUT) {
                 Slog.v(TAG_WM, "Resuming WindowToken " + window);
             }

             window.paused = false;
             updateInputWindowsLw(true /*force*/);
         }
     }

     void dump(PrintWriter pw, String prefix) {
         final Set<String> inputConsumerKeys = mInputConsumers.keySet();
         if (!inputConsumerKeys.isEmpty()) {
             pw.println(prefix + "InputConsumers:");
             for (String key : inputConsumerKeys) {
                 mInputConsumers.get(key).dump(pw, key, prefix);
             }
         }
     }

     private final class UpdateInputForAllWindowsConsumer implements Consumer<WindowState> {
         InputConsumerImpl navInputConsumer;
         InputConsumerImpl pipInputConsumer;
         InputConsumerImpl wallpaperInputConsumer;
         InputConsumerImpl recentsAnimationInputConsumer;

         private boolean mAddInputConsumerHandle;
         private boolean mAddPipInputConsumerHandle;
         private boolean mAddWallpaperInputConsumerHandle;
         private boolean mAddRecentsAnimationInputConsumerHandle;

         boolean inDrag;
         WallpaperController wallpaperController;

         // An invalid window handle that tells SurfaceFlinger not update the input info.
         final InputWindowHandle mInvalidInputWindow = new InputWindowHandle(null, null, mDisplayId);

         private void updateInputWindows(boolean inDrag) {
             Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "updateInputWindows");

             navInputConsumer = getInputConsumer(INPUT_CONSUMER_NAVIGATION);
             pipInputConsumer = getInputConsumer(INPUT_CONSUMER_PIP);
             wallpaperInputConsumer = getInputConsumer(INPUT_CONSUMER_WALLPAPER);
             recentsAnimationInputConsumer = getInputConsumer(INPUT_CONSUMER_RECENTS_ANIMATION);

             mAddInputConsumerHandle = navInputConsumer != null;
             mAddPipInputConsumerHandle = pipInputConsumer != null;
             mAddWallpaperInputConsumerHandle = wallpaperInputConsumer != null;
             mAddRecentsAnimationInputConsumerHandle = recentsAnimationInputConsumer != null;

             mTmpRect.setEmpty();
             mDisableWallpaperTouchEvents = false;
             this.inDrag = inDrag;
             wallpaperController = mDisplayContent.mWallpaperController;

             resetInputConsumers(mInputTransaction);

             mDisplayContent.forAllWindows(this,
                     true /* traverseTopToBottom */);

             if (mAddWallpaperInputConsumerHandle) {
                 wallpaperInputConsumer.show(mInputTransaction, 0);
             }

             if (mApplyImmediately) {
                 mInputTransaction.apply();
             } else {
                 mDisplayContent.getPendingTransaction().merge(mInputTransaction);
                 mDisplayContent.scheduleAnimation();
             }

             Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
         }

         @Override
         public void accept(WindowState w) {
             final InputChannel inputChannel = w.mInputChannel;
             final InputWindowHandle inputWindowHandle = w.mInputWindowHandle;
             if (inputChannel == null || inputWindowHandle == null || w.mRemoved
                     || w.cantReceiveTouchInput()) {
                 if (w.mWinAnimator.hasSurface()) {
                     mInputTransaction.setInputWindowInfo(
                             w.mWinAnimator.mSurfaceController.mSurfaceControl, mInvalidInputWindow);
                 }
                 // Skip this window because it cannot possibly receive input.
                 return;
             }

             final int flags = w.mAttrs.flags;
             final int privateFlags = w.mAttrs.privateFlags;
             final int type = w.mAttrs.type;
             final boolean hasFocus = w.isFocused();
             final boolean isVisible = w.isVisibleLw();

             if (mAddRecentsAnimationInputConsumerHandle) {
                 final RecentsAnimationController recentsAnimationController =
                         mService.getRecentsAnimationController();
                 if (recentsAnimationController != null
                         && recentsAnimationController.shouldApplyInputConsumer(w.mAppToken)) {
                     if (recentsAnimationController.updateInputConsumerForApp(
                             recentsAnimationInputConsumer.mWindowHandle, hasFocus)) {
                         recentsAnimationInputConsumer.show(mInputTransaction, w);
                         mAddRecentsAnimationInputConsumerHandle = false;
                     }
                 }
             }

             if (w.inPinnedWindowingMode()) {
                 if (mAddPipInputConsumerHandle) {
                     // Update the bounds of the Pip input consumer to match the window bounds.
                     w.getBounds(mTmpRect);
                     pipInputConsumer.layout(mInputTransaction, mTmpRect);

                     // The touchable region is relative to the surface top-left
                     mTmpRect.offsetTo(0, 0);
                     pipInputConsumer.mWindowHandle.touchableRegion.set(mTmpRect);
                     pipInputConsumer.show(mInputTransaction, w);
                     mAddPipInputConsumerHandle = false;
                 }
             }

             if (mAddInputConsumerHandle
                     && inputWindowHandle.layer <= navInputConsumer.mWindowHandle.layer) {
                 navInputConsumer.show(mInputTransaction, w);
                 mAddInputConsumerHandle = false;
             }

             if (mAddWallpaperInputConsumerHandle) {
                 if (w.mAttrs.type == TYPE_WALLPAPER && w.isVisibleLw()) {
                     // Add the wallpaper input consumer above the first visible wallpaper.
                     wallpaperInputConsumer.show(mInputTransaction, w);
                     mAddWallpaperInputConsumerHandle = false;
                 }
             }

             if ((privateFlags & PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS) != 0) {
                 mDisableWallpaperTouchEvents = true;
             }
             final boolean hasWallpaper = wallpaperController.isWallpaperTarget(w)
                     && (privateFlags & PRIVATE_FLAG_KEYGUARD) == 0
                     && !mDisableWallpaperTouchEvents;

             // If there's a drag in progress and 'child' is a potential drop target,
             // make sure it's been told about the drag
             if (inDrag && isVisible && w.getDisplayContent().isDefaultDisplay) {
                 mService.mDragDropController.sendDragStartedIfNeededLocked(w);
             }

             populateInputWindowHandle(
                     inputWindowHandle, w, flags, type, isVisible, hasFocus, hasWallpaper);

             if (w.mWinAnimator.hasSurface()) {
                 mInputTransaction.setInputWindowInfo(
                         w.mWinAnimator.mSurfaceController.mSurfaceControl, inputWindowHandle);
             }
         }
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.wm;

	import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;
	import static android.view.WindowManager.INPUT_CONSUMER_NAVIGATION;
	import static android.view.WindowManager.INPUT_CONSUMER_PIP;
	import static android.view.WindowManager.INPUT_CONSUMER_RECENTS_ANIMATION;
	import static android.view.WindowManager.INPUT_CONSUMER_WALLPAPER;
	import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
	import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS;
	import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
	import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;

	import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS_LIGHT;
	import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_INPUT;
	import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_POSITIONING;
	import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;

	import android.graphics.Rect;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Looper;
	import android.os.Process;
	import android.os.Trace;
	import android.os.UserHandle;
	import android.util.ArrayMap;
	import android.util.Log;
	import android.util.Slog;
	import android.view.InputApplicationHandle;
	import android.view.InputChannel;
	import android.view.InputEventReceiver;
	import android.view.InputWindowHandle;
	import android.view.SurfaceControl;

	import com.android.server.AnimationThread;
	import com.android.server.policy.WindowManagerPolicy;

	import java.io.PrintWriter;
	import java.util.Set;
	import java.util.function.Consumer;

	final class InputMonitor {
	private final WindowManagerService mService;

	// Current window with input focus for keys and other non-touch events. May be null.
	private WindowState mInputFocus;

	// When true, need to call updateInputWindowsLw().
	private boolean mUpdateInputWindowsNeeded = true;
	private boolean mUpdateInputWindowsPending;
	private boolean mApplyImmediately;

	// Currently focused input window handle.
	private InputWindowHandle mFocusedInputWindowHandle;

	private boolean mDisableWallpaperTouchEvents;
	private final Rect mTmpRect = new Rect();
	private final UpdateInputForAllWindowsConsumer mUpdateInputForAllWindowsConsumer;

	private final int mDisplayId;
	private final DisplayContent mDisplayContent;
	private boolean mDisplayRemoved;

	private final SurfaceControl.Transaction mInputTransaction;
	private final Handler mHandler;

	/**
	* The set of input consumer added to the window manager by name, which consumes input events
	* for the windows below it.
	*/
	private final ArrayMap<String, InputConsumerImpl> mInputConsumers = new ArrayMap();

	private static final class EventReceiverInputConsumer extends InputConsumerImpl
	implements WindowManagerPolicy.InputConsumer {
	private InputMonitor mInputMonitor;
	private final InputEventReceiver mInputEventReceiver;

	EventReceiverInputConsumer(WindowManagerService service, InputMonitor monitor,
	Looper looper, String name,
	InputEventReceiver.Factory inputEventReceiverFactory,
	int clientPid, UserHandle clientUser, int displayId) {
	super(service, null /* token /, name, null / inputChannel */, clientPid, clientUser,
	displayId);
	mInputMonitor = monitor;
	mInputEventReceiver = inputEventReceiverFactory.createInputEventReceiver(
	mClientChannel, looper);
	}

	@Override
	public void dismiss() {
	synchronized (mService.mGlobalLock) {
	if (mInputMonitor.destroyInputConsumer(mWindowHandle.name)) {
	mInputEventReceiver.dispose();
	}
	}
	}
	}

	private final Runnable mUpdateInputWindows = new Runnable() {
	@Override
	public void run() {
	synchronized (mService.mGlobalLock) {
	mUpdateInputWindowsPending = false;
	mUpdateInputWindowsNeeded = false;

	if (mDisplayRemoved) {
	return;
	}

	// Populate the input window list with information about all of the windows that
	// could potentially receive input.
	// As an optimization, we could try to prune the list of windows but this turns
	// out to be difficult because only the native code knows for sure which window
	// currently has touch focus.

	// If there's a drag in flight, provide a pseudo-window to catch drag input
	final boolean inDrag = mService.mDragDropController.dragDropActiveLocked();
	final boolean inPositioning =
	mService.mTaskPositioningController.isPositioningLocked();
	if (inPositioning) {
	if (DEBUG_TASK_POSITIONING) {
	Log.d(TAG_WM, "Inserting window handle for repositioning");
	}
	mService.mTaskPositioningController.showInputSurface(mInputTransaction,
	mDisplayId);
	} else {
	mService.mTaskPositioningController.hideInputSurface(mInputTransaction,
	mDisplayId);
	}

	// Add all windows on the default display.
	mUpdateInputForAllWindowsConsumer.updateInputWindows(inDrag);
	}
	}
	};

	public InputMonitor(WindowManagerService service, int displayId) {
	mService = service;
	mDisplayContent = mService.mRoot.getDisplayContent(displayId);
	mDisplayId = displayId;
	mInputTransaction = mService.mTransactionFactory.make();
	mHandler = AnimationThread.getHandler();
	mUpdateInputForAllWindowsConsumer = new UpdateInputForAllWindowsConsumer();
	}

	void onDisplayRemoved() {
	mHandler.removeCallbacks(mUpdateInputWindows);
	mService.mInputManager.onDisplayRemoved(mDisplayId);
	mDisplayRemoved = true;
	}

	private void addInputConsumer(String name, InputConsumerImpl consumer) {
	mInputConsumers.put(name, consumer);
	consumer.linkToDeathRecipient();
	updateInputWindowsLw(true /* force */);
	}

	boolean destroyInputConsumer(String name) {
	if (disposeInputConsumer(mInputConsumers.remove(name))) {
	updateInputWindowsLw(true /* force */);
	return true;
	}
	return false;
	}

	private boolean disposeInputConsumer(InputConsumerImpl consumer) {
	if (consumer != null) {
	consumer.disposeChannelsLw();
	consumer.hide(mInputTransaction);
	return true;
	}
	return false;
	}

	InputConsumerImpl getInputConsumer(String name) {
	return mInputConsumers.get(name);
	}

	void layoutInputConsumers(int dw, int dh) {
	try {
	Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "layoutInputConsumer");
	for (int i = mInputConsumers.size() - 1; i >= 0; i--) {
	mInputConsumers.valueAt(i).layout(mInputTransaction, dw, dh);
	}
	} finally {
	Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}
	}

	// The visibility of the input consumers is recomputed each time we
	// update the input windows. We use a model where consumers begin invisible
	// (set so by this function) and must meet some condition for visibility on each update.
	void resetInputConsumers(SurfaceControl.Transaction t) {
	for (int i = mInputConsumers.size() - 1; i >= 0; i--) {
	mInputConsumers.valueAt(i).hide(t);
	}
	}

	WindowManagerPolicy.InputConsumer createInputConsumer(Looper looper, String name,
	InputEventReceiver.Factory inputEventReceiverFactory) {
	if (mInputConsumers.containsKey(name)) {
	throw new IllegalStateException("Existing input consumer found with name: " + name
	+ ", display: " + mDisplayId);
	}
	final EventReceiverInputConsumer consumer = new EventReceiverInputConsumer(mService,
	this, looper, name, inputEventReceiverFactory, Process.myPid(),
	UserHandle.SYSTEM, mDisplayId);
	addInputConsumer(name, consumer);
	return consumer;
	}

	void createInputConsumer(IBinder token, String name, InputChannel inputChannel, int clientPid,
	UserHandle clientUser) {
	if (mInputConsumers.containsKey(name)) {
	throw new IllegalStateException("Existing input consumer found with name: " + name
	+ ", display: " + mDisplayId);
	}

	final InputConsumerImpl consumer = new InputConsumerImpl(mService, token, name,
	inputChannel, clientPid, clientUser, mDisplayId);
	switch (name) {
	case INPUT_CONSUMER_WALLPAPER:
	consumer.mWindowHandle.hasWallpaper = true;
	break;
	case INPUT_CONSUMER_PIP:
	// The touchable region of the Pip input window is cropped to the bounds of the
	// stack, and we need FLAG_NOT_TOUCH_MODAL to ensure other events fall through
	consumer.mWindowHandle.layoutParamsFlags \|= FLAG_NOT_TOUCH_MODAL;
	break;
	}
	addInputConsumer(name, consumer);
	}


	void populateInputWindowHandle(final InputWindowHandle inputWindowHandle,
	final WindowState child, int flags, final int type, final boolean isVisible,
	final boolean hasFocus, final boolean hasWallpaper) {
	// Add a window to our list of input windows.
	inputWindowHandle.name = child.toString();
	flags = child.getSurfaceTouchableRegion(inputWindowHandle, flags);
	inputWindowHandle.layoutParamsFlags = flags;
	inputWindowHandle.layoutParamsType = type;
	inputWindowHandle.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos();
	inputWindowHandle.visible = isVisible;
	inputWindowHandle.canReceiveKeys = child.canReceiveKeys();
	inputWindowHandle.hasFocus = hasFocus;
	inputWindowHandle.hasWallpaper = hasWallpaper;
	inputWindowHandle.paused = child.mAppToken != null ? child.mAppToken.paused : false;
	inputWindowHandle.layer = child.mLayer;
	inputWindowHandle.ownerPid = child.mSession.mPid;
	inputWindowHandle.ownerUid = child.mSession.mUid;
	inputWindowHandle.inputFeatures = child.mAttrs.inputFeatures;
	inputWindowHandle.displayId = child.getDisplayId();

	final Rect frame = child.getFrameLw();
	inputWindowHandle.frameLeft = frame.left;
	inputWindowHandle.frameTop = frame.top;
	inputWindowHandle.frameRight = frame.right;
	inputWindowHandle.frameBottom = frame.bottom;

	// Surface insets are hardcoded to be the same in all directions
	// and we could probably deprecate the "left/right/top/bottom" concept.
	// we avoid reintroducing this concept by just choosing one of them here.
	inputWindowHandle.surfaceInset = child.getAttrs().surfaceInsets.left;

	if (child.mGlobalScale != 1) {
	// If we are scaling the window, input coordinates need
	// to be inversely scaled to map from what is on screen
	// to what is actually being touched in the UI.
	inputWindowHandle.scaleFactor = 1.0f/child.mGlobalScale;
	} else {
	inputWindowHandle.scaleFactor = 1;
	}

	if (DEBUG_INPUT) {
	Slog.d(TAG_WM, "addInputWindowHandle: "
	+ child + ", " + inputWindowHandle);
	}

	if (hasFocus) {
	mFocusedInputWindowHandle = inputWindowHandle;
	}
	}

	void setUpdateInputWindowsNeededLw() {
	mUpdateInputWindowsNeeded = true;
	}

	/* Updates the cached window information provided to the input dispatcher. */
	void updateInputWindowsLw(boolean force) {
	if (!force && !mUpdateInputWindowsNeeded) {
	return;
	}
	scheduleUpdateInputWindows();
	}

	private void scheduleUpdateInputWindows() {
	if (mDisplayRemoved) {
	return;
	}

	if (!mUpdateInputWindowsPending) {
	mUpdateInputWindowsPending = true;
	mHandler.post(mUpdateInputWindows);
	}
	}

	void updateInputWindowsImmediately() {
	if (mUpdateInputWindowsPending) {
	mApplyImmediately = true;
	mUpdateInputWindows.run();
	mApplyImmediately = false;
	}
	}

	/* Called when the current input focus changes.
	* Layer assignment is assumed to be complete by the time this is called.
	*/
	public void setInputFocusLw(WindowState newWindow, boolean updateInputWindows) {
	if (DEBUG_FOCUS_LIGHT \|\| DEBUG_INPUT) {
	Slog.d(TAG_WM, "Input focus has changed to " + newWindow);
	}

	if (newWindow != mInputFocus) {
	if (newWindow != null && newWindow.canReceiveKeys()) {
	// Displaying a window implicitly causes dispatching to be unpaused.
	// This is to protect against bugs if someone pauses dispatching but
	// forgets to resume.
	newWindow.mToken.paused = false;
	}

	mInputFocus = newWindow;
	setUpdateInputWindowsNeededLw();

	if (updateInputWindows) {
	updateInputWindowsLw(false /force/);
	}
	}
	}

	public void setFocusedAppLw(AppWindowToken newApp) {
	// Focused app has changed.
	if (newApp == null) {
	mService.mInputManager.setFocusedApplication(mDisplayId, null);
	} else {
	final InputApplicationHandle handle = newApp.mInputApplicationHandle;
	handle.name = newApp.toString();
	handle.dispatchingTimeoutNanos = newApp.mInputDispatchingTimeoutNanos;

	mService.mInputManager.setFocusedApplication(mDisplayId, handle);
	}
	}

	public void pauseDispatchingLw(WindowToken window) {
	if (! window.paused) {
	if (DEBUG_INPUT) {
	Slog.v(TAG_WM, "Pausing WindowToken " + window);
	}

	window.paused = true;
	updateInputWindowsLw(true /force/);
	}
	}

	public void resumeDispatchingLw(WindowToken window) {
	if (window.paused) {
	if (DEBUG_INPUT) {
	Slog.v(TAG_WM, "Resuming WindowToken " + window);
	}

	window.paused = false;
	updateInputWindowsLw(true /force/);
	}
	}

	void dump(PrintWriter pw, String prefix) {
	final Set<String> inputConsumerKeys = mInputConsumers.keySet();
	if (!inputConsumerKeys.isEmpty()) {
	pw.println(prefix + "InputConsumers:");
	for (String key : inputConsumerKeys) {
	mInputConsumers.get(key).dump(pw, key, prefix);
	}
	}
	}

	private final class UpdateInputForAllWindowsConsumer implements Consumer<WindowState> {
	InputConsumerImpl navInputConsumer;
	InputConsumerImpl pipInputConsumer;
	InputConsumerImpl wallpaperInputConsumer;
	InputConsumerImpl recentsAnimationInputConsumer;

	private boolean mAddInputConsumerHandle;
	private boolean mAddPipInputConsumerHandle;
	private boolean mAddWallpaperInputConsumerHandle;
	private boolean mAddRecentsAnimationInputConsumerHandle;

	boolean inDrag;
	WallpaperController wallpaperController;

	// An invalid window handle that tells SurfaceFlinger not update the input info.
	final InputWindowHandle mInvalidInputWindow = new InputWindowHandle(null, null, mDisplayId);

	private void updateInputWindows(boolean inDrag) {
	Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "updateInputWindows");

	navInputConsumer = getInputConsumer(INPUT_CONSUMER_NAVIGATION);
	pipInputConsumer = getInputConsumer(INPUT_CONSUMER_PIP);
	wallpaperInputConsumer = getInputConsumer(INPUT_CONSUMER_WALLPAPER);
	recentsAnimationInputConsumer = getInputConsumer(INPUT_CONSUMER_RECENTS_ANIMATION);

	mAddInputConsumerHandle = navInputConsumer != null;
	mAddPipInputConsumerHandle = pipInputConsumer != null;
	mAddWallpaperInputConsumerHandle = wallpaperInputConsumer != null;
	mAddRecentsAnimationInputConsumerHandle = recentsAnimationInputConsumer != null;

	mTmpRect.setEmpty();
	mDisableWallpaperTouchEvents = false;
	this.inDrag = inDrag;
	wallpaperController = mDisplayContent.mWallpaperController;

	resetInputConsumers(mInputTransaction);

	mDisplayContent.forAllWindows(this,
	true /* traverseTopToBottom */);

	if (mAddWallpaperInputConsumerHandle) {
	wallpaperInputConsumer.show(mInputTransaction, 0);
	}

	if (mApplyImmediately) {
	mInputTransaction.apply();
	} else {
	mDisplayContent.getPendingTransaction().merge(mInputTransaction);
	mDisplayContent.scheduleAnimation();
	}

	Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}

	@Override
	public void accept(WindowState w) {
	final InputChannel inputChannel = w.mInputChannel;
	final InputWindowHandle inputWindowHandle = w.mInputWindowHandle;
	if (inputChannel == null \|\| inputWindowHandle == null \|\| w.mRemoved
	\|\| w.cantReceiveTouchInput()) {
	if (w.mWinAnimator.hasSurface()) {
	mInputTransaction.setInputWindowInfo(
	w.mWinAnimator.mSurfaceController.mSurfaceControl, mInvalidInputWindow);
	}
	// Skip this window because it cannot possibly receive input.
	return;
	}

	final int flags = w.mAttrs.flags;
	final int privateFlags = w.mAttrs.privateFlags;
	final int type = w.mAttrs.type;
	final boolean hasFocus = w.isFocused();
	final boolean isVisible = w.isVisibleLw();

	if (mAddRecentsAnimationInputConsumerHandle) {
	final RecentsAnimationController recentsAnimationController =
	mService.getRecentsAnimationController();
	if (recentsAnimationController != null
	&& recentsAnimationController.shouldApplyInputConsumer(w.mAppToken)) {
	if (recentsAnimationController.updateInputConsumerForApp(
	recentsAnimationInputConsumer.mWindowHandle, hasFocus)) {
	recentsAnimationInputConsumer.show(mInputTransaction, w);
	mAddRecentsAnimationInputConsumerHandle = false;
	}
	}
	}

	if (w.inPinnedWindowingMode()) {
	if (mAddPipInputConsumerHandle) {
	// Update the bounds of the Pip input consumer to match the window bounds.
	w.getBounds(mTmpRect);
	pipInputConsumer.layout(mInputTransaction, mTmpRect);

	// The touchable region is relative to the surface top-left
	mTmpRect.offsetTo(0, 0);
	pipInputConsumer.mWindowHandle.touchableRegion.set(mTmpRect);
	pipInputConsumer.show(mInputTransaction, w);
	mAddPipInputConsumerHandle = false;
	}
	}

	if (mAddInputConsumerHandle
	&& inputWindowHandle.layer <= navInputConsumer.mWindowHandle.layer) {
	navInputConsumer.show(mInputTransaction, w);
	mAddInputConsumerHandle = false;
	}

	if (mAddWallpaperInputConsumerHandle) {
	if (w.mAttrs.type == TYPE_WALLPAPER && w.isVisibleLw()) {
	// Add the wallpaper input consumer above the first visible wallpaper.
	wallpaperInputConsumer.show(mInputTransaction, w);
	mAddWallpaperInputConsumerHandle = false;
	}
	}

	if ((privateFlags & PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS) != 0) {
	mDisableWallpaperTouchEvents = true;
	}
	final boolean hasWallpaper = wallpaperController.isWallpaperTarget(w)
	&& (privateFlags & PRIVATE_FLAG_KEYGUARD) == 0
	&& !mDisableWallpaperTouchEvents;

	// If there's a drag in progress and 'child' is a potential drop target,
	// make sure it's been told about the drag
	if (inDrag && isVisible && w.getDisplayContent().isDefaultDisplay) {
	mService.mDragDropController.sendDragStartedIfNeededLocked(w);
	}

	populateInputWindowHandle(
	inputWindowHandle, w, flags, type, isVisible, hasFocus, hasWallpaper);

	if (w.mWinAnimator.hasSurface()) {
	mInputTransaction.setInputWindowInfo(
	w.mWinAnimator.mSurfaceController.mSurfaceControl, inputWindowHandle);
	}
	}
	}
	}