Android系统层的input设备解析

                 

前言：这篇从2011年写到2012年，呵呵，2012来临了，祝大家新年快乐，心想事成。

     上一篇从linux内核角度分析input驱动，那么android怎么获取input信息呢？本文重点讨论这个话题。

      在Java层，处理input类型消息在InputManager.java文件里，当然首先要找到源头，即InputManager类由谁来创建？在WindowManagerService.java这个界面窗口管理服务文件里。

     WindowManagerService类的构造函数：

     private WindowManagerService(Context context, PowerManagerService pm,

            boolean haveInputMethods, boolean showBootMsgs) {

           …..

 

        mInputManager = new InputManager(context, this);

           …..

        mInputManager.start();

           .….

    }

…..省掉与InputManager无关的部分，创建InputManager对象，然后调用其start方法来监控input事件。

 

进入InputManager.java文件，先看看它的构造函数，之后分析start方法。

public InputManager(Context context, WindowManagerService windowManagerService) {

        this.mContext = context;

        this.mWindowManagerService = windowManagerService;

        this.mCallbacks = new Callbacks();//创建回调对象

 

        Looper looper = windowManagerService.mH.getLooper();//创建looper

 

        Slog.i(TAG, "Initializing input manager");

        nativeInit(mContext, mCallbacks, looper.getQueue());//调用本地方法nativeInit来//进行C++层的初始化操作

 

        // Add ourself to the Watchdog monitors.

        Watchdog.getInstance().addMonitor(this);//watchdog监视器

    }

   在这里，重点关注nativeInit。进入C++层，在com_android_server_InputManager.cpp文件：

  static JNINativeMethod gInputManagerMethods[] = {

    /* name, signature, funcPtr */

    { "nativeInit", "(Landroid/content/Context;"

            "Lcom/android/server/wm/InputManager$Callbacks;Landroid/os/MessageQueue;)V",

            (void*) android_server_InputManager_nativeInit },// nativeInit与java层的关//联

    { "nativeStart", "()V",

       (void*) android_server_InputManager_nativeStart },// nativeStart与java层的关联

 

………..

}

在这里，分析android_server_InputManager_nativeInit函数.

static void android_server_InputManager_nativeInit(JNIEnv* env, jclass clazz,

        jobject contextObj, jobject callbacksObj, jobject messageQueueObj) {

    // gNativeInputManager为空，便创建对象.

    if (gNativeInputManager == NULL) {

        sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj);// sp<Looper>: Looper类强指针

        gNativeInputManager = new NativeInputManager(contextObj, callbacksObj, looper);//创建NativeInputManager对象

    } else {

        LOGE("Input manager already initialized.");

        jniThrowRuntimeException(env, "Input manager already initialized.");

    }

}

通过android_server_InputManager_nativeInit函数完成Looper和NativeInputManager初始化。

重点关注NativeInputManager类构造函数：

NativeInputManager::NativeInputManager(jobject contextObj,

        jobject callbacksObj, const sp<Looper>& looper) :

        mLooper(looper) {

    JNIEnv* env = jniEnv();

 

    mContextObj = env->NewGlobalRef(contextObj);

    mCallbacksObj = env->NewGlobalRef(callbacksObj);

 

    {

        AutoMutex _l(mLock);

        mLocked.displayWidth = -1;

        mLocked.displayHeight = -1;

        mLocked.displayExternalWidth = -1;

        mLocked.displayExternalHeight = -1;

        mLocked.displayOrientation = DISPLAY_ORIENTATION_0;

 

        mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;

        mLocked.pointerSpeed = 0;

        mLocked.pointerGesturesEnabled = true;

        mLocked.showTouches = false;

    }

 

    sp<EventHub> eventHub = new EventHub();//new一个EventHub对象

    mInputManager = new InputManager(eventHub, this, this);//创建InputManager对象

}

这个函数创建一个EventHub对象，然后把它作为参数来创建InputManager对象。特别注意，InputManager是在C++里，具体在InputManager.cpp里。EventHub类在EventHub.cpp里，这个类和input事件获取有关。

 

首先是去InputManager.cpp文件，下面是InputManager类的构造函数：

InputManager::InputManager(

        const sp<EventHubInterface>& eventHub,

        const sp<InputReaderPolicyInterface>& readerPolicy,

        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {

    mDispatcher = new InputDispatcher(dispatcherPolicy);

    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);

    initialize();

}

它创建了InputDispatcher对象，同时也创建了InputReader对象。并分别暂存于mDispatcher和mReader变量中。注意eventHub和mDispatcher都作为参数创建InputReader对象。后面还用initialize来初始化。下面是initialize函数的定义：

void InputManager::initialize() {

    mReaderThread = new InputReaderThread(mReader);

    mDispatcherThread = new InputDispatcherThread(mDispatcher);

}

它创建两个线程，一个是InputReaderThread线程，负责input事件的获取；另一个是InputDispatcherThread线程，负责input消息的发送。

 

先回头解决在开始InputManager.java的mInputManager.start()这个start方法。看究竟怎么启动。

    public void start() {

        Slog.i(TAG, "Starting input manager");

        nativeStart();//调用本地方法nativeStart

        …..

    }

重点关注nativeStart。进入C++层，在com_android_server_InputManager.cpp文件：

  static JNINativeMethod gInputManagerMethods[] = {

    /* name, signature, funcPtr */

    { "nativeInit", "(Landroid/content/Context;"

            "Lcom/android/server/wm/InputManager$Callbacks;Landroid/os/MessageQueue;)V",

            (void*) android_server_InputManager_nativeInit },// nativeInit与java层的关//联

    { "nativeStart", "()V",

       (void*) android_server_InputManager_nativeStart },// nativeStart与java层的关联

 

………..

}

关注android_server_InputManager_nativeStart函数：

    static void android_server_InputManager_nativeStart(JNIEnv* env, jclass clazz) {

    if (checkInputManagerUnitialized(env)) {

        return;

    }

 

    status_t result = gNativeInputManager->getInputManager()->start();

    if (result) {

        jniThrowRuntimeException(env, "Input manager could not be started.");

    }

          先看getInputManager：

inline sp<InputManager> getInputManager() const { return mInputManager; }

getInputManager是InputManager类，它的start方法继承InputManager类的方法(注意是InputManager.cpp的InputManager类)。

status_t InputManager::start() {

    status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);

    if (result) {

        LOGE("Could not start InputDispatcher thread due to error %d.", result);

        return result;

    }

 

    result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);

    if (result) {

        LOGE("Could not start InputReader thread due to error %d.", result);

 

        mDispatcherThread->requestExit();

        return result;

    }

 

    return OK;

}

      它主要是启动InputDispatcherThread和InputReaderThread这两个线程。前面提到了创建这两个线程。也创建了InputDispatcher和InputReader对象。下面就这两个对象做分解.

       下面是class InputDispatcherThread : public Thread {

public:

    explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);

    ~InputDispatcherThread();

 

private:

    virtual bool threadLoop();

 

    sp<InputDispatcherInterface> mDispatcher;

};

由于它是Thread子类，于是继承它的run方法，进入run方法后会调用threadLoop()，在Thread类中它是虚函数，得由子类来复写，如下所示：

bool InputDispatcherThread::threadLoop() {

    mDispatcher->dispatchOnce();

    return true;

}

启动mDispatcher->dispatchOnce();

void InputDispatcher::dispatchOnce() {

    nsecs_t nextWakeupTime = LONG_LONG_MAX;

    { // acquire lock

        AutoMutex _l(mLock);

        dispatchOnceInnerLocked(&nextWakeupTime);

 

        if (runCommandsLockedInterruptible()) {

            nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately

        }

    } // 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);

}

函数功能：dispatchOnceInnerLocked函数处理input输入消息，mLooper->pollOnce是等待下一次输入事件。

mLooper->pollOnce(timeoutMillis):

这个请看Looper.cpp文件中的Looper::pollOnce()函数。Looper里主要通过linux管道方式实现进程间通信，通过epoll机制实现外界事件请求作出响应。

 

接着，来分析InputReaderThread的启动。

class InputReaderThread : public Thread {

public:

    InputReaderThread(const sp<InputReaderInterface>& reader);

    virtual ~InputReaderThread();

 

private:

    sp<InputReaderInterface> mReader;

 

    virtual bool threadLoop();//loop

};

在这里直接到InputReader.cpp文件

bool InputReaderThread::threadLoop() {

    mReader->loopOnce();

    return true;

}

往下走,

void InputReader::loopOnce() {

    int32_t timeoutMillis;

    { // acquire lock

        …….

    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);

        ……

}

这个函数主要通过EventHub的getEvents方法来获取input事件。

 

接下来进入到EventHub.cpp文件。一睹getEvents方法。

bool EventHub::getEvent(RawEvent* outEvent)

{

    outEvent->deviceId = 0;

    outEvent->type = 0;

    outEvent->scanCode = 0;

    outEvent->keyCode = 0;

    outEvent->flags = 0;

    outEvent->value = 0;

    outEvent->when = 0;

 

    // Note that we only allow one caller to getEvent(), so don't need

    // to do locking here...  only when adding/removing devices.

 

    if (!mOpened) {

        mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;

        mOpened = true;

        mNeedToSendFinishedDeviceScan = true;

    }

 

    for (;;) {

        // Report any devices that had last been added/removed.

        if (mClosingDevices != NULL) {

            device_t* device = mClosingDevices;

            LOGV("Reporting device closed: id=0x%x, name=%s\n",

                 device->id, device->path.string());

            mClosingDevices = device->next;

            if (device->id == mFirstKeyboardId) {

                outEvent->deviceId = 0;

            } else {

                outEvent->deviceId = device->id;

            }

            outEvent->type = DEVICE_REMOVED;

            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);

            delete device;

            mNeedToSendFinishedDeviceScan = true;

            return true;

        }

 

        if (mOpeningDevices != NULL) {

            device_t* device = mOpeningDevices;

            LOGV("Reporting device opened: id=0x%x, name=%s\n",

                 device->id, device->path.string());

            mOpeningDevices = device->next;

            if (device->id == mFirstKeyboardId) {

                outEvent->deviceId = 0;

            } else {

                outEvent->deviceId = device->id;

            }

            outEvent->type = DEVICE_ADDED;

            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);

            mNeedToSendFinishedDeviceScan = true;

            return true;

        }

 

        if (mNeedToSendFinishedDeviceScan) {

            mNeedToSendFinishedDeviceScan = false;

            outEvent->type = FINISHED_DEVICE_SCAN;

            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);

            return true;

        }

 

        // Grab the next input event.

        for (;;) {

            // Consume buffered input events, if any.

            if (mInputBufferIndex < mInputBufferCount) {

                const struct input_event& iev = mInputBufferData[mInputBufferIndex++];

                const device_t* device = mDevices[mInputDeviceIndex];

 

                LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", device->path.string(),

                     (int) iev.time.tv_sec, (int) iev.time.tv_usec, iev.type, iev.code, iev.value);

                if (device->id == mFirstKeyboardId) {

                    outEvent->deviceId = 0;

                } else {

                    outEvent->deviceId = device->id;

                }

                outEvent->type = iev.type;

                outEvent->scanCode = iev.code;

                if (iev.type == EV_KEY) {

                    status_t err = device->layoutMap->map(iev.code,

                            & outEvent->keyCode, & outEvent->flags);

                    LOGV("iev.code=%d keyCode=%d flags=0x%08x err=%d\n",

                        iev.code, outEvent->keyCode, outEvent->flags, err);

                    if (err != 0) {

                        outEvent->keyCode = AKEYCODE_UNKNOWN;

                        outEvent->flags = 0;

                    }

                } else {

                    outEvent->keyCode = iev.code;

                }

                outEvent->value = iev.value;

 

                // Use an event timestamp in the same timebase as

                // java.lang.System.nanoTime() and android.os.SystemClock.uptimeMillis()

                // as expected by the rest of the system.

                outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);

                return true;

            }

 

            // Finish reading all events from devices identified in previous poll().

            // This code assumes that mInputDeviceIndex is initially 0 and that the

            // revents member of pollfd is initialized to 0 when the device is first added.

            // Since mFDs[0] is used for inotify, we process regular events starting at index 1.

            mInputDeviceIndex += 1;

            if (mInputDeviceIndex >= mFDCount) {

                break;

            }

 

            const struct pollfd& pfd = mFDs[mInputDeviceIndex];

            if (pfd.revents & POLLIN) {

                int32_t readSize = read(pfd.fd, mInputBufferData,

                        sizeof(struct input_event) * INPUT_BUFFER_SIZE);

                if (readSize < 0) {

                    if (errno != EAGAIN && errno != EINTR) {

                        LOGW("could not get event (errno=%d)", errno);

                    }

                } else if ((readSize % sizeof(struct input_event)) != 0) {

                    LOGE("could not get event (wrong size: %d)", readSize);

                } else {

                    mInputBufferCount = readSize / sizeof(struct input_event);

                    mInputBufferIndex = 0;

                }

            }

        }

 

#if HAVE_INOTIFY

        // readNotify() will modify mFDs and mFDCount, so this must be done after

        // processing all other events.

        if(mFDs[0].revents & POLLIN) {

            readNotify(mFDs[0].fd);

            mFDs[0].revents = 0;

            continue; // report added or removed devices immediately

        }

#endif

 

        mInputDeviceIndex = 0;

 

        // Poll for events.  Mind the wake lock dance!

        // We hold a wake lock at all times except during poll().  This works due to some

        // subtle choreography.  When a device driver has pending (unread) events, it acquires

        // a kernel wake lock.  However, once the last pending event has been read, the device

        // driver will release the kernel wake lock.  To prevent the system from going to sleep

        // when this happens, the EventHub holds onto its own user wake lock while the client

        // is processing events.  Thus the system can only sleep if there are no events

        // pending or currently being processed.

        release_wake_lock(WAKE_LOCK_ID);

 

        int pollResult = poll(mFDs, mFDCount, -1);

 

        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);

 

        if (pollResult <= 0) {

            if (errno != EINTR) {

                LOGW("poll failed (errno=%d)\n", errno);

                usleep(100000);

            }

        }

    }

}

函数功能：如果是第一次进入到这个函数中时，并且成员变量mOpened的值为false，于是就会调用openPlatformInput函数来打开系统输入设备。打开了这些输入设备文件后，就可以对这些输入设备进行是监控了。如果不是第一次进入到这个函数，那么就会分析当前有没有input事件发生，如果有，就返回这个事件，否则就会进入等待状态，等待下一次input事件的发生。这个函数很关键，上次分析input内核驱动，通过这个函数读取(打开设备文件形式)由input驱动传送过来的事件信息。

     这一节分解到这里，下回再分解。