首页 > 资讯 > 移动开发 >Android开发InputManagerService创建与启动流程

711

分享到

Android开发InputManagerService创建与启动流程

Android InputManagerService Android InputManagerService 2022-11-13 19:11:28 711人浏览薄情痞子

摘要

目录前言启动流程创建输入系统启动输入系统输入系统就绪结束前言之前写过几篇关于输入系统的文章，但是还没有写完，后来由于工作的变动，这个事情就一直耽搁了。而现在，在工作中，遇到输入系统

前言

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

InputManagerService 系统文章，基于 Android 12 进行分析。

本文将以 IMS 简称 InputManagerService。

启动流程

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

// SystemServer.java
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
            // ..
    // 1. 创建
    inputManager = new InputManagerService(context);
    // 注册服务    
    ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
                     false, DUMP_FLAG_PRioRITY_CRITICAL);
    // 保存 wms 的回调
    inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
    // 2. 启动
    inputManager.start();    
    try {
        // 3. 就绪
        if (inputManagerF != null) {
            inputManagerF.systemRunning();
        }
    } catch (Throwable e) {
        reportWtf("Notifying InputManagerService running", e);
    }
    // ...
}

IMS 的启动流程分为三步

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

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

创建输入系统

// 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() 来初始化底层输入系统。

// com_android_server_input_InputManagerService.cpp
static jlong nativeInit(JNIEnv* env, jclass ,
        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 对象，然后返回给上层。

但是 NativeInputManager 并不是底层输入系统的服务，它只是一个连接上层输入系统和底层输入系统的桥梁而已。来看下它的创建过程

// 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 构造过程如下

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

原来，InputManager 才是底层输入系统的服务，而 NativeInputManagerService 通过 mServiceObj 保存了上层 InputManagerService 引用，并且上层 InputManagerService 通过 mPtr 指向底层的 NativeInputManager。因此，我们可以判定 NativeInputManager 就是一个连接上层与底层的桥梁。

我们注意到创建 InputManager 使用了两个 this 参数，这里介绍下 NativeInputManager 和 InputManager 的结构图

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

// 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 实现的。

InputManager 创建了三个模块，InputReader、InputClassifier、InputDispatcher。 InputReader 负责从 EventHub 中获取事件，然后把事件加工后，发送给 InputClassfier。InputClassifer 会把事件发送给 InputDispatcher，但是它会对触摸事件进行一个分类工作。最后 InputDispatcher 对进行事件分发。

那么现在我们可以大致推算下输入系统的关系图，如下

这个关系图很好的体现了设计模式的单一职责原则。

EventHub 其实只属于 InputReader，因此要想解剖整个输入系统，我们得逐一解剖 InputReader、InputClassifier、InputDispatcher。后面的一系列的文章将逐个来剖析。

启动输入系统

// 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.监听数据库，当值发生改变时，通过 native 层
        // 监听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. 从数据库获取值，并传递给 native 层
        updatePointerSpeedFromSettings();
        updateShowTouchesFromSettings();
        updateAccessibilityLargePointerFromSettings();
        updateDeepPressStatusFromSettings("just booted");
    }

输入系统的启动过程如下

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

第2步和第3步，本质上其实都是更新配置到底层，但是需要我们对 InputReader 的运行过程比较熟悉，因此这个配置更新过程，留到后面分析。

现在我们直接看下如何启动底层的输入系统

// com_android_server_input_InputManagerService.cpp
static void nativeStart(JNIEnv* env, jclass , 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 的桥梁作用，现在感受到了吗？

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 创建一个线程来执行任务。

//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 才是一个线程，如下

//InputThread.cpp
class InputThreadImpl : public Thread {
public:
    explicit InputThreadImpl(std::function<void()> loop)
          : Thread( true), mThreadLoop(loop) {}
    ~InputThreadImpl() {}
private:
    std::function<void()> mThreadLoop;
    bool threadLoop() override {
        mThreadLoop();
        return true;
    }
};

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

// 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()。

输入系统就绪

// 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 , InputDevice.SOURCE_ANY, SW_LID);
        for (int i = 0; i < mLidSwitchCallbacks.size(); i++) {
            LidSwitchCallback callback = mLidSwitchCallbacks.get(i);
            callback.notifyLidSwitchChanged(0 , 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 的功能。

以上就是Android开发InputManagerService创建与启动流程的详细内容，更多关于Android InputManagerService创建启动的资料请关注编程网其它相关文章！

--结束END--

本文标题: Android开发InputManagerService创建与启动流程

本文链接: https://lsjlt.com/news/170645.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

回答

如何调试操作系统的错误？
操作系统

2023-11-15发布

回答

操作系统中的I/O系统是如何实现的？
操作系统

2023-11-15发布

回答

如何实现操作系统的内存管理？
操作系统

2023-11-15发布

回答

什么是虚拟内存，它对操作系统有什么影响？
操作系统

2023-11-15发布

回答

ASP中的MVC架构和WebForms架构有什么区别和使用场景？
ASP.NET

2023-11-15发布

回答

ASP中的数据验证和数据校验有什么不同？
ASP.NET

2023-11-15发布

回答

ASP中的ADO对象和DAO对象有什么区别和使用方法？
ASP.NET

2023-11-15发布

回答

Node.js中的包管理器NPM是什么？如何使用它进行依赖管理？
node.js

2023-11-15发布

回答

Vue.js中的动态组件是什么？如何使用它来动态渲染组件？
VUE

2023-11-15发布

回答

如何使用Vue.js实现懒加载和预加载？
VUE

2023-11-15发布

Android开发InputManagerService创建与启动流程

目录

前言

启动流程

创建输入系统

启动输入系统

输入系统就绪

结束

Android开发InputManagerService创建与启动流程

Android开发App启动流程与消息机制详解

Android Activity启动流程一：从Intent到Activity创建

android Activity启动流程

Android开发基础之创建启动界面Splash Screen的方法

Android系统启动流程

Android 11 SystemUI 启动流程

SpringBoot 项目的创建与启动

Android zygote启动流程详解

Android Activity 启动流程二：setContentView

android启动流程是什么

Android Service启动流程刨析

Android Activity启动流程刨析

Android 12 S HIDL Service创建流程

详解Android Activity的启动流程

android launcher启动流程是什么

android activity启动流程是什么

Android 系统启动流分析 & Zygote启动流程分析

Android APP启动方式、启动流程及启动优化分析

Netty分布式server启动流程Nio创建源码分析

Mac清理软件cleanmymac x4.14.4破解版,2024年有免费cleanmymac x激活码

山东移动CM311-5-ZG_国科GK6323V100C_安卓4.4.2_免拆U盘卡刷刷机固件包

基于微信海南海口某健身房私教预约小程序系统设计与实现研究背景和意义、国内外现状

Android Studio常用快捷键、Android Studio快捷键大全

xcode15下载ios17模拟器失败

C51模拟CSGO的C4炸弹小程序

uniapp中video层级太高解决方案，适用安卓/IOS/H5

基于微信小程序化妆品商城系统设计与实现

Axios使用方法详解，从入门到进阶

微信小程序使用自定义tabbar 想要获取tabbar的高度,返回的结果是null,该如何获取?