Android Framework-Input-2 构建和启动InputManagerService的启动是在syste

InputManagerService的启动是在systemServer.startOtherServices()方法里


//systemServer.startOtherServices()
//services/core/java/com/android/server/input/InputManagerService.java

 private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
   //省略 
   InputManagerService inputManager = null;
   
      inputManager = new InputManagerService(context);
        inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
            inputManager.start();
   //这里的inputManager会传递给 wms
   
 }

 public InputManagerService(Context context) {
   
     mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());
 }

 public void start() {
     nativeStart(mPtr);
   //省略。。。
   
 }

这里传入的参数分包含 mHandler.getLooper().getQueue() 继续调用JNI。

//services/core/jni/com_android_server_input_InputManagerService.cpp

//serviceObj ->InputServiceManager
//contextObj ->context
//messageQueueObj-->handler的msgQueue

static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
        jobject serviceObj,
                        jobject contextObj,
                        jobject messageQueueObj) {
  //构建msgQueue
    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
    if (messageQueue == nullptr) {
        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
        return 0;
    }
  //构建native NativeInputManager  
    NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
            messageQueue->getLooper());
    im->incStrong(0);//引用计数0
    return reinterpret_cast<jlong>(im);
}


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.");
    }
}

构建完 NativeInputManager 调用了start()方法


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

    mServiceObj = env->NewGlobalRef(serviceObj);

    {
        AutoMutex _l(mLock);
        mLocked.systemUiLightsOut = false;
        mLocked.pointerSpeed = 0;
        mLocked.pointerGesturesEnabled = true;
        mLocked.showTouches = false;
        mLocked.pointerCapture = false;
        mLocked.pointerDisplayId = ADISPLAY_ID_DEFAULT;
    }
    mInteractive = true;
    //注意 传入两个构造参数 分别是this 如果是接口肯定就会回吊回去
    InputManager* im = new InputManager(this, this);
    mInputManager = im;
          //添加inputService  名字是 inputflinger  将 InputManager add进去
    defaultServiceManager()->addService(String16("inputflinger"), im);
}

这一步主要作用是构建了InputManager，并添加进SM里，名字为inputflinger。

进入InputManager查看一下

//native/services/inputflinger/InputManager.cpp
InputManager::InputManager(
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
  //构建 Dispatcher 和InputReader
  //mDispatcher 传入的是外面引用 将 传给 mDispatcher 在传给 reader
    mDispatcher = createInputDispatcher(dispatcherPolicy);
    mClassifier = new InputClassifier(mDispatcher);
  // 注意 这里一路传下去的其实还是 最外层引用
    mReader = createInputReader(readerPolicy, mClassifier);
}


status_t InputManager::start() {
    status_t result = mDispatcher->start();
    result = mReader->start();
   
    return OK;
}

这一步主要构建了InputDispatcher和 InputReader，也可以看到InputManager的start(),其实就是调用他俩的start（）

先看下 InputDispatcher

InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy)
      : mPolicy(policy),
        mPendingEvent(nullptr),
        mLastDropReason(DropReason::NOT_DROPPED),
        mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
        mAppSwitchSawKeyDown(false),
        mAppSwitchDueTime(LONG_LONG_MAX),
        mNextUnblockedEvent(nullptr),
        mDispatchEnabled(false),
        mDispatchFrozen(false),
        mInputFilterEnabled(false),

        mInTouchMode(true),
        mMaximumObscuringOpacityForTouch(1.0f),
        mFocusedDisplayId(ADISPLAY_ID_DEFAULT),
        mFocusedWindowRequestedPointerCapture(false),
        mWindowTokenWithPointerCapture(nullptr),
        mLatencyAggregator(),
        mLatencyTracker(&mLatencyAggregator),
        mCompatService(getCompatService()) {
          //构建一个Looper和createInputReporter 
    mLooper = new Looper(false);
    mReporter = createInputReporter();

    mKeyRepeatState.lastKeyEntry = nullptr;
    //将外部引用 赋值给内部的policy
    policy->getDispatcherConfiguration(&mConfig);
}

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

InputDispatcher的构造里构建了Looper, 在start()方法里开启了一个线程，去执行dispatchOnce(),唤醒了Looper。

继续看InputClassifier ,我们已经知道InputDispatcher做了哪些工作。

//native/services/inputflinger/InputClassifier.cpp
InputClassifier::InputClassifier(const sp<InputListenerInterface>& listener)
      : mListener(listener), mHalDeathRecipient(new HalDeathRecipient(*this)) {}
//就构建了一下 将外部赋值给mListener

其实 InputClassifier 简单理解就是做了个桥接工作。

InputReader的构建。

//native/services/inputflinger/reader/InputReaderFactory.cpp

sp<InputReaderInterface> createInputReader(const sp<InputReaderPolicyInterface>& policy,
                                           const sp<InputListenerInterface>& listener) {
  //构建了一个eventHub 将外部引用继续传 第二个参数现在是 InputClassifier了
    return new InputReader(std::make_unique<EventHub>(), policy, listener);
}


//native/services/inputflinger/reader/InputReader.cpp
InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub,
                         const sp<InputReaderPolicyInterface>& policy,
                         const sp<InputListenerInterface>& listener)
      : mContext(this),
        mEventHub(eventHub),
        mPolicy(policy),
        mGlobalMetaState(0),
        mLedMetaState(AMETA_NUM_LOCK_ON),
        mGeneration(1),
        mNextInputDeviceId(END_RESERVED_ID),
        mDisableVirtualKeysTimeout(LLONG_MIN),
        mNextTimeout(LLONG_MAX),
        mConfigurationChangesToRefresh(0) {
          //构建mQueuedListener  传入 InputClassifier
    mQueuedListener = new QueuedInputListener(listener);

    { // 申请锁
        std::scoped_lock _l(mLock);

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


//构建了线程调用了loopOnce  mEventHub也被激活
status_t InputReader::start() {
    if (mThread) {
        return ALREADY_EXISTS;
    }
    mThread = std::make_unique<InputThread>(
            "InputReader", [this]() { loopOnce(); }, [this]() { mEventHub->wake(); });
    return OK;
}

总结：

SystemServer的startOtherServices 先构建InputManagerService，然后调用了 start（）方法。在java层 InputManagerService 构造方法里调用了 nativeInit()，调用 NativeInputManager，构建出来Inputmanger，并调用defaultServiceManager()->addService(String16("inputflinger"), im);。
Java层传递 Looper 赋值给了 NativeInputManager的 mLooper。构建出来的 Inputmanger 赋值给了 NativeInputManager 的 mInputManager。
然后在 Inputmanger 里构建了 Inputreader 和Dispatcher 。构造函数传入的都是 NativeInputManager，便于以后回调。
Dispatcher 构造构建了自己的 Looper。
Inputreader 在构造里将 NativeInputManager 赋值到了 mListener，方便向外回调。也是和Dispatcher 串联起来。这里虽然经过了 InputClassifier的桥接。但是其实还是相当于回调到了NativeInputManager，该mListener 中包含一个 mArgsQueue 队列，方便处理完的数据往里塞。
调用 start方法的时候，调用了nativeStart()，调用了InputManager的start()，将 Dispatcher和Inputreader 的start()调用，InputReader的start()里，调用 loopOnce 并唤醒 mEventHub。Dispatcher的start() 调用 dispatchOnce并唤醒mLooper ,等待消息的到来。
InputDispatcher 依赖于InputClassifier 和 InputReader 串联起来。