Android 输入子系统1：IMS 初始化与启动

static jlong nativeInit(JNIEnv* env, jclass /* clazz */, jobject serviceObj,
    jobject contextObj, jobject messageQueueObj) {
    // 构造一个 native 层的 MessageQueue
    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
    // 构造 NativeInputManager
    NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
            messageQueue->getLooper());
    im->incStrong(0);
    return reinterpret_cast<jlong>(im);
}

// NativeInputManager 类结构
class NativeInputManager : public virtual RefBase,
    public virtual InputReaderPolicyInterface,
    public virtual InputDispatcherPolicyInterface,
    public virtual PointerControllerPolicyInterface {}

// 构造函数
NativeInputManager::NativeInputManager(jobject contextObj, jobject serviceObj,
    const sp<Looper>& looper) : mLooper(looper), mInteractive(true) {
    JNIEnv* env = jniEnv();
    // 全局引用
    mContextObj = env->NewGlobalRef(contextObj);
    mServiceObj = env->NewGlobalRef(serviceObj);
    mInteractive = true;
    // 构造 EventHub 实例并通过该实例构造 InputManager 实例
    sp<EventHub> eventHub = new EventHub();
    mInputManager = new InputManager(eventHub, this/*InputReaderPolicyInterface*/,
        this/*InputDispatcherPolicyInterface*/);
}

EventHub::EventHub(void) :
        mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1),
        mIRDeviceId(NO_IR_KEYBOARD), 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);
    // 创建 epoll 对象
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    // 创建 inotify 对象
    mINotifyFd = inotify_init();
    // 监听 /dev/path/ 目录的删除和创建事件，即输入设备的增删事件
    // 当目录下的设备节点发生增删事件时，可已通过 read(fd) 获取事件的详细信息
    int result = inotify_add_watch(mINotifyFd, "/dev/path", IN_DELETE | IN_CREATE);

    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN; // 监听 write 事件
    eventItem.data.u32 = EPOLL_ID_INOTIFY; // 自定义值
    // 把 inotify 添加到 epoll 监听队列中，当 inotify 事件到来时，epoll_wait() 会
    // 立即返回，EventHub 可以从 fd 中读取设备节点的增删信息并进行处理
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);

    int wakeFds[2];
    // 创建管道，fds[0] 表示管道的读端，fds[1] 表示管道的写端
    result = pipe(wakeFds);
    mWakeReadPipeFd = wakeFds[0];
    mWakeWritePipeFd = wakeFds[1];
    
    // 设置唤醒读端为非阻塞式
    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
    // 设置唤醒写端为非阻塞式
    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);

    eventItem.data.u32 = EPOLL_ID_WAKE;
    // 把唤醒读端的 fd 添加到 epoll 监听队列中，目的是在必要时唤醒 reader 线程
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
}

InputManager::InputManager(const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    // 构造出 InputDispatcher 和 InputRader，分别用于事件分发和事件读取
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
    initialize();
}

void InputManager::initialize() {
    // 构造出 InputRaderThread 和 InputDispatcherThread，事件读取和事件分发的
    // 实际执行者
    mReaderThread = new InputReaderThread(mReader);
    mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
    // nativeInit() 时返回的 NativeInputManager 指针
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
    // 调用 NativeInputManager 的 start() 函数
    status_t result = im->getInputManager()->start();
}

status_t InputManager::start() {
    // 启动 Dispatcher 线程，run() 方法内部会调用 threadLoop() 方法
    status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
    if (result) { // 启动失败，直接返回
        return result;
    }
    // 启动 Rader 线程，同样 run() 方法内部也会调用 threadLoop() 方法
    result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
    if (result) { // 如果启动失败，则退出 Dispatcher 线程
        mDispatcherThread->requestExit();
        return result;
    }
    return OK;
}

bool InputReaderThread::threadLoop() {
    // loopOnce() 会从 EventHub 中取出原始的输入事件并进行加工，随后发布给
    // Dispatcher 进行分发
    mReader->loopOnce();
    // 返回 true 表示会一直循环知道发生错误或线程退出
    return true;
}

bool InputDispatcherThread::threadLoop() {
    // dispatchOnce() 会对从 EventHub 中取出的事件进行分发
    mDispatcher->dispatchOnce();
    // 返回 true 表示会一直循环知道发生错误或线程退出
    return true;
}