InputManagerService服务的初始化

最新推荐文章于 2024-08-02 20:30:08 发布

风再起时与不羁的风

最新推荐文章于 2024-08-02 20:30:08 发布

阅读量690

点赞数

CC 4.0 BY-SA版权

分类专栏： Android 文章标签： android 输入系统

本文链接：https://blog.youkuaiyun.com/chewbee/article/details/78144967

Android 专栏收录该内容

23 篇文章

订阅专栏

本文详细解析了Android系统中InputManagerService的初始化过程，从WindowManagerService启动InputManagerService开始，涵盖NativeInputManager、EventHub、InputReader、InputDispatcher等组件的创建与初始化，以及InputDispatcherThread和InputReaderThread的工作原理。InputManagerService的初始化最终完成输入事件的读取、分发和处理机制的建立。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

InputManagerService的初始化

- InputManagerService的初始化

1.简介

Android系统的输入事件是由InputManagerService服务来监控的，而InputManagerService是由窗口管理服务WindowManagerService来启动的。WindowManagerService服务是在system_server进程中启动关键服务时启动的。

2.初始化流程

InputManagerService也是一个系统服务，在SystemServer中初始化，其初始化流程如下：

2.1 SystemServer.startOtherServices()

private void startOtherServices() {
    ....
    inputManager = new InputManagerService(context);//构造InputManagerService服务，见2.2
    wm = WindowManagerService.main(context, inputManager,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
            !mFirstBoot, mOnlyCore);//将InputManagerService设置到WindowManagerService中，见2.12
    ServiceManager.addService(Context.WINDOW_SERVICE, wm);
    ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
    inputManager.setWindowManagerCallbacks(wm.getInputMonitor());// 将InputMonitor对象保存在InputManagerService对象中
    inputManager.start();//启动InputManagerService服务，见2.13
    ....
}

可以看到，在SystemServer的startOtherService方法中，不但构造了InputManagerService服务，而且在启动InputManagerService之前，将其自身注入到WindowMangerService中，进行关联。

2.2 InputManagerService()

public InputManagerService(Context context) {
    this.mContext = context;
    this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper());//初始化Handler，运行在“android.display”线程
    ..... 
    mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());// 调用本地方法初始化，见2.3
    ......
    LocalServices.addService(InputManagerInternal.class, new LocalService());
}

nativeInit方法在com_android_server_input_InputManagerService.cpp文件中实现

2.3 nativeInit()

static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
    jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
    //获取InputManagerService对应的native消息队列
    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
    if (messageQueue == NULL) {
        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
        return 0;
    }
    // 构造NativeInputManager，见2.4
    NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
        messageQueue->getLooper());
    im->incStrong(0);
    return reinterpret_cast<jlong>(im);//返回native指针，保存在InputManagerService的mPtr变量中。
}

android_os_MessageQueue_getMessageQueue方法主要是获取Java层消息队列对应的native消息队列。

sp<MessageQueue> android_os_MessageQueue_getMessageQueue(JNIEnv* env, jobject messageQueueObj) {
    jlong ptr = env->GetLongField(messageQueueObj, gMessageQueueClassInfo.mPtr);//获取InputManagerService中mHanlder对应的消息队列
    return reinterpret_cast<NativeMessageQueue*>(ptr);
}

2.4 NativeInputManager()

NativeInputManager::NativeInputManager(jobject contextObj,
    jobject serviceObj, const sp<Looper>& looper) :
    mLooper(looper), mInteractive(true) {
    JNIEnv* env = jniEnv();

    mContextObj = env->NewGlobalRef(contextObj);//保存InputManagerService中的Context
    mServiceObj = env->NewGlobalRef(serviceObj);// 保存InputManagerService对象

    {
        AutoMutex _l(mLock);
        mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;
        mLocked.pointerSpeed = 0;
        mLocked.pointerGesturesEnabled = true;
        mLocked.showTouches = false;
    }
    mInteractive = true;

    sp<EventHub> eventHub = new EventHub();//构建EventHub，见2.5
    mInputManager = new InputManager(eventHub, this, this);//构建InputManager,见2.6
}

在NativeInputManager的构造过程中，会创建一个EventHub实例，并且把这个EventHub作为参数来创建InputManager对象。EventHub类是真正执行监控键盘事件操作的地方。mLooper是指“android.display”线程的Looper。

2.5 EventHub()

EventHub::EventHub(void) :
    mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1), mControllerNumbers(),
    mOpeningDevices(0), mClosingDevices(0),
    mNeedToSendFinishedDeviceScan(false),
    mNeedToReopenDevices(false), mNeedToScanDevices(true),
    mPendingEventCount(0), mPendingEventIndex(0), mPendingINotify(false) {

    acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);//获取锁

    mEpollFd = epoll_create(EPOLL_SIZE_HINT);//创建epoll句柄

    mINotifyFd = inotify_init();
    // 此处DEVICE_PATH为“/dev/input”，监听该设备路径
    int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);

    // 构建需要监控的epoll事件
    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN;
    eventItem.data.u32 = EPOLL_ID_INOTIFY;
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);// 监控mINotifyFd文件描述符

    int wakeFds[2];
    result = pipe(wakeFds);//创建管道

    mWakeReadPipeFd = wakeFds[0];//管道的读端
    mWakeWritePipeFd = wakeFds[1];//管道的写端

    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);// 将pipe的读设置为非阻塞模式

    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);// 将pipe的写设置为非阻塞模式

    eventItem.data.u32 = EPOLL_ID_WAKE;
    // 添加管道的读端到epoll实例
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);

    int major, minor;
    getLinuxRelease(&major, &minor);

    mUsingEpollWakeup = major > 3 || (major == 3 && minor >= 5);
}

在构造EventHub时，主要是通过IO多路复用机制epoll来监控输入事件是否已经准备好了。

2.6 InputManager()

InputManager::InputManager(
    const sp<EventHubInterface>& eventHub,
    const sp<InputReaderPolicyInterface>& readerPolicy,
    const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    //构建InputDispatcher对象，见2.7
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    //构建InputReader对象，见2.8
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
    initialize();//初始化操作，见2.9
}

这里主要是创建一个InputDispatcher对象和一个InputReader对象，并且分别保存在成员变量mDispatcher和mReader中。InputDispatcher类是负责把输入消息分发给当前激活的Activity窗口的，而InputReader类则是通过EventHub类来实现读取输入事件的。

这里的readerPolicy和dispatcherPolicy都是指向NativeInputManager对象，即InputDispatcher和InputReader的mPolicy成员变量都是指向NativeInputManager对象。

2.7 InputDispatcher()

InputDispatcher::InputDispatcher(const  sp<InputDispatcherPolicyInterface>& policy) :
    mPolicy(policy),
    mPendingEvent(NULL), mLastDropReason(DROP_REASON_NOT_DROPPED),
    mAppSwitchSawKeyDown(false), mAppSwitchDueTime(LONG_LONG_MAX),
    mNextUnblockedEvent(NULL),
    mDispatchEnabled(false), mDispatchFrozen(false), mInputFilterEnabled(false),
    mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {

    mLooper = new Looper(false);//构建一个属于InputDispatcher的Looper对象

    mKeyRepeatState.lastKeyEntry = NULL;

    policy->getDispatcherConfiguration(&mConfig);
}

mPolicy变量指向NativeInputManager对象，在构建InputDispatcher时，会创建一个属于自己线程的Looper实例，在Looper会通过epoll监控唤醒事件。

2.8 InputReader()

InputReader::InputReader(const sp<EventHubInterface>& eventHub,
    const sp<InputReaderPolicyInterface>& policy,
    const sp<InputListenerInterface>& listener) :
    mContext(this), mEventHub(eventHub), mPolicy(policy),
    mGlobalMetaState(0), mGeneration(1),
    mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
    mConfigurationChangesToRefresh(0) {
    // 构建一个QueuedInputListener监听器
    mQueuedListener = new QueuedInputListener(listener);

    { // acquire lock
        AutoMutex _l(mLock);

        refreshConfigurationLocked(0);
        updateGlobalMetaStateLocked();
    } // release lock
}

QueuedInputListener::QueuedInputListener(const sp<InputListenerInterface>& innerListener) :
    mInnerListener(innerListener) {
}

mPolicy变量指向NativeInputManager对象，mQueueListener数据类型为QueuedInputListener，通过其内部成员变量mInnerListener指向InputDispatcher对象。这个mQueueListener对象便是InputDispatcher跟InputReader交互的中间枢纽。

2.9 InputManager.initialize()

void InputManager::initialize() {
    // 构建InputReaderThread线程，见2.10
    mReaderThread = new InputReaderThread(mReader);
    // 构建InputDispatchThread线程，见2.11
    mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

在这个函数中，创建了一个InputDispatcherThread线程实例和InputReaderThread线程实例。这里的InputReader实例mReader就是通过这里的InputReaderThread线程实例mReaderThread来读取键盘事件的，而InputDispatcher实例mDispatcher则是通过这里的InputDispatcherThread线程实例mDispatcherThread来分发键盘消息的。

2.10 InputReaderThread()

InputReaderThread线程定义及初始化。

/* Reads raw events from the event hub and processes them, endlessly. */
class InputReaderThread : public Thread {
    public:
    InputReaderThread(const sp<InputReaderInterface>& reader);
    virtual ~InputReaderThread();

    private:
    sp<InputReaderInterface> mReader;

    virtual bool threadLoop();
};

// --- InputReaderThread ---

InputReaderThread::InputReaderThread(const sp<InputReaderInterface>& reader) :
    Thread(/*canCallJava*/ true), mReader(reader) {
}

InputReaderThread::~InputReaderThread() {
}

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

这里mReader变量指向InputReader对象。

2.11 InputDispatcherThread()

InputDispatcherThread定义及初始化。

/* Enqueues and dispatches input events, endlessly. */
class InputDispatcherThread : public Thread {
public:
    explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);
    ~InputDispatcherThread();

private:
    virtual bool threadLoop();

    sp<InputDispatcherInterface> mDispatcher;
};


// --- InputDispatcherThread ---

InputDispatcherThread::InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher) :
    Thread(/*canCallJava*/ true), mDispatcher(dispatcher) {
}

InputDispatcherThread::~InputDispatcherThread() {
}

bool InputDispatcherThread::threadLoop() {
    // 调用InputDispatcher的dispatchOnce方法
    mDispatcher->dispatchOnce();
    return true;
}

这里mDispatcher变量指向InputDispatcher对象。

至此InputManagerService的初始化工作以及完成了，在初始化InputManager类的时候，同时也初始化了InputDispatcher、InputReader以及InputReaderThread和InputDispatcherThread。其中InputReaderThread和InputDispatcherThread是由InputManager管理的两个重要线程，其作用和具体的逻辑均与InputReader和InputDispatcher相关。接着回到2.1中WindowManagerService的初始化工作。

2.12 WindowManagerService.main()

public static WindowManagerService main(final Context context,
        final InputManagerService im,
        final boolean haveInputMethods, final boolean showBootMsgs,
        final boolean onlyCore) {
    final WindowManagerService[] holder = new WindowManagerService[1];
    DisplayThread.getHandler().runWithScissors(new Runnable() {
        @Override
        public void run() {
            holder[0] = new WindowManagerService(context, im,
                    haveInputMethods, showBootMsgs, onlyCore);// 构建WindowManagerService
        }
    }, 0);
    return holder[0];
}

private WindowManagerService(Context context, InputManagerService inputManager,
        boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore) {
    mContext = context;
    .....
    mInputManager = inputManager;//关联InputManagerService对象
    .....
}

在构建WindowManagerService服务时，会与InputManagerService服务进行关联。在构建完WindowManagerService服务之后，会启动InputManagerService服务中的线程，调用InputManagerService的start方法。

2.13 InputManagerService.start()

public void start() {
    //调用本地方法启动InputReaderThread和InputDispatcherThread线程
    nativeStart(mPtr);//调用本地方法，见2.14
    .....
}

这个函数主要是启动InputDispatcherThread线程和InputReaderThread线程来分别分发和读取输入事件。

2.14 InputManager.nativeStart()

static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
    //调用InputManager的start方法启动线程
    status_t result = im->getInputManager()->start();
    if (result) {
        jniThrowRuntimeException(env, "Input manager could not be started.");
    }
}

nativeStart方法最终调用是InputManager的start方法，启动InputReaderThread和InputDispatcherThread线程。

status_t InputManager::start() {
    // 启动InputDispatcherThread线程，见2.15
    status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
    if (result) {
        ALOGE("Could not start InputDispatcher thread due to error %d.", result);
        return result;
    }
    // 启动InputReaderThread线程，见2.17
    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;
}

InputDispatcherThread和InputReaderThread线程调用他们的run方法之后，就会进入到他们的threadLoop函数中，只要threadLoop函数返回true，函数threadLoop就会一直被循环调用，于是这两个线程就起到了不断地读取和分发键盘消息的作用。

2.15 InputDispatcherThread.threadLoop()

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

mDispatcher变量是前面创建的InputDispatcher对象，调用它的dispatchOnce成员函数进行一次输入消息的分发操作；

2.16 InputDispatcher.dispatchOnce()

void InputDispatcher::dispatchOnce() {
    nsecs_t nextWakeupTime = LONG_LONG_MAX;
    {
        AutoMutex _l(mLock);
        mDispatcherIsAliveCondition.broadcast();

        if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);//处理输入消息
        }


        if (runCommandsLockedInterruptible()) {
            nextWakeupTime = LONG_LONG_MIN;
        }
    } 

    nsecs_t currentTime = now();
    int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
    mLooper->pollOnce(timeoutMillis);//等待下一次输入消息
}

在该方法中，主要做了两件事情，一个将输入消息交给dispatchOnceInnerLocked函数来处理，另外一个是调用Looper的pollOnce()方法来等待下一次输入消息的到来。

在Looper类中，会创建一个管道，当调用Looper类的pollOnce函数时，如果管道中没有内容可读，那么当前线程就会进入到空闲等待状态；当有输入事件发生时，InputReader就会往这个管道中写入新的内容，这样就会唤醒前面正在等待键盘事件发生的线程。

2.17 InputReaderThread.threadLoop()

bool InputReaderThread::threadLoop() {  
    mReader->loopOnce(); //见2.18
    return true;  
}

mReader变量是前面创建的InputReader对象，调用它的loopOnce成员函数执行一次输入事件的读取操作。

2.18 InputReader.loopOnce()

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

    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);//1.读取输入事件，可能阻塞

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

        if (count) {
            processEventsLocked(mEventBuffer, count);//2.处理消息
        }

        if (mNextTimeout != LLONG_MAX) {
            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
            if (now >= mNextTimeout) {
                mNextTimeout = LLONG_MAX;
                timeoutExpiredLocked(now);
            }
        }

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

    if (inputDevicesChanged) {
        mPolicy->notifyInputDevicesChanged(inputDevices);
    }

    mQueuedListener->flush();
}

在loopOnce函数中，主要通过mEventHub来负责输入事件的读取工作，该方法是阻塞的方法。如果当前有输入事件发生，或者有输入事件等待处理，则通过mEventHub的getEvent函数就可以得到这个事件。然后交由processEventsLocked函数进行处理，这个函数的主要作用是唤醒前面的InputDispatcherThread线程，通知它有新的输入事件发生了。InputDispatcherThread线程需要进行一次输入消息的分发操作。如果没有输入事件发生或者没有输入事件等待处理，那么调用mEventHub的getEvent函数时就会进入等待状态。

至此InputManagerService的初始化工作完成了。

3.总结

输入系统的主要组成部分有：

Native层的InputReader，负责从读取出EventHub事件并处理，再交给InputDispatcher处理；
Native层的InputDispatcher，负责接收来自InputReader的输入事件，并记录处于激活Activity的窗口信息，用于派发事件到合适的窗口；
Java层的InputManagerService，负责跟WindowManagerService交互，WindowManagerService记录了所有的窗口信息，并同步更新到了InputManagerService中，这样InputDispatcher就可以正确派发事件到ViewRootImpl中。

输入系统的类图如下：