Android—IMS的InputDispatcher

已于 2023-04-19 18:30:16 修改
阅读量818 收藏 3
点赞数 1
文章标签： android
于 2023-04-19 18:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41939525/article/details/130112571
版权

前文说到InputReader调用mQueuedListener->flush()会去换下InputDispatcher的Looper然后处理输入事件。

frameworks\native\services\inputflinger\InputDispatcher.cpp：

bool InputDispatcherThread::threadLoop() {
    mDispatcher->dispatchOnce();
    return true;
}

void InputDispatcher::dispatchOnce() {
    nsecs_t nextWakeupTime = LONG_LONG_MAX;
    { // acquire lock
        std::scoped_lock _l(mLock);
        mDispatcherIsAlive.notify_all();

        // Run a dispatch loop if there are no pending commands.
        // The dispatch loop might enqueue commands to run afterwards.
        if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);
        }

        // Run all pending commands if there are any.
        // If any commands were run then force the next poll to wake up immediately.
        if (runCommandsLockedInterruptible()) {
            nextWakeupTime = LONG_LONG_MIN;
        }
    } // release lock

    // Wait for callback or timeout or wake.  (make sure we round up, not down)
    nsecs_t currentTime = now();
    int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
    mLooper->pollOnce(timeoutMillis);
}

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
    ....
    switch (mPendingEvent->type) {
    case EventEntry::TYPE_CONFIGURATION_CHANGED:
        ....
    case EventEntry::TYPE_DEVICE_RESET: 
        ....
    case EventEntry::TYPE_KEY: 
        ....
    case EventEntry::TYPE_MOTION:{
        MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
        if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
            dropReason = DROP_REASON_APP_SWITCH;
        }
        if (dropReason == DROP_REASON_NOT_DROPPED
                && isStaleEvent(currentTime, typedEntry)) {
            dropReason = DROP_REASON_STALE;
        }
        if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
            dropReason = DROP_REASON_BLOCKED;
        }
        done = dispatchMotionLocked(currentTime, typedEntry,
                &dropReason, nextWakeupTime);
        break;
    }
    default:
        ALOG_ASSERT(false);
        break;
    }
    if (done) {
        if (dropReason != DROP_REASON_NOT_DROPPED) {
            dropInboundEventLocked(mPendingEvent, dropReason);
        }
        mLastDropReason = dropReason;

        releasePendingEventLocked();
        *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
    }
}

我们主要看Motion屏幕输入事件的

bool InputDispatcher::dispatchMotionLocked(
        nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
    ....
    bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;
    if (isPointerEvent) {
        // Pointer event.  (eg. touchscreen)
        injectionResult = findTouchedWindowTargetsLocked(currentTime,
                entry, inputTargets, nextWakeupTime, &conflictingPointerActions);
    } else {
        // Non touch event.  (eg. trackball)
        injectionResult = findFocusedWindowTargetsLocked(currentTime,
                entry, inputTargets, nextWakeupTime);
    }
    ....
    // Dispatch the motion.
    dispatchEventLocked(currentTime, entry, inputTargets);
    return true;
}

1.findTouchedWindowTargetsLocked  寻找目标Window

2.WMS与IMS的联系

3.dispatchEventLocked 分发事件

1.findTouchedWindowTargetsLocked

int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
                                                        const MotionEntry& entry,
                                                        std::vector<InputTarget>& inputTargets,
                                                        nsecs_t* nextWakeupTime,
                                                        bool* outConflictingPointerActions) {
    ATRACE_CALL();
    ...
    // 读取触控事件所属的Display的id信息
    int32_t displayId = entry.displayId;
    ...
    // 只有ACTION_DOWN类型代表新的触控事件，需要寻找新的目标窗口，后续的ACTION_MOVE或ACTION_UP类型的触控事件直接发送导已经找到的目标窗口
    bool newGesture = (maskedAction == AMOTION_EVENT_ACTION_DOWN ||
                       maskedAction == AMOTION_EVENT_ACTION_SCROLL || isHoverAction);
    ...

    if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
        // 读取触控事件的x、y坐标位置
        int32_t x;
        int32_t y;
        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));
        }
        // 根据触控事件所属的displayid、x/y坐标位置等属性信息，调用findTouchedWindowAtLocked找到目标窗口
        sp<InputWindowHandle> newTouchedWindowHandle =
                findTouchedWindowAtLocked(displayId, x, y, &tempTouchState,
                                          isDown /*addOutsideTargets*/, true /*addPortalWindows*/);
        ...
    } else {
        ...
    }
    ...
}

sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t displayId,
        int32_t x, int32_t y, bool addOutsideTargets, bool addPortalWindows) {
    // 从前到后遍历窗口找到被触摸的窗口。
    const std::vector<sp<InputWindowHandle>> windowHandles = getWindowHandlesLocked(displayId);
    for (const sp<InputWindowHandle>& windowHandle : windowHandles) {
        const InputWindowInfo* windowInfo = windowHandle->getInfo();
        if (windowInfo->displayId == displayId) {
            int32_t flags = windowInfo->layoutParamsFlags;
            if (windowInfo->visible) {
                if (!(flags & InputWindowInfo::FLAG_NOT_TOUCHABLE)) {
                    ...
                    // 根据触控事件的x/y坐标位置信息与窗口的可见区域进行匹配找到目标窗口
                    if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {
                        ...
                        return windowHandle;
                    }
                }
            ...

            }
        }
    }
    return nullptr;
}

std::vector<sp<InputWindowHandle>> InputDispatcher::getWindowHandlesLocked(
        int32_t displayId) const {
    // 从集合mWindowHandlesByDisplay中根据传入的displayId取出对应的可见窗口集合
    return getValueByKey(mWindowHandlesByDisplay, displayId);
}

所以findTouchedWindowTargetsLocked就是用DeviceId和触摸的坐标轴来找到对应Window，那mWindowHandlesByDisplay的窗口数据是从哪里来的？

frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp：

void InputDispatcher::updateWindowHandlesForDisplayLocked(
        const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) {
    ...
    // Insert or replace
    mWindowHandlesByDisplay[displayId] = newHandles;
}

void InputDispatcher::setInputWindowsLocked(
        const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) {
    ...
    updateWindowHandlesForDisplayLocked(inputWindowHandles, displayId);
    ...
}

void InputDispatcher::setInputWindows(
        const std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>& handlesPerDisplay) {
    { // acquire lock
        std::scoped_lock _l(mLock);
        for (auto const& i : handlesPerDisplay) {
            setInputWindowsLocked(i.second, i.first);
        }
    }
    ...
}

frameworks\base\services\core\jni\com_android_server_input_InputManagerService.cpp：

void NativeInputManager::setInputWindows(JNIEnv* env, jobjectArray windowHandleObjArray,
         int32_t displayId) {
    std::vector<sp<InputWindowHandle> > windowHandles;

    if (windowHandleObjArray) {
        jsize length = env->GetArrayLength(windowHandleObjArray);
        for (jsize i = 0; i < length; i++) {
            jobject windowHandleObj = env->GetObjectArrayElement(windowHandleObjArray, i);
            if (! windowHandleObj) {
                break; // found null element indicating end of used portion of the array
            }

            sp<InputWindowHandle> windowHandle =
                    android_view_InputWindowHandle_getHandle(env, windowHandleObj);
            if (windowHandle != nullptr) {
                windowHandles.push_back(windowHandle);
            }
            env->DeleteLocalRef(windowHandleObj);
        }
    }

    mInputManager->getDispatcher()->setInputWindows(windowHandles, displayId);
    ....
}

static void nativeSetInputWindows(JNIEnv* env, jclass /* clazz */,
        jlong ptr, jobjectArray windowHandleObjArray) {
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    im->setInputWindows(env, windowHandleObjArray);
}

所以Java层可以调用IMS的nativeSetInputWindows方法给IMS设置窗口数据。

2.WMS与IMS的联系

在handleResumeActivity中，将 DecorView 添加到 WindowManager中，

wm.addView(decor, l);

frameworks\base\core\java\android\view\WindowManagerGlobal.java：

    public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
            ....
            root = new ViewRootImpl(view.getContext(), display);
            view.setLayoutParams(wparams);
            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);
            // do this last because it fires off messages to start doing things
            try {
                root.setView(view, wparams, panelParentView);
            } catch (RuntimeException e) {
                // BadTokenException or InvalidDisplayException, clean up.
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
        }
    }

frameworks\base\core\java\android\view\ViewRootImpl.java：

   public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                ......
                if ((mWindowAttributes.inputFeatures
                        & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                    mInputChannel = new InputChannel();
                }
                try {
                    ......
                    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mInputChannel);
                } catch (RemoteException e) {
                    ......
                } finally {
                    ......
                }
                ......
                if (mInputChannel != null) {
                    if (mInputQueueCallback != null) {
                        mInputQueue = new InputQueue();
                        mInputQueueCallback.onInputQueueCreated(mInputQueue);
                    }
                    // 接收输入事件
                    mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                            Looper.myLooper());
                }
                ......
            }
        }
    }
  1. 在mWindowSession.addToDisplay中，会调用setInputWindows设置窗口数据。
  2. 创建了InputChannel用于接受输入事件。
  3. new WindowInputEventReceiver(mInputChannel, Looper.myLooper());接受处理事件。

mWindowSession.addToDisplay会调用WMS的addWindow，InputChannel是参数之一，把InputChannel传给了WMS。

frameworks\base\services\core\java\com\android\server\wm\WindowManagerService.java：

    public int addWindow(Session session, IWindow client, int seq,
            LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,
            Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
            DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,
            InsetsState outInsetsState) {
            ....
            final boolean openInputChannels = (outInputChannel != null
                    && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
            if  (openInputChannels) {
                win.openInputChannel(outInputChannel);
            }
            ....
    }

frameworks\base\services\core\java\com\android\server\wm\WindowState.java：

    void openInputChannel(InputChannel outInputChannel) {
        if (mInputChannel != null) {
            throw new IllegalStateException("Window already has an input channel.");
        }
        String name = getName();
        InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
        mInputChannel = inputChannels[0];
        mClientChannel = inputChannels[1];
        mInputWindowHandle.token = mClient.asBinder();
        if (outInputChannel != null) {
            mClientChannel.transferTo(outInputChannel);
            mClientChannel.dispose();
            mClientChannel = null;
        } else {
            // If the window died visible, we setup a dummy input channel, so that taps
            // can still detected by input monitor channel, and we can relaunch the app.
            // Create dummy event receiver that simply reports all events as handled.
            mDeadWindowEventReceiver = new DeadWindowEventReceiver(mClientChannel);
        }
        mWmService.mInputManager.registerInputChannel(mInputChannel, mClient.asBinder());
    }

frameworks\base\core\java\android\view\InputChannel.java：

    public static InputChannel[] openInputChannelPair(String name) {
        if (name == null) {
            throw new IllegalArgumentException("name must not be null");
        }

        if (DEBUG) {
            Slog.d(TAG, "Opening input channel pair '" + name + "'");
        }
        return nativeOpenInputChannelPair(name);
    }

frameworks\base\core\jni\android_view_InputChannel.cpp：

static jobjectArray android_view_InputChannel_nativeOpenInputChannelPair(JNIEnv* env,
        jclass clazz, jstring nameObj) {
    ScopedUtfChars nameChars(env, nameObj);
    std::string name = nameChars.c_str();

    sp<InputChannel> serverChannel;
    sp<InputChannel> clientChannel;
    status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);

    if (result) {
        String8 message;
        message.appendFormat("Could not open input channel pair.  status=%d", result);
        jniThrowRuntimeException(env, message.string());
        return NULL;
    }

    jobjectArray channelPair = env->NewObjectArray(2, gInputChannelClassInfo.clazz, NULL);
    if (env->ExceptionCheck()) {
        return NULL;
    }

    jobject serverChannelObj = android_view_InputChannel_createInputChannel(env,
            std::make_unique<NativeInputChannel>(serverChannel));
    if (env->ExceptionCheck()) {
        return NULL;
    }

    jobject clientChannelObj = android_view_InputChannel_createInputChannel(env,
            std::make_unique<NativeInputChannel>(clientChannel));
    if (env->ExceptionCheck()) {
        return NULL;
    }

    env->SetObjectArrayElement(channelPair, 0, serverChannelObj);
    env->SetObjectArrayElement(channelPair, 1, clientChannelObj);
    return channelPair;
}

frameworks\native\libs\input\InputTransport.cpp：

status_t InputChannel::openInputChannelPair(const std::string& name,
        sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {
    int sockets[2];
    if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
        status_t result = -errno;
        ALOGE("channel '%s' ~ Could not create socket pair.  errno=%d",
                name.c_str(), errno);
        outServerChannel.clear();
        outClientChannel.clear();
        return result;
    }

    int bufferSize = SOCKET_BUFFER_SIZE;
    setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));

    std::string serverChannelName = name;
    serverChannelName += " (server)";
    outServerChannel = new InputChannel(serverChannelName, sockets[0]);

    std::string clientChannelName = name;
    clientChannelName += " (client)";
    outClientChannel = new InputChannel(clientChannelName, sockets[1]);
    return OK;
}

openInputChannel里面创建一对InputChannel，然后将Server端的InputChannel注册到InputDispatcher中，将Client端的InputChannel返回给客户端即ViewRootImpl使用。InputChannel封装了name和fd。通过文件描述符fd实现进程通信。

3.dispatchEventLocked 分发事件

void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
        EventEntry* eventEntry, const std::vector<InputTarget>& inputTargets) {
    ....
    for (const InputTarget& inputTarget : inputTargets) {
        ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);
        if (connectionIndex >= 0) {
            sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);
            prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);
        }
        ....
    }
}

ssize_t InputDispatcher::getConnectionIndexLocked(const sp<InputChannel>& inputChannel) {
    if (inputChannel == nullptr) {
        return -1;
    }

    for (size_t i = 0; i < mConnectionsByFd.size(); i++) {
        sp<Connection> connection = mConnectionsByFd.valueAt(i);
        if (connection->inputChannel->getToken() == inputChannel->getToken()) {
            return i;
        }
    }

    return -1;
}

getConnectionIndexLocked通过inputChannel获取Connection对象。

所以说dispatchEventLocked会获取窗口对应的inputChannel，并调用prepareDispatchCycleLocked进行处理。 prepareDispatchCycleLocked方法内部调用了enqueueDispatchEntriesLocked方法，后续通过inputChannel传输事件。

void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
        const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
    ....
    // Not splitting.  Enqueue dispatch entries for the event as is.
    enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
}

void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
        const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
    bool wasEmpty = connection->outboundQueue.isEmpty();

    // Enqueue dispatch entries for the requested modes.
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_OUTSIDE);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_IS);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);

    // If the outbound queue was previously empty, start the dispatch cycle going.
    if (wasEmpty && !connection->outboundQueue.isEmpty()) {
        startDispatchCycleLocked(currentTime, connection);
    }
}

1.enqueueDispatchEntryLocked将事件插入队列

2.startDispatchCycleLocked开始分发事件

1.enqueueDispatchEntryLocked将事件插入队列

void InputDispatcher::enqueueDispatchEntryLocked(
        const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget,
        int32_t dispatchMode) {
    ....
    // This is a new event.
    // Enqueue a new dispatch entry onto the outbound queue for this connection.
    DispatchEntry* dispatchEntry = new DispatchEntry(eventEntry, // increments ref
            inputTargetFlags, inputTarget->xOffset, inputTarget->yOffset,
            inputTarget->globalScaleFactor, inputTarget->windowXScale,
            inputTarget->windowYScale);

    // Apply target flags and update the connection's input state.
    switch (eventEntry->type) {
    case EventEntry::TYPE_KEY: {
        KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);
        dispatchEntry->resolvedAction = keyEntry->action;
        dispatchEntry->resolvedFlags = keyEntry->flags;

        if (!connection->inputState.trackKey(keyEntry,
                dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags)) {
#if DEBUG_DISPATCH_CYCLE
            ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent key event",
                    connection->getInputChannelName().c_str());
#endif
            delete dispatchEntry;
            return; // skip the inconsistent event
        }
        break;
    }

    case EventEntry::TYPE_MOTION: {
        MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);
        if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
        } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT) {
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_EXIT;
        } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER) {
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
        } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT) {
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_CANCEL;
        } else if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER) {
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_DOWN;
        } else {
            dispatchEntry->resolvedAction = motionEntry->action;
        }
        if (dispatchEntry->resolvedAction == AMOTION_EVENT_ACTION_HOVER_MOVE
                && !connection->inputState.isHovering(
                        motionEntry->deviceId, motionEntry->source, motionEntry->displayId)) {
#if DEBUG_DISPATCH_CYCLE
        ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: filling in missing hover enter event",
                connection->getInputChannelName().c_str());
#endif
            dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_HOVER_ENTER;
        }

        dispatchEntry->resolvedFlags = motionEntry->flags;
        if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_OBSCURED) {
            dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
        }
        if (dispatchEntry->targetFlags & InputTarget::FLAG_WINDOW_IS_PARTIALLY_OBSCURED) {
            dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
        }

        if (!connection->inputState.trackMotion(motionEntry,
                dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags)) {
#if DEBUG_DISPATCH_CYCLE
            ALOGD("channel '%s' ~ enqueueDispatchEntryLocked: skipping inconsistent motion event",
                    connection->getInputChannelName().c_str());
#endif
            delete dispatchEntry;
            return; // skip the inconsistent event
        }

        dispatchPointerDownOutsideFocus(motionEntry->source,
                dispatchEntry->resolvedAction, inputTarget->inputChannel->getToken());

        break;
    }
    }

    // Remember that we are waiting for this dispatch to complete.
    if (dispatchEntry->hasForegroundTarget()) {
        incrementPendingForegroundDispatches(eventEntry);
    }

    // Enqueue the dispatch entry.
    connection->outboundQueue.enqueueAtTail(dispatchEntry);
    traceOutboundQueueLength(connection);

}

enqueueDispatchEntryLocked里面将输入事件重新封装为一个DispatchEntry，根据不同的Event填充数据，然后放到connection的outboundQueue队列中。

2.startDispatchCycleLocked开始分发事件

void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
        const sp<Connection>& connection) {

    while (connection->status == Connection::STATUS_NORMAL
            && !connection->outboundQueue.isEmpty()) {
        DispatchEntry* dispatchEntry = connection->outboundQueue.head;
        dispatchEntry->deliveryTime = currentTime;

        // Publish the event.
        status_t status;
        EventEntry* eventEntry = dispatchEntry->eventEntry;
        switch (eventEntry->type) {
        case EventEntry::TYPE_KEY: {
            KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);

            // Publish the key event.
            status = connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,
                    keyEntry->deviceId, keyEntry->source, keyEntry->displayId,
                    dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,
                    keyEntry->keyCode, keyEntry->scanCode,
                    keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,
                    keyEntry->eventTime);
            break;
        }

        case EventEntry::TYPE_MOTION: {
            MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);

            PointerCoords scaledCoords[MAX_POINTERS];
            const PointerCoords* usingCoords = motionEntry->pointerCoords;

            // Set the X and Y offset depending on the input source.
            float xOffset, yOffset;
            if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)
                    && !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {
                float globalScaleFactor = dispatchEntry->globalScaleFactor;
                float wxs = dispatchEntry->windowXScale;
                float wys = dispatchEntry->windowYScale;
                xOffset = dispatchEntry->xOffset * wxs;
                yOffset = dispatchEntry->yOffset * wys;
                if (wxs != 1.0f || wys != 1.0f || globalScaleFactor != 1.0f) {
                    for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
                        scaledCoords[i] = motionEntry->pointerCoords[i];
                        scaledCoords[i].scale(globalScaleFactor, wxs, wys);
                    }
                    usingCoords = scaledCoords;
                }
            } else {
                xOffset = 0.0f;
                yOffset = 0.0f;

                // We don't want the dispatch target to know.
                if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {
                    for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
                        scaledCoords[i].clear();
                    }
                    usingCoords = scaledCoords;
                }
            }

            // Publish the motion event.
            status = connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,
                    motionEntry->deviceId, motionEntry->source, motionEntry->displayId,
                    dispatchEntry->resolvedAction, motionEntry->actionButton,
                    dispatchEntry->resolvedFlags, motionEntry->edgeFlags,
                    motionEntry->metaState, motionEntry->buttonState, motionEntry->classification,
                    xOffset, yOffset, motionEntry->xPrecision, motionEntry->yPrecision,
                    motionEntry->downTime, motionEntry->eventTime,
                    motionEntry->pointerCount, motionEntry->pointerProperties,
                    usingCoords);
            break;
        }

        default:
            ALOG_ASSERT(false);
            return;
        }

        // Check the result.
        if (status) {
            if (status == WOULD_BLOCK) {
                if (connection->waitQueue.isEmpty()) {
                    ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
                            "This is unexpected because the wait queue is empty, so the pipe "
                            "should be empty and we shouldn't have any problems writing an "
                            "event to it, status=%d", connection->getInputChannelName().c_str(),
                            status);
                    abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
                } else {
                    // Pipe is full and we are waiting for the app to finish process some events
                    // before sending more events to it.
#if DEBUG_DISPATCH_CYCLE
                    ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
                            "waiting for the application to catch up",
                            connection->getInputChannelName().c_str());
#endif
                    connection->inputPublisherBlocked = true;
                }
            } else {
                ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
                        "status=%d", connection->getInputChannelName().c_str(), status);
                abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
            }
            return;
        }

        // Re-enqueue the event on the wait queue.
        connection->outboundQueue.dequeue(dispatchEntry);
        traceOutboundQueueLength(connection);
        connection->waitQueue.enqueueAtTail(dispatchEntry);
        traceWaitQueueLength(connection);
    }
}

startDispatchCycleLocked会根据事件类型选择inputPublisher.publishKeyEvent和inputPublisher.publishMotionEvent，这两个方法将事件写入InputChannel通道中。这样ViewRootImpl端的InputChannel就可以通过socket获取到事件信息，然后在WindowInputEventReceiver中将事件传递到DecorView最后传到对应的View上。

在发送完毕后会将事件移出connection->outboundQueue队列，并放入到waitQueue等待队列中，等待事件处理完毕后再移出。

总结：ViewRootImpl的setView中，会调用WMS.addWindow，会先创建一对InputChannel，给到ViewRootImpl和IMS，InputChannel是由通过文件描述符fd创建的，并通过fd实现两个服务的进程通信。在InputDispatcher被唤醒后，InputDispatcher会遍历窗口数据，找到对应窗口的InputChannel，根据事件类型key或者motion封装输入事件，然后将事件通过InputChannel发送给WindowInputEventReceiver中处理，最后发送到对应的View中。

#全家桶
关注
Android WMS——输入系统管理（十八）
小旭的专栏
11-20 230
Android 系统服务，分为 Java 层和 Native 层两部分，Java 层负责与 WMS 通信，而 Native 层则是 InputReader 和 InputDispatcher 两个输入系统关键组件的运行容器；1）创建 IMS 对象创建 NativeInputManager 对象，此对象将是 Native 层组件与 Java 层 IMS 进行通信的桥梁。创建 Native 层的 InputManager，创建 InputDispatcher、InputReader、EventHub。
Android 事件传递流程 - 基于WMS、IMS、ViewRootImpl等学习笔记
json_it的博客
09-14 1555
概述 在Android中，Touch事件的分发分服务端和应用端。在服务端由WindowManagerService（借助InputManagerService）负责采集和分发的，在应用端则是由ViewRootImpl（内部有一个mView变量指向View树的根，负责控制View树的UI绘制和事件消息的分发）负责分发的。 WMS在启动之后，经过逐层的调用，在Native层启动两个线程：Input...
Android 源码 输入系统之窗口关联
洪伟的专栏
06-01 1039
在前一节中，InputDispatcher 的事件派发工作调用 InputChannel sendMessage 方法标志着 InputDispatcher 一个周期的工作结束。但意味着事件找到对应的窗口处理的开始。 上一节中 mFocusedWindowHandle 是 InputDispatcher 的成员变量，它是确定发送事件消息的关键。我们以它为突破口寻找“出路”。mFocusedWindowHandle 在 setInputWindows 方法中进行了赋值，我们需要反推一下。 frameworks
Android Input
峻峰飞阳的博客 blog.csdn.net/while0
07-16 588
https://www.jianshu.com/p/2bff4ecd86c9 本篇博客主要是过一下Android Input的框架，在熟悉Android input框架后，以及与App的事件传递流程后，再过一下事件的处理流程，以及ANR是怎样发生的。如果在不了解input的框架情况下就去直接按键等事件就会觉得很卡。 一、Android Input的工作模型 1.1InputDispatch...
Android Input系统4 InputDispatcher线程
liuwg1226的专栏
02-06 2192
一　InputDispatcher起点 上篇文章输入系统之InputReader线程，介绍InputReader利用EventHub获取数据后生成EventEntry事件，加入到InputDispatcher的mInboundQueue队列，再唤醒InputDispatcher线程。本文将介绍InputDispatcher，同样从threadLoop为起点开始分析。 1.1 threadLoop 先来回顾一下InputDispatcher对象的初始化过程: InputDispatcher::InputDis
Android InputDispatcher分发输入事件
最新发布
薛文旺
06-28 602
InputDispatcher —> dispatchEventLocked:dispatchEventLocked 根据 InputTarget 中的 InputChannel 找到对应的Connection。派发循环是指 InputDispatcher 不断地派发队列取出事件，寻找合适的窗口并进行发送的过程，是 InputDispatcher 线程的主要工作。事件发送循环是 InputDispatcher 通过 Connection 对象将事件发送给窗口，并接受其反馈的过程。
Android Input 之Input InputDispatcher
探索未知，成就非凡
06-19 1054
新入队的触摸事件的目标是另一个窗口，则将这个新事件保存到mNextUnblockEvent中，随后的dispatchOnceInnerLocked()会将此事件之。EventEntry是输入事件在InputDispatcher中的存在形式，另外，由于InputDispatcher在没有事件可以派发时，会进入休眠。为事件寻找合适的目标窗口。因此在前一个事件的派发。这个程序，然而由于派发事件的串行性，用户所按的HOME键在其之前的输入事件成功派发给无响应的窗口之前无法获得派发的机会，因此在ANR。
Android 输入系统之InputDispatcher篇
愿景的博客
11-19 9592
InputDispatcher.cpp位置：framework/base/service/input/InputDispatcher.cpp 上一篇文章分析到args->notify(mInnerListener); 我们只分析key event类型 void NotifyKeyArgs::notify(const sp& listener) const {     listener-
Android Input (3) -- inputDispatcher
wd229047557的博客
09-12 1572
Link: Android Input (1) -- InputManagerService启动 Android Input (2) -- inputReader Android Input (3) -- inputDispatcher Android Input (4) -- inputDispatcher到ViewRootImpl Android Input (5) -- ViewR...
Android11_IMS创建与event分发流程
kuang921011的博客
02-13 252
Android11_IMS创建与event分发流程
Android——简单易懂说原理之PMS、IMS和Binder
nanquan11的博客
01-26 1555
写在前面：这次给大家推荐一个看源码的网站，虽然不能调试，但是看起来很方便。Android OS在线源码 目录一、PMS1.PackageInstaller的初始化与安装APK过程2.PMS对APK安装过程的处理3.PMS的构造方法分析4.App的安装流程整体回顾与其他补充二、IMS三、Binder 一、PMS PackageManagerService（PMS）是包管理机制的核心，负责对包进行管理。AMS总是会使用PMS加载包的信息，将其封装在LoadedApk这个类对象中，然后我们就可以从中取出在Andr
Android 源码 输入系统之 InputDispatcher
洪伟的专栏
06-01 1892
InputDispatcherThread 线程负责派发事件。InputDispatcherThread 启动后会执行 threadLoop 函数。threadLoop 函数返回 true，InputDispatcherThread 就会循环执行 threadLoop 函数。具体可以参见关于 Native Thread 实现一节《Android 源码 Native Thread 分析》。InputDispatcherThread（称为“ InputDispatcher”）线程在队列上等待新事件，并异步将其分
Android Framework重要服务之InputManagerService(三) inputDispatcher
Code1994的博客
06-02 1104
InputDispatcher线程用于从mInboundQueue队列获取及分发事件，本章将介绍InputDispatcher的相关知识。InputDispatcherThread线程启动后，同样会调用一个方法，该方法mInboundQueue队列获取事件，并进行后续处理，相关代码位于: 线程执行Looper->pollOnce，进入epoll_wait等待状态，当发生以下任一情况则退出等待状态：会从队头取出赋值给，并根据输入事件的类型作不同的处理，处理完成之后再释放,相关代码位于: 从上述代码中可以看出，
Android Input流程分析（四）：InputDispatcher
Invoker123的博客
12-20 3272
之前提到，InputReader将Key的信息封装成一个NotifyKeyArgs对象，调用InputDispatcher的notifyKey来处理。再进行一些初步的处理后，将个NotifyKeyArgs对象拆包，得到的信息构成一个KeyEvent，并调用interceptKeyBeforeQueueing进行第一次事件拦截，该函数最终会调到java层PhoneWindowManager的inte
Android4.4——InputManagerService之InputDispatcher线程
WellYiu的专栏
12-03 1454
上篇博客《Android4.4——InputManagerService之InputReader线程》的最后已经进入到InputDispatcher线程中。现在接着InputReader开始着手分析InputDispatcher线程。         我们由上一篇博客最后调用的InputDispatcher::notifyMotion函数开始分析。
android input(二) InputDispatcher
zhzhangnews的博客
06-16 5524
唤醒InputDispatcher 以Motion事件的分发过程来进行举例 void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) { //检查Motion事件的参数是否有效，对于motion事件，主要时校验触控点的数量与ID是否在合理范围 if (!validateMotionEvent(args->action, args->actionButton, args->poi
Android input处理机制（三）InputDispatcher
热门推荐
Ron的专栏
01-09 1万+
1.回顾 通过前两篇总结Android input处理机制（一）InputReader ， Android input处理机制（二）改键机制，我们大致了解了InputReader和EventHub处理机制，EventHub负责处理设备与事件相关问题。InputReader通过使用EventHub循环获取事件，当没有事件发生时InputReaderThread会休眠。 2.InputD
Android Framework 输入子系统（05）InputDispatcher解读
wangdsh的博客
06-20 1953
系列文章解读&说明： Android Framework 输入子系统 的 分析主要分为以下部分： Android Framework 输入子系统（01）核心机制 inotify和epoll Android Framework 输入子系统（02）核心机制 双向通信(socketpair+binder) Android Framework 输入子系统（03）输入系统框架 Androi...
Android输入子系统之InputDispatcher分发键盘消息过程分析
chenweiaiyanyan的专栏
06-09 1908
InputDispatcher分发键盘消息过程分析在Android输入子系统之启动过程分析中，InputManagerService启动之后，会调用start函数，之后调用native层的nativeStart函数，然后调用InputManager::start函数，该函数会调用InputDispatcherThread的threadLoop函数，该函数会调用InputDispatcher的disp
Android IMS来电
08-06
您好！对于Android平台上的IMS来电，我可以为您提供一些基本信息。IMS（IP Multimedia Subsystem）是一种基于IP网络的多媒体通信系统，它提供语音、视频、消息和其他多媒体服务。IMS来电是指通过IMS网络进行的语音通话。 在Android上，IMS来电通常是通过VoLTE（Voice over LTE）实现的。VoLTE是一种基于LTE网络的语音通信技术，它允许将语音数据以IP数据流的形式传输，提供更高的音质和更快的连接速度。 Android设备支持VoLTE和IMS来电需要满足一些条件。首先，运营商必须支持VoLTE服务并将其部署在其网络中。其次，您的Android设备必须支持VoLTE功能，并且具备相应的硬件和软件支持。最后，您需要在设备上启用VoLTE选项。 一旦满足这些条件，您就可以通过IMS网络进行来电通话，享受更高质量的语音通信体验。请注意，具体的操作方式可能因设备和运营商而有所不同。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值