本篇內容介紹了“Android怎么開發Input系統觸摸事件分發”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！
Input系統: InputReader 處理觸摸事件 分析了 InputReader 對觸摸事件的處理流程，最終的結果是把觸摸事件包裝成 NotifyMotionArgs，然后分發給下一環。根據 Input系統: InputManagerService的創建與啟動 可知，下一環是 InputClassifier。然而系統目前并不支持 InputClassifier 的功能，因此事件會被直接發送到 InputDispatcher。
Input系統: 按鍵事件分發 分析了按鍵事件的分發流程，雖然分析的目標是按鍵事件，但是也從整體上，描繪了事件分發的框架。
void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
if (!validateMotionEvent(args->action, args->actionButton, args->pointerCount,
args->pointerProperties)) {
return;
}
uint32_t policyFlags = args->policyFlags;
// 來自InputReader/InputClassifier的 motion 事件，都是受信任的
policyFlags |= POLICY_FLAG_TRUSTED;
android::base::Timer t;
// 1. 對觸摸事件執行截斷策略
// 觸摸事件入隊前，查詢截斷策略，查詢的結果保存到參數 policyFlags
mPolicy->interceptMotionBeforeQueueing(args->displayId, args->eventTime, /*byref*/ policyFlags);
if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
std::to_string(t.duration().count()).c_str());
}
bool needWake;
{ // acquire lock
mLock.lock();
if (shouldSendMotionToInputFilterLocked(args)) {
// ...
}
// 包裝成 MotionEntry
// Just enqueue a new motion event.
std::unique_ptr<MotionEntry> newEntry =
std::make_unique<MotionEntry>(args->id, args->eventTime, args->deviceId,
args->source, args->displayId, policyFlags,
args->action, args->actionButton, args->flags,
args->metaState, args->buttonState,
args->classification, args->edgeFlags,
args->xPrecision, args->yPrecision,
args->xCursorPosition, args->yCursorPosition,
args->downTime, args->pointerCount,
args->pointerProperties, args->pointerCoords, 0, 0);
// 2. 把觸摸事件加入收件箱
needWake = enqueueInboundEventLocked(std::move(newEntry));
mLock.unlock();
} // release lock
// 3. 如果有必要，喚醒線程處理觸摸事件
if (needWake) {
mLooper->wake();
}
}InputDispatcher 收到觸摸事件后的處理流程，與收到按鍵事件的處理流程非常相似
對觸摸事件進行截斷策略查詢。
把觸摸事件加入 InputDispatcher 收件箱，然后喚醒線程處理觸摸事件。
void NativeInputManager::interceptMotionBeforeQueueing(const int32_t displayId, nsecs_t when,
uint32_t& policyFlags) {
bool interactive = mInteractive.load();
if (interactive) {
policyFlags |= POLICY_FLAG_INTERACTIVE;
}
// 受信任，并且是非注入的事件
if ((policyFlags & POLICY_FLAG_TRUSTED) && !(policyFlags & POLICY_FLAG_INJECTED)) {
if (policyFlags & POLICY_FLAG_INTERACTIVE) {
// 設備處于交互狀態下，受信任且非注入的事件，直接發送給用戶，而不經過截斷策略處理
policyFlags |= POLICY_FLAG_PASS_TO_USER;
} else {
// 只有設備處于非交互狀態，觸摸事件才需要執行截斷策略
JNIEnv* env = jniEnv();
jint wmActions = env->CallIntMethod(mServiceObj,
gServiceClassInfo.interceptMotionBeforeQueueingNonInteractive,
displayId, when, policyFlags);
if (checkAndClearExceptionFromCallback(env,
"interceptMotionBeforeQueueingNonInteractive")) {
wmActions = 0;
}
handleInterceptActions(wmActions, when, /*byref*/ policyFlags);
}
} else { // 注入事件，或者不受信任事件
// 只有在交互狀態下，才傳遞給用戶
// 注意，這里還有另外一層意思: 非交互狀態下，不發送給用戶
if (interactive) {
policyFlags |= POLICY_FLAG_PASS_TO_USER;
}
}
}
void NativeInputManager::handleInterceptActions(jint wmActions, nsecs_t when,
uint32_t& policyFlags) {
if (wmActions & WM_ACTION_PASS_TO_USER) {
policyFlags |= POLICY_FLAG_PASS_TO_USER;
}
}一個觸摸事件，必須滿足下面三種情況，才執行截斷策略
觸摸事件是受信任的。來自輸入設備的觸摸事件都是受信任的。
觸摸事件是非注入的。monkey 的原理就是注入觸摸事件，因此它的事件是不需要經過截斷策略處理的。
設備處于非交互狀態。一般來說，非交互狀態指的就是顯示屏處于滅屏狀態。
另外還需要關注的是，事件在什么時候是不需要經過截斷策略，有兩種情況
對于受信任且非注入的觸摸事件，如果設備處于交互狀態，直接發送給用戶。 也就是說，如果顯示屏處于亮屏狀態，輸入設備產生的觸摸事件一定會發送給窗口。
對于不受信任，或者注入的觸摸事件，如果設備處于交互狀態，也是直接發送給用戶。也就是說，如果顯示屏處于亮屏狀態，monkey 注入的觸摸事件，也是直接發送給窗口的。
最后還要注意一件事，如果一個觸摸事件是不受信任的事件，或者是注入事件，當設備處于非交互狀態下(通常指滅屏)，那么它不經過截斷策略，也不會發送給用戶，也就是會被丟棄。
在實際工作中處理的觸摸事件，通常都是來自輸入設備，它肯定是受信任的，而且非注入的，因此它只有在設備處于非交互狀態下(一般指滅屏)下，非會執行截斷策略，而如果設備處于交互狀態(通常指亮屏)，會被直接分發給窗口。
現在來看下截斷策略的具體實現
// PhoneWindowManager.java
public int interceptMotionBeforeQueueingNonInteractive(int displayId, long whenNanos,
int policyFlags) {
// 1. 如果策略要求喚醒屏幕，那么截斷這個觸摸事件
// 一般來說，喚醒屏幕的策略取決于設備的配置文件
if ((policyFlags & FLAG_WAKE) != 0) {
if (wakeUp(whenNanos / 1000000, mAllowTheaterModeWakeFromMotion,
PowerManager.WAKE_REASON_WAKE_MOTION, "android.policy:MOTION")) {
// 返回 0，表示截斷觸摸事件
return 0;
}
}
// 2. 判斷非交互狀態下，是否截斷事件
if (shouldDispatchInputWhenNonInteractive(displayId, KEYCODE_UNKNOWN)) {
// 返回這個值，表示不截斷事件，也就是事件分發給用戶
return ACTION_PASS_TO_USER;
}
// 忽略 theater mode
if (isTheaterModeEnabled() && (policyFlags & FLAG_WAKE) != 0) {
wakeUp(whenNanos / 1000000, mAllowTheaterModeWakeFromMotionWhenNotDreaming,
PowerManager.WAKE_REASON_WAKE_MOTION, "android.policy:MOTION");
}
// 3. 默認截斷觸摸事件
// 返回0，表示截斷事件
return 0;
}
private boolean shouldDispatchInputWhenNonInteractive(int displayId, int keyCode) {
// Apply the default display policy to unknown displays as well.
final boolean isDefaultDisplay = displayId == DEFAULT_DISPLAY
|| displayId == INVALID_DISPLAY;
final Display display = isDefaultDisplay
? mDefaultDisplay
: mDisplayManager.getDisplay(displayId);
final boolean displayOff = (display == null
|| display.getState() == STATE_OFF);
if (displayOff && !mHasFeatureWatch) {
return false;
}
// displayOff 表示屏幕處于 off 狀態，但是非 off 狀態，并不表示一定是亮屏狀態
// 對于 doze 狀態，屏幕處于 on 狀態，但是屏幕可能仍然是黑的
// 因此，只要屏幕處于 on 狀態，并且顯示了鎖屏，觸摸事件不會截斷
if (isKeyguardShowingAndNotOccluded() && !displayOff) {
return true;
}
// 對于觸摸事件，keyCode 的值為 KEYCODE_UNKNOWN
if (mHasFeatureWatch && (keyCode == KeyEvent.KEYCODE_BACK
|| keyCode == KeyEvent.KEYCODE_STEM_PRIMARY
|| keyCode == KeyEvent.KEYCODE_STEM_1
|| keyCode == KeyEvent.KEYCODE_STEM_2
|| keyCode == KeyEvent.KEYCODE_STEM_3)) {
return false;
}
// 對于默認屏幕，如果設備處于夢境狀態，那么觸摸事件不截斷
// 因為 doze 組件需要接收觸摸事件，可能會喚醒屏幕
if (isDefaultDisplay) {
IDreamManager dreamManager = getDreamManager();
try {
if (dreamManager != null && dreamManager.isDreaming()) {
return true;
}
} catch (RemoteException e) {
Slog.e(TAG, "RemoteException when checking if dreaming", e);
}
}
// Otherwise, consume events since the user can't see what is being
// interacted with.
return false;
}截斷策略是否截斷觸摸事件，取決于策略的返回值，有兩種情況
返回 0，表示截斷觸摸事件。
返回 ACTION_PASS_TO_USER ，表示不截斷觸摸事件，也就是把觸摸事件分發給用戶/窗口。
下面列舉觸摸事件截斷與否的情況，但是要注意一個前提，設備處于非交互狀態(一般就是指滅屏狀態)
事件會被傳遞給用戶，也就是不截斷，情況如下
有鎖屏，并且顯示屏處于非 off 狀態。注意，非 off 狀態，并不是表示屏幕處于 on(亮屏) 狀態，也可能是 doze 狀態(屏幕處于低電量狀態)，doze 狀態屏幕也是黑的。
夢境狀態。因為夢境狀態下會運行 doze 組件。
事件被截斷，情況如下
策略標志位包含 FLAG_WAKE ，它會導致屏幕被喚醒，因此需要截斷觸摸事件。FLAG_WAKE 一般來自于輸入設備的配置文件。
沒有鎖屏，沒有夢境，也沒有 FLAG_WAKE，默認就會截斷。
從上面的分析可以總結出了兩條結論
如果系統有組件在運行，例如，鎖屏、doze組件，那么觸摸事件需要分發到這些組件，因此不會被截斷。
如果沒有組件運行，觸摸事件都會被截斷。觸摸事件由于需要喚醒屏幕，而導致被截斷，只是其中一個特例。
由 Input系統: InputManagerService的創建與啟動 可知，InputDispatcher 通過線程循環來處理收件箱中的事件，而且一次循環只能處理一個事件
void InputDispatcher::dispatchOnce() {
nsecs_t nextWakeupTime = LONG_LONG_MAX;
{ // acquire lock
std::scoped_lock _l(mLock);
mDispatcherIsAlive.notify_all();
if (!haveCommandsLocked()) {
// 1. 分發一個觸摸事件
dispatchOnceInnerLocked(&nextWakeupTime);
}
// 觸摸事件的分發過程不會產生命令
if (runCommandsLockedInterruptible()) {
nextWakeupTime = LONG_LONG_MIN;
}
// 2. 計算線程下次喚醒的時間點，以便處理 anr
const nsecs_t nextAnrCheck = processAnrsLocked();
nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
if (nextWakeupTime == LONG_LONG_MAX) {
mDispatcherEnteredIdle.notify_all();
}
} // release lock
// 3. 線程休眠指定的時長
nsecs_t currentTime = now();
int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
mLooper->pollOnce(timeoutMillis);
}一次線程循環處理觸摸事件的過程如下
分發一個觸摸事件。
當事件分發給窗口后，會計算一個窗口反饋的超時時間，利用這個時間，計算線程下次喚醒的時間點。
利用上一步計算出的線程喚醒的時間點，計算出線程最終需要休眠多長時間。當線程被喚醒后，會檢查接收觸摸時間的窗口，是否反饋超時，如果超時，會引發 ANR。
現在來看看如何分發一個觸摸事件
void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
nsecs_t currentTime = now();
if (!mDispatchEnabled) {
resetKeyRepeatLocked();
}
if (mDispatchFrozen) {
return;
}
// 這里是優化 app 切換的延遲
// mAppSwitchDueTime 是 app 切換的超時時間，如果小于當前時間，那么表明app切換超時了
// 如果app切換超時，那么在app切換按鍵事件之前的未處理的事件，都將會被丟棄
bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
if (mAppSwitchDueTime < *nextWakeupTime) {
*nextWakeupTime = mAppSwitchDueTime;
}
// mPendingEvent 表示正在處理的事件
if (!mPendingEvent) {
if (mInboundQueue.empty()) {
// ...
} else {
// 1. 從收件箱隊列中取出事件
mPendingEvent = mInboundQueue.front();
mInboundQueue.pop_front();
traceInboundQueueLengthLocked();
}
// 如果這個事件需要傳遞給用戶，那么需要同上層的 PowerManagerService，此時有用戶行為，這個作用就是延長亮屏的時間
if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
pokeUserActivityLocked(*mPendingEvent);
}
}
ALOG_ASSERT(mPendingEvent != nullptr);
bool done = false;
// 檢測丟棄事件的原因
DropReason dropReason = DropReason::NOT_DROPPED;
if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
// 被截斷策略截斷
dropReason = DropReason::POLICY;
} else if (!mDispatchEnabled) {
// 一般是由于系統正在系統或者正在關閉
dropReason = DropReason::DISABLED;
}
if (mNextUnblockedEvent == mPendingEvent) {
mNextUnblockedEvent = nullptr;
}
switch (mPendingEvent->type) {
// ....
case EventEntry::Type::MOTION: {
std::shared_ptr<MotionEntry> motionEntry =
std::static_pointer_cast<MotionEntry>(mPendingEvent);
if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
// app 切換超時，導致觸摸事件被丟棄
dropReason = DropReason::APP_SWITCH;
}
if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
// 10s 之前的事件，已經過期
dropReason = DropReason::STALE;
}
// 這里是優化應用無響應的一個措施，會丟棄mNextUnblockedEvent之前的所有觸摸事件
if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
dropReason = DropReason::BLOCKED;
}
// 2. 分發觸摸事件
done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
break;
}
// ...
}
// 3. 如果事件被處理，重置一些狀態，例如 mPendingEvent
// 返回 true，就表示已經處理了事件
// 事件被丟棄，或者發送完畢，都會返回 true
// 返回 false，表示暫時不知道如何處理事件，因此線程會休眠
// 然后，線程再次被喚醒時，再來處理這個事件
if (done) {
if (dropReason != DropReason::NOT_DROPPED) {
dropInboundEventLocked(*mPendingEvent, dropReason);
}
mLastDropReason = dropReason;
// 重置 mPendingEvent
releasePendingEventLocked();
// 立即喚醒，處理下一個事件
*nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
}
}Input系統: 按鍵事件分發 已經分析過 InputDispatcher 的線程循環。而對于觸摸事件，是通過 InputDispatcher::dispatchMotionLocked() 進行分發
bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
DropReason* dropReason, nsecs_t* nextWakeupTime) {
if (!entry->dispatchInProgress) {
entry->dispatchInProgress = true;
}
// 1. 觸摸事件有原因需要丟棄，那么不走后面的分發流程
if (*dropReason != DropReason::NOT_DROPPED) {
setInjectionResult(*entry,
*dropReason == DropReason::POLICY ? InputEventInjectionResult::SUCCEEDED
: InputEventInjectionResult::FAILED);
return true;
}
bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;
std::vector<InputTarget> inputTargets;
bool conflictingPointerActions = false;
InputEventInjectionResult injectionResult;
if (isPointerEvent) {
// 尋找觸摸的窗口，窗口保存到 inputTargets
// 2. 為觸摸事件，尋找觸摸的窗口
// 觸摸的窗口保存到 inputTargets 中
injectionResult =
findTouchedWindowTargetsLocked(currentTime, *entry, inputTargets, nextWakeupTime,
&conflictingPointerActions);
} else {
// ...
}
if (injectionResult == InputEventInjectionResult::PENDING) {
// 返回 false，表示暫時不知道如何處理這個事件，這會導致線程休眠
// 等線程下次被喚醒時，再來處理這個事件
return false;
}
// 走到這里，表示觸摸事件已經被處理，因此保存處理的結果
// 只要返回的不是 InputEventInjectionResult::PENDING
// 都表示事件被處理，無論是權限拒絕還是失敗，或是成功
setInjectionResult(*entry, injectionResult);
if (injectionResult == InputEventInjectionResult::PERMISSION_DENIED) {
ALOGW("Permission denied, dropping the motion (isPointer=%s)", toString(isPointerEvent));
return true;
}
if (injectionResult != InputEventInjectionResult::SUCCEEDED) {
CancelationOptions::Mode mode(isPointerEvent
? CancelationOptions::CANCEL_POINTER_EVENTS
: CancelationOptions::CANCEL_NON_POINTER_EVENTS);
CancelationOptions options(mode, "input event injection failed");
synthesizeCancelationEventsForMonitorsLocked(options);
return true;
}
// 走到這里，表示觸摸事件已經成功找到觸摸的窗口
// Add monitor channels from event's or focused display.
// 3. 觸摸事件找到了觸摸窗口，在分發給窗口前，保存 global monitor 到 inputTargets 中
// 開發者選項中的 Show taps 和 Pointer location，利用的 global monitor
addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
if (isPointerEvent) {
// ... 省略 portal window 處理的代碼
}
if (conflictingPointerActions) {
// ...
}
// 4. 分發事件給 inputTargets 中的所有窗口
dispatchEventLocked(currentTime, entry, inputTargets);
return true;
}一個觸摸事件的分發過程，可以大致總結為以下幾個過程
如果有原因表明觸摸事件需要被丟棄，那么觸摸事件不會走后面的分發流程，即被丟棄。
通常觸摸事件是發送給窗口的，因此需要為觸摸事件尋找觸摸窗口。窗口最終被保存到 inputTargets 中。
inputTargets 保存觸摸窗口后，還要保存 global monitor 窗口。例如開發者選項中的 Show taps 和 Pointer location，就是利用這個窗口實現的。
啟動分發循環，把觸摸事件分發給 inputTargets 保存的窗口。 由于 Input系統: 按鍵事件分發 已經分發過這個過程，本文不再分析。
InputEventInjectionResult InputDispatcher::findTouchedWindowTargetsLocked(
nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,
nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) {
// ...
// 6. 對于非 DOWN 事件，獲取已經 DOWN 事件保存的 TouchState
// TouchState 保存了接收 DOWN 事件的窗口
const TouchState* oldState = nullptr;
TouchState tempTouchState;
std::unordered_map<int32_t, TouchState>::iterator oldStateIt =
mTouchStatesByDisplay.find(displayId);
if (oldStateIt != mTouchStatesByDisplay.end()) {
oldState = &(oldStateIt->second);
tempTouchState.copyFrom(*oldState);
}
// ...
// 第一個條件 newGesture 表示第一個手指按下
// 后面一個條件，表示當前窗口支持 split motion，并且此時有另外一個手指按下
if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
/* Case 1: New splittable pointer going down, or need target for hover or scroll. */
// 觸摸點的獲取 x, y 坐標
int32_t x;
int32_t y;
int32_t pointerIndex = getMotionEventActionPointerIndex(action);
if (isFromMouse) {
// ...
} else {
x = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_X));
y = int32_t(entry.pointerCoords[pointerIndex].getAxisValue(AMOTION_EVENT_AXIS_Y));
}
// 這里檢測是否是第一個手指按下
bool isDown = maskedAction == AMOTION_EVENT_ACTION_DOWN;
// 1. 對于 DOWN 事件，根據觸摸事件的x,y坐標，尋找觸摸窗口
// 參數 addOutsideTargets 表示，只有在第一個手指按下時，如果沒有找到觸摸的窗口，
// 那么需要保存那些可以接受 OUTSIZE 事件的窗口到 tempTouchState
newTouchedWindowHandle =
findTouchedWindowAtLocked(displayId, x, y, &tempTouchState,
isDown /*addOutsideTargets*/, true /*addPortalWindows*/);
// 省略 ... 處理窗口異常的情況 ...
// 2. 獲取所有的 getsture monitor
const std::vector<TouchedMonitor> newGestureMonitors = isDown
? selectResponsiveMonitorsLocked(
findTouchedGestureMonitorsLocked(displayId, tempTouchState.portalWindows))
: tempTouchState.gestureMonitors;
// 既沒有找到觸摸點所在的窗口，也沒有找到 gesture monitor，那么此次尋找觸摸窗口的任務就失敗了
if (newTouchedWindowHandle == nullptr && newGestureMonitors.empty()) {
ALOGI("Dropping event because there is no touchable window or gesture monitor at "
"(%d, %d) in display %" PRId32 ".",
x, y, displayId);
injectionResult = InputEventInjectionResult::FAILED;
goto Failed;
}
// 走到這里，表示找到了觸摸的窗口，或者找到 gesture monitor
if (newTouchedWindowHandle != nullptr) {
// 馬上要保存窗口了，現在獲取窗口的 flag
int32_t targetFlags = InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS;
if (isSplit) {
targetFlags |= InputTarget::FLAG_SPLIT;
}
if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {
targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
} else if (isWindowObscuredLocked(newTouchedWindowHandle)) {
targetFlags |= InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
}
// Update hover state.
if (maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT) {
newHoverWindowHandle = nullptr;
} else if (isHoverAction) {
newHoverWindowHandle = newTouchedWindowHandle;
}
// Update the temporary touch state.
// 如果窗口支持 split，那么用 tempTouchState 保存窗口的時候，要特別保存 pointer id
BitSet32 pointerIds;
if (isSplit) {
uint32_t pointerId = entry.pointerProperties[pointerIndex].id;
pointerIds.markBit(pointerId);
}
// 3. tempTouchState 保存找到的觸摸的窗口
// 如果是真的找到的觸摸窗口，那么這里就是保存，如果是找到可以接受 OUTSIDE 的窗口，那么這里是更新
tempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
} else if (tempTouchState.windows.empty()) {
// If no window is touched, set split to true. This will allow the next pointer down to
// be delivered to a new window which supports split touch.
tempTouchState.split = true;
}
if (isDown) {
// tempTouchState 保存所有的 gesture monitor
// 4. 第一個手指按下時，tempTouchState 保存 gesture monitor
tempTouchState.addGestureMonitors(newGestureMonitors);
}
} else {
// ...
}
if (newHoverWindowHandle != mLastHoverWindowHandle) {
// ....
}
{
// 權限檢測 ...
}
// 保存接收 AMOTION_EVENT_ACTION_OUTSIDE 的窗口
if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
// ...
}
// 第一個手指按下時，保存壁紙窗口
if (maskedAction == AMOTION_EVENT_ACTION_DOWN) { //
// ...
}
// 走到這里，表示沒有異常情況了
injectionResult = InputEventInjectionResult::SUCCEEDED;
// 5. 把 tempTouchState 保存了觸摸窗口和gesture monitor，保存到 inputTargets 中
for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
touchedWindow.pointerIds, inputTargets);
}
for (const TouchedMonitor& touchedMonitor : tempTouchState.gestureMonitors) {
addMonitoringTargetLocked(touchedMonitor.monitor, touchedMonitor.xOffset,
touchedMonitor.yOffset, inputTargets);
}
// Drop the outside or hover touch windows since we will not care about them
// in the next iteration.
tempTouchState.filterNonAsIsTouchWindows();
Failed:
// ...
// 6. 緩存 tempTouchState
if (maskedAction != AMOTION_EVENT_ACTION_SCROLL) {
if (tempTouchState.displayId >= 0) {
mTouchStatesByDisplay[displayId] = tempTouchState;
} else {
mTouchStatesByDisplay.erase(displayId);
}
}
return injectionResult;
}為觸摸事件尋找觸摸窗口的過程，極其復雜。雖然這段代碼被我省略了很多過程，但是我估計讀者也會看得頭暈。
對于 DOWN 事件
根據 x,y 坐標尋找觸摸的窗口。
獲取所有的 gesture monitor 窗口 。
把觸摸窗口保存到 tempTouchState 中。
把所有的 gesture monitor 窗口保存到 tempTouchState 中。
為 tempTouchState 保存所有窗口，創建 InputTarget 對象，并保存到參數 inputTargets 中。
使用 mTouchStatesByDisplay 緩存 tempTouchState。
gesture monitor 是為了實現手勢功能而添加的一個窗口。什么是手勢功能？ 例如在屏幕的左邊/右邊，向屏幕中央滑動，會觸發返回手勢。這個手勢功能用來替代導航鍵。在下一篇文章中，我會剖析這個手勢功能的原理。
對于非 DOWN 事件，一般為 MOVE, UP 事件
獲取 DOWN 事件緩存的 tempTouchState。 因為 tempTouchState 保存了處理 DOWN 事件的觸摸窗口和 gesture monitor，非 DOWN 事件，也會發送給這些窗口。
重復 DOWN 事件的第5步。
當分析的代碼量很大的時候，我們需要有一個整體的觀念。為觸摸事件尋找觸摸窗口，最終的結果就是把找到的窗口保存到參數 inputTargets 中，后面會把事件分發給 inputTargets 保存的窗口。
// addOutsideTargets 在第一個手指按下是為 true
// addPortalWindows 值為 true
// ignoreDragWindow 默認為 false
sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId, int32_t x,
int32_t y, TouchState* touchState,
bool addOutsideTargets,
bool addPortalWindows,
bool ignoreDragWindow) {
if ((addPortalWindows || addOutsideTargets) && touchState == nullptr) {
LOG_ALWAYS_FATAL(
"Must provide a valid touch state if adding portal windows or outside targets");
}
// Traverse windows from front to back to find touched window.
// 從前到后，遍歷窗口
const std::vector<sp<InputWindowHandle>>& windowHandles = getWindowHandlesLocked(displayId);
for (const sp<InputWindowHandle>& windowHandle : windowHandles) {
// ignoreDragWindow 默認為 false
if (ignoreDragWindow && haveSameToken(windowHandle, mDragState->dragWindow)) {
continue;
}
// 獲取窗口信息
const InputWindowInfo* windowInfo = windowHandle->getInfo();
// 匹配屬于特定屏幕的窗口
if (windowInfo->displayId == displayId) {
auto flags = windowInfo->flags;
// 窗口要可見
if (windowInfo->visible) {
// 窗口要可觸摸
if (!flags.test(InputWindowInfo::Flag::NOT_TOUCHABLE)) {
// 檢測是否為觸摸模型: 可獲取焦點，并且不允許窗口之外的觸摸事件發送到它后面的窗口
bool isTouchModal = !flags.test(InputWindowInfo::Flag::NOT_FOCUSABLE) &&
!flags.test(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
// 窗口是觸摸模型，或者觸摸的坐標點落在窗口上
if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {
int32_t portalToDisplayId = windowInfo->portalToDisplayId;
// 如果是 portal window
if (portalToDisplayId != ADISPLAY_ID_NONE &&
portalToDisplayId != displayId) {
if (addPortalWindows) {
// For the monitoring channels of the display.
// touchState 保存 portal window
touchState->addPortalWindow(windowHandle);
}
// 遞歸調用，獲取 portal display id 下的觸摸窗口
return findTouchedWindowAtLocked(portalToDisplayId, x, y, touchState,
addOutsideTargets, addPortalWindows);
}
// 不是 portal window，直接返回找到的窗口
return windowHandle;
}
}
// 走到這里，表示沒有找到觸摸窗口。也就是說，既沒有找到觸摸模型的窗口，也沒有找到包含觸摸點的窗口
// 當第一個手指按下是，addOutsideTargets 值為 true
// NOT_TOUCH_MODAL 和 WATCH_OUTSIDE_TOUCH 一起使用，當第一個手指按下時，如果落在窗口之外
// 窗口會收到 MotionEvent.ACTION_OUTSIDE 事件
if (addOutsideTargets && flags.test(InputWindowInfo::Flag::WATCH_OUTSIDE_TOUCH)) {
touchState->addOrUpdateWindow(windowHandle,
InputTarget::FLAG_DISPATCH_AS_OUTSIDE,
BitSet32(0));
}
}
}
}
return nullptr;
}這里涉及一個 portal window 的概念，由于我沒有找到具體使用的地方，我大致猜測它的意思就是，設備外接一個屏幕，然后在主屏幕上顯示一個窗口來操作這個外接屏幕。后面的分析，我將略過 portal window 的部分。當然，觸摸掌握了觸摸事件的分發流程，以后遇到了 portal window 的事情，再來分析，應該沒問題的。
尋找觸摸點所在的窗口，其實就是從上到下遍歷所有窗口，然后找到滿足條件的窗口。
窗口首先要滿足前置條件
窗口要在指定屏幕上。
窗口要可見。
窗口要可觸摸。
滿足了所有的前置條件后，只要滿足以下任意一個條件，那么就找到了觸摸點所在的窗口
是觸摸模型的窗口: 可獲取焦點，并且不允許窗口之外的觸摸事件發送到它后面的窗口。
觸摸點的 x,y 坐標落在窗口坐標系中。
// InputDispatcher 保存觸摸窗口
void InputDispatcher::addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
int32_t targetFlags, BitSet32 pointerIds,
std::vector<InputTarget>& inputTargets) {
std::vector<InputTarget>::iterator it =
std::find_if(inputTargets.begin(), inputTargets.end(),
[&windowHandle](const InputTarget& inputTarget) {
return inputTarget.inputChannel->getConnectionToken() ==
windowHandle->getToken();
});
const InputWindowInfo* windowInfo = windowHandle->getInfo();
// 創建 InputTarget，并保存到參數 inputTargets
if (it == inputTargets.end()) {
InputTarget inputTarget;
std::shared_ptr<InputChannel> inputChannel =
getInputChannelLocked(windowHandle->getToken());
if (inputChannel == nullptr) {
ALOGW("Window %s already unregistered input channel", windowHandle->getName().c_str());
return;
}
inputTarget.inputChannel = inputChannel;
inputTarget.flags = targetFlags;
inputTarget.globalScaleFactor = windowInfo->globalScaleFactor;
inputTarget.displaySize =
int2(windowHandle->getInfo()->displayWidth, windowHandle->getInfo()->displayHeight);
inputTargets.push_back(inputTarget);
it = inputTargets.end() - 1;
}
ALOG_ASSERT(it->flags == targetFlags);
ALOG_ASSERT(it->globalScaleFactor == windowInfo->globalScaleFactor);
// 保存 InputTarget 后，在保存窗口的坐標轉換參數，
// 這個參數可以把顯示屏的坐標，轉換為窗口的坐標
it->addPointers(pointerIds, windowInfo->transform);
}
// InputDispatcher 保存 gesture monitor
void InputDispatcher::addMonitoringTargetLocked(const Monitor& monitor, float xOffset,
float yOffset,
std::vector<InputTarget>& inputTargets) {
InputTarget target;
target.inputChannel = monitor.inputChannel;
target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
ui::Transform t;
t.set(xOffset, yOffset);
target.setDefaultPointerTransform(t);
inputTargets.push_back(target);
}對于觸摸事件，無論是觸摸窗口，還是 gesture monitor，都會被轉化為 InputTarget，然后保存到參數 inputTargets 中。當后面啟動分發循環后，觸摸事件就會發送到 inputTargets 保存的窗口中。
“Android怎么開發Input系統觸摸事件分發”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
