Android input 事件分发 -- inputReader

最新推荐文章于 2024-07-30 00:23:16 发布
最新推荐文章于 2024-07-30 00:23:16 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： input Android 事件分发 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisiwei1994/article/details/128563015
版权

inputReader

inputReader

	这个章节主要是围绕inputReader 、inputReaderThread进行的，老规矩先上时序图

在这里插入图片描述
通过前面我们已经知道了InputReader和InputReaderThread都是在InputManager的构造函数里面new出来的，然后InputReaderThread的启动是在SystemServer里面InputManagerService 调用start间接调到了InputManager的start，然后调到InputReaderThread.run()

frameworks/native/services/inputflinger/InputManager.cpp

InputManager::InputManager(
        const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    // 这里new 出来 InputReader
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
    initialize();
}

InputManager::InputManager(
        const sp<InputReaderInterface>& reader,
        const sp<InputDispatcherInterface>& dispatcher) :
        mReader(reader),
        mDispatcher(dispatcher) {
    initialize();
}

InputManager::~InputManager() {
    stop();
}

// 这里new出来InputReaderThread，并且持有ReaderThread对象
void InputManager::initialize() {
    mReaderThread = new InputReaderThread(mReader);
    mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

// 这里的start会在inputManagerServer里面间接调用
status_t InputManager::start() {
    status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
    if (result) {
        ALOGE("Could not start InputDispatcher thread due to error %d.", result);
        return result;
    }

	// 启动ReaderThread线程
    result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
    if (result) {
        ALOGE("Could not start InputReader thread due to error %d.", result);

        mDispatcherThread->requestExit();
        return result;
    }

    return OK;
}

后面跟着时序图走，前面已经启动了inputReaderThread后面线程启动就会走到InputReaderThread::threadLoop

bool InputReaderThread::threadLoop() {
	// 调到了InputReader里面的loopOnce方法
    mReader->loopOnce();
    return true;
}

void InputReader::loopOnce() {
    int32_t oldGeneration;
    int32_t timeoutMillis;
    bool inputDevicesChanged = false;
    Vector<InputDeviceInfo> inputDevices;
    { // acquire lock
        AutoMutex _l(mLock);

        oldGeneration = mGeneration;
        timeoutMillis = -1;

        uint32_t changes = mConfigurationChangesToRefresh;
        if (changes) {
            mConfigurationChangesToRefresh = 0;
            timeoutMillis = 0;
            refreshConfigurationLocked(changes);
        } else if (mNextTimeout != LLONG_MAX) {
            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
            timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
        }
    } // release lock

    // 获得事件, 没有事件就block在EventHub中的epoll处
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);

    { // acquire lock
        AutoMutex _l(mLock);
        mReaderIsAliveCondition.broadcast();

        if (count) {
           // 上面从EventHub得到EventBuffer后就会想着把事件处理后给到InputDispatcher，继续看这个方法
            processEventsLocked(mEventBuffer, count);
        }

        if (mNextTimeout != LLONG_MAX) {
            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
            if (now >= mNextTimeout) {
#if DEBUG_RAW_EVENTS
                ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
#endif
                mNextTimeout = LLONG_MAX;
                timeoutExpiredLocked(now);
            }
        }

        if (oldGeneration != mGeneration) {
            inputDevicesChanged = true;
            getInputDevicesLocked(inputDevices);
        }
    } // release lock

    // Send out a message that the describes the changed input devices.
    if (inputDevicesChanged) {
        mPolicy->notifyInputDevicesChanged(inputDevices);
    }

    // Flush queued events out to the listener.
    // This must happen outside of the lock because the listener could potentially call
    // back into the InputReader's methods, such as getScanCodeState, or become blocked
    // on another thread similarly waiting to acquire the InputReader lock thereby
    // resulting in a deadlock.  This situation is actually quite plausible because the
    // listener is actually the input dispatcher, which calls into the window manager,
    // which occasionally calls into the input reader.
    // 这里会接收到不同的事件类型，然后调不同的notify（keyEvent、MotionEvent）去处理，在后面讲解
    mQueuedListener->flush();
}

mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE) 看看这个方法


size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
    ALOG_ASSERT(bufferSize >= 1);
 
    AutoMutex _l(mLock);
    // 创建读取buffer
    struct input_event readBuffer[bufferSize];
    RawEvent* event = buffer;
    size_t capacity = bufferSize;
    // 在这个for循环里面读取设备节点里面的内容读到上面申请的buffer里面
    for (;;) {
	
    // 处理代码
             if (eventItem.data.u32 == EPOLL_ID_WAKE) {
                if (eventItem.events & EPOLLIN) {
                    ALOGV("awoken after wake()");
                    awoken = true;
                    char buffer[16];
                    ssize_t nRead;
                    do {
                    // 读取管道中的数据
                        nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
                    } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
                } else {
                    ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
                            eventItem.events);
                }
                continue;
            }
    }
 
    // All done, return the number of events we read.
    // 返回已经被读取的buffer
    return event - buffer;
}

EventHub算是一个比较大的内容了，大家可以参考一下这个文章，不过我觉得你看完整个文章后再去细追这个。

processEventsLocked(mEventBuffer, count);


void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
    for (const RawEvent* rawEvent = rawEvents; count;) {
        int32_t type = rawEvent->type;
        size_t batchSize = 1;
        if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
            int32_t deviceId = rawEvent->deviceId;
            while (batchSize < count) {
                if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
                        || rawEvent[batchSize].deviceId != deviceId) {
                    break;
                }
                batchSize += 1;
            }
#if DEBUG_RAW_EVENTS
            ALOGD("BatchSize: %zu Count: %zu", batchSize, count);
#endif
           // 这里会根据不同的设备，发送不同的input事件
            processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
        } else {
            switch (rawEvent->type) {
            case EventHubInterface::DEVICE_ADDED:
                addDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::DEVICE_REMOVED:
                removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::FINISHED_DEVICE_SCAN:
                handleConfigurationChangedLocked(rawEvent->when);
                break;
            default:
                ALOG_ASSERT(false); // can't happen
                break;
            }
        }
        count -= batchSize;
        rawEvent += batchSize;
    }
}


void InputReader::processEventsForDeviceLocked(int32_t deviceId,
        const RawEvent* rawEvents, size_t count) {
    ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
    if (deviceIndex < 0) {
        ALOGW("Discarding event for unknown deviceId %d.", deviceId);
        return;
    }

    // KeyedVector<int32_t, InputDevice*> mDevices 这mDevices 里面add了不同的设备节点
    InputDevice* device = mDevices.valueAt(deviceIndex);
    if (device->isIgnored()) {
        //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
        return;
    }

    device->process(rawEvents, count);
}

// 这里是往mDevices里面add的内容
InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
        const InputDeviceIdentifier& identifier, uint32_t classes) {
    InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),
            controllerNumber, identifier, classes);

    // External devices.
    if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {
        device->setExternal(true);
    }

    // Devices with mics.
    // 麦克风设备
    if (classes & INPUT_DEVICE_CLASS_MIC) {
        device->setMic(true);
    }

    // Switch-like devices.
    // switch 类似的设备
    if (classes & INPUT_DEVICE_CLASS_SWITCH) {
        device->addMapper(new SwitchInputMapper(device));
    }

    // Scroll wheel-like devices.
    // 鼠标设备
    if (classes & INPUT_DEVICE_CLASS_ROTARY_ENCODER) {
        device->addMapper(new RotaryEncoderInputMapper(device));
    }

    // Vibrator-like devices.
    // 振动器设备
    if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {
        device->addMapper(new VibratorInputMapper(device));
    }

    // Keyboard-like devices.
    // 键盘
    uint32_t keyboardSource = 0;
    int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;
    if (classes & INPUT_DEVICE_CLASS_KEYBOARD) {
        keyboardSource |= AINPUT_SOURCE_KEYBOARD;
    }
    if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) {
        keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;
    }
    if (classes & INPUT_DEVICE_CLASS_DPAD) {
        keyboardSource |= AINPUT_SOURCE_DPAD;
    }
    if (classes & INPUT_DEVICE_CLASS_GAMEPAD) {
        keyboardSource |= AINPUT_SOURCE_GAMEPAD;
    }

    if (keyboardSource != 0) {
        device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));
    }

    // Cursor-like devices.
    if (classes & INPUT_DEVICE_CLASS_CURSOR) {
        device->addMapper(new CursorInputMapper(device));
    }

    // Touchscreens and touchpad devices.
    // 屏幕touch
    if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {
        device->addMapper(new MultiTouchInputMapper(device));
    } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {
        device->addMapper(new SingleTouchInputMapper(device));
    }

    // Joystick-like devices.
    if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {
        device->addMapper(new JoystickInputMapper(device));
    }

    // External stylus-like devices.
    if (classes & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
        device->addMapper(new ExternalStylusInputMapper(device));
    }

    return device;
}

接着上面device->process(rawEvents, count);我们会看到在InputReader.cpp里面有多个process方法

void TouchInputMapper::process(const RawEvent* rawEvent) {
    mCursorButtonAccumulator.process(rawEvent);
    mCursorScrollAccumulator.process(rawEvent);
    mTouchButtonAccumulator.process(rawEvent);

    if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
        sync(rawEvent->when);
    }
}

void CursorScrollAccumulator::process(const RawEvent* rawEvent) {
    if (rawEvent->type == EV_REL) {
        switch (rawEvent->code) {
        case REL_WHEEL:
            mRelWheel = rawEvent->value;
            break;
        case REL_HWHEEL:
            mRelHWheel = rawEvent->value;
            break;
        }
    }
}

void SwitchInputMapper::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
    case EV_SW:
        processSwitch(rawEvent->code, rawEvent->value);
        break;

    case EV_SYN:
        if (rawEvent->code == SYN_REPORT) {
            sync(rawEvent->when);
        }
    }
}
.................
这就是我们前面吧这些InputMapper的子类都set到了mDevices里面了，我们这里假设调用的是
TouchInputMapper::process

frameworks/native/services/inputflinger/InputReader.cpp

void TouchInputMapper::process(const RawEvent* rawEvent) {
	// 这几个都属于touch事件里面的
    mCursorButtonAccumulator.process(rawEvent);
    mCursorScrollAccumulator.process(rawEvent);
    mTouchButtonAccumulator.process(rawEvent);

    if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
        // 继续跟这里
        sync(rawEvent->when);
    }
}

void TouchInputMapper::sync(nsecs_t when) {
	..........
    processRawTouches(false /*timeout*/);
}

void TouchInputMapper::processRawTouches(bool timeout) {
    const size_t N = mRawStatesPending.size();
    size_t count;
    for(count = 0; count < N; count++) {
        const RawState& next = mRawStatesPending[count];

        // A failure to assign the stylus id means that we're waiting on stylus data
        // and so should defer the rest of the pipeline.
        if (assignExternalStylusId(next, timeout)) {
            break;
        }

        // All ready to go.
        clearStylusDataPendingFlags();
        mCurrentRawState.copyFrom(next);
        if (mCurrentRawState.when < mLastRawState.when) {
            mCurrentRawState.when = mLastRawState.when;
        }
        // 这里
        cookAndDispatch(mCurrentRawState.when);
    }

}

void TouchInputMapper::cookAndDispatch(nsecs_t when) {

        if (!mCurrentMotionAborted) {
            dispatchButtonRelease(when, policyFlags);
            dispatchHoverExit(when, policyFlags);
            // 这里
            dispatchTouches(when, policyFlags);
            dispatchHoverEnterAndMove(when, policyFlags);
            dispatchButtonPress(when, policyFlags);
        }
}

void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
    BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;
    BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits;
    int32_t metaState = getContext()->getGlobalMetaState();
    int32_t buttonState = mCurrentCookedState.buttonState;

    if (currentIdBits == lastIdBits) {
        if (!currentIdBits.isEmpty()) {
            // No pointer id changes so this is a move event.
            // The listener takes care of batching moves so we don't have to deal with that here.
            dispatchMotion(when, policyFlags, mSource,
                    AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState,
                    AMOTION_EVENT_EDGE_FLAG_NONE,
                    mCurrentCookedState.deviceTimestamp,
                    mCurrentCookedState.cookedPointerData.pointerProperties,
                    mCurrentCookedState.cookedPointerData.pointerCoords,
                    mCurrentCookedState.cookedPointerData.idToIndex,
                    currentIdBits, -1,
                    mOrientedXPrecision, mOrientedYPrecision, mDownTime);
        }
    } else {

        // Dispatch pointer up events.
        while (!upIdBits.isEmpty()) {
            uint32_t upId = upIdBits.clearFirstMarkedBit();

            dispatchMotion(when, policyFlags, mSource,
                    AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, metaState, buttonState, 0,
                    mCurrentCookedState.deviceTimestamp,
                    mLastCookedState.cookedPointerData.pointerProperties,
                    mLastCookedState.cookedPointerData.pointerCoords,
                    mLastCookedState.cookedPointerData.idToIndex,
                    dispatchedIdBits, upId, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
            dispatchedIdBits.clearBit(upId);
        }

        // Dispatch move events if any of the remaining pointers moved from their old locations.
        // Although applications receive new locations as part of individual pointer up
        // events, they do not generally handle them except when presented in a move event.
        if (moveNeeded && !moveIdBits.isEmpty()) {
            ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);
            // 这里
            dispatchMotion(when, policyFlags, mSource,
                    AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, 0,
                    mCurrentCookedState.deviceTimestamp,
                    mCurrentCookedState.cookedPointerData.pointerProperties,
                    mCurrentCookedState.cookedPointerData.pointerCoords,
                    mCurrentCookedState.cookedPointerData.idToIndex,
                    dispatchedIdBits, -1, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
        }

        // Dispatch pointer down events using the new pointer locations.
        while (!downIdBits.isEmpty()) {
            uint32_t downId = downIdBits.clearFirstMarkedBit();
            dispatchedIdBits.markBit(downId);

            if (dispatchedIdBits.count() == 1) {
                // First pointer is going down.  Set down time.
                mDownTime = when;
            }
			
            dispatchMotion(when, policyFlags, mSource,
                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, metaState, buttonState, 0,
                    mCurrentCookedState.deviceTimestamp,
                    mCurrentCookedState.cookedPointerData.pointerProperties,
                    mCurrentCookedState.cookedPointerData.pointerCoords,
                    mCurrentCookedState.cookedPointerData.idToIndex,
                    dispatchedIdBits, downId, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
        }
    }
}

void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
        int32_t action, int32_t actionButton, int32_t flags,
        int32_t metaState, int32_t buttonState, int32_t edgeFlags, uint32_t deviceTimestamp,
        const PointerProperties* properties, const PointerCoords* coords,
        const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId,
        float xPrecision, float yPrecision, nsecs_t downTime) {
    PointerCoords pointerCoords[MAX_POINTERS];
    PointerProperties pointerProperties[MAX_POINTERS];
    uint32_t pointerCount = 0;
    while (!idBits.isEmpty()) {
        uint32_t id = idBits.clearFirstMarkedBit();
        uint32_t index = idToIndex[id];
        pointerProperties[pointerCount].copyFrom(properties[index]);
        pointerCoords[pointerCount].copyFrom(coords[index]);

        if (changedId >= 0 && id == uint32_t(changedId)) {
            action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
        }

        pointerCount += 1;
    }

    ALOG_ASSERT(pointerCount != 0);

    if (changedId >= 0 && pointerCount == 1) {
        // Replace initial down and final up action.
        // We can compare the action without masking off the changed pointer index
        // because we know the index is 0.
        if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) {
            action = AMOTION_EVENT_ACTION_DOWN;
        } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) {
            action = AMOTION_EVENT_ACTION_UP;
        } else {
            // Can't happen.
            ALOG_ASSERT(false);
        }
    }

	// 这里构造出NotifyMotionArgs 对象
    NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,
            action, actionButton, flags, metaState, buttonState, edgeFlags,
            mViewport.displayId, deviceTimestamp, pointerCount, pointerProperties, pointerCoords,
            xPrecision, yPrecision, downTime);
    // 然后这里又调回到QueuedInputListener中，将这个对象set到mArgsQueue队列里面
    getListener()->notifyMotion(&args);
}

frameworks/native/services/inputflinger/InputListener.cpp

void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
    mArgsQueue.push(new NotifyMotionArgs(*args));
}

接着看
mQueuedListener->flush();

void QueuedInputListener::flush() {
    size_t count = mArgsQueue.size();
    for (size_t i = 0; i < count; i++) {
        NotifyArgs* args = mArgsQueue[i];
        这个mInnerListener就是我们的InputDispatcher对象
        args->notify(mInnerListener);
        delete args;
    }
    mArgsQueue.clear();
}

void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {
	// 调用到InputDispatcher的notifyMotion
    listener->notifyMotion(this);
}

从上面的文章我们就看到了整个从InputReaderThread --> EventHub读取设备节点 --> InputReader --> inputDispatcher

干一行，爱一行
关注
专栏目录
Android Input系统(1) Input事件的产生与传递
我其实什么都不会
07-21 2659
这篇博客介绍了Android系统中的Input系统，它是负责处理用户输入操作的核心组件。该系统从各种输入设备获取原始输入事件，并将其转换为Android应用可以理解和消费的KeyEvent或MotionEvent对象。博客详细解释了Input系统的角色和重要性，以及它的主要组成部分，包括InputReader、InputDispatcher等。还介绍了输入事件的来源，包括硬件设备和软件模拟，以及不同类型的输入事件，如按键事件和触摸事件。
Android 4.0 事件输入(Event Input)系统
08-29
android input
Android 输入事件分发全流程梳理（二）
最新发布
moke926的博客
07-30 917
本章节将从`ViewRootImpl`的`WindowInputEventReceiver`开始讲起，重点梳理客户端app进程内对于输入事件的分发与消费。
android input命令模拟事件以及事件注入实现
yimelancholy的博客
05-04 1320
在坐标(500,100)的位置模拟点击事件参数解析：int inputSource：表示模拟事件的类型float x, float y：表示事件坐标点int displayId：在哪个屏幕上触发事件（一般用于多屏）
【Framework】Android Input系统事件分发分析
to_perfect的博客
04-29 3093
你知道Android是怎么分发点击事件吗？
深入Android S (12.0) 探索Framework之输入子系统InputReader的流程
neuHenry
01-19 963
上一篇文章深入探索了 Android Framework 的输入系统 IMS 的构成与启动，对 IMS 的重要成员有了初步的理解，然后通过源码对 IMS 的整个启动流程进行分析，在 IMS 启动并准备就绪后，输入系统就可以从设备节点源源不断的抽取输入事件，并交给事件处理者进行加工处理，即输入子系统 InputReader。本篇将深入探索 InputReader 的工作流程，它是如何从设备节点将输入事件交给 InputDispatcher 的派发的？
Android-input-system-analysis.rar_Android input system_android
09-24
1. **InputReader**：它是输入系统的核心部分，负责读取来自硬件设备的原始输入事件，并将这些事件转化为可被应用程序使用的格式。InputReader会根据设备类型（例如触摸屏、键盘等）来解析事件，然后通过 Binder ...
Android input系统.pdf
07-24
InputReader.cpp : 负责从硬件获取输入, 转换成事件（Event), 并分发给Input Dispatcher.  InputDispatcher.cpp : 将Input Reader传送过来的Events 通过socket分发给合适的窗口, 并监控ANR.  ...
android input 事件的获取
01-06
InputReader 负责从硬件设备读取事件，InputDispatcher 负责将事件分发给应用程序，InputManager 负责管理所有的 input 设备。 2. 创建流程 Input System 的创建流程开始于系统启动时，系统会创建 InputManager ...
android4.0 input touch分析
09-17
* InputReader：InputReader 从 EventHub 中读取原始事件数据（RawEvent），并由各个 InputMapper 处理之后输入对应的 input listener。InputReader 拥有一个 InputMapper 集合，并拥有一个 EventHub 对象，但这个...
Android Input之InputReader
探索未知，成就非凡
06-19 309
InputReader的一次线程循环的工作思路总共分为三步：1 从EvenHub中抽取为处理的事件列表。事件分为两类：一类是从设备节点读取的原始输入事件，另一类是输入设备的可用性变化事件，即设备事件2 通过processEventsLocked()对事件进行处理。对于设备事件此函数根据设备的可用性加载或者移除设备对应的配置信息；对于原始输入事件，则在进行转译、封装与加工后将结果存储到mQueueListener中。
Android input事件处理流程
小匠码农
04-26 696
input事件
Android Input机制详解
qq_42281628的博客
04-21 1724
在上文我们提到的获取到InputStage之后执行deliver操作就是判断当前stage是否已被处理过，如果处理过则跳过，执行下一个stage（forward方法） ，如果没有，则执行onProcess方法进行stage的处理。从源码来看，我的理解是正确的：input事件（QueuedInputEvent）分为多阶段处理（InputStage）,每个阶段对应一个stage，一个事件对应多个stage，当前阶段（stage）若是已经被。，对于input的多阶段处理就是使用inputStage进行处理，
Android R input (二) 之 InputReader 工作流程
pecuyu
10-23 1601
文章托管在gitee上 Android Notes , 同步csdn InputReader 的创建 如前所述,InputReader是在 InputManager 构造方法中通过工厂方法createInputReader创建,在此方法中,还创建了EventHub作为构造参数. 此处的policy即NativeInputManager对象,listener的值实际上是mDispatcher的封装. /// @frameworks/native/services/inputflinger/reader/I.
android input 事件分发 --- 注册input
android
01-04 1200
input event
经验总结---Android事件分发机制及设计思路
2401_84046577的博客
04-02 943
Android系统中将输入事件定义为InputEvent，而InputEvent根据输入事件的类型又分为了KeyEvent和// 输入事件的基类复制代码KeyEvent对应了键盘的输入事件，那么什么是？顾名思义，就是移动事件，鼠标、笔、手指、轨迹球等相关输入设备的事件都属于，本文我们简单地将其视为屏幕触摸事件。用户的输入种类繁多，由此可见，Android输入系统的设计中，将输入事件抽象为InputEvent是有必要的。
android anr的分析以及input事件的流程分析
我的博客
01-08 352
android anr的分析以及input事件的流程分析
Android FrameWork Input触控事件处理流程 笔记
zhangqiluGrubby的博客
11-02 2008
input 是最常见的事件之一，用户的点击、滑动、长按等操作，都属于 input 事件驱动。标识 Input 事件区域，这里可以看到一个 Input_Down 事件 + 若干个 Input_Move 事件 + 一个 Input_Up 事件的处理阶段都被算到了这里。队列（“aq”）中记录的是应用需要处理的Input事件，这里可以看到input事件已经传递到了应用进程。队列里面记录的是已经派发给 App（“wq”），但是 App还在处理没有返回处理成功的事件。
“framework必会”系列：Android Input系统（二）事件分发机制
大模型学习路线
12-07 434
关于为什么会有这“framework必会系列”文章？对，卷王太多了。。对于目前应用开发已经饱和的大环境下，作为一个多年Android开发，逼迫我们Android开发往更深层次的framework层走，于是就有了这么个系列。好了这都不谈了，我们来进入正文。 上一篇文章我们讲解了Android输入系统事件读取，这里再来回顾下：开机后SystemServer启动过程中创建了InputManagerService，InputManagerService构造方法中在native层创建了NativeInputManag
Android输入事件处理：从InputManager到应用
本讲座主要探讨了Android输入系统的架构，特别是输入事件的分发和处理流程，涉及到了InputManager、InputReader、InputDispatcher以及应用程序主线程的消息循环。 Android输入系统概述 ---------------------- ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值