devbox
思考机器2
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android P 屏保和休眠相关知识

作者：思考机器2 | 2024-01-29 23:54:22

赞

踩

Android P 屏保和休眠相关知识

Android P添加屏保功能，如果休眠时间设定大于屏保时间，则先进入屏保，达到休眠时间后再进入休眠

需求：

  1. 添加屏幕互保开关，默认关闭。
  2. 只保留时钟，可设定指针和数字、夜间模式。
  3. 启用时间改多长时间无操作进入屏保，可设定1、5、10、15、30分钟。
  4. 如果休眠时间设定小于屏保时间，则优先进入休眠，如果休眠时间设定大于屏保时间，则先进入屏保，达到休眠时间后再进入休眠

修改后的屏保：

 

 分析与实现：

1.修改进入屏保的条件

由于Android原生系统默认进入屏保的条件是充电或插入基座时，但到达休眠时才进入屏保。所以需要把进入屏保的条件修改为任何时候都能进入。

  1. frameworks\base\core\res\res\values\config.xml
  2. 把"config_dreamsEnabledOnBattery"修改为true即实现任何时候都能进入屏保
  3.  
  4. <!-- Are we allowed to dream while not plugged in? -->
  5.     <bool name="config_dreamsEnabledOnBattery">true</bool>

2.在设置–>显示–>屏保中添加“屏幕互保”选项开关

2.1添加系统自定义全局变量，用来保存“屏幕互保”选项开关的状态值

  1. frameworks/base/core/java/android/provider/Settings.java
  2.  
  3. +        /** @hide */
  4. +        public static final String SCREENSAVER_SWITCH= "seewo.screensavers.switch";
  5. public static final class Secure extends NameValueTable {
  6. /** @hide */
  7. public static final String SCREENSAVER_TIMEOUT= “seewo.screensavers.timeout”;

2.2 vendor/mediatek/proprietary/packages/apps/MtkSettings/res/values-zh-rCN/strings.xml

<string name="screensaver_switch_title">屏幕互保</string>

2.3 vendor/mediatek/proprietary/packages/apps/MtkSettings/res/xml/dream_fragment_overview.xml

  1. <PreferenceScreen
  2.      xmlns:android="http://schemas.android.com/apk/res/android"
  3. +    xmlns:settings="http://schemas.android.com/apk/res-auto"
  4.      android:key="dream_overview_screen"
  5. <SwitchPreference
  6.         android:key="screensaver_switch"
  7.         android:title="@string/screensaver_switch_title"/>

2.4添加vendor/mediatek/proprietary/packages/apps/MtkSettings/src/com/android/settings/dream/ScreenSaverSwitchPreferenceController.java文件

  1. /*
  2.  * Copyright (C) 2017 The Android Open Source Project
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of the License at
  6.  *
  7.  *      http://www.apache.org/licenses/LICENSE-2.0
  8.  *
  9.  * Unless required by applicable law or agreed to in writing, software distributed under the
  10.  * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  11.  * KIND, either express or implied. See the License for the specific language governing
  12.  * permissions and limitations under the License.
  13.  */
  14. package com.android.settings.dream;
  15.  
  16. import static android.provider.Settings.Secure.SCREENSAVER_SWITCH;
  17.  
  18. import android.content.Context;
  19. import android.provider.Settings;
  20. import android.support.v14.preference.SwitchPreference;
  21. import android.support.v7.preference.Preference;
  22.  
  23. import com.android.settings.R;
  24. import com.android.settings.core.PreferenceControllerMixin;
  25. import com.android.settingslib.core.AbstractPreferenceController;
  26.  
  27. public class ScreenSaverSwitchPreferenceController extends AbstractPreferenceController
  28.         implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
  29.  
  30.     private static final String KEY_SCREENSAVER_SWITCH_NAME = "screensaver_switch";
  31.  
  32.     public ScreenSaverSwitchPreferenceController(Context context) {
  33.         super(context);
  34.     }
  35.  
  36.     @Override
  37.     public boolean isAvailable() {
  38.         return true;
  39.     }
  40.  
  41.     @Override
  42.     public String getPreferenceKey() {
  43.         return KEY_SCREENSAVER_SWITCH_NAME;
  44.     }
  45.  
  46.     @Override
  47.     public boolean onPreferenceChange(Preference preference, Object newValue) {
  48.         boolean value = (Boolean) newValue;
  49.         Settings.Secure.putInt(mContext.getContentResolver(),
  50.                 KEY_SCREENSAVER_SWITCH_NAME, value ? 1 : 0);
  51.         if (value) {
  52.             Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.SCREENSAVER_SWITCH,
  53.                     1);
  54.         } else {
  55.             Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.SCREENSAVER_SWITCH,
  56.                     0);
  57.         }
  58.         return true;
  59.     }
  60.  
  61.     @Override
  62.     public void updateState(Preference preference) {
  63.         int value = Settings.Secure.getInt(mContext.getContentResolver(),
  64.                 KEY_SCREENSAVER_SWITCH_NAME, 0);
  65.         ((SwitchPreference) preference).setChecked(value == 1);
  66.     }
  67. }
  68.

2.5 vendor/mediatek/proprietary/packages/apps/MtkSettings/src/com/android/settings/dream/DreamSettings.java

  1. @@ -132,6 +132,7 @@ public class DreamSettings extends DashboardFragment {
  2.          controllers.add(new StartNowPreferenceController(context));
  3. +        controllers.add(new ScreenSaverSwitchPreferenceController(context));
  4.          return controllers;
  5.

3.隐藏“启动时间”

  1. --- a/vendor/mediatek/proprietary/packages/apps/MtkSettings/src/com/android/settings/dream/StartNowPreferenceController.java
  2. +++ b/vendor/mediatek/proprietary/packages/apps/MtkSettings/src/com/android/settings/dream/StartNowPreferenceController.java
  3. @@ -40,7 +40,7 @@ public class StartNowPreferenceController extends AbstractPreferenceController i
  4.  
  5.      @Override
  6.      public boolean isAvailable() {
  7. -        return true;
  8. +        return false;
  9.      }
  10.

4.添加选择无操作多少分钟后进入屏保的ListPreference

4.1添加系统自定义全局变量，用来保存无操作多少分钟后进入屏保的时间。
frameworks/base/core/java/android/provider/Settings.java

  1.  public static final class Secure extends NameValueTable {
  2. 		 /** @hide */
  3.         public static final String SCREENSAVER_TIMEOUT= "seewo.screensavers.timeout";

4.2设置–>显示–>屏保中添加ListPreference
vendor/mediatek/proprietary/packages/apps/MtkSettings/res/xml/dream_fragment_overview.xml

  1. +    <ListPreference
  2. +        android:key="screensaver_timeout"
  3. +        android:title="@string/screensaver_timeout"
  4. +        android:entries="@array/screensaver_timeout_entries"
  5. +        android:entryValues="@array/screensaver_timeout_values"
  6. +        settings:controller="com.android.settings.dream.ScreenSaverTimeoutPreferenceController" />

vendor/mediatek/proprietary/packages/apps/MtkSettings/res/values/arrays.xml

  1. +    <!--  Titles for screensaver preference. -->
  2. +    <string-array name="screensaver_timeout_entries" >
  3. +        <item>@string/screensaver_timeout_1min</item>
  4. +        <item>@string/screensaver_timeout_5mins</item>
  5. +        <item>@string/screensaver_timeout_10mins</item>
  6. +        <item>@string/screensaver_timeout_15mins</item>
  7. +        <item>@string/screensaver_timeout_30mins</item>
  8. +    </string-array>
  9. +
  10. +    <!--  Values for screensaver preference. -->
  11. +    <string-array name="screensaver_timeout_values" translatable="false" >
  12. +        <item>60000</item>
  13. +        <item>300000</item>
  14. +        <item>600000</item>
  15. +        <item>900000</item>
  16. +        <item>1800000</item>
  17. +    </string-array>

vendor/mediatek/proprietary/packages/apps/MtkSettings/res/values-zh-rCN/strings.xml

  1. +    <string name="screensaver_timeout">屏保</string>
  2. +    <string name="screensaver_timeout_1min">1 分钟</string>
  3. +    <string name="screensaver_timeout_5mins">5 分钟</string>
  4. +    <string name="screensaver_timeout_10mins">10 分钟</string>
  5. +    <string name="screensaver_timeout_15mins">15 分钟</string>
  6. +    <string name="screensaver_timeout_30mins">30 分钟</string>
  7. +    <string name="screensaver_timeout_summary">"无操作<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>后"</string>
  8. +    <string name="screensaver_switch_title">屏幕互保</string>

4.3添加vendor\mediatek\proprietary\packages\apps\MtkSettings\src\com\android\settings\dream\ScreenSaverTimeoutPreferenceController.java

  1. /*
  2.  * Copyright (C) 2018 The Android Open Source Project
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License
  15.  */
  16.  
  17. package com.android.settings.dream;
  18.  
  19. import static android.provider.Settings.Secure.SCREENSAVER_TIMEOUT;
  20.  
  21. import android.content.Context;
  22. import android.provider.Settings;
  23. import android.support.v7.preference.ListPreference;
  24. import android.support.v7.preference.Preference;
  25. import android.support.v7.preference.PreferenceScreen;
  26. import android.util.FeatureFlagUtils;
  27. import com.android.settings.R;
  28. import com.android.settings.core.BasePreferenceController;
  29. import com.android.settings.core.PreferenceControllerMixin;
  30. import com.android.settingslib.core.AbstractPreferenceController;
  31. /**
  32.  * Setting where user can pick if SystemUI will be light, dark or try to match
  33.  * the wallpaper colors.
  34.  */
  35. public class ScreenSaverTimeoutPreferenceController extends BasePreferenceController
  36.         implements Preference.OnPreferenceChangeListener {
  37.  
  38.     private ListPreference mScreenSaverTimeoutPref;
  39.  
  40.     public ScreenSaverTimeoutPreferenceController(Context context, String preferenceKey) {
  41.         super(context, preferenceKey);
  42.     }
  43.  
  44.     @Override
  45.     public int getAvailabilityStatus() {
  46.         return AVAILABLE;
  47.     }
  48.  
  49.     @Override
  50.     public void displayPreference(PreferenceScreen screen) {
  51.         super.displayPreference(screen);
  52.         mScreenSaverTimeoutPref = (ListPreference) screen.findPreference(getPreferenceKey());
  53.         int value = Settings.Secure.getInt(mContext.getContentResolver(), SCREENSAVER_TIMEOUT, 60000);
  54.         mScreenSaverTimeoutPref.setValue(Integer.toString(value));
  55.     }
  56.  
  57.     @Override
  58.     public boolean onPreferenceChange(Preference preference, Object newValue) {
  59.         int value = Integer.parseInt((String) newValue);
  60.         Settings.Secure.putInt(mContext.getContentResolver(), SCREENSAVER_TIMEOUT, value);
  61.         refreshSummary(preference);
  62.         return true;
  63.     }
  64.  
  65.     @Override
  66.     public CharSequence getSummary() {
  67.         int value = Settings.Secure.getInt(mContext.getContentResolver(), SCREENSAVER_TIMEOUT, 60000);
  68.         int index = mScreenSaverTimeoutPref.findIndexOfValue(Integer.toString(value));
  69.         
  70.         return mContext.getString(R.string.screensaver_timeout_summary, mScreenSaverTimeoutPref.getEntries()[index]);
  71.     }
  72. }
  73.

5.屏保默认为原生时钟，移除“万花筒”

5.1 原生屏保默认是使用Google GMS中的时钟，因此修改为默认使用原生的时钟。
frameworks/base/core/res/res/values/config.xml

  1. -    <string name="config_dreamsDefaultComponent" translatable="false">com.google.android.deskclock/com.android.deskclock.Screensaver</string>
  2. +    <string name="config_dreamsDefaultComponent" translatable="false">com.android.deskclock/com.android.deskclock.Screensaver</string>

5.2移除“万花筒”
vendor/mediatek/proprietary/packages/apps/SettingsLib/src/com/android/settingslib/dream/DreamBackend.java

  1.      public List<DreamInfo> getDreamInfos() {
  2.          logd("getDreamInfos()");
  3. +        String componentName;//del basic.Colors
  4.          ComponentName activeDream = getActiveDream();
  5.          PackageManager pm = mContext.getPackageManager();
  6.          Intent dreamIntent = new Intent(DreamService.SERVICE_INTERFACE);
  7. @@ -124,6 +125,12 @@ public class DreamBackend {
  8.              dreamInfo.caption = resolveInfo.loadLabel(pm);
  9.              dreamInfo.icon = resolveInfo.loadIcon(pm);
  10.              dreamInfo.componentName = getDreamComponentName(resolveInfo);
  11. +            componentName = dreamInfo.componentName.toString();
  12. +            if(componentName.contains("com.android.dreams.basic.Colors")){
  13. +                continue;
  14. +            }
  15.              dreamInfo.isActive = dreamInfo.componentName.equals(activeDream);

6.定制屏保时间

如果休眠时间设定小于屏保时间，则优先进入休眠，如果休眠时间设定大于屏保时间，则先进入屏保，达到休眠时间后再进入休眠的实现
frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java

6.1修改进入屏保的条件由Setting中的“屏幕互保”选项的开或关来决定

  1.  private boolean updateWakefulnessLocked(int dirty) {
  2.         boolean changed = false;
  3.         if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED
  4.                 | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE
  5.                 | DIRTY_DOCK_STATE)) != 0) {
  6.             if (mWakefulness == WAKEFULNESS_AWAKE && isItBedTimeYetLocked()) {
  7.                 if (DEBUG_SPEW) {
  8.                     Slog.d(TAG, "updateWakefulnessLocked: Bed time...");
  9.                 }
  10.                 final long time = SystemClock.uptimeMillis();
  11.                 if (shouldNapAtBedTimeLocked()) {//此处为进入屏保的条件
  12.                     changed = napNoUpdateLocked(time, Process.SYSTEM_UID);
  13.                 } else {
  14.                     changed = goToSleepNoUpdateLocked(time,
  15.                             PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID);
  16.                 }
  17.             }
  18.         }
  19.         return changed;
  20.     }

shouldNapAtBedTimeLocked()为进入屏保的条件，所以需要修改shouldNapAtBedTimeLocked()的返回值。

  1.     private boolean shouldNapAtBedTimeLocked() {
  2. -        return mDreamsActivateOnSleepSetting
  3. -                || (mDreamsActivateOnDockSetting
  4. -                        && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED);
  5. +        return Settings.Secure.getInt(mContext.getContentResolver(),Settings.Secure.SCREENSAVER_SWITCH,0) == 1;
  6. +        //return mDreamsActivateOnSleepSetting
  7. +        //        || (mDreamsActivateOnDockSetting
  8. +        //                && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED);
  9.  
  10.      }

Settings.Secure.getInt(mContext.getContentResolver(),Settings.Secure.SCREENSAVER_SWITCH,0)是获取“屏幕互保”的状态值，1表示打开，0表示关闭。

6.2修改取决于什么时候进入屏保的逻辑。

  1.  private void updateUserActivitySummaryLocked(long now, int dirty) {
  2.         // Update the status of the user activity timeout timer.
  3.         if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY
  4.                 | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) {
  5.             mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);
  6.  
  7.             long nextTimeout = 0;
  8.             long screenSaverNextTimeout = 0;//添加计算下次进入屏保的时间
  9.             boolean isScreenSaverEnabled = Settings.Secure.getInt(mContext.getContentResolver(),Settings.Secure.SCREENSAVER_SWITCH,0) == 1;//获取“屏幕互保”是否打开
  10.             if (mWakefulness == WAKEFULNESS_AWAKE
  11.                     || mWakefulness == WAKEFULNESS_DREAMING
  12.                     || mWakefulness == WAKEFULNESS_DOZING) {
  13.                 final long sleepTimeout = getSleepTimeoutLocked();
  14.                 final long screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout);//无操作多少分钟后进入休眠的时间
  15.                 final long screenDimDuration = getScreenDimDurationLocked(screenOffTimeout);
  16.                 final boolean userInactiveOverride = mUserInactiveOverrideFromWindowManager;
  17.                 final long nextProfileTimeout = getNextProfileTimeoutLocked(now);
  18.                 final long screenSaverTimeout = Settings.Secure.getInt(mContext.getContentResolver(),Settings.Secure.SCREENSAVER_TIMEOUT,60000);//无操作多少分钟后进入屏保的时间
  19.                 mUserActivitySummary = 0;
  20.                 if (mLastUserActivityTime >= mLastWakeTime) {
  21.                     nextTimeout = mLastUserActivityTime
  22.                             + screenOffTimeout - screenDimDuration;
  23.                     screenSaverNextTimeout = mLastUserActivityTime + screenSaverTimeout;//无操作后下次进入屏保的时间
  24.                     if (now < nextTimeout) {
  25. 						//当“屏幕互保”是打开的，并且无操作后进入休眠的时间 大于 无操作后进入屏保的时间，
  26. 						//而且当前的时间 大于 无操作后下次进入屏保的时间则进入屏保
  27.                         if(isScreenSaverEnabled && screenOffTimeout > screenSaverTimeout && now > screenSaverNextTimeout ){
  28.                             mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
  29.                         }else{//否则保持屏保亮屏
  30.                             mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
  31.                         }
  32. 						//Neostra dangziming end screensaver
  33.                     } else {
  34.                         nextTimeout = mLastUserActivityTime + screenOffTimeout;
  35.                         if (now < nextTimeout) {
  36.                             mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
  37.                         }
  38.                     }
  39.                 }
  40.                 if (mUserActivitySummary == 0
  41.                         && mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {
  42.                     nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout;
  43.                     if (now < nextTimeout) {
  44.                         if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT
  45.                                 || mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_VR) {
  46.                             mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
  47.                         } else if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
  48.                             mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
  49.                         }
  50.                     }
  51.                 }
  52.  
  53.                 if (mUserActivitySummary == 0) {
  54.                     if (sleepTimeout >= 0) {
  55.                         final long anyUserActivity = Math.max(mLastUserActivityTime,
  56.                                 mLastUserActivityTimeNoChangeLights);
  57.                         if (anyUserActivity >= mLastWakeTime) {
  58.                             nextTimeout = anyUserActivity + sleepTimeout;
  59.                             if (now < nextTimeout) {
  60.                                 mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
  61.                             }
  62.                         }
  63.                     } else {
  64.                         //mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;//删除系统进入休眠后才进入屏保的逻辑
  65.                         nextTimeout = -1;
  66.                     }
  67.                 }
  68.  
  69.                 if (mUserActivitySummary != USER_ACTIVITY_SCREEN_DREAM && userInactiveOverride) {
  70.                     if ((mUserActivitySummary &
  71.                             (USER_ACTIVITY_SCREEN_BRIGHT | USER_ACTIVITY_SCREEN_DIM)) != 0) {
  72.                         // Device is being kept awake by recent user activity
  73.                         if (nextTimeout >= now && mOverriddenTimeout == -1) {
  74.                             // Save when the next timeout would have occurred
  75.                             mOverriddenTimeout = nextTimeout;
  76.                         }
  77.                     }
  78.                     mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
  79.                     nextTimeout = -1;
  80.                 }
  81.  
  82.                 if (nextProfileTimeout > 0) {
  83.                     nextTimeout = Math.min(nextTimeout, nextProfileTimeout);
  84.                 }
  85.  
  86.                 if (mUserActivitySummary != 0 && nextTimeout >= 0) {
  87. 				//当“屏幕互保”是打开的，并且无操作后进入休眠的时间 大于 无操作后进入屏保的时间，
  88. 						//而且当前的时间 大于 无操作后下次进入屏保的时间则发送信息进入屏保
  89.                     if(isScreenSaverEnabled && screenOffTimeout > screenSaverTimeout && now <= screenSaverNextTimeout ){
  90.                         scheduleUserInactivityTimeout(screenSaverNextTimeout);
  91.                     }else{//否则发送进入休眠的信息
  92.                         scheduleUserInactivityTimeout(nextTimeout);
  93.                     }
  94. 					//Neostra dangziming end screensaver
  95.                 }
  96.             } else {
  97.                 mUserActivitySummary = 0;
  98.             }
  99.  
  100.             if (DEBUG_SPEW) {
  101.                 Slog.d(TAG, "updateUserActivitySummaryLocked: mWakefulness="
  102.                         + PowerManagerInternal.wakefulnessToString(mWakefulness)
  103.                         + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)
  104.                         + ", nextTimeout=" + TimeUtils.formatUptime(nextTimeout));
  105.             }
  106.         }
  107.     }

updateUserActivitySummaryLocked()的逻辑分析可以参考Android 8.1 PowerManagerService分析(二) ——updatePowerStateLocked()方法

如果此文章解答了您的相关疑惑，节约了您的宝贵时间，可以赏小编鸡腿哟！

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/45682?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号