一、應用程式在繪製View時註冊監聽事件

[/frameworks/base/core/java/android/view/ViewRootImpl.java]
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            mView = view;
            ...
            requestLayout();
            //建立InputChannel例項，建立後的InputChannel是未初始化的，可以通過從Parcel物件中讀取資訊初始化
            //或者呼叫transferTo(InputChannel outParameter)從另一個InputChannel例項中獲取初始化資訊。
            if
 
 ((mWindowAttributes.inputFeatures &   
                    WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                mInputChannel = new InputChannel();
            }

            try {
                ...
                //addToDisplay()方法會呼叫WindowManagerService的addWindow()方法。
                res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,getHostVisibility(), mDisplay.getDisplayId(),mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,mAttachInfo.mOutsets, mInputChannel);
            } catch (RemoteException e) {
                ...
 

                mView = null;
                mInputChannel = null;
                ...
                throw new RuntimeException("Adding window failed", e);
            } finally {
                ...
            }

            if (mInputChannel != null) {
                if (mInputQueueCallback != null) {
                    mInputQueue = new InputQueue();
                    mInputQueueCallback.onInputQueueCreated(mInputQueue);
                }

                //建立WindowInputEventReceiver例項，使用前面建立好的InputChannel例項作引數。
                mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                        Looper.myLooper());
            }
        }
    }
}
 

Session類的addToDisplay()方法會呼叫WindowManagerService的addWindow()方法，這個方法非常重要。

[/frameworks/base/services/java/com/android/server/wm/WindowManagerService.java]
public int addWindow(Session session, IWindow client, int seq,
        WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
        Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
        InputChannel outInputChannel) {
    ...
    synchronized(mWindowMap) {
        ...
        if (outInputChannel != null && (attrs.inputFeatures
                & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
            String name = win.makeInputChannelName();
            //建立名為name的socketpair例項，將socket[0](服務端)註冊到InputManagerService中，
            //將socket[1](客戶端)傳遞給應用程序。
            InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
            win.setInputChannel(inputChannels[0]);
            inputChannels[1].transferTo(outInputChannel);

            mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
        }
    }//synchronized

    return res;
}

二、InputManagerService對socketpair服務端的處理

2.1 InputManagerService的初始化和啟動

public InputManagerService(Context context) {
    this.mContext = context;
    //InputManagerService的Handler使用的是DisplayThread的Looper。
    this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper());

    mUseDevInputEventForAudioJack =
            context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);

    //在native層完成初始化, nativeInit()返回的是JNI層建立的NativeInputManager物件的指標。Java層儲存Native的物件指標，這個是Android中非常常見的用法。
    mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());

    LocalServices.addService(InputManagerInternal.class, new LocalService());
}

[com_android_server_input_InputManagerService.cpp]
static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
sp messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
if (messageQueue == NULL) {
jniThrowRuntimeException(env, “MessageQueue is not initialized.”);
return 0;
}

//new一個NativeInputManager例項，
NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,messageQueue->getLooper());
im->incStrong(0);
return reinterpret_cast<jlong>(im);

}

NativeInputManager類

NativeInputManager類的設計

class NativeInputManager : public virtual RefBase,
    public virtual InputReaderPolicyInterface,
    public virtual InputDispatcherPolicyInterface,
    public virtual PointerControllerPolicyInterface {
protected:
    virtual ~NativeInputManager();

public:
    NativeInputManager(jobject contextObj, jobject serviceObj, const sp<Looper>& looper);
    inline sp<InputManager> getInputManager() const { return mInputManager; }
    status_t registerInputChannel(JNIEnv* env, const sp<InputChannel>& inputChannel,
            const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
    status_t unregisterInputChannel(JNIEnv* env, const sp<InputChannel>& inputChannel);
    ...
private:
    sp<InputManager> mInputManager;

    jobject mContextObj;
    jobject mServiceObj;
    sp<Looper> mLooper;
}

NativeInputManager的建構函式

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

    {
        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();
    mInputManager = new InputManager(eventHub, this, this);
}

“`

“`####InputManagerService的啟動####
主要的工作是把Native層的InputReaderThread和InputDispatcherThread兩個執行緒啟動起來。

public void start() {
    //在native層啟動
    nativeStart(mPtr);

    // Add ourself to the Watchdog monitors.
    Watchdog.getInstance().addMonitor(this);

    registerPointerSpeedSettingObserver();
    registerShowTouchesSettingObserver();

    mContext.registerReceiver(new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            updatePointerSpeedFromSettings();
            updateShowTouchesFromSettings();
        }
    }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler);

    updatePointerSpeedFromSettings();
    updateShowTouchesFromSettings();
}

com_android_server_input_InputManagerService.cpp

static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    status_t result = im->getInputManager()->start();
    if (result) {
        jniThrowRuntimeException(env, "Input manager could not be started.");
    }
}

InputManager的設計

介面:

class InputManagerInterface : public virtual RefBase {
protected:
    InputManagerInterface() { }
    virtual ~InputManagerInterface() { }

public:
    /* Starts the input manager threads. */
    virtual status_t start() = 0;

    /* Stops the input manager threads and waits for them to exit. */
    virtual status_t stop() = 0;

    /* Gets the input reader. */
    virtual sp<InputReaderInterface> getReader() = 0;

    /* Gets the input dispatcher. */
    virtual sp<InputDispatcherInterface> getDispatcher() = 0;
};

具體類：

class InputManager : public InputManagerInterface {
protected:
    virtual ~InputManager();

public:
    InputManager(
            const sp<EventHubInterface>& eventHub,
            const sp<InputReaderPolicyInterface>& readerPolicy,
            const sp<InputDispatcherPolicyInterface>& dispatcherPolicy);

    // (used for testing purposes)
    InputManager(
            const sp<InputReaderInterface>& reader,
            const sp<InputDispatcherInterface>& dispatcher);

    virtual status_t start();
    virtual status_t stop();

    virtual sp<InputReaderInterface> getReader();
    virtual sp<InputDispatcherInterface> getDispatcher();

private:
    sp<InputReaderInterface> mReader;
    sp<InputReaderThread> mReaderThread;

    sp<InputDispatcherInterface> mDispatcher;
    sp<InputDispatcherThread> mDispatcherThread;

    void initialize();
};

socketpair服務端的註冊

最終呼叫的是InputDispatcher的registerInputChannel()函式。

status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel, 
        const sp<InputWindowHandle>& inputWindowHandle, bool monitor);

1. 以socketFd作為索引，將Connection例項新增到：KeyedVector

InputDispatcher的分發執行緒

分發流程：
1. 輪詢mCommandQueue；
2. 輪詢mLooper。
void InputDispatcher::dispatchOnce() {
nsecs_t nextWakeupTime = LONG_LONG_MAX;
{ // acquire lock
AutoMutex _l(mLock);
mDispatcherIsAliveCondition.broadcast();

        //如果佇列mCommandQueue不為空，則呼叫dispatchOnceInnerLocked()函式進行分發。
        if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);
        }

        if (runCommandsLockedInterruptible()) {
            nextWakeupTime = LONG_LONG_MIN;
        }
    } // release lock

    nsecs_t currentTime = now();
    int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
    mLooper->pollOnce(timeoutMillis);
}

bool InputDispatcher::runCommandsLockedInterruptible() {
    //如果佇列mCommandQueue為空，直接返回flase。
    if (mCommandQueue.isEmpty()) {
        return false;
    }

    do {
        //依次從佇列mCommandQueue中出列一個元素，呼叫command()函式，直到佇列為空為止，返回true。
        CommandEntry* commandEntry = mCommandQueue.dequeueAtHead();

        Command command = commandEntry->command;
        (this->*command)(commandEntry);

        commandEntry->connection.clear();
        delete commandEntry;
    } while (! mCommandQueue.isEmpty());
    return true;
}

三、應用程式對SocketPair客戶端事件的處理

3.1 Native層的InputEventReceiver的設計

    [/frameworks/base/core/jni/android_view_InputEventReceiver.cpp]
    class NativeInputEventReceiver : public LooperCallback {
    public:
        NativeInputEventReceiver(JNIEnv* env,
                jobject receiverWeak, const sp<InputChannel>& inputChannel,
                const sp<MessageQueue>& messageQueue);

        status_t initialize();
        void dispose();
        status_t finishInputEvent(uint32_t seq, bool handled);
        status_t consumeEvents(JNIEnv* env, bool consumeBatches, nsecs_t frameTime,
                bool* outConsumedBatch);

    protected:
        virtual ~NativeInputEventReceiver();

    private:
        struct Finish {
            uint32_t seq;
            bool handled;
        };

        jobject mReceiverWeakGlobal;
        InputConsumer mInputConsumer;
        sp<MessageQueue> mMessageQueue;
        PreallocatedInputEventFactory mInputEventFactory;
        bool mBatchedInputEventPending;
        int mFdEvents;
        Vector<Finish> mFinishQueue;

        void setFdEvents(int events);

        const char* getInputChannelName() {
            return mInputConsumer.getChannel()->getName().string();
        }

        virtual int handleEvent(int receiveFd, int events, void* data);
    };

status_t NativeInputEventReceiver::initialize() {
        //監聽型別為ALOOPER_EVENT_INPUT
        setFdEvents(ALOOPER_EVENT_INPUT);
        return OK;
    }

    //NativeInputEventReceiver繼承自LooperCallback，有事件發生時會回撥handleEvent()函式。
    void NativeInputEventReceiver::setFdEvents(int events) {
        if (mFdEvents != events) {
            mFdEvents = events;
            int fd = mInputConsumer.getChannel()->getFd();
            if (events) {
                mMessageQueue->getLooper()->addFd(fd, 0, events, this, NULL);
            } else {
                mMessageQueue->getLooper()->removeFd(fd);
            }
        }
    }

    int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {
        if (events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP)) {
            return 0; // remove the callback
        }

        if (events & ALOOPER_EVENT_INPUT) {
            JNIEnv* env = AndroidRuntime::getJNIEnv();
            status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);
            mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");
            return status == OK || status == NO_MEMORY ? 1 : 0;
        }

        if (events & ALOOPER_EVENT_OUTPUT) {
            for (size_t i = 0; i < mFinishQueue.size(); i++) {
                const Finish& finish = mFinishQueue.itemAt(i);
                status_t status = mInputConsumer.sendFinishedSignal(finish.seq, finish.handled);
                if (status) {
                    mFinishQueue.removeItemsAt(0, i);

                    if (status == WOULD_BLOCK) {
                        return 1; // keep the callback, try again later
                    }

                    ALOGW("Failed to send finished signal on channel '%s'.  status=%d",
                            getInputChannelName(), status);
                    if (status != DEAD_OBJECT) {
                        JNIEnv* env = AndroidRuntime::getJNIEnv();
                        String8 message;
                        message.appendFormat("Failed to finish input event.  status=%d", status);
                        jniThrowRuntimeException(env, message.string());
                        mMessageQueue->raiseAndClearException(env, "finishInputEvent");
                    }
                    return 0; // remove the callback
                }
            }
            mFinishQueue.clear();
            setFdEvents(ALOOPER_EVENT_INPUT);
            return 1;
        }

        return 1;
    }

    status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,
            bool consumeBatches, nsecs_t frameTime, bool* outConsumedBatch) {
        if (consumeBatches) {
            mBatchedInputEventPending = false;
        }
        if (outConsumedBatch) {
            *outConsumedBatch = false;
        }

        ScopedLocalRef<jobject> receiverObj(env, NULL);
        bool skipCallbacks = false;
        for (;;) {
            uint32_t seq;
            InputEvent* inputEvent;
            status_t status = mInputConsumer.consume(&mInputEventFactory,
                    consumeBatches, frameTime, &seq, &inputEvent);
            if (status) {
                if (status == WOULD_BLOCK) {
                    ...
                }
                ALOGE("channel '%s' ~ Failed to consume input event.  status=%d",
                        getInputChannelName(), status);
                return status;
            }
            assert(inputEvent);

            if (!skipCallbacks) {
                ...
                jobject inputEventObj;
                switch (inputEvent->getType()) {
                case AINPUT_EVENT_TYPE_KEY:
                    inputEventObj = android_view_KeyEvent_fromNative(env,
                            static_cast<KeyEvent*>(inputEvent));
                    break;

                case AINPUT_EVENT_TYPE_MOTION: {
                    MotionEvent* motionEvent = static_cast<MotionEvent*>(inputEvent);
                    if ((motionEvent->getAction() & AMOTION_EVENT_ACTION_MOVE) && outConsumedBatch) {
                        *outConsumedBatch = true;
                    }
                    inputEventObj = android_view_MotionEvent_obtainAsCopy(env, motionEvent);
                    break;
                }

                default:
                    assert(false); // InputConsumer should prevent this from ever happening
                    inputEventObj = NULL;
                }

                if (inputEventObj) {
                    //呼叫Java層的dispatchInputEvent()方法。
                    env->CallVoidMethod(receiverObj.get(),
                            gInputEventReceiverClassInfo.dispatchInputEvent, seq, inputEventObj);
                    if (env->ExceptionCheck()) {
                        ALOGE("Exception dispatching input event.");
                        skipCallbacks = true;
                    }
                    env->DeleteLocalRef(inputEventObj);
                } else {
                    ALOGW("channel '%s' ~ Failed to obtain event object.", getInputChannelName());
                    skipCallbacks = true;
                }
            }

            /* 前面執行成功時,skipCallbacks為false, 最終會呼叫sendFinishedSignal()函式，
               它會構建InputMessage，格式：
                 InputMessage msg;
                 msg.header.type = InputMessage::TYPE_FINISHED;
                 msg.body.finished.seq = seq;
                 msg.body.finished.handled = handled;
                 mChannel->sendMessage(&msg);
               socketpair的服務端會收到該訊息後，就知道該訊息已經成功分發了。
            */
            if (skipCallbacks) {
                mInputConsumer.sendFinishedSignal(seq, false);
            }
        }
    }

四、InputDispatcher事件傳送成功後的處理

int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {
        InputDispatcher* d = static_cast<InputDispatcher*>(data);

        { // acquire lock
            AutoMutex _l(d->mLock);

            ssize_t connectionIndex = d->mConnectionsByFd.indexOfKey(fd);
            if (connectionIndex < 0) {
                ALOGE("Received spurious receive callback for unknown input channel.  "
                        "fd=%d, events=0x%x", fd, events);
                return 0; // remove the callback
            }

            bool notify;
            sp<Connection> connection = d->mConnectionsByFd.valueAt(connectionIndex);
            if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
                if (!(events & ALOOPER_EVENT_INPUT)) {
                    ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event.  "
                            "events=0x%x", connection->getInputChannelName(), events);
                    return 1;
                }

                nsecs_t currentTime = now();
                bool gotOne = false;
                status_t status;
                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;
                    }
                }

                notify = status != DEAD_OBJECT || !connection->monitor;
                if (notify) {
                    ALOGE("channel '%s' ~ Failed to receive finished signal.  status=%d",
                            connection->getInputChannelName(), status);
                }
            } else {
                // Monitor channels are never explicitly unregistered.
                // We do it automatically when the remote endpoint is closed so don't warn
                // about them.
                notify = !connection->monitor;
                if (notify) {
                    ALOGW("channel '%s' ~ Consumer closed input channel or an error occurred.  "
                            "events=0x%x", connection->getInputChannelName(), events);
                }
            }

            // Unregister the channel.
            d->unregisterInputChannelLocked(connection->inputChannel, notify);
            return 0; // remove the callback
        } // release lock
    }


    status_t InputDispatcher::unregisterInputChannelLocked(const sp<InputChannel>& inputChannel,
            bool notify) {
        ssize_t connectionIndex = getConnectionIndexLocked(inputChannel);
        if (connectionIndex < 0) {
            ALOGW("Attempted to unregister already unregistered input channel '%s'",
                    inputChannel->getName().string());
            return BAD_VALUE;
        }

        //移除mConnectionsByFd中與connIndex對應的鍵值對。
        sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);
        mConnectionsByFd.removeItemsAt(connectionIndex);

        if (connection->monitor) {
            removeMonitorChannelLocked(inputChannel);
        }

        //移除該InputChannel包含的socketFd。
        mLooper->removeFd(inputChannel->getFd());

        nsecs_t currentTime = now();
        abortBrokenDispatchCycleLocked(currentTime, connection, notify);

        connection->status = Connection::STATUS_ZOMBIE;
        return OK;
    }