Android开发InputManagerService创建与启动流程

百目鬼建

前言

之前写过几篇关于输入系统的文章，但是还没有写完，后来由于工作的变动，这个事情就一直耽搁了。而现在，在工作中，遇到输入系统相关的事情也越来越多，其中有一个非常有意思的需求，因此是时候继续分析 InputManagerService。

1. InputManagerService 系统文章，基于 Android 12 进行分析。
   
2. 本文将以 IMS 简称 InputManagerService。

复制代码

启动流程

InputManagerService 是一个系统服务，启动流程如下

1. // SystemServer.java
   
2. private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
   
3.             // ..
   
4.     // 1. 创建
   
5.     inputManager = new InputManagerService(context);
   
6.     // 注册服务   
   
7.     ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
   
8.                     /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
   
9.     // 保存 wms 的回调
   
10.     inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
    
11.     // 2. 启动
    
12.     inputManager.start();   
    
13.     try {
    
14.         // 3. 就绪
    
15.         if (inputManagerF != null) {
    
16.             inputManagerF.systemRunning();
    
17.         }
    
18.     } catch (Throwable e) {
    
19.         reportWtf("Notifying InputManagerService running", e);
    
20.     }
    
21.     // ...
    
22. }

复制代码

IMS 的启动流程分为三步

• 创建输入系统，建立上层与底层的映射关系。
  
• 启动输入系统，其实就是启动底层输入系统的几个模块。
  
• 输入系统就绪，上层会同步一些配置给底层输入系统。
  

下面分三个模块，分别讲解这三步。

创建输入系统

1. // InputManagerService.java
   
2. public InputManagerService(Context context) {
   
3.     this.mContext = context;
   
4.     this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper());
   
5.     // 配置为空
   
6.     mStaticAssociations = loadStaticInputPortAssociations();
   
7.     // 默认 false
   
8.     mUseDevInputEventForAudioJack =
   
9.             context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
   
10.     // 1. 底层进行初始化
    
11.     // mPtr 指向底层创建的 NativeInputManager 对象
    
12.     mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());
    
13.     // 空
    
14.     String doubleTouchGestureEnablePath = context.getResources().getString(
    
15.             R.string.config_doubleTouchGestureEnableFile);
    
16.     // null
    
17.     mDoubleTouchGestureEnableFile = TextUtils.isEmpty(doubleTouchGestureEnablePath) ? null :
    
18.         new File(doubleTouchGestureEnablePath);
    
19.     LocalServices.addService(InputManagerInternal.class, new LocalService());
    
20. }

复制代码

IMS 构造函数，主要就是调用 nativeInit() 来初始化底层输入系统。

1. // com_android_server_input_InputManagerService.cpp
   
2. static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
   
3.         jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
   
4.     // 从Java层的MessageQueue中获取底层映射的MessageQueue
   
5.     sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
   
6.     if (messageQueue == nullptr) {
   
7.         jniThrowRuntimeException(env, "MessageQueue is not initialized.");
   
8.         return 0;
   
9.     }
   
10.     // 创建 NativeInputManager
    
11.     NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
    
12.             messageQueue->getLooper());
    
13.     im->incStrong(0);
    
14.     // 返回指向 NativeInputManager 对象的指针
    
15.     return reinterpret_cast<jlong>(im);
    
16. }

复制代码

原来底层创建了 NativeInputManager 对象，然后返回给上层。
但是 NativeInputManager 并不是底层输入系统的服务，它只是一个连接上层输入系统和底层输入系统的桥梁而已。来看下它的创建过程

1. // com_android_server_input_InputManagerService.cpp
   
2. NativeInputManager::NativeInputManager(jobject contextObj,
   
3.         jobject serviceObj, const sp<Looper>& looper) :
   
4.         mLooper(looper), mInteractive(true) {
   
5.     JNIEnv* env = jniEnv();
   
6.     // 1.保存上层的InputManagerService对象
   
7.     mServiceObj = env->NewGlobalRef(serviceObj);
   
8.     // 2. 初始化一些参数
   
9.     {
   
10.         AutoMutex _l(mLock);
    
11.         // mLocked 的类型是 struct Locked，这里初始化了一些参数
    
12.         // 这些参数会被上层改变
    
13.         mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;
    
14.         mLocked.pointerSpeed = 0;
    
15.         mLocked.pointerGesturesEnabled = true;
    
16.         mLocked.showTouches = false;
    
17.         mLocked.pointerCapture = false;
    
18.         mLocked.pointerDisplayId = ADISPLAY_ID_DEFAULT;
    
19.     }
    
20.     mInteractive = true;
    
21.     // 3.创建并注册服务 InputManager
    
22.     mInputManager = new InputManager(this, this);
    
23.     defaultServiceManager()->addService(String16("inputflinger"),
    
24.             mInputManager, false);
    
25. }

复制代码

NativeInputManager 构造过程如下

• 创建一个全局引用，并通过 mServiceObj 指向上层的 InputManagerService 对象。
  
• 初始化参数。这里要注意一个结构体变量 mLocked，它的一些参数都是由上层控制的。例如，mLocked.showTouches 是由开发者选项中 "Show taps" 决定的，它的功能是在屏幕上显示一个触摸点。
  
• 创建并注册服务 InputManager。
  

原来，InputManager 才是底层输入系统的服务，而 NativeInputManagerService 通过 mServiceObj 保存了上层 InputManagerService 引用，并且上层 InputManagerService 通过 mPtr 指向底层的 NativeInputManager。因此，我们可以判定 NativeInputManager 就是一个连接上层与底层的桥梁。
我们注意到创建 InputManager 使用了两个 this 参数，这里介绍下 NativeInputManager 和 InputManager 的结构图

InputManager 构造函数需要的两个接口正好是由 NativeInputManager 实现的，然而，具体使用这两个接口的不是 InputManager，而是它的子模块。这些子模块都是在 InputManager 的构造函数中创建的

1. // InputManager.cpp
   
2. InputManager::InputManager(
   
3.         const sp<InputReaderPolicyInterface>& readerPolicy,
   
4.         const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
   
5.     // 1. 创建InputDispatcher对象，使用 InputDispatcherPolicyInterface 接口
   
6.     mDispatcher = createInputDispatcher(dispatcherPolicy);
   
7.     // 2. 创建InputClassifier对象，使用 InputListenerInterface
   
8.     mClassifier = new InputClassifier(mDispatcher);
   
9.     // 3. 创建InputReader对象，使用 InputReaderPolicyInterface 和 InputListenerInterface
   
10.     mReader = createInputReader(readerPolicy, mClassifier);
    
11. }
    
12. // InputDispatcherFactory.cpp
    
13. sp<InputDispatcherInterface> createInputDispatcher(
    
14.         const sp<InputDispatcherPolicyInterface>& policy) {
    
15.     return new android::inputdispatcher::InputDispatcher(policy);
    
16. }
    
17. // InputReaderFactory.cpp
    
18. sp<InputReaderInterface> createInputReader(const sp<InputReaderPolicyInterface>& policy,
    
19.                                            const sp<InputListenerInterface>& listener) {
    
20.     return new InputReader(std::make_unique<EventHub>(), policy, listener);
    
21. }

复制代码

InputManager 构造函数所使用的两个接口，分别由 InputDispatcher 和 InputReader 所使用。因此 InputManager 向上通信的能力是由子模块 InputDispatcher 和 InputReader 实现的。
InputManager 创建了三个模块，InputReader、InputClassifier、InputDispatcher。 InputReader 负责从 EventHub 中获取事件，然后把事件加工后，发送给 InputClassfier。InputClassifer 会把事件发送给 InputDispatcher，但是它会对触摸事件进行一个分类工作。最后 InputDispatcher 对进行事件分发。
那么现在我们可以大致推算下输入系统的关系图，如下

这个关系图很好的体现了设计模式的单一职责原则。
EventHub 其实只属于 InputReader，因此要想解剖整个输入系统，我们得逐一解剖 InputReader、InputClassifier、InputDispatcher。后面的一系列的文章将逐个来剖析。

启动输入系统

1. // InputManagerService.java
   
2.     public void start() {
   
3.         Slog.i(TAG, "Starting input manager");
   
4.         // 1.启动native层
   
5.         nativeStart(mPtr);
   
6.         // Add ourself to the Watchdog monitors.
   
7.         Watchdog.getInstance().addMonitor(this);
   
8.         // 2.监听数据库，当值发生改变时，通过 native 层
   
9.         // 监听Settings.System.POINTER_SPEED，这个表示手指的速度
   
10.         registerPointerSpeedSettingObserver();
    
11.         // 监听Settings.System.SHOW_TOUCHES，这个表示是否在屏幕上显示触摸坐标
    
12.         registerShowTouchesSettingObserver();
    
13.         // 监听Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON
    
14.         registerAccessibilityLargePointerSettingObserver();
    
15.         // 监听Settings.Secure.LONG_PRESS_TIMEOUT，这个多少毫秒触发长按事件
    
16.         registerLongPressTimeoutObserver();
    
17.         // 监听用户切换
    
18.         mContext.registerReceiver(new BroadcastReceiver() {
    
19.             @Override
    
20.             public void onReceive(Context context, Intent intent) {
    
21.                 updatePointerSpeedFromSettings();
    
22.                 updateShowTouchesFromSettings();
    
23.                 updateAccessibilityLargePointerFromSettings();
    
24.                 updateDeepPressStatusFromSettings("user switched");
    
25.             }
    
26.         }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler);
    
27.         // 3. 从数据库获取值，并传递给 native 层
    
28.         updatePointerSpeedFromSettings();
    
29.         updateShowTouchesFromSettings();
    
30.         updateAccessibilityLargePointerFromSettings();
    
31.         updateDeepPressStatusFromSettings("just booted");
    
32.     }

复制代码

输入系统的启动过程如下

• 启动底层输入系统。其实就是启动刚刚说到的 InputReader, InputDispatcher。
  
• 监听一些广播。因为这些广播与输入系统的配置有关，当接收到这些广播，会更新配置到底层。
  
• 直接读取配置，更新到底层输入系统。
  

第2步和第3步，本质上其实都是更新配置到底层，但是需要我们对 InputReader 的运行过程比较熟悉，因此这个配置更新过程，留到后面分析。
现在我们直接看下如何启动底层的输入系统

1. // com_android_server_input_InputManagerService.cpp
   
2. static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
   
3.     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
   
4.     // 调用InputManager::start()
   
5.     status_t result = im->getInputManager()->start();
   
6.     if (result) {
   
7.         jniThrowRuntimeException(env, "Input manager could not be started.");
   
8.     }
   
9. }

复制代码

通过 JNI 层的 NativeInputManager 这个桥梁来启动 InputManager。
前面用一幅图表明了 NativeInputManager 的桥梁作用，现在感受到了吗？

1. status_t InputManager::start() {
   
2.     // 启动 Dispatcher
   
3.     status_t result = mDispatcher->start();
   
4.     if (result) {
   
5.         ALOGE("Could not start InputDispatcher thread due to error %d.", result);
   
6.         return result;
   
7.     }
   
8.     // 启动 InputReader
   
9.     result = mReader->start();
   
10.     if (result) {
    
11.         ALOGE("Could not start InputReader due to error %d.", result);
    
12.         mDispatcher->stop();
    
13.         return result;
    
14.     }
    
15.     return OK;
    
16. }

复制代码

InputManager 的启动过程很简单，就是直接启动它的子模块 InputDispatcher 和 InputReader。
InputDispatcher 和 InputReader 的启动，都是通过 InputThread 创建一个线程来执行任务。

1. //InputThread.cpp
   
2. InputThread::InputThread(std::string name, std::function<void()> loop, std::function<void()> wake)
   
3.      : mName(name), mThreadWake(wake) {
   
4.    mThread = new InputThreadImpl(loop);
   
5.    mThread->run(mName.c_str(), ANDROID_PRIORITY_URGENT_DISPLAY);
   
6. }

复制代码

注意 InputThread 可不是一个线程，InputThreadImpl 才是一个线程，如下

1. //InputThread.cpp
   
2. class InputThreadImpl : public Thread {
   
3. public:
   
4.     explicit InputThreadImpl(std::function<void()> loop)
   
5.           : Thread(/* canCallJava */ true), mThreadLoop(loop) {}
   
6.     ~InputThreadImpl() {}
   
7. private:
   
8.     std::function<void()> mThreadLoop;
   
9.     bool threadLoop() override {
   
10.         mThreadLoop();
    
11.         return true;
    
12.     }
    
13. };

复制代码

当线程启动后，会循环调用 threadLoop()，直到这个函数返回 false。从 InputThreadImpl 的定义可以看出，threadLoop() 会一直保持循环，并且每一次循环，会调用一次 mThreadLoop()，而函数 mThreadLoop 是由 InputReader 和 InputDispacher 在启动时传入

1. // InputReader.cpp
   
2. status_t InputReader::start() {
   
3.     if (mThread) {
   
4.         return ALREADY_EXISTS;
   
5.     }
   
6.     // 线程启动后，循环调用 loopOnce()
   
7.     mThread = std::make_unique<InputThread>(
   
8.             "InputReader", [this]() { loopOnce(); }, [this]() { mEventHub->wake(); });
   
9.     return OK;
   
10. }
    
11. // InputDispatcher.cpp
    
12. status_t InputDispatcher::start() {
    
13.     if (mThread) {
    
14.         return ALREADY_EXISTS;
    
15.     }
    
16.     // 线程启动后，循环调用 dispatchOnce()
    
17.     mThread = std::make_unique<InputThread>(
    
18.             "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
    
19.     return OK;
    
20. }

复制代码

现在，我们可以明白，InputReader 启动时，会创建一个线程，然后循环调用 loopOnce() 函数，而 InputDispatcher 启动时，也会创建一个线程，然后循环调用 dispatchOnce()。

输入系统就绪

1. // InputManagerService.java
   
2. public void systemRunning() {
   
3.     mNotificationManager = (NotificationManager)mContext.getSystemService(
   
4.             Context.NOTIFICATION_SERVICE);
   
5.     synchronized (mLidSwitchLock) {
   
6.         mSystemReady = true;
   
7.         // Send the initial lid switch state to any callback registered before the system was
   
8.         // ready.
   
9.         int switchState = getSwitchState(-1 /* deviceId */, InputDevice.SOURCE_ANY, SW_LID);
   
10.         for (int i = 0; i < mLidSwitchCallbacks.size(); i++) {
    
11.             LidSwitchCallback callback = mLidSwitchCallbacks.get(i);
    
12.             callback.notifyLidSwitchChanged(0 /* whenNanos */, switchState == KEY_STATE_UP);
    
13.         }
    
14.     }
    
15.     // 监听广播，通知底层加载键盘布局
    
16.     IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
    
17.     filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
    
18.     filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
    
19.     filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
    
20.     filter.addDataScheme("package");
    
21.     mContext.registerReceiver(new BroadcastReceiver() {
    
22.         @Override
    
23.         public void onReceive(Context context, Intent intent) {
    
24.             updateKeyboardLayouts();
    
25.         }
    
26.     }, filter, null, mHandler);
    
27.     // 监听广播，通知底层加载设备别名
    
28.     filter = new IntentFilter(BluetoothDevice.ACTION_ALIAS_CHANGED);
    
29.     mContext.registerReceiver(new BroadcastReceiver() {
    
30.         @Override
    
31.         public void onReceive(Context context, Intent intent) {
    
32.             reloadDeviceAliases();
    
33.         }
    
34.     }, filter, null, mHandler);
    
35.     // 直接通知一次底层加载键盘布局和加载设备别名
    
36.     mHandler.sendEmptyMessage(MSG_RELOAD_DEVICE_ALIASES);
    
37.     mHandler.sendEmptyMessage(MSG_UPDATE_KEYBOARD_LAYOUTS);
    
38.     if (mWiredAccessoryCallbacks != null) {
    
39.         mWiredAccessoryCallbacks.systemReady();
    
40.     }
    
41. }
    
42. private void reloadKeyboardLayouts() {
    
43.     nativeReloadKeyboardLayouts(mPtr);
    
44. }
    
45. private void reloadDeviceAliases() {
    
46.     nativeReloadDeviceAliases(mPtr);
    
47. }

复制代码

无论是通知底层加载键盘布局，还是加载设备别名，其实都是让底层更新配置。与前面一样，更新配置的过程，留到后面分析。

结束

通过本文，我们能大致掌握输入系统的轮廓。后面，我们将逐步分析子模块 InputReader 和 InputDispatcher 的功能。
以上就是Android开发InputManagerService创建与启动流程的详细内容，更多关于Android InputManagerService创建启动的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

Ginger112

感谢楼主分享～～～～～

身经百战

顶顶更健康！！！

隔壁老王

感谢楼主分享。

领认府菜边

路过，支持一下

宣娅心

感谢楼主，顶。