android touch处理流程,Android输入输出系统之TouchEvent流程

怼烎@ 2022-10-18 01:28 36阅读 0赞

int32\_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs\_t currentTime,

const MotionEntry\* entry, nsecs\_t\* nextWakeupTime) \{

enum InjectionPermission \{

INJECTION\_PERMISSION\_UNKNOWN,

INJECTION\_PERMISSION\_GRANTED,

INJECTION\_PERMISSION\_DENIED

\};

mCurrentInputTargets.clear();

nsecs\_t startTime = now();

// For security reasons, we defer updating the touch state until we are sure that

// event injection will be allowed.

// FIXME In the original code, screenWasOff could never be set to true.

//       The reason is that the POLICY\_FLAG\_WOKE\_HERE

//       and POLICY\_FLAG\_BRIGHT\_HERE flags were set only when preprocessing raw

//       EV\_KEY, EV\_REL and EV\_ABS events.  As it happens, the touch event was

//       actually enqueued using the policyFlags that appeared in the final EV\_SYN

//       events upon which no preprocessing took place.  So policyFlags was always 0.

//       In the new native input dispatcher we're a bit more careful about event

//       preprocessing so the touches we receive can actually have non-zero policyFlags.

//       Unfortunately we obtain undesirable behavior.

//       Here's what happens:

//       When the device dims in anticipation of going to sleep, touches

//       in windows which have FLAG\_TOUCHABLE\_WHEN\_WAKING cause

//       the device to brighten and reset the user activity timer.

//       Touches on other windows (such as the launcher window)

//       are dropped.  Then after a moment, the device goes to sleep.  Oops.

//       Also notice how screenWasOff was being initialized using POLICY\_FLAG\_BRIGHT\_HERE

//       instead of POLICY\_FLAG\_WOKE\_HERE...

bool screenWasOff = false; // original policy: policyFlags & POLICY\_FLAG\_BRIGHT\_HERE;

int32\_t action = entry->action;

int32\_t maskedAction = action & AMOTION\_EVENT\_ACTION\_MASK;

// Update the touch state as needed based on the properties of the touch event.

int32\_t injectionResult = INPUT\_EVENT\_INJECTION\_PENDING;

InjectionPermission injectionPermission = INJECTION\_PERMISSION\_UNKNOWN;

if (maskedAction == AMOTION\_EVENT\_ACTION\_DOWN) \{

mTempTouchState.reset();

mTempTouchState.down = true;

\} else \{

mTempTouchState.copyFrom(mTouchState);

bool isSplit = mTempTouchState.split && mTempTouchState.down;

if (maskedAction == AMOTION\_EVENT\_ACTION\_DOWN

|| (isSplit && maskedAction == AMOTION\_EVENT\_ACTION\_POINTER\_DOWN)) \{

/\* Case 1: New splittable pointer going down. \*/

int32\_t pointerIndex = getMotionEventActionPointerIndex(action);

int32\_t x = int32\_t(entry->firstSample.pointerCoords\[pointerIndex\].x);

int32\_t y = int32\_t(entry->firstSample.pointerCoords\[pointerIndex\].y);

const InputWindow\* newTouchedWindow = NULL;

const InputWindow\* topErrorWindow = NULL;

// Traverse windows from front to back to find touched window and outside targets.

size\_t numWindows = mWindows.size();

for (size\_t i = 0; i

const InputWindow\* window = & mWindows.editItemAt(i);

int32\_t flags = window->layoutParamsFlags;

if (flags & InputWindow::FLAG\_SYSTEM\_ERROR) \{

if (! topErrorWindow) \{

topErrorWindow = window;

if (window->visible) \{

if (! (flags & InputWindow::FLAG\_NOT\_TOUCHABLE)) \{

bool isTouchModal = (flags & (InputWindow::FLAG\_NOT\_FOCUSABLE

| InputWindow::FLAG\_NOT\_TOUCH\_MODAL)) == 0;

if (isTouchModal || window->touchableAreaContainsPoint(x, y)) \{

if (! screenWasOff || flags & InputWindow::FLAG\_TOUCHABLE\_WHEN\_WAKING) \{

newTouchedWindow = window;

break; // found touched window, exit window loop

if (maskedAction == AMOTION\_EVENT\_ACTION\_DOWN

&& (flags & InputWindow::FLAG\_WATCH\_OUTSIDE\_TOUCH)) \{

int32\_t outsideTargetFlags = InputTarget::FLAG\_OUTSIDE;

if (isWindowObscuredAtPointLocked(window, x, y)) \{

outsideTargetFlags |= InputTarget::FLAG\_WINDOW\_IS\_OBSCURED;

mTempTouchState.addOrUpdateWindow(window, outsideTargetFlags, BitSet32(0));

// If there is an error window but it is not taking focus (typically because

// it is invisible) then wait for it.  Any other focused window may in

// fact be in ANR state.

if (topErrorWindow && newTouchedWindow != topErrorWindow) \{

\#if DEBUG\_FOCUS

LOGD("Waiting because system error window is pending.");

\#endif

injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

NULL, NULL, nextWakeupTime);

injectionPermission = INJECTION\_PERMISSION\_UNKNOWN;

goto Unresponsive;

// Figure out whether splitting will be allowed for this window.

if (newTouchedWindow

&& (newTouchedWindow->layoutParamsFlags & InputWindow::FLAG\_SPLIT\_TOUCH)) \{

// New window supports splitting.

isSplit = true;

\} else if (isSplit) \{

// New window does not support splitting but we have already split events.

// Assign the pointer to the first foreground window we find.

// (May be NULL which is why we put this code block before the next check.)

newTouchedWindow = mTempTouchState.getFirstForegroundWindow();

// If we did not find a touched window then fail.

if (! newTouchedWindow) \{

if (mFocusedApplication) \{

\#if DEBUG\_FOCUS

LOGD("Waiting because there is no touched window but there is a "

"focused application that may eventually add a new window: %s.",

getApplicationWindowLabelLocked(mFocusedApplication, NULL).string());

\#endif

injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

mFocusedApplication, NULL, nextWakeupTime);

goto Unresponsive;

LOGI("Dropping event because there is no touched window or focused application.");

injectionResult = INPUT\_EVENT\_INJECTION\_FAILED;

goto Failed;

// Set target flags.

int32\_t targetFlags = InputTarget::FLAG\_FOREGROUND;

if (isSplit) \{

targetFlags |= InputTarget::FLAG\_SPLIT;

if (isWindowObscuredAtPointLocked(newTouchedWindow, x, y)) \{

targetFlags |= InputTarget::FLAG\_WINDOW\_IS\_OBSCURED;

// Update the temporary touch state.

BitSet32 pointerIds;

if (isSplit) \{

uint32\_t pointerId = entry->pointerIds\[pointerIndex\];

pointerIds.markBit(pointerId);

mTempTouchState.addOrUpdateWindow(newTouchedWindow, targetFlags, pointerIds);

\} else \{

/\* Case 2: Pointer move, up, cancel or non-splittable pointer down. \*/

// If the pointer is not currently down, then ignore the event.

if (! mTempTouchState.down) \{

LOGI("Dropping event because the pointer is not down.");

injectionResult = INPUT\_EVENT\_INJECTION\_FAILED;

goto Failed;

// Check permission to inject into all touched foreground windows and ensure there

// is at least one touched foreground window.

bool haveForegroundWindow = false;

for (size\_t i = 0; i

const TouchedWindow& touchedWindow = mTempTouchState.windows\[i\];

if (touchedWindow.targetFlags & InputTarget::FLAG\_FOREGROUND) \{

haveForegroundWindow = true;

if (! checkInjectionPermission(touchedWindow.window, entry->injectionState)) \{

injectionResult = INPUT\_EVENT\_INJECTION\_PERMISSION\_DENIED;

injectionPermission = INJECTION\_PERMISSION\_DENIED;

goto Failed;

if (! haveForegroundWindow) \{

\#if DEBUG\_INPUT\_DISPATCHER\_POLICY

LOGD("Dropping event because there is no touched foreground window to receive it.");

\#endif

injectionResult = INPUT\_EVENT\_INJECTION\_FAILED;

goto Failed;

// Permission granted to injection into all touched foreground windows.

injectionPermission = INJECTION\_PERMISSION\_GRANTED;

// Ensure all touched foreground windows are ready for new input.

for (size\_t i = 0; i

const TouchedWindow& touchedWindow = mTempTouchState.windows\[i\];

if (touchedWindow.targetFlags & InputTarget::FLAG\_FOREGROUND) \{

// If the touched window is paused then keep waiting.

if (touchedWindow.window->paused) \{

\#if DEBUG\_INPUT\_DISPATCHER\_POLICY

LOGD("Waiting because touched window is paused.");

\#endif

injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

NULL, touchedWindow.window, nextWakeupTime);

goto Unresponsive;

// If the touched window is still working on previous events then keep waiting.

if (! isWindowFinishedWithPreviousInputLocked(touchedWindow.window)) \{

\#if DEBUG\_FOCUS

LOGD("Waiting because touched window still processing previous input.");

\#endif

injectionResult = handleTargetsNotReadyLocked(currentTime, entry,

NULL, touchedWindow.window, nextWakeupTime);

goto Unresponsive;

// If this is the first pointer going down and the touched window has a wallpaper

// then also add the touched wallpaper windows so they are locked in for the duration

// of the touch gesture.

if (maskedAction == AMOTION\_EVENT\_ACTION\_DOWN) \{

const InputWindow\* foregroundWindow = mTempTouchState.getFirstForegroundWindow();

if (foregroundWindow->hasWallpaper) \{

for (size\_t i = 0; i

const InputWindow\* window = & mWindows\[i\];

if (window->layoutParamsType == InputWindow::TYPE\_WALLPAPER) \{

mTempTouchState.addOrUpdateWindow(window,

InputTarget::FLAG\_WINDOW\_IS\_OBSCURED, BitSet32(0));

// Success!  Output targets.

injectionResult = INPUT\_EVENT\_INJECTION\_SUCCEEDED;

for (size\_t i = 0; i

const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i);

addWindowTargetLocked(touchedWindow.window, touchedWindow.targetFlags,

touchedWindow.pointerIds);

// Drop the outside touch window since we will not care about them in the next iteration.

mTempTouchState.removeOutsideTouchWindows();

Failed:

// Check injection permission once and for all.

if (injectionPermission == INJECTION\_PERMISSION\_UNKNOWN) \{

if (checkInjectionPermission(NULL, entry->injectionState)) \{

injectionPermission = INJECTION\_PERMISSION\_GRANTED;

\} else \{

injectionPermission = INJECTION\_PERMISSION\_DENIED;

// Update final pieces of touch state if the injector had permission.

if (injectionPermission == INJECTION\_PERMISSION\_GRANTED) \{

if (maskedAction == AMOTION\_EVENT\_ACTION\_UP

|| maskedAction == AMOTION\_EVENT\_ACTION\_CANCEL) \{

// All pointers up or canceled.

mTempTouchState.reset();

\} else if (maskedAction == AMOTION\_EVENT\_ACTION\_DOWN) \{

// First pointer went down.

if (mTouchState.down) \{

\#if DEBUG\_FOCUS

LOGD("Pointer down received while already down.");

\#endif

\} else if (maskedAction == AMOTION\_EVENT\_ACTION\_POINTER\_UP) \{

// One pointer went up.

if (isSplit) \{

int32\_t pointerIndex = getMotionEventActionPointerIndex(action);

uint32\_t pointerId = entry->pointerIds\[pointerIndex\];

for (size\_t i = 0; i

TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i);

if (touchedWindow.targetFlags & InputTarget::FLAG\_SPLIT) \{

touchedWindow.pointerIds.clearBit(pointerId);

if (touchedWindow.pointerIds.isEmpty()) \{

mTempTouchState.windows.removeAt(i);

continue;

i += 1;

// Save changes to touch state.

mTouchState.copyFrom(mTempTouchState);

\} else \{

\#if DEBUG\_FOCUS

LOGD("Not updating touch focus because injection was denied.");

\#endif

Unresponsive:

// Reset temporary touch state to ensure we release unnecessary references to input channels.

mTempTouchState.reset();

nsecs\_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);

updateDispatchStatisticsLocked(currentTime, entry,

injectionResult, timeSpentWaitingForApplication);

\#if DEBUG\_FOCUS

LOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, "

"timeSpentWaitingForApplication=%0.1fms",

injectionResult, injectionPermission, timeSpentWaitingForApplication / 1000000.0);

\#endif

return injectionResult;

android touch处理流程,Android输入输出系统之TouchEvent流程

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java 流程控制之输入输出

相关 Android渲染流程

相关 Android 系统启动流程

相关 android touch处理流程,Android输入输出系统之TouchEvent流程

相关 android 打电话流程,Android 打电话流程

相关 Android事件处理分析+Android事件处理 +Android输入事件流程

相关 Android touch事件传递及View的绘制流程

相关 Android 自定义 View 之处理 TouchEvent

相关 Android系统的启动流程

相关 Android打包流程