前言
在以前，我觉得 Input 系统没有什么值得研究的，就只是事件的传递过程而已。然而，在工作中，接触到越来越多的与 Input 系统相关的任务，掌握 Input 系统变得越来越重要，因此是时候全面分析一波 Input 系统。
Input 系统是由上层的 InputManagerSerice 启动的，而上层的 InputManagerService 只是 Input 系统一小部分，而主要的功能是集中在 native 层，因此 InuptManagerService 这个系统服务并不能代表整个 Input 系统。
Input系统的系列文章，是基于 Android 12 进行分析。
本文将以 IMS 简称 InputManagerService。
启动流程
InputManagerService 是一个系统服务，启动流程如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// SystemServer.java private void startOtherServices(@NonNull TimingsTraceAndSlog t) { // .. // 1. 创建 inputManager = new InputManagerService(context); // 注册服务 ServiceManager.addService(Context.INPUT_SERVICE, inputManager, /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL); // 保存 wms 的回调 inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback()); // 2. 启动 inputManager.start(); // 3. 就绪 if (inputManagerF != null) { inputManagerF.systemRunning(); } // ... } |
IMS 的启动流程分为三步
- 创建输入系统，建立上层与底层的映射关系。
- 启动输入系统，其实就是启动底层输入系统的几个模块。
- 输入系统就绪，上层会同步一些配置给底层输入系统。
下面分三个模块，分别讲解这三步。
创建输入系统
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// InputManagerService.java public InputManagerService(Context context) { this.mContext = context; this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper()); // 配置为空 mStaticAssociations = loadStaticInputPortAssociations(); // 默认 false mUseDevInputEventForAudioJack = context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack); // 1. 底层进行初始化 // mPtr 指向底层创建的 NativeInputManager 对象 mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue()); // 空 String doubleTouchGestureEnablePath = context.getResources().getString( R.string.config_doubleTouchGestureEnableFile); // null mDoubleTouchGestureEnableFile = TextUtils.isEmpty(doubleTouchGestureEnablePath) ? null : new File(doubleTouchGestureEnablePath); LocalServices.addService(InputManagerInternal.class, new LocalService()); } |
IMS 构造函数，主要就是调用 nativeInit() 来初始化底层输入系统。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// com_android_server_input_InputManagerService.cpp static jlong nativeInit(JNIEnv* env, jclass /* clazz */, jobject serviceObj, jobject contextObj, jobject messageQueueObj) { // 从Java层的MessageQueue中获取底层映射的MessageQueue sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj); if (messageQueue == nullptr) { jniThrowRuntimeException(env, "MessageQueue is not initialized."); return 0; } // 创建 NativeInputManager NativeInputManager* im = new NativeInputManager(contextObj, serviceObj, messageQueue->getLooper()); im->incStrong(0); // 返回指向 NativeInputManager 对象的指针 return reinterpret_cast<jlong>(im); } |
底层输入系统的初始化，其实就是创建 NativeInputManager，然后上层用 InputManagerService#mPtr 指向这个 NativeInputManager 对象。
NativeInputManager 的创建过程，其实初始化了底层的 Input 系统
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// com_android_server_input_InputManagerService.cpp NativeInputManager::NativeInputManager(jobject contextObj, jobject serviceObj, const sp<Looper>& looper) : mLooper(looper), mInteractive(true) { JNIEnv* env = jniEnv(); // 1.保存上层的InputManagerService对象 mServiceObj = env->NewGlobalRef(serviceObj); // 2. 初始化一些参数 { AutoMutex _l(mLock); // mLocked 的类型是 struct Locked，这里初始化了一些参数 // 这些参数会被上层改变 mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE; mLocked.pointerSpeed = 0; mLocked.pointerGesturesEnabled = true; mLocked.showTouches = false; mLocked.pointerCapture = false; mLocked.pointerDisplayId = ADISPLAY_ID_DEFAULT; } mInteractive = true; // 3.创建并注册服务 InputManager mInputManager = new InputManager(this, this); defaultServiceManager()->addService(String16("inputflinger"), mInputManager, false); } |
NativeInputManager 构造过程如下
- 创建一个全局引用，并通过 NativeInputManager::mServiceObj 指向上层的 InputManagerService 对象。
- 初始化参数。这里要注意一个结构体变量 mLocked，它的一些参数都是由上层控制的。例如，mLocked.showTouches 是由开发者选项中 “Show taps” 决定的，它的功能是在屏幕上显示一个触摸点。
- 创建并注册服务 InputManager。
从这里，我们要明白几点事情
- 底层的 NativeInputManagerService 与上层的 InputManagerService 相互引用，这样它们就可以相互通信。
- InputManager 才是底层 Input 系统的真正的服务。
注意，创建 InputManager 使用了两个 this 参数，这里介绍下 NativeInputManager 和 InputManager 的结构图
`
InputManager 构造函数需要的两个接口正好是由 NativeInputManager 实现的，然而，具体使用这两个接口的不是 InputManager，而是它的子模块。这些子模块都是在 InputManager 的构造函数中创建的
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// InputManager.cpp InputManager::InputManager( const sp<InputReaderPolicyInterface>& readerPolicy, const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) { // 1. 创建InputDispatcher对象，使用 InputDispatcherPolicyInterface 接口 mDispatcher = createInputDispatcher(dispatcherPolicy); // 2. 创建InputClassifier对象，使用 InputListenerInterface mClassifier = new InputClassifier(mDispatcher); // 3. 创建InputReader对象，使用 InputReaderPolicyInterface 和 InputListenerInterface mReader = createInputReader(readerPolicy, mClassifier); } // InputDispatcherFactory.cpp sp<InputDispatcherInterface> createInputDispatcher( const sp<InputDispatcherPolicyInterface>& policy) { return new android::inputdispatcher::InputDispatcher(policy); } // InputReaderFactory.cpp sp<InputReaderInterface> createInputReader(const sp<InputReaderPolicyInterface>& policy, const sp<InputListenerInterface>& listener) { return new InputReader(std::make_unique<EventHub>(), policy, listener); } |
InputManager 构造函数所使用的两个接口，分别由 InputDispatcher 和 InputReader 所使用。因此 InputManager 向上通信的能力是由子模块 InputDispatcher 和 InputReader 实现的。
从这里可以看出，NativeInputManager 只是底层 Input 系统与上层的 Input 系统的桥梁而已。
那么现在，我们可以推算出Input 系统的底层与上层的沟通方式
InputManager 创建了三个模块，InputReader、InputClassifier、InputDispatcher。 InputReader 负责从 EventHub 中获取事件，然后把事件加工后，发送给 InputClassfier。InputClassfier 会对事件进行分类，然后把事件发送给 InputDispatcher。最后 InputDispatcher 对进行事件分发给指定的窗口。基于这个理论，我们可以总结事件传递的流程，如下
EventHub 其实只属于 InputReader，因此要想解剖整个输入系统，我们得逐一解剖 InputReader、InputClassifier、InputDispatcher。后面的一系列的文章将逐个来剖析。
启动输入系统
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
// InputManagerService.java public void start() { Slog.i(TAG, "Starting input manager"); // 1.启动native层 nativeStart(mPtr); // Add ourself to the Watchdog monitors. Watchdog.getInstance().addMonitor(this); // 2.监听数据库和广播，更新配置给底层 // 监听Settings.System.POINTER_SPEED，这个表示手指的速度 registerPointerSpeedSettingObserver(); // 监听Settings.System.SHOW_TOUCHES，这个表示是否在屏幕上显示触摸坐标 registerShowTouchesSettingObserver(); // 监听Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON registerAccessibilityLargePointerSettingObserver(); // 监听Settings.Secure.LONG_PRESS_TIMEOUT，这个多少毫秒触发长按事件 registerLongPressTimeoutObserver(); // 监听用户切换 mContext.registerReceiver(new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { updatePointerSpeedFromSettings(); updateShowTouchesFromSettings(); updateAccessibilityLargePointerFromSettings(); updateDeepPressStatusFromSettings("user switched"); } }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler); // 3. 直接更新一次配置给底层 updatePointerSpeedFromSettings(); updateShowTouchesFromSettings(); updateAccessibilityLargePointerFromSettings(); updateDeepPressStatusFromSettings("just booted"); } |
输入系统的启动过程如下
- 启动底层输入系统。其实就是启动刚刚说到的 InputReader, InputDispatcher。
- 监听一些数据和广播，在合适的时机，更新配置给底层。
- 直接读取配置，更新到底层输入系统。
第2步和第3步，本质上其实都是更新配置到底层，但是要分析这个配置更新的过程，需要我们对 InputReader 的运行过程比较熟悉，因此这个配置更新过程，留到后面分析。
现在我们直接看下如何启动底层的输入系统
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// com_android_server_input_InputManagerService.cpp static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); // 调用InputManager::start() status_t result = im->getInputManager()->start(); if (result) { jniThrowRuntimeException(env, "Input manager could not be started."); } } |
通过 JNI 层的 NativeInputManager 这个桥梁来启动 InputManager。
前面用一幅图表明了 NativeInputManager 的桥梁作用，现在感受到了吗？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
status_t InputManager::start() { // 启动 Dispatcher status_t result = mDispatcher->start(); if (result) { ALOGE("Could not start InputDispatcher thread due to error %d.", result); return result; } // 启动 InputReader result = mReader->start(); if (result) { ALOGE("Could not start InputReader due to error %d.", result); mDispatcher->stop(); return result; } return OK; } |
InputManager 的启动过程很简单，就是直接启动它的子模块 InputDispatcher 和 InputReader。
InputDispatcher 和 InputReader 的启动，都是通过 InputThread 创建一个线程来执行任务。
|
1 2 3 4 5 6 7 8 9 |
//InputThread.cpp InputThread::InputThread(std::string name, std::function<void()> loop, std::function<void()> wake) : mName(name), mThreadWake(wake) { mThread = new InputThreadImpl(loop); mThread->run(mName.c_str(), ANDROID_PRIORITY_URGENT_DISPLAY); } |
注意 InputThread 可不是一个线程，InputThreadImpl 才是一个线程，如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
//InputThread.cpp class InputThreadImpl : public Thread { public: explicit InputThreadImpl(std::function<void()> loop) : Thread(/* canCallJava */ true), mThreadLoop(loop) {} ~InputThreadImpl() {} private: std::function<void()> mThreadLoop; bool threadLoop() override { mThreadLoop(); return true; } }; |
当线程启动后，会循环调用 threadLoop()，直到这个函数返回 false。从 InputThreadImpl 的定义可以看出，threadLoop() 会一直保持循环，并且每一次循环，会调用一次 mThreadLoop()，而函数 mThreadLoop 是由 InputReader 和 InputDispacher 在启动时传入
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
// InputReader.cpp status_t InputReader::start() { if (mThread) { return ALREADY_EXISTS; } // 线程启动后，循环调用 loopOnce() mThread = std::make_unique<InputThread>( "InputReader", [this]() { loopOnce(); }, [this]() { mEventHub->wake(); }); return OK; } // InputDispatcher.cpp status_t InputDispatcher::start() { if (mThread) { return ALREADY_EXISTS; } // 线程启动后，循环调用 dispatchOnce() mThread = std::make_unique<InputThread>( "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); }); return OK; } |
现在，我们可以明白，InputReader 启动时，会创建一个线程，然后循环调用 loopOnce() 函数，而 InputDispatcher 启动时，也会创建一个线程，然后循环调用 dispatchOnce()。
输入系统就绪
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
// InputManagerService.java public void systemRunning() { mNotificationManager = (NotificationManager)mContext.getSystemService( Context.NOTIFICATION_SERVICE); synchronized (mLidSwitchLock) { mSystemReady = true; // Send the initial lid switch state to any callback registered before the system was // ready. int switchState = getSwitchState(-1 /* deviceId */, InputDevice.SOURCE_ANY, SW_LID); for (int i = 0; i < mLidSwitchCallbacks.size(); i++) { LidSwitchCallback callback = mLidSwitchCallbacks.get(i); callback.notifyLidSwitchChanged(0 /* whenNanos */, switchState == KEY_STATE_UP); } } // 监听广播，通知底层加载键盘布局 IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED); filter.addAction(Intent.ACTION_PACKAGE_REMOVED); filter.addAction(Intent.ACTION_PACKAGE_CHANGED); filter.addAction(Intent.ACTION_PACKAGE_REPLACED); filter.addDataScheme("package"); mContext.registerReceiver(new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { updateKeyboardLayouts(); } }, filter, null, mHandler); // 监听广播，通知底层加载设备别名 filter = new IntentFilter(BluetoothDevice.ACTION_ALIAS_CHANGED); mContext.registerReceiver(new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { reloadDeviceAliases(); } }, filter, null, mHandler); // 直接通知一次底层加载键盘布局和加载设备别名 mHandler.sendEmptyMessage(MSG_RELOAD_DEVICE_ALIASES); mHandler.sendEmptyMessage(MSG_UPDATE_KEYBOARD_LAYOUTS); if (mWiredAccessoryCallbacks != null) { mWiredAccessoryCallbacks.systemReady(); } } private void reloadKeyboardLayouts() { nativeReloadKeyboardLayouts(mPtr); } private void reloadDeviceAliases() { nativeReloadDeviceAliases(mPtr); } |
无论是通知底层加载键盘布局，还是加载设备别名，其实都是让底层更新配置。与前面一样，更新配置的过程，留到后面分析。
结束
通过本文，我们能大致掌握输入系统的轮廓。后面，我们将逐步分析子模块 InputReader 和 InputDispatcher 的功能。
本文转自 https://juejin.cn/post/7161376731096432653，如有侵权，请联系删除。
