Android底层事件分发机制-完结篇

最新推荐文章于 2024-05-23 18:59:29 发布
置顶 最新推荐文章于 2024-05-23 18:59:29 发布
阅读量671 收藏 19
点赞数 22
分类专栏： Android Framework 文章标签： android 大前端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jh1988abc/article/details/135829834
版权

前序

书接上文，前面我们讲了下Android输入事件的全貌，从底层硬件产生事件，经过IMS的InputReader加工转换再经过InputDspatcher分发转给WMS中间层，再通过WMS定位到准确的window进行我们熟悉的上层事件处理。

上文我们详细讲解了IMS的初始化流程及底层事件的拦截处理流程，今天我们继续讲解InputReader处理完的事件怎么进行分发的。

InputDspatcher 分发事件

将封装的事件压入到队列中并唤醒 InputDispatchert 线程进行分发处理。

InputDispatcher线程唤醒

status_t InputDispatcher::start() {
        if (mThread) {
            return ALREADY_EXISTS;
        }
        mThread = std::make_unique<InputThread>(
                "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
        return OK;
    }

和InputReader一样运行在单独的线程，执行 threadLoop 时的回调函数dispatchOnce

void InputDispatcher::dispatchOnce() {
        nsecs_t nextWakeupTime = LONG_LONG_MAX;
        { // acquire lock
            std::scoped_lock _l(mLock);
            mDispatcherIsAlive.notify_all();
​
            //注释1
            if (!haveCommandsLocked()) {
                //注释2
                dispatchOnceInnerLocked(&nextWakeupTime);
            }
            // 注释3
            if (runCommandsLockedInterruptible()) {
                nextWakeupTime = LONG_LONG_MIN;
            }
            const nsecs_t nextAnrCheck = processAnrsLocked();
            nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);
​
            // We are about to enter an infinitely long sleep, because we have no commands or
            // pending or queued events
            if (nextWakeupTime == LONG_LONG_MAX) {
                mDispatcherEnteredIdle.notify_all();
            }
        } // release lock
        nsecs_t currentTime = now();
        int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
        mLooper->pollOnce(timeoutMillis);
    }

首先判断是否有指令需要执行，如果没有，则调用注释2处的dispatchOnceInnerLocked去根据事件类型进行处理，如果有则优先调用3处的runCommandsLockedInterruptible处理事件， 为了让线程可以立即进入事件处理，将nextWakeupTime 设置为LONG_LONG_MIN，这样线程在指令执行完毕后可以立即被唤醒去处理输入事件。

我们先看下2处的事件处理

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
        .....
        // 如果 InputDispatcher 被冻结，则不进行派发操作
        if (mDispatchFrozen) {
            if (DEBUG_FOCUS) {
                ALOGD("Dispatch frozen.  Waiting some more.");
            }
            return;
        }
        .......
        // 如果没有待分发的事件，去 mInboundQueue 取出一个事件
        if (!mPendingEvent) {
            //如果没有待分发的事件，就去 mInboundQueue 中取出一个事件
            if (mInboundQueue.empty()) {
                .......
                if (!mPendingEvent) {
                    return;
                }
            } else {
                //不为空，则从头部取出一个事件
                mPendingEvent = mInboundQueue.front();
                mInboundQueue.pop_front();
                traceInboundQueueLengthLocked();
            }
            // Poke user activity for this event.
            if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
                pokeUserActivityLocked(*mPendingEvent);
            }
        }
​
        ALOG_ASSERT(mPendingEvent != nullptr);
        bool done = false;
        DropReason dropReason = DropReason::NOT_DROPPED; //1
        .....
        switch (mPendingEvent->type) {
            case EventEntry::Type::CONFIGURATION_CHANGED:  .....
            case EventEntry::Type::DEVICE_RESET: .....
            case EventEntry::Type::FOCUS:  .....
            case EventEntry::Type::DRAG:  .....
            case EventEntry::Type::KEY:.....
            case EventEntry::Type::MOTION: { //2
                std::shared_ptr<MotionEntry> motionEntry =
                        std::static_pointer_cast<MotionEntry>(mPendingEvent);
                //如果没有及时响应窗口切换操作
                if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
                    dropReason = DropReason::APP_SWITCH;
                }
                //事件过期
                if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
                    dropReason = DropReason::STALE;
                }
                //阻碍其他窗口获取事件
                if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
                    dropReason = DropReason::BLOCKED;
                }
                //3
                done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
                break;
            }
​
            case EventEntry::Type::SENSOR: .....
        }
​
        if (done) {
            if (dropReason != DropReason::NOT_DROPPED) {
                dropInboundEventLocked(*mPendingEvent, dropReason);
            }
            mLastDropReason = dropReason;
            //释放本次事件处理对象
            releasePendingEventLocked();
            //使得 inputDispatcher 能够快速处理下一个分发事件
            *nextWakeupTime = LONG_LONG_MIN;
        }
    }

上面代码主要截取了 Motion 事件相关的源码，主要的事情有下面几点：

如果 InputDispatcher 被冻结，则不进行派发操作，InputDispatcher 有三种状态，分别是正常，冻结，和禁用。

  • 注释1代表了事件被丢弃的原因，默认值是 NOT_DROPPED ，代表不会丢弃

  • 注释2对事件类型进行区分，这里主要是看 Motion 事件。

  • 注释3最终会调用 dispatchMotionLocked 来为这个事件寻找合适的窗口。

InputChannel注册

首先需要一定的WMS知识储备，我们回顾下Window是在ViewRootImpl的setView方法中传入WMS的。

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        ...
        InputChannel inputChannel = null;
        if ((mWindowAttributes.inputFeatures
                & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
            inputChannel = new InputChannel();
        }
        ...
        res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                getHostVisibility(), mDisplay.getDisplayId(),
                mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                mAttachInfo.mOutsets, mInputChannel);
        ...
        if (mInputChannel != null) {
            mInputEventReceiver = new WindowInputEventReceiver(inputChannel,
                    Looper.myLooper());
        }
    }

​mWindowSession是IWindowSession在app端的代理对象。实际执行的是Session类，最终会调用到WMS的addWindow

public int addWindow(Session session, IWindow client, WindowManager.LayoutParams attrs, int viewVisibility,
                         int displayId, int requestUserId, InsetsState requestedVisibility,
                         InputChannel outInputChannel...) {
​
        ...
        final boolean openInputChannels = (outInputChannel != null
                && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
        if  (openInputChannels) {
            win.openInputChannel(outInputChannel);
        }
        ...
    }

注释1处调用WindowState打开InputChannel通道，继续看

void openInputChannel(InputChannel outInputChannel) {
    ...
    String name = getName();
    InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);//1
    mInputChannel = inputChannels[0];
    mClientChannel = inputChannels[1];
    mInputWindowHandle.inputChannel = inputChannels[0];
    if (outInputChannel != null) {
        mClientChannel.transferTo(outInputChannel);
        mClientChannel.dispose();
        mClientChannel = null;
    }
    ...
    mService.mInputManager.registerInputChannel(mInputChannel, mInputWindowHandle);//2
}

public static InputChannel[] openInputChannelPair(String name) {
    ...
    return nativeOpenInputChannelPair(name);
}
static jobjectArray android_view_InputChannel_nativeOpenInputChannelPair(JNIEnv* env...) {
    ...
    sp<InputChannel> serverChannel;
    sp<InputChannel> clientChannel;
    status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);
​
​
    jobjectArray channelPair = env->NewObjectArray(2, gInputChannelClassInfo.clazz, NULL);
    jobject serverChannelObj = android_view_InputChannel_createInputChannel(env,
            std::make_unique<NativeInputChannel>(serverChannel));
    jobject clientChannelObj = android_view_InputChannel_createInputChannel(env,
            std::make_unique<NativeInputChannel>(clientChannel));
    ...
    env->SetObjectArrayElement(channelPair, 0, serverChannelObj);
    env->SetObjectArrayElement(channelPair, 1, clientChannelObj);
    return channelPair;
​
}
status_t InputChannel::openInputChannelPair(const String8& name,
        sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {
    int sockets[2];
    if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
        ...
        return result;
    }
    ...
    outServerChannel = new InputChannel(serverChannelName, sockets[0]);
    outClientChannel = new InputChannel(clientChannelName, sockets[1]);
    return OK;
}

通过以上代码可以看出InputChannel使用的是socket通讯，且WindowState的openInputChannel中会根据名称返回的inputChannels是一个服务端和客户端的输入通道数组 其中：下标0：表示服务端的InputChannel 下标1：表示客户端的InputChannel

上面代码最后会调用mService.mInputManager.registerInputChannel是将wms在服务端的InputChannel注册到IMS中。这样在IMS输入系统就可以给服务端的InputChannel写入数据，在WMS的客户端InputChannel就可以读取数据

而调用mClientChannel.transferTo(outInputChannel)可以将app端的InputChannel和wms的客户端InputChannel关联 这样就可以向客户端InputChannel中写入数据然后通知app端的InputChannel，实际传递给ViewRootImpl对象处理，接着就是View层面的处理了。

继续跟进registerInputChannel会进入native侧

static void nativeRegisterInputChannel(JNIEnv* env, jclass /* clazz */,
        jlong ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) {
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
    ...
    status_t status = im->registerInputChannel(
            env, inputChannel, inputWindowHandle, monitor);//1
​
}
​
status_t NativeInputManager::registerInputChannel(JNIEnv* /* env */,
        const sp<InputChannel>& inputChannel,
        const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {
    return mInputManager->getDispatcher()->registerInputChannel(
            inputChannel, inputWindowHandle, monitor);
}
​
status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel,
        const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {
        ...
        sp<Connection> connection = new Connection(inputChannel, inputWindowHandle, monitor);
        int fd = inputChannel->getFd();
        mConnectionsByFd.add(fd, connection);
        ...
        // registerInputChannel里面传入的monitor是false --> nativeRegisterInputChannel(mPtr, inputChannel, inputWindowHandle, false);
        // 所以这个流程不会将窗口的channel放到mMonitoringChannels里面
        if (monitor) {
            mMonitoringChannels.push(inputChannel);
        }
        ...
}

​最后InputChannel会进入native侧通过NativeInputManager调用InputDispatcher并进行注册，这里传入的inputchannel是WMS在服务端InputChannel，在InputDispatcher中创建一个Connection并加入到mConnectionsByFd队列中，key为当前inputChannel的fd。获取的时候也是通过inputChannel的fd去获取。

小结：WMS和输入系统InputDispatcher使用的socket通讯，在View端，WMS端以及IMS端都有一个InputChannel。

确认窗口

bool InputDispatcher::dispatchMotionLocked(
       nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
            ...
            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);
            }
            ...
            dispatchEventLocked(currentTime, entry, inputTargets);
            return true;
        }

回到dispatchMotionLocked最后会调用dispatchEventLocked,而且通过findFocusedWindowTargetsLocked方法来确认当前需要传递事件的窗口。

int32_t InputDispatcher::findFocusedWindowTargetsLocked(...inputTargets){
    ...
    addWindowTargetLocked(mFocusedWindowHandle,
            InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS, BitSet32(0),
            inputTargets);
    ...
}
​
void InputDispatcher::addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
        int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets) {
    inputTargets.push();
​
    const InputWindowInfo* windowInfo = windowHandle->getInfo();
    InputTarget& target = inputTargets.editTop();
    target.inputChannel = windowInfo->inputChannel;
    target.flags = targetFlags;
    target.xOffset = - windowInfo->frameLeft;
    target.yOffset = - windowInfo->frameTop;
    target.scaleFactor = windowInfo->scaleFactor;
    target.pointerIds = pointerIds;
​
}

windowInfo->inputChannel通道赋值给了target.inputChannel，windowInfo是一个mFocusedWindowHandle对象，是一个包含焦点Window信息的对象。

窗口注册

public int addWindow(Session session, IWindow client, WindowManager.LayoutParams attrs, int viewVisibility,
                         int displayId, int requestUserId, InsetsState requestedVisibility,
                         InputChannel outInputChannel...)
{
​
        ...
        final boolean openInputChannels = (outInputChannel != null
                && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
        if  (openInputChannels) {
            win.openInputChannel(outInputChannel);
        }
        ...
        if (focusChanged) {
                displayContent.getInputMonitor().setInputFocusLw(displayContent.mCurrentFocus,
                        false /*updateInputWindows*/);
        }
        displayContent.getInputMonitor().updateInputWindowsLw(false /*force*/);
        ...
​
    }

updateInputWindowsLw经过层层调用最终会走到InputDispatcher::setInputWindows中,

void InputDispatcher::setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) {
    ...
    mWindowHandles = inputWindowHandles;
​
    sp<InputWindowHandle> newFocusedWindowHandle;
    ...
    for (size_t i = 0; i < mWindowHandles.size(); i++) {
        const sp<InputWindowHandle>& windowHandle = mWindowHandles.itemAt(i);
        ...
        if (windowHandle->getInfo()->hasFocus) {
            newFocusedWindowHandle = windowHandle;
        }
        ...
        mFocusedWindowHandle = newFocusedWindowHandle;
    }
    ...

}

我们知道了window相关的信息赋值，上下关联起来了，其中

  • mWindowHandles：代表所有Window的Handler对象

  • mFocusedWindowHandle：表示焦点Window的Handler对象 通过这些代码就让我们IMS中获取到了需要处理的焦点Window。

兜兜转转，我们再回到最终触发事件分发的方法

void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
        EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {
    ...
    for (size_t i = 0; i < inputTargets.size(); i++) {
        const InputTarget& inputTarget = inputTargets.itemAt(i);
​
        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) {
    ssize_t connectionIndex = mConnectionsByFd.indexOfKey(inputChannel->getFd());
    if (connectionIndex >= 0) {
        sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);
        if (connection->inputChannel.get() == inputChannel.get()) {
            return connectionIndex;
        }
    }
​
    return -1;
​
}

dispatchEventLocked主要作用：轮询inputTargets，根据inputTarget.inputChannel获取其在mConnectionsByFd中的索引，根据索引获取Connection对象，并调用prepareDispatchCycleLocked进行处理。prepareDispatchCycleLocked方法内部调用了enqueueDispatchEntriesLocked方法。

void InputDispatcher::enqueueDispatchEntriesLocked(connection,..){
    // Enqueue dispatch entries for the requested modes.
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,...);//1
    ...
    // If the outbound queue was previously empty, start the dispatch cycle going.
    if (wasEmpty && !connection->outboundQueue.isEmpty()) {//2
        startDispatchCycleLocked(currentTime, connection);//3
    }
}

​enqueueDispatchEntryLocked方法中会将输入事件重新封装为一个DispatchEntry并压入connection的outboundQueue队列中。然后判断如果事件不为空，则调用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;
        ...
        EventEntry* eventEntry = dispatchEntry->eventEntry;
        switch (eventEntry->type) {
        case EventEntry::TYPE_KEY: {
        }
        case EventEntry::TYPE_MOTION: {
        ...
        status = connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,
                motionEntry->deviceId, motionEntry->source, motionEntry->displayId,
                dispatchEntry->resolvedAction, motionEntry->actionButton,
                dispatchEntry->resolvedFlags, motionEntry->edgeFlags,
                motionEntry->metaState, motionEntry->buttonState,
                xOffset, yOffset, motionEntry->xPrecision, motionEntry->yPrecision,
                motionEntry->downTime, motionEntry->eventTime,
                motionEntry->pointerCount, motionEntry->pointerProperties,
                usingCoords);
        ...
        }
        ...
        connection->outboundQueue.dequeue(dispatchEntry);
        connection->waitQueue.enqueueAtTail(dispatchEntry)
    }   
    ...
​
}

startDispatchCycleLocked中通过publishKeyEvent会将事件写入到WMS传递下来的InputChannel通道中。这样WMS端的InputChannel就可以通过socket获取到数据。在发送完毕后会将事件移出outboundQueue队列，并放入到waitQueue等待队列中，等待事件处理完毕后再移出.

那什么时候知道事件处理完毕呢？

在InputDispatcher::registerInputChannel方法里面注册了handleReceiveCallback回调:

status_t InputDispatcher::registerInputChannel(...) {
        ...
        mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
        ...
}

当app层的事件处理完毕之后就会回调handleReceiveCallback

int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {
        InputDispatcher * d = static_cast < InputDispatcher * > (data);
        ...
        for (;;) {
            uint32_t seq;
            bool handled;
            status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);
            if (status) {
                break;
            }
            d->finishDispatchCycleLocked(currentTime, connection, seq, handled);
            gotOne = true;
            }
        if (gotOne) {
            d->runCommandsLockedInterruptible();
            if (status == WOULD_BLOCK) {
                return 1;
            }
        }
        ...
        // Unregister the channel.
        d->unregisterInputChannelLocked(connection->inputChannel, notify);
    }

先调用finishDispatchCycleLocked去往mCommandQueue里面加入一个执行doDispatchCycleFinishedLockedInterruptible的命令。

void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(
        CommandEntry* commandEntry) {
    sp<Connection> connection = commandEntry->connection;
    ...
    if (dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {
        KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);
        restartEvent = afterKeyEventLockedInterruptible(connection,
                dispatchEntry, keyEntry, handled);
    } else if (dispatchEntry->eventEntry->type == EventEntry::TYPE_MOTION) {
        MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);
        restartEvent = afterMotionEventLockedInterruptible(connection,
                dispatchEntry, motionEntry, handled);
    } else {
        restartEvent = false;
    }
    ...
    DispatchEntry* dispatchEntry = connection->findWaitQueueEntry(seq);
    ...
    if (dispatchEntry == connection->findWaitQueueEntry(seq)) {
        connection->waitQueue.dequeue(dispatchEntry);
        ...
    }
}

该方法会将connection->waitQueue出栈，这样整个输入系统的分发过程就闭环了。

简单总结下：

  1. ViewRootImpl在setView方法中创建一个InputChannel通道并在将Window添加给WMS的时候作为参数传递给WMS。

  2. WMS在添加Window的过程中会调用updateInputWindows，这个方法最终会调用到InputDispatcher::setInputWindows中， 并给InputDispatcher的Window队列以及焦点Window赋值，这样IMS就可以找到对应的Window了

  3. 在WMS在添加Window的过程中还会创建一个socketpair通道的InputChannel，其中客户端的socket与app层的InputChannel关联，用于WMS与app通讯 服务端的socket传递给IMS，用于IMS和WMS通讯。

  4. 客户端在接收到输入事件后会根据当前获取焦点Window的InputChannel找到对应的Connection连接，这个Connection用于与WMS进行通讯，内部其实就是使用前面的socket通讯。

  5. 事件分发后将输入事件放入到waitQueue中，等待事件处理完毕后，将事件移出waitQueue

结尾

本文将事件分发的流程从底到上梳理了一下，希望能帮助大家清楚知道硬件产生的事件是怎么从输入系统传到app层进行处理的，欢迎关注我学习硬核技术，感谢支持，欢迎关注、转发、评论。

微信公众号首发：欢迎关注、转发、评论

江湖修行
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android自定义控件进阶11-事件分发机制原理
黎程雨的博客
08-12 412
之前讲解了很多与View绘图相关的知识， 那么至少2D绘图部分不是难题了，大部分的需求都能满足，但是关于View还有很多知识点，例如: 让绘图更加炫酷的Paint，让View动起来的动画，与用户交互的触控事件 等一系列内容。本次就带大家简单的了解一下与交互息息相关的东西－事件分发原理。 本次魔法小火车的终点站是事件分发，请各位魔法师带好装备，准备登车启程。 注意：本文中所有源码分析部分均基于 API23(Android 6.0) 版本，由于安卓系统源码改变很多，可能与之前版本有所不同，但基本流程都是一致
秒懂Android事件分发机制
qq_23921815的博客
03-08 486
秒懂Android事件分发机制
Android事件分发机制详解
zjm807778317的博客
04-06 2352
从浅入深分析事件分发。
Android事件分发机制
qq_43589739的博客
11-22 686
Android中的dispatchTouchEvent()、onInterceptTouchEvent()和onTouchEvent() 首先 先简单了解Android事件处理的过程,以及Android中的以上三个方法的作用. 事件处理 : 从用户开始到结束分为两个部分( 分为按下down , 抬起 up 两个部分) 简单附一张图,很好理解.这里就是简单的大家对手机,平板,iPad等的操作...
带你深入了解Android的事件分发机制
Dakaring的专栏
05-25 2247
事件拦截（Event Intercept）：事件拦截是指在事件分发过程中，某个ViewGroup可以拦截事件的传递，阻止它传递给子View。Android的事件分发机制是指在Android系统中，如何将用户的触摸事件、按键事件等传递给正确的View进行处理的一套机制。值得注意的是，在编写代码时，需要仔细理解每个方法的作用和调用时机，确保事件的正确传递和处理，避免潜在的问题和冲突。通过重写以上方法，你可以根据自己的需求来实现事件的分发和处理逻辑，例如拦截特定的手势，定制化事件的响应等。
Android的事件分发机制（跟随源码一步一步解析）
qq_39431405的博客
11-03 1394
一 事件的产生与起始 我们在点击手机的时候，屏幕下的电容传感器就会把坐标通过模数转换成具体的数字，然后通过android的linux层里面的JNI进行封装，最终把这么具体的坐标值和动作封装到PhoneWindowService里的一个队列，然后依次在这个队列取出event，分发给Activity的dispathTounchEvent这个方法。我们做android开发的只需要了解事件分发从Actiivty开始就行了，前面的比较底层就不深入研究了。 二 事件调用的方法 我们都知道，事件分发的难点其实就是搞懂事件
Android事件分发的底层原理
qq_42165012的博客
02-27 2136
在Android中，Touch事件的分发分服务端和应用端。在服务端由WindowManagerService（借助InputManagerService）负责采集和分发的，在应用端则是由ViewRootImpl（内部有一个mView变量指向View树的根，负责控制View树的UI绘制和事件消息的分发）负责分发的。 当输入设备可用时，比如触屏，Linux内核会在/dev/input中创建对应的设备节点。 IMS（InputManagerService）所做的工作...
Android-Touch事件分发机制流程及源码解析笔记
JeeZhong的博客
12-14 889
触摸事件是如何触发并传递到view的？ 触摸事件来源的大致流程： 事件来源： 手指触摸屏幕时，即产生了触摸信息。这个触摸信息由屏幕这个硬件产生，被系统底层驱动获取，交给Android的输入系统服务：InputManagerService，也就是IMS IMS会对这个触摸信息进行处理，经过WMS找到要分发的window，随后发送给对应的viewRootImpl。因此发送触摸信息的并非WMS，WMS提供的是window的相关信息。 当viewRootImpl接收到触摸信息时，也正是应用程序进程事件分发的开始。
Android View的事件分发机制
s003603u的专栏
07-29 942
Android View的事件分发机制
Android View 事件分发机制详解
09-01
本文主要介绍Android View 事件分发机制，这里整理了相关资料并详细介绍了view分发机制的知识及简单示例代码，有兴趣的小伙伴可以参考下
Android View事件分发机制详解
09-01
主要为大家详细介绍了Android View事件分发机制，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
android事件分发机制的实现原理
01-04
android中的事件处理，以及解决滑动冲突问题都离不开事件分发机制，android中的事件流，即MotionEvent都会经历一个从分发，拦截到处理的一个过程。即dispatchTouchEvent(),onInterceptEvent()到onTouchEvent()的一个...
android高斯模糊填充imageview背景
cf8833的博客
05-21 211
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Android 屏保开关
最新发布
weixin_44021334的博客
05-23 319
设置-显示-屏保，
安卓部署ffmpeg全平台so并实现命令行调用
codeofcc的博客
05-17 1106
前面的章节实现了ffmpeg全平台so的生成，接下来的步骤就是部署以及使用了，部署so还是比较简单的，用gradle和cmake都可以部署，部署好了就可以直接使用了，如果需要c++进行封装一层，则需要链接，对cmake熟悉的话链接也是比较简单的。以上就是今天讲述的内容，ffmpeg的so部署还是比较容易的，但是命令行的调用会麻烦一些，尤其是要解决ffmpeg退出问题，在c++中比较好解决，java理论上也比较好实现，如果在dart中则会比较麻烦，因为dart的方法通常不能跨线程调用，多线程的情况会出问题。
Android正向开发实现客户端证书认证
dafan0的博客
05-18 399
如果第三方模块被混淆，那hook方式均不能生效。这时就需要根据系统包去定位校验的函数，因此需要对安卓开发者是如何实现客户端证书校验的有一定了解，接下来就介绍这部分内容。开发者实现客户端证书校验的本质是：证书/密钥 + 代码。在形式上有：公钥校验、证书校验和Host（主机）校验。
Android 11 触摸小圆点显示流程
littleyards的博客
05-21 569
当SHOW_TOUCHES 这个key的值有改变时，调用updateShowTouchesFromSettings方法，在updateShowTouchesFromSettings方法中，是调用nativeSetShowTouches这个native方法，直接来看下这个方法。小圆点的图片资源已经被加载，并将其保存在相应的变量中了，接下来就需要将其显示出来了。在开发者选项中，打开 “显示点按操作反馈” 开关，当我们在触摸屏幕时，会显示一个小圆点，来分析下小圆点的显示流程。
android view事件分发机制
03-16
Android中的View事件分发机制是指当用户触摸屏幕时，系统如何将触摸事件分发给各个View，并由它们来处理事件的过程。事件分发机制主要包括三个部分：事件的产生、事件的分发和事件的处理。 事件的产生：当用户触摸屏幕时，系统会产生一个MotionEvent对象，该对象包含了触摸点的坐标、触摸的时间、触摸的压力等信息。 事件的分发：事件分发是由ViewGroup来完成的，它会将事件分发给它的子View，并根据子View的返回值来决定是否继续分发事件。如果子View处理了事件，那么事件就不会再传递给其他View。 事件的处理：事件的处理是由View来完成的，它会根据事件的类型来调用相应的回调方法，如onTouchEvent()、onClickListener()等。 总的来说，Android的View事件分发机制是一个复杂的过程，需要开发者深入理解和掌握，才能编写出高效、稳定的应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值