1. 首页
  2. 文章中心
  3. Android

PowerManagerService启动-Android12PowerManagerService启动-Android12

66 阅读 0 评论
我是靠谱客的博主 繁荣白云，这篇文章主要介绍PowerManagerService启动-Android12PowerManagerService启动-Android12，现在分享给大家，希望可以做个参考。

PowerManagerService启动-Android12

android12-release

1. 在SystemServer的startBootstrapServices中启动

  • mSystemServiceManager.startService(PowerManagerService.class)先调用CameraServiceProxy构造方法constructor.newInstance(mContext)，在调用CameraServiceProxy的service.onStart()方法
  • mPowerManagerService.systemReady() 获取各类本地服务、远程服务以及相关联的功能类；注册SettingsObserver监听 等。

frameworks/base/services/java/com/android/server/SystemServer.java

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
	// ... ...
    t.traceBegin("StartPowerManager");
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
    t.traceEnd();
    // ... ...
}

private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
	// ... ...
    t.traceBegin("MakePowerManagerServiceReady");
    try {
        // TODO: use boot phase
        mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
    } catch (Throwable e) {
        reportWtf("making Power Manager Service ready", e);
    }
    t.traceEnd();
    // ... ...
}

2. PowerManagerService初始化并调用onStart()方法

2.1 初始化

  • mBinderService = new BinderService()作为Binder IPC的服务端
  • mLocalService = new LocalService()为同进程的其它模块提供支持
  • mNativeWrapper = injector.createNativeWrapper()是对调用native方法提供的一层包装
  • 了解Native层：
    mNativeWrapper.nativeInit(this); native方法初始化并连接HAL层PowerHalController.init()
    mNativeWrapper.nativeSetAutoSuspend(false); 关闭自动休眠
    mNativeWrapper.nativeSetPowerMode(Mode.INTERACTIVE, true); 保持屏幕点亮
    mNativeWrapper.nativeSetPowerMode(Mode.DOUBLE_TAP_TO_WAKE, false); 禁用双击屏幕唤醒系统的功能

frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java

复制代码
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
PowerManagerService(Context context, Injector injector) {
    super(context);

    mContext = context;
    mBinderService = new BinderService();
    mLocalService = new LocalService();
    mNativeWrapper = injector.createNativeWrapper();
    mSystemProperties = injector.createSystemPropertiesWrapper();
    mClock = injector.createClock();
    mInjector = injector;

    mHandlerThread = new ServiceThread(TAG,
            Process.THREAD_PRIORITY_DISPLAY, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = injector.createHandler(mHandlerThread.getLooper(),
            new PowerManagerHandlerCallback());
    mConstants = new Constants(mHandler);
    mAmbientDisplayConfiguration = mInjector.createAmbientDisplayConfiguration(context);
    mAmbientDisplaySuppressionController =
            mInjector.createAmbientDisplaySuppressionController(context);
    mAttentionDetector = new AttentionDetector(this::onUserAttention, mLock);
    mFaceDownDetector = new FaceDownDetector(this::onFlip);

    mBatterySavingStats = new BatterySavingStats(mLock);
    mBatterySaverPolicy =
            mInjector.createBatterySaverPolicy(mLock, mContext, mBatterySavingStats);
    mBatterySaverController = mInjector.createBatterySaverController(mLock, mContext,
            mBatterySaverPolicy, mBatterySavingStats);
    mBatterySaverStateMachine = mInjector.createBatterySaverStateMachine(mLock, mContext,
            mBatterySaverController);

    mInattentiveSleepWarningOverlayController =
            mInjector.createInattentiveSleepWarningController();

    // Save brightness values:
    // Get float values from config.
    // Store float if valid
    // Otherwise, get int values and convert to float and then store.
    final float min = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingMinimumFloat);
    final float max = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingMaximumFloat);
    final float def = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingDefaultFloat);
    final float doze = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessDozeFloat);
    final float dim = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessDimFloat);

    if (min == INVALID_BRIGHTNESS_IN_CONFIG || max == INVALID_BRIGHTNESS_IN_CONFIG
            || def == INVALID_BRIGHTNESS_IN_CONFIG) {
        mScreenBrightnessMinimum = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessSettingMinimum));
        mScreenBrightnessMaximum = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessSettingMaximum));
        mScreenBrightnessDefault = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessSettingDefault));
    } else {
        mScreenBrightnessMinimum = min;
        mScreenBrightnessMaximum = max;
        mScreenBrightnessDefault = def;
    }
    if (doze == INVALID_BRIGHTNESS_IN_CONFIG) {
        mScreenBrightnessDoze = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessDoze));
    } else {
        mScreenBrightnessDoze = doze;
    }
    if (dim == INVALID_BRIGHTNESS_IN_CONFIG) {
        mScreenBrightnessDim = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessDim));
    } else {
        mScreenBrightnessDim = dim;
    }

    final float vrMin = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingForVrMinimumFloat);
    final float vrMax = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingForVrMaximumFloat);
    final float vrDef = mContext.getResources().getFloat(com.android.internal.R.dimen
            .config_screenBrightnessSettingForVrDefaultFloat);
    if (vrMin == INVALID_BRIGHTNESS_IN_CONFIG || vrMax == INVALID_BRIGHTNESS_IN_CONFIG
            || vrDef == INVALID_BRIGHTNESS_IN_CONFIG) {
        mScreenBrightnessMinimumVr = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessForVrSettingMinimum));
        mScreenBrightnessMaximumVr = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessForVrSettingMaximum));
        mScreenBrightnessDefaultVr = BrightnessSynchronizer.brightnessIntToFloat(
                mContext.getResources().getInteger(com.android.internal.R.integer
                        .config_screenBrightnessForVrSettingDefault));
    } else {
        mScreenBrightnessMinimumVr = vrMin;
        mScreenBrightnessMaximumVr = vrMax;
        mScreenBrightnessDefaultVr = vrDef;
    }

    synchronized (mLock) {
        mWakeLockSuspendBlocker =
                mInjector.createSuspendBlocker(this, "PowerManagerService.WakeLocks");
        mDisplaySuspendBlocker =
                mInjector.createSuspendBlocker(this, "PowerManagerService.Display");
        if (mDisplaySuspendBlocker != null) {
            mDisplaySuspendBlocker.acquire();
            mHoldingDisplaySuspendBlocker = true;
        }
        mHalAutoSuspendModeEnabled = false;
        mHalInteractiveModeEnabled = true;

        mWakefulnessRaw = WAKEFULNESS_AWAKE;
        sQuiescent = mSystemProperties.get(SYSTEM_PROPERTY_QUIESCENT, "0").equals("1")
                || InitProperties.userspace_reboot_in_progress().orElse(false);

        mNativeWrapper.nativeInit(this);
        mNativeWrapper.nativeSetAutoSuspend(false);
        mNativeWrapper.nativeSetPowerMode(Mode.INTERACTIVE, true);
        mNativeWrapper.nativeSetPowerMode(Mode.DOUBLE_TAP_TO_WAKE, false);
        mInjector.invalidateIsInteractiveCaches();
    }
}

2.2 onStart()方法

  • publishBinderService() 添加名为POWER_SERVICE = "power"的Binder IPC的服务端
  • publishLocalService(PowerManagerInternal.class, mLocalService) 添加到LocalServices，为同进程的其它模块提供支持
复制代码
1
2
3
4
5
6
7
8
9
public void onStart() {
    publishBinderService(Context.POWER_SERVICE, mBinderService, /* allowIsolated= */ false,
            DUMP_FLAG_PRIORITY_DEFAULT | DUMP_FLAG_PRIORITY_CRITICAL);
    publishLocalService(PowerManagerInternal.class, mLocalService);

    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

3. PowerManagerService.systemReady

  1. 获取各类本地服务、远程服务以及相关联的功能类，如屏保(DreamManagerInternal)、窗口(WindowManagerPolicy)、电池状态监听服务(BatteryManagerInternal)、屏显服务(DisplayManagerInternal)、背光服务（LightsManager）、无线充电（WirelessChargerDetector)等
  2. mSettingsObserver = new SettingsObserver(mHandler) 注册SettingsObserver监听，监听Settings中的值的变化
  3. readConfigurationLocked()读取配置文件中的默认值，如 插拔USB是否亮屏 、是否支持屏保 、充电和睡眠时屏保是否激活 、是否支持双击唤醒屏幕 等等
  4. updateSettingsLocked() 查询Settings中配置的值，如 是否打开屏保、休眠时是否启用屏保、设备在一段时间不活动后进入休眠或者屏保状态的时间等待
  5. 注册广播接收者，监听特定的广播事件，如 电池状态的改变mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler) 、进入屏保mContext.registerReceiver(new DreamReceiver(), filter, null, mHandler)、切换用户mContext.registerReceiver(new UserSwitchedReceiver(), filter, null, mHandler)、设备物理插槽状态的改变（通常用于监听是否接入了有线充电器）mContext.registerReceiver(new DockReceiver(), filter, null, mHandler)
复制代码
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
public void systemReady(IAppOpsService appOps) {
    synchronized (mLock) {
        mSystemReady = true;
        mAppOps = appOps;
        mDreamManager = getLocalService(DreamManagerInternal.class);
        mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class);
        mPolicy = getLocalService(WindowManagerPolicy.class);
        mBatteryManagerInternal = getLocalService(BatteryManagerInternal.class);
        mAttentionDetector.systemReady(mContext);
        mDisplayGroupPowerStateMapper = mInjector.createDisplayPowerRequestMapper(mLock,
                mDisplayManagerInternal, new DisplayGroupPowerChangeListener());

        SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper());

        // The notifier runs on the system server's main looper so as not to interfere
        // with the animations and other critical functions of the power manager.
        mBatteryStats = BatteryStatsService.getService();
        mNotifier = mInjector.createNotifier(Looper.getMainLooper(), mContext, mBatteryStats,
                mInjector.createSuspendBlocker(this, "PowerManagerService.Broadcasts"),
                mPolicy, mFaceDownDetector);

        mWirelessChargerDetector = mInjector.createWirelessChargerDetector(sensorManager,
                mInjector.createSuspendBlocker(
                        this, "PowerManagerService.WirelessChargerDetector"),
                mHandler);
        mSettingsObserver = new SettingsObserver(mHandler);

        mLightsManager = getLocalService(LightsManager.class);
        mAttentionLight = mLightsManager.getLight(LightsManager.LIGHT_ID_ATTENTION);

        // Initialize display power management.
        mDisplayManagerInternal.initPowerManagement(
                mDisplayPowerCallbacks, mHandler, sensorManager);

        try {
            final ForegroundProfileObserver observer = new ForegroundProfileObserver();
            ActivityManager.getService().registerUserSwitchObserver(observer, TAG);
        } catch (RemoteException e) {
            // Shouldn't happen since in-process.
        }

        // Go.
        readConfigurationLocked();
        updateSettingsLocked();
        mDirty |= DIRTY_BATTERY_STATE;
        updatePowerStateLocked();
    }

    final ContentResolver resolver = mContext.getContentResolver();
    mConstants.start(resolver);

    mBatterySaverController.systemReady();
    mBatterySaverPolicy.systemReady();
    mFaceDownDetector.systemReady(mContext);

    // Register for settings changes.
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.SCREENSAVER_ENABLED),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.System.getUriFor(
            Settings.System.SCREEN_OFF_TIMEOUT),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.SLEEP_TIMEOUT),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.ATTENTIVE_TIMEOUT),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Global.getUriFor(
            Settings.Global.STAY_ON_WHILE_PLUGGED_IN),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.System.getUriFor(
            Settings.System.SCREEN_BRIGHTNESS_MODE),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.System.getUriFor(
            Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Global.getUriFor(
            Settings.Global.THEATER_MODE_ON),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.DOZE_ALWAYS_ON),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Secure.getUriFor(
            Settings.Secure.DOUBLE_TAP_TO_WAKE),
            false, mSettingsObserver, UserHandle.USER_ALL);
    resolver.registerContentObserver(Settings.Global.getUriFor(
            Settings.Global.DEVICE_DEMO_MODE),
            false, mSettingsObserver, UserHandle.USER_SYSTEM);
    IVrManager vrManager = IVrManager.Stub.asInterface(getBinderService(Context.VR_SERVICE));
    if (vrManager != null) {
        try {
            vrManager.registerListener(mVrStateCallbacks);
        } catch (RemoteException e) {
            Slog.e(TAG, "Failed to register VR mode state listener: " + e);
        }
    }

    // Register for broadcasts from other components of the system.
    IntentFilter filter = new IntentFilter();
    filter.addAction(Intent.ACTION_BATTERY_CHANGED);
    filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
    mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler);

    filter = new IntentFilter();
    filter.addAction(Intent.ACTION_DREAMING_STARTED);
    filter.addAction(Intent.ACTION_DREAMING_STOPPED);
    mContext.registerReceiver(new DreamReceiver(), filter, null, mHandler);

    filter = new IntentFilter();
    filter.addAction(Intent.ACTION_USER_SWITCHED);
    mContext.registerReceiver(new UserSwitchedReceiver(), filter, null, mHandler);

    filter = new IntentFilter();
    filter.addAction(Intent.ACTION_DOCK_EVENT);
    mContext.registerReceiver(new DockReceiver(), filter, null, mHandler);
}

4. PowerManagerService.onBootPhase

  • SystemServiceManager.startBootPhase()触发SystemService.PHASE_THIRD_PARTY_APPS_CAN_START、SystemService.PHASE_BOOT_COMPLETED最终此方法会调用到PowerManagerService的onBootPhase方法
  • PHASE_THIRD_PARTY_APPS_CAN_START 阶段incrementBootCount()开机启动次数+1
  • updatePowerStateLocked()负责更新电源状态信息：基础状态的更新、更新唤醒状态、锁定处于非活动状态的配置文件、异步更新显示电源状态、更新屏保状态、通知唤醒状态改变的事件给其他的观察者，比如 WindowManagerPolicy、更新锁状态

frameworks/base/services/java/com/android/server/SystemServer.java

复制代码
1
2
3
4
5
6
7
8
9
10
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
    // ... ...
    mActivityManagerService.systemReady(() -> {
        // ... ...
        mSystemServiceManager.startBootPhase(t, SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
        // ... ...
    }, t);
    // ... ...
}

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

复制代码
1
2
3
4
5
6
7
8
9
10
11
final void finishBooting() {
    // ... ...
    // Let the ART runtime in zygote and system_server know that the boot completed.
    ZYGOTE_PROCESS.bootCompleted();
    VMRuntime.bootCompleted();
    // ... ...
    // Let system services know.
    mSystemServiceManager.startBootPhase(t, SystemService.PHASE_BOOT_COMPLETED);
    // ... ...
}

frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java

复制代码
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
    public void onBootPhase(int phase) {
        synchronized (mLock) {
            if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
                incrementBootCount();

            } else if (phase == PHASE_BOOT_COMPLETED) {
                final long now = mClock.uptimeMillis();
                mBootCompleted = true;
                mDirty |= DIRTY_BOOT_COMPLETED;

                mBatterySaverStateMachine.onBootCompleted();
                userActivityNoUpdateLocked(
                        now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID);

                updatePowerStateLocked();
                if (sQuiescent) {
                    sleepDisplayGroupNoUpdateLocked(Display.DEFAULT_DISPLAY_GROUP,
                            mClock.uptimeMillis(),
                            PowerManager.GO_TO_SLEEP_REASON_QUIESCENT,
                            PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE, Process.SYSTEM_UID);
                }
            }
        }
    }

5. 简要时序图

在这里插入图片描述

最后

以上就是繁荣白云最近收集整理的关于PowerManagerService启动-Android12PowerManagerService启动-Android12的全部内容，更多相关PowerManagerService启动-Android12PowerManagerService启动-Android12内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(44)

相关文章

Android环境搭建
Android环境搭建
Android 系统启动流分析 & Zygote启动流程分析
Android 系统启动流分析 & Zygote启动流程分析
Android 5.1 ActivityManagerService启动
Android 5.1 ActivityManagerService启动
Android 系统服务的两种注册方式前言一、ServiceManager.addService 方式二、mSystemServiceManager.startService 方式总结
Android 系统服务的两种注册方式前言一、ServiceManager.addService 方式二、mSystemServiceManager.startService 方式总结
PowerManagerService启动-Android12PowerManagerService启动-Android12
PowerManagerService启动-Android12PowerManagerService启动-Android12
android 5.1 如何添加一个系统serviceIntro:Pre:HW:The HAL:The JNI Layer:The ServiceThe ManagerRegistering service and ManagerDeploy and testing
android 5.1 如何添加一个系统serviceIntro:Pre:HW:The HAL:The JNI Layer:The ServiceThe ManagerRegistering service and ManagerDeploy and testing
Android5.1--PowerManagerService电源管理 系统电源管理简介 电源管理服务--PowerManagerService 三、控制系统的休眠机制
Android5.1--PowerManagerService电源管理 系统电源管理简介 电源管理服务--PowerManagerService 三、控制系统的休眠机制
Android5.1 PowerManagerService深入分析
Android5.1 PowerManagerService深入分析

评论列表共有 0 条评论

立即
投稿
返回
顶部