Android开发InputManagerService创建与启动流程

目录
  • 前言
  • 启动流程
    • 创建输入系统
    • 启动输入系统
    • 输入系统就绪
  • 结束

前言

之前写过几篇关于输入系统的文章,但是还没有写完,后来由于工作的变动,这个事情就一直耽搁了。而现在,在工作中,遇到输入系统相关的事情也越来越多,其中有一个非常有意思的需求,因此是时候继续分析 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,
                    /* allowIsolated= */ 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 /* 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 对象,然后返回给上层。

但是 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 /* 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 的桥梁作用,现在感受到了吗?

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(/* canCallJava */ 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 /* 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 的功能。

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

(0)

相关推荐

  • 可定制react18 input otp 一次性密码输入组件

    目录 正文 主要特点 基本用法 1.安装和导入 2.将OtpInput组件添加到应用程序中 3.所有默认的道具 预览 正文 一个完全可定制的.用于React驱动的应用程序的一次性密码(OTP).电话号码和pin码输入组件. 主要特点 它在React和ionic应用程序上都很好用.在手机上也能正常工作. 你可以用inputNum道具只指定数字输入. 在网页和手机上与剪贴板粘贴功能完美配合. npm上唯一支持'enter'键提交的OTP输入包. 在Android上没有OTP粘贴问题. 在iOS ch

  • Input系统之InputReader概要性实例分析

    目录 InputReader 的创建 EventHub 创建过程如下 InputReader 的运行 EventHub 提供事件 InputReader 的创建 从 InputManagerService: 创建与启动 可知,Input 系统的主要功能,主要集中在 native 层,并且Input 系统的 native 层又包含 InputReader, InputClassifer, InputDispatcher 三个子模块.本文来分析 InputReader 从创建到启动的基本流程,为后续

  • iview-table组件嵌套input select数据无法双向绑定解决

    目录 一.前言 二.问题描述 三.解决办法 1.基础数据表格 2.树形数据表格 四.后记 一.前言 本篇主要介绍关于iview-ui组件库中的table表格组件嵌套input组件,数据无法及时更新问题的解决办法. 二.问题描述 在我们开发的过程中,经常会遇到需要在表格内操作数据的情况,但是在vue2中,双向绑定的值必须是在data中声明的变量,然而我们在table中展示的每一行数据,通常都是使用的scope中的row去获取的当前行数据,但是row却并没有在data中声明,这样就出现了,无法实现数

  • Android开发InputManagerService创建与启动流程

    目录 前言 启动流程 创建输入系统 启动输入系统 输入系统就绪 结束 前言 之前写过几篇关于输入系统的文章,但是还没有写完,后来由于工作的变动,这个事情就一直耽搁了.而现在,在工作中,遇到输入系统相关的事情也越来越多,其中有一个非常有意思的需求,因此是时候继续分析 InputManagerService. InputManagerService 系统文章,基于 Android 12 进行分析. 本文将以 IMS 简称 InputManagerService. 启动流程 InputManagerS

  • Android开发中简单设置启动界面的方法

    本文实例讲述了Android开发中简单设置启动界面的方法.分享给大家供大家参考,具体如下: 启动界面的意义是为了让后台处理耗时的复杂工作,当工作处理完成后,即可进入主界面.相比让用户等待布局加载完成,使用一张图片作为启动背景,会带来更好的体验. 首先,需要建立一个简单的布局: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas

  • Android开发之创建可点击的Button实现方法

    本文实例讲述了Android创建可点击的Button实现方法.分享给大家供大家参考,具体如下: 感觉到自己有必要学习下手机开发方面的知识,不论是为了以后的工作需求还是目前的公司项目. 当然,任何新东西的开始,必然伴随着第一个HelloWorld,Android学习也不例外.既然才开始,我就不做过多的描述了. 对于Android开发的IDE:ADT来说,打开的第一眼有点迷糊,不过看了网上各种目录结构的介绍,慢慢的就明白了,做这个实例,我们尤其需要关注两个地方,一个是src目录,一个就是res目录下

  • android开发教程之开机启动服务service示例

    个例子实现的功能是:1,安装程序后看的一个Activity程序界面,里面有个按钮,点击按钮就会启动一个Service服务,此时在设置程序管理里面会看的有个Activity和一个Service服务运行2,如果手机关机重启,会触发你的程序里面的Service服务,当然,手机启动后是看不到你的程序界面.好比手机里面自带的闹钟功能,手机重启看不到闹钟设置界面只是启动服务,时间到了,闹钟就好响铃提醒. 程序代码是: 首先要有一个用于开机启动的Activity,给你们的按钮设置OnClickListener

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

    本文实例讲述了Android开发基础之创建启动界面Splash Screen的方法.分享给大家供大家参考.具体如下: 启动界面Splash Screen在应用程序是很常用的,往往在启动界面中显示产品Logo.公司Logo或者开发者信息,如果应用程序启动时间比较长,那么启动界面就是一个很好的东西,可以让用户耐心等待这段枯燥的时间. Android 应用程序创建一个启动界面Splash Screen非常简单.比如创建一个工程MySample,主Acitity就叫MySample,创建另一个Activ

  • 安装android开发环境原始版(windows版)

    一.下载需要用到的工具:(1)下载JAVA的IDE开发工具– Eclipse到Eclipse官方网站下载Ecplise For Java EE的最新Windows版本(2)下载Java开发包 - Java SE Development Kit (JDK) JDK 6到Sun官方网站下载JDK6,选择JDK 6 Update 12(3)下载Android开发包 - Android SDK到Google的官方网站下载Android的开发包For Windows的 二.下载完需要的工具之后,开始安装(

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

    目录 引言 1.第一步了解 ThreadLocal 2.App的启动流程 3.Activity中创建Handler 引言 相信很多人对这个问题不陌生,但是大家回答的都比较简单,如谈到app启动流程有人就会是app的生命周期去了,谈到消息机制有人就会说looper循环消息进行分发,如果是面试可能面试官不会满意,今天我们搞一篇完善的源码解析来进行阐述上面的问题 1.第一步了解 ThreadLocal 什么是ThreadLocal呢,专业的来讲,ThreadLocal 是一个线程内部的数据存储类,通过

  • 一文带你看懂Android Application启动流程是怎样的

    基于Android11-API30 总览 获取applicationThread,AMS这两个Binder2.attach时,将获取applicationThread对象也传递到AMS进程,请求远程调用通知AMS应用进程想要创建Application,此时AMS为服务端 AMS收到消息,请求调用applicationThread的远程接口,此时AMS为客户端 applicationThread收到AMS的请求,通过Handler发起创建Application的处理任务,后面就没有远程接口调用了

  • 用Eclipse搭建Android开发环境并创建第一个Android项目(eclipse+android sdk)

    一.搭建Android开发环境 准备工作:下载Eclipse.JDK.Android SDK.ADT插件 1.安装和配置JAVA开发环境:  ①把准备好的Eclipse和JDK安装到本机上(最好安装在全英文路径下),并给JDK配置环境变量,其中JDK的变量值为JDK安装路径的根目录,如我的为:D:\Program Files\Java\jdk1.7.0_02: ②打开命令提示符(cmd),输入java -version命令,显示如下图则说明JAVA环境变量已经配置好了. 2.安装ADT插件: ①

  • android开发环境遇到adt无法启动的问题分析及解决方法

    开始研究android开发,搭建开发环境的时候就出了问题--果然是好事多磨~ 安装了jdk,配置环境变量,安装了完整版的adt.创建了helloworld程序,启动的时候就报错 "Please ensure that adb is correctly located at 'D:\adt-bundle-windows-x86_64\sdk\platform-tools\adb.exe' and can be executed." 网上查了大量的资料,群里问了很多人,都说是配置环境有问题

随机推荐

其他