android的休眠和唤醒

合集下载

Android应用程序保持后台唤醒（使用WakeLock实现）

Android应⽤程序保持后台唤醒（使⽤WakeLock实现）在使⽤⼀些产品列如微信、QQ之类的，如果有新消息来时，⼿机屏幕即使在锁屏状态下也会亮起并提⽰声⾳，这时⽤户就知道有新消息来临了。

但是，⼀般情况下⼿机锁屏后，Android系统为了省电以及减少CPU消耗，在⼀段时间后会使系统进⼊休眠状态，这时，Android系统中CPU会保持在⼀个相对较低的功耗状态。

针对前⾯的例⼦，收到新消息必定有⽹络请求，⽽⽹络请求是消耗CPU的操作，那么如何在锁屏状态乃⾄系统进⼊休眠后，仍然保持系统的⽹络状态以及通过程序唤醒⼿机呢？答案就是Android中的WakeLock机制。

⾸先看看官⽅的解释：PowerManager:This class gives you control of the power state of the device.PowerManager.WakeLock: lets you say that you need to have the device on.PowerManager负责对Android设备电源相关进⾏管理，⽽系统通过各种锁对电源进⾏控制，WakeLock是⼀种锁机制，只要有⼈拿着这把所，系统就⽆法进⼊休眠阶段。

既然要保持应⽤程序⼀直在后台运⾏，那⾃然要获得这把锁才可以保证程序始终在后台运⾏。

之前我做过⼀个需求是要在后台跑⼀个Service执⾏轮询，但发现⼀段时间以后，轮询就中断了（我测试是⼆⼗分钟后请求停⽌），但重新解锁屏幕后，轮询请求⼜开始了，后来在Stackoverflow上找到的WakeLock的⽤法，试了⼀下，还挺管⽤。

在使⽤这个⽅法之前，我把Service置成前台Service等⽅法都不奏效，不知在这个需求上⼤家是否还有更好的办法，⼤家可以留⾔和我讨论！接下来看如何使⽤WakeLock：WakeLock wakeLock = null;//获取电源锁，保持该服务在屏幕熄灭时仍然获取CPU时，保持运⾏private void acquireWakeLock(){if (null == wakeLock){PowerManager pm = (PowerManager)this.getSystemService(Context.POWER_SERVICE);wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK|PowerManager.ON_AFTER_RELEASE, "PostLocationService");if (null != wakeLock){wakeLock.acquire();}}}//释放设备电源锁private void releaseWakeLock(){if (null != wakeLock){wakeLock.release();wakeLock = null;}}上⾯第⼀个⽅法是获取锁，第⼆个⽅法是释放锁，⼀旦获取锁后，及时屏幕在熄灭或锁屏长时间后，系统后台⼀直可以保持获取到锁的应⽤程序运⾏。

Android开发中的语音唤醒和语音识别技术(七)

Android开发中的语音唤醒和语音识别技术在现代科技的发展中，语音技术正逐渐成为我们生活的一部分。

尤其在移动设备领域，语音唤醒和语音识别技术在Android开发中扮演着重要角色。

这些先进的技术使得用户可以通过简单的语音指令或交互来操作手机，为用户提供了更加便捷和自然的互动方式。

一、语音唤醒技术语音唤醒技术是一种能够让设备从待机状态中快速响应用户语音指令的技术。

在Android开发中，语音唤醒技术常常用于唤醒语音助手或其他语音交互应用。

具体而言，当用户说出预定的唤醒词时，设备将会立即从待机状态中唤醒并启动相关应用。

为实现语音唤醒功能，开发者需要使用语音唤醒引擎，并提供唤醒词训练服务。

在唤醒词训练服务中，开发者可以通过录制和上传自定义唤醒词样本，让引擎学习并识别唤醒词。

通过灵活设置和训练，开发者可以根据实际需求来定制专属的唤醒词。

二、语音识别技术语音识别技术是指将人类语音转换成文本的技术。

在Android开发中，语音识别技术通常用于实现语音助手或识别用户输入的语音指令。

利用语音识别技术，用户可以通过说话的方式轻松与设备进行交互，实现文字输入、应用控制、查询信息等功能。

实现语音识别功能，开发者需要使用语音识别引擎，并通过API接口进行调用。

当用户发出语音指令后，语音识别引擎将会将语音信号转化为文本，并返回给应用程序。

开发者可以根据返回的文本内容来执行相应的操作，例如搜索、发送短信或者调用其他应用程序。

三、语音唤醒和语音识别技术的优势语音唤醒和语音识别技术带来了诸多优势。

首先，语音交互方式更加直观自然，用户无需进行复杂的输入操作，只需通过简单的语音指令即可完成任务。

其次，语音技术使得手机在接听电话、发送短信等操作时变得更加方便，避免了手指操作的不便。

此外，对于身处特殊场景或有身体上的障碍的用户来说，语音交互更是一种便利和协助。

然而，尽管语音唤醒和语音识别技术有诸多优势，但也存在一些挑战。

首先，语音技术的准确性和适应性需要不断改进，特别是在区分不同人的语音和准确识别方言时。

android休眠唤醒流程2

android休眠唤醒流程2android系统⼀段时间没有操作,屏幕(screen)将从⾼亮(bright)变为暗淡(dim),如果再过段时间还是没有操作,屏幕(screen)从暗淡(dim)变为关闭(off).这时,系统将进⼊休眠.⽽对于某些需要保持系统唤醒甚⾄屏幕唤醒的应⽤(⽐如视频播放器和⾳乐播放器)来说,就必须要有⼀个机制,使得系统不进⼊休眠状态,设置保持屏幕亮屏状态.wakelock即⽤来实现以上⽬的先上⽹上偷来的⼀副图,说⼀下android系统的整个电源管理流程图接下来对每⼀个模块具体分析:powermanager对应⽂件是android/frameworks/base/core/java/android/os/PowerManager.java在Android中应⽤程序并不是直接同PowerManagerService交互的，⽽是通过PowerManager间接地与PowerManagerService打交道。

此⽂件定义了⼀个powermanager类.主要实现了1,wakelock的申请与释放public WakeLock newWakeLock(int flags, String tag)2,系统延时进⼊休眠public void userActivity(long when, boolean noChangeLights)3,系统强制休眠public void goToSleep(long time)4,屏幕亮度设置public void setBacklightBrightness(int brightness)5,屏幕状态查询public boolean isScreenOn()6,系统重启public void reboot(String reason)细节wakelock的申请与释放{@samplecode*PowerManager pm = (PowerManager)mContext.getSystemService(* Context.POWER_SERVICE);*PowerManager.WakeLock wl = pm.newWakeLock(* PowerManager.SCREEN_DIM_WAKE_LOCK* | PowerManager.ON_AFTER_RELEASE,* TAG);*wl.acquire();* // ...*wl.release();⼀共有如下⼏个flag来进⾏不⼀样的唤醒⽅式.可以根据需要设置Flag Value CPU Screen KeyboardPARTIAL_WAKE_LOCK On* can-off OffSCREEN_DIM_WAKE_LOCK On Dim OffPROXIMITY_SCREEN_OFF_WAKE_LOCK on 距离传感器时关闭 offSCREEN_BRIGHT_WAKE_LOCK On Bright OffFULL_WAKE_LOCK On Bright BrightACQUIRE_CAUSES_WAKEUP 确保wakelock,主要⽤于视频播放器ON_AFTER_RELEASE = 0x20000000 release后倒计时,关闭屏幕...userActivity的作⽤:使系统从其他状态进⼊全部打开状态,⽐如从暗屏(dim)切换到亮屏,并重置倒计时计数器(待续)。

android休眠与唤醒驱动流程分析

android休眠与唤醒驱动流程分析标准linux休眠过程：●power management notifiers are executed with PM_SUSPEND_PREPARE●tasks are frozen●target system sleep state is announced to the platform-handling code●devices are suspended●platform-specific global suspend preparation methods are executed●non-boot CPUs are taken off-line●interrupts are disabled on the remaining (main) CPU●late suspend of devices is carried out (一般有一些BUS driver的动作进行)‏●platform-specific global methods are invoked to put the system to sleep标准linux唤醒过程：●t he main CPU is switched to the appropriate mode, if necessary●early resume of devices is carried out (一般有一些BUS driver的动作进行)‏●interrupts are enabled on the main CPU●non-boot CPUs are enabled●platform-specific global resume preparation methods are invoked●devices are woken up●tasks are thawed●power management notifiers are executed with PM_POST_SUSPEND用户可以通过sys文件系统控制系统进入休眠：查看系统支持的休眠方式：#cat /sys/power/state常见有standby(suspend to RAM)、mem(suspend to RAM)和disk(suspend to disk)，只是standby耗电更多，返回到正常工作状态的时间更短。

【Android休眠】之休眠锁的获取和释放

【Android休眠】之休眠锁的获取和释放一、PowerManagerService引起休眠动作(进入休眠前执行一些必要的操作)的事件有两个：PowerKey事件，通过JNI调用PowerManagerService中的goToSleepFromNative()方法Timeout，指【设置->显示->休眠】中设置的Timeout数值Android休眠在PowerManagerService中的流程如下图：图示：最终都会调用到updatePowerStateLocked()方法，在更新一些标志的状态、发送休眠通知后，调用updateSuspendBlockerLocked()执行休眠锁的释放动作。

二、PowerManagerService中Timeout处理流程1./**2.* PowerManagerService设置了很多的标志位，用来标识某个事件的状态是否发生改变，比如：3.* DIRTY_SETTINGS，一旦系统设置发生变化，DIRTY_SETTINGS位就会被设置，4.* 处理函数检测到DIRTY_SETTINGS被置位，就进行相应的动作5.* dirty：包含了所有发生变化的标志6.*/7.private void updateUserActivitySummaryLocked(long now, int dirty) {8.// Update the status of the user activity timeout timer.9.if ((dirty & (DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) {10.// 1、消息队列中含有尚未处理的MSG_USER_ACTIVITY_TIMEOUT，就移除，避免重复进入休眠操作11.mHandler.removeMessages(MSG_USER_ACTIVITY _TIMEOUT);12.13.long nextTimeout = 0;14.// 2、mWakefulness != WAKEFULNESS_ASLEEP：当前醒着15.if (mWakefulness != WAKEFULNESS_ASLEEP) {16.// 3、获取Timeout的值，比如30s17.final int screenOffTimeout = getScreenOffTimeoutLocked();18.// 屏幕在熄灭前，会先变暗一段时间，这段时间叫DimDuration，计算方式：19.// SCREEN_DIM_DURATION = 7s，MAXIMUM_SCREEN_DIM_RATIO = 0.220.// Math.min(SCREEN_DIM_DURATION, (int)(screenOffTimeout * MAXIMUM_SCREEN_DIM_RATIO))21.// 4、获取DimDuration的值，30s x 0.2 = 6s22.final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout);23.24.mUserActivitySummary = 0;25.// 5、mLastUserActivityTime >= mLastWakeTime：用户最后使用机器的时间在上次唤醒时间之后26.if (mLastUserActivityTime >= mLastWakeTime) {27.// nextTimeout：此处指到屏幕Dim的时间间隔28.// 6、nextTimeout的时间：BASE + 30 - 6 = BASE + 2429.nextTimeout = mLastUserActivityTime30.+ screenOffTimeout - screenDimDuration;31.if (now < nextTimeout) {32.// now在屏幕Dim之前，说明屏幕亮着，设置flag33.mUserActivitySummary |= USER_ACTIVITY_SCREEN_BRIGHT;34.} else {35.// extTimeout：此处指到屏幕熄灭的时间间隔36.//7、nextTimeout的时间：BASE + 30 = BASE + 3037.nextTimeout = mLastUserActivityTime + screenOffTimeout;38.// 8、now处于屏幕Dim之后、屏幕熄灭之前设置DIM flag39.if (now < nextTimeout) {40.mUserActivitySummary |= USER_ACTIVITY_SCREEN_DIM;41.}42.}43.}44.if (mUserActivitySummary == 045.&& mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {46.nextTimeout =mLastUserActivityTimeNoChangeLights + screenOffTimeout;47.if (now < nextTimeout48.&& mDisplayPowerRequest.screenState49.!= DisplayPowerRequest.SCREEN_STATE_OFF) {50.mUserActivitySummary = mDisplayPowerRequest.screenState51.== DisplayPowerRequest.SCREEN_STATE_BRIGHT ?ER_ACTIVITY_SCREEN_BRIGHT : USER_ACTIVITY_SCREEN_DIM;53.}54.}55.// mUserActivitySummary发生了改变56.if (mUserActivitySummary != 0) {57.Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT);58.Slog.i(TAG, "updateUserActivitySummaryLocked, send MSG_USER_ACTIVITY_TIMEOUT");59.msg.setAsynchronous(true);60.mHandler.sendMessageAtTime(msg, nextTimeout);61.}62.} else {63.mUserActivitySummary = 0;64.}65.}66.}67.68.69.MSG_USER_ACTIVITY_TIMEOUT事件处理：70.71.private final class PowerManagerHandler extends Handler {72.@Override73.public void handleMessage(Message msg) {74.switch (msg.what) {75.case MSG_USER_ACTIVITY_TIMEOUT:76.handleUserActivityTimeout();77.break;78.}79.}80.81./**82.* Called when a user activity timeout has occurred.83.* Simply indicates that something about user activity has changed so that the new84.* state can be recomputed when the power state is updated.85.*/86.private void handleUserActivityTimeout() { // runs on handler thread87.mDirty |= DIRTY_USER_ACTIVITY;88.updatePowerStateLocked();89.}90.91.92.三、PowerManagerService中休眠锁的获取/释放93.这部分代码清晰，直接看下：94.95.private void updatePowerStateLocked() {96.if (!mSystemReady || mDirty == 0) {97.return;98.}99.// Phase 0: Basic state updates.100.101.// Phase 1: Update wakefulness.102.103.// Phase 2: Update dreams and display power state.104.105.// Phase 3: Send notifications, if needed.106.107.// Phase 4: Update suspend blocker.108.// Because we might release the last suspend blocker here, we need to make sure109.// we finished everything else first!110.updateSuspendBlockerLocked();111.}112.113./**114.* Updates the suspend blocker that keeps the CPU alive.115.*/116.private void updateSuspendBlockerLocked() {117.final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);118.final boolean needDisplaySuspendBlocker = needDisplaySuspendBlocker();119.120.// First acquire suspend blockers if needed.121.if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) {122.mWakeLockSuspendBlocker.acquire();123.mHoldingWakeLockSuspendBlocker = true;124.}125.if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) {126.mDisplaySuspendBlocker.acquire();127.mHoldingDisplaySuspendBlocker = true;128.}129.130.// Then release suspend blockers if needed.131.if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) {132.mWakeLockSuspendBlocker.release();133.mHoldingWakeLockSuspendBlocker = false;134.}135.if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) {136.mDisplaySuspendBlocker.release();137.mHoldingDisplaySuspendBlocker = false;138.}139.}140.141.private final class SuspendBlockerImpl implements SuspendBlocker {142.private final String mName;143.private int mReferenceCount;144.145.public SuspendBlockerImpl(String name) {146.mName = name;147.}148.149.@Override150.public void acquire() {151.synchronized (this) {152.mReferenceCount += 1;153.if (mReferenceCount == 1) {154.nativeAcquireSuspendBlocker(mName);155.}156.}157.}158.159.@Override160.public void release() {161.synchronized (this) {162.mReferenceCount -= 1;163.if (mReferenceCount == 0) {164.165.nativeReleaseSuspendBlocker(mName);166.}167.}168.}169.}170.171.休眠锁的获取和释放，最终通过JNI方式读写/sys/power/wake_lock、/sys/power/wake_unlock：172.173.// 1、JNI接口_android_server_power_PowerManagerServic e.cpp (frameworks\base\services\jni)175.static void nativeAcquireSuspendBlocker(JNIEnv*env, jclass clazz, jstring nameStr) {176.ScopedUtfChars name(env, nameStr);177.acquire_wake_lock(PARTIAL_WAKE_LOCK, name.c_str());178.}179.180.// 2、定义要操作的文件181.power.c (hardware\libhardware_legacy\power)182.const char * const NEW_PATHS[] = {183."/sys/power/wake_lock",184."/sys/power/wake_unlock",185.};186.187.// 3、初始化设备节点188.static inline void initialize_fds(void)189.{190.if (g_initialized == 0) {191.if(open_file_descriptors(NEW_PATHS) < 0)192.open_file_descriptors(OLD_PATHS);193.g_initialized = 1;194.}195.}196.197.static int open_file_descriptors(const char * const paths[])198.{199.int i;200.for (i=0; i<OUR_FD_COUNT; i++) {201.int fd = open(paths[i], O_RDWR);202.if (fd < 0) {203.fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]);204.g_error = errno;205.return -1;206.}207.g_fds[i] = fd;208.}209.210.g_error = 0;211.return 0;212.}213.214.// 4、id即为锁的名字，之后就是读写设备215.int acquire_wake_lock(int lock, const char* id)216.{217.initialize_fds();218.219.if (g_error) return g_error;220.221.int fd;222.223.if (lock == PARTIAL_WAKE_LOCK) {224.fd = g_fds[ACQUIRE_PARTIAL_WAKE_LOCK];225.}226.else {227.return EINVAL;228.}229.230.return write(fd, id, strlen(id));231.}232.MSG_USER_ACTIVITY_TIMEOUT事件处理：1.private final class PowerManagerHandler extends Handler {2.@Override3.public void handleMessage(Message msg) {4.switch (msg.what) {5.case MSG_USER_ACTIVITY_TIMEOUT:6.handleUserActivityTimeout();7.break;8.}9.}10.11./**12.* Called when a user activity timeout has occurred.13.* Simply indicates that something about user activity has changed so that the new14.* state can be recomputed when the power state is updated.15.*/16.private void handleUserActivityTimeout() { // runs on handler thread17.mDirty |= DIRTY_USER_ACTIVITY;18.updatePowerStateLocked();19.}三、PowerManagerService中休眠锁的获取/释放这部分代码清晰，直接看下：1.private void updatePowerStateLocked() {2.if (!mSystemReady || mDirty == 0) {3.return;4.}5.// Phase 0: Basic state updates.6.7.// Phase 1: Update wakefulness.8.9.// Phase 2: Update dreams and display power state.10.11.// Phase 3: Send notifications, if needed.12.13.// Phase 4: Update suspend blocker.14.// Because we might release the last suspend blocker here, we need to make sure15.// we finished everything else first!16.updateSuspendBlockerLocked();17.}18.19./**20.* Updates the suspend blocker that keeps the CPU alive.21.*/22.private void updateSuspendBlockerLocked() {23.final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);24.final boolean needDisplaySuspendBlocker = needDisplaySuspendBlocker();25.26.// First acquire suspend blockers if needed.27.if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) {28.mWakeLockSuspendBlocker.acquire();29.mHoldingWakeLockSuspendBlocker = true;30.}31.if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) {32.mDisplaySuspendBlocker.acquire();33.mHoldingDisplaySuspendBlocker = true;34.}35.36.// Then release suspend blockers if needed.37.if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) {38.mWakeLockSuspendBlocker.release();39.mHoldingWakeLockSuspendBlocker = false;40.}41.if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) {42.mDisplaySuspendBlocker.release();43.mHoldingDisplaySuspendBlocker = false;44.}45.}46.47.private final class SuspendBlockerImpl implements SuspendBlocker {48.private final String mName;49.private int mReferenceCount;50.51.public SuspendBlockerImpl(String name) {52.mName = name;53.}54.55.@Override56.public void acquire() {57.synchronized (this) {58.mReferenceCount += 1;59.if (mReferenceCount == 1) {60.nativeAcquireSuspendBlocker(mName);61.}62.}63.}64.65.@Override66.public void release() {67.synchronized (this) {68.mReferenceCount -= 1;69.if (mReferenceCount == 0) {70.71.nativeReleaseSuspendBlocker(mName);72.}73.}74.}75.}休眠锁的获取和释放，最终通过JNI方式读写/sys/power/wake_lock、/sys/power/wake_unlock：1.// 1、JNI接口_android_server_power_PowerManagerService.cpp (frameworks\base\services\jni)3.static void nativeAcquireSuspendBlocker(JNIEnv *env, jclass clazz, jstring nameStr) {4.ScopedUtfChars name(env, nameStr);5.acquire_wake_lock(PARTIAL_WAKE_LOCK, name.c_str());6.}7.8.// 2、定义要操作的文件9.power.c (hardware\libhardware_legacy\power)10.const char * const NEW_PATHS[] = {11."/sys/power/wake_lock",12."/sys/power/wake_unlock",13.};14.15.// 3、初始化设备节点16.static inline void initialize_fds(void)17.{18.if (g_initialized == 0) {19.if(open_file_descriptors(NEW_PATHS) < 0)20.open_file_descriptors(OLD_PATHS);21.g_initialized = 1;22.}23.}24.25.static int open_file_descriptors(const char * const paths[])26.{27.int i;28.for (i=0; i<OUR_FD_COUNT; i++) {29.int fd = open(paths[i], O_RDWR);30.if (fd < 0) {31.fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]);32.g_error = errno;33.return -1;34.}35.g_fds[i] = fd;36.}37.38.g_error = 0;39.return 0;40.}41.42.// 4、id即为锁的名字，之后就是读写设备43.int acquire_wake_lock(int lock, const char* id)44.{45.initialize_fds();46.47.if (g_error) return g_error;48.49.int fd;50.51.if (lock == PARTIAL_WAKE_LOCK) {52.fd = g_fds[ACQUIRE_PARTIAL_WAKE_LOCK];53.}54.else {55.return EINVAL;56.}57.58.return write(fd, id, strlen(id));59.}。

Android熄屏与亮屏控制

Android熄屏与亮屏控制目前做一个电子班牌的项目，需要做到熄屏与亮屏，网上找了很多，都是利用PowerManager，但是需要系统权限，这个比较麻烦，后面找到一个，测试发现可行的方案，就是利用设备管理器DevicePolicyManager执行熄屏，利用PowerManager进行亮屏，下面是步骤与代码。

1.注册：DeviceAdminReceiver<receiverandroid:name=".sreencontroldemo.Sc reenOffAdminReceiver"android:label="@string/app_name"android:permission="android.permission.BIND_DEVICE_AD MIN" ><meta-dataandroid:name="android.app.device_admin"android:resource="@xml/device_admin" /><intent-filter><actionandroid:name="android.app.action.DEVICE_ADMIN_ENABLED" /> </intent-filter></receiver>ScreenOffAdminReceiver为继承DeviceAdminReceiver：public class ScreenOffAdminReceiver extends DeviceAdminReceiver {private void showT oast(Context context, String msg) {Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();}@Overridepublic void onEnabled(Context context, Intent intent) { showToast(context,"设备管理器使能");}@Overridepublic void onDisabled(Context context, Intent intent) { showToast(context,"设备管理器没有使能");}}device_admin为device_admin.xml，在res/xml文件夹下面：<?xml version="1.0" encoding="utf-8"?><device-admin xmlns:android="/apk/res/android"><uses-policies><limit-password /><reset-password /><force-lock /></uses-policies></device-admin>2.xml代码：<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android" xmlns:app="/apk/res-auto"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"tools:context=".sreencontroldemo.Ma inActivity"><Buttonandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onClick="checkScreen"android:text="检测屏幕状态" /><Buttonandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onClick="checkScreenOn"android:text="亮屏" /><Buttonandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onClick="checkScreenOff"android:text="熄屏" /><Buttonandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onClick="checkScreenOffAndDelayOn"android:text="熄屏后再亮屏" /><Buttonandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onClick="checkAndTurnOnDeviceManager"android:text="去启动设备管理器权限" /></LinearLayout>3.MainActivity代码：public class MainActivity extends AppCompatActivity {private String tag = "MainActivity";private Handler handler = new Handler() {@Overridepublic void handleMessage(Message msg) {super.handleMessage(msg);switch (msg.what) {case 1:checkScreenOn(null);break;case 2:break;}}};private DevicePolicyManager policyManager;private ComponentName adminReceiver;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);adminReceiver = new ComponentName(MainActivity.this, ScreenOffAdminReceiver.class);mPowerManager = (PowerManager) getSystemService(POWER_SERVICE);policyManager = (DevicePolicyManager) MainActivity.this.getSystemService(Context.DEVICE_POLICY_SER VICE);checkAndTurnOnDeviceManager(null);}@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) {super.onActivityResult(requestCode, resultCode, data);isOpen();}private void isOpen() {if (policyManager.isAdminActive(adminReceiver)) {//判断超级管理员是否激活showToast("设备已被激活");} else {showToast("设备没有被激活");}}private PowerManager mPowerManager;private PowerManager.WakeLock mWakeLock;/*** @param view 检测屏幕状态*/public void checkScreen(View view) {PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);boolean screenOn = pm.isScreenOn();if (!screenOn) {//如果灭屏//相关操作showToast("屏幕是息屏");} else {showToast("屏幕是亮屏");}}/*** @param view 亮屏*/public void checkScreenOn(View view) {mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT _WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "tag");mWakeLock.acquire();mWakeLock.release();}/*** @param view 熄屏*/public void checkScreenOff(View view) {boolean admin = policyManager.isAdminActive(adminReceiver);if (admin) {policyManager.lockNow();} else {showToast("没有设备管理权限");}}/*** @param view 熄屏并延时亮屏*/public void checkScreenOffAndDelayOn(View view) {boolean admin = policyManager.isAdminActive(adminReceiver);if (admin) {policyManager.lockNow();handler.sendEmptyMessageDelayed(1, 3000);} else {showToast("没有设备管理权限");}}/*** @param view 检测并去激活设备管理器权限*/public void checkAndTurnOnDeviceManager(View view) {Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMI N, adminReceiver);intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANA TION, "开启后就可以使用锁屏功能了...");//显示位置见图二startActivityForResult(intent, 0);}private void showT oast(String Str) {Toast.makeText(this, Str, Toast.LENGTH_SHORT).show();}}4.发现的问题如果手机有屏保，熄屏后再亮屏会显示屏保。

wakelock用法

wakelock用法Wakelock是Android开发中非常重要的一个概念，它允许应用程序保持设备处于唤醒状态，以便执行任务或运行服务，而不会受到设备休眠的干扰。

Wakelock的原理是在应用程序需要保持设备唤醒状态时，获得设备CPU的锁，防止CPU进入睡眠模式，从而保证应用程序可以继续执行任务或运行服务。

但是，Wakelock在使用时也会导致设备耗电量增加，因此应该在必要的情况下谨慎使用。

使用Wakelock需要了解以下几个方面：1. 获取Wakelock：可以通过PowerManager的acquire方法获取一个Wakelock实例。

在获取Wakelock实例时，可以传递不同参数来控制设备的唤醒方式，例如PARTIAL_WAKE_LOCK表示设备只保持CPU唤醒，而屏幕和键盘灯会关闭；FULL_WAKE_LOCK表示设备保持CPU、屏幕和键盘灯均保持唤醒。

2. 释放Wakelock：在使用完Wakelock后，需要通过Wakelock的release方法来释放锁，以允许设备进入休眠状态。

如果不释放Wakelock，则可能会导致设备的电量快速消耗。

为了确保Wakelock被正确释放，建议将其放置在finally块中。

3. 使用场景：Wakelock适用于需要长时间执行任务或运行服务的场景，例如下载长时间需要的文件、播放音乐、持续运行后台服务等。

在使用Wakelock时，需要选择合适的锁类型和释放时机，以避免不必要的电量消耗和资源浪费。

4. Wakelock的注意事项：由于Wakelock会导致设备耗电量增加，因此在使用Wakelock时需谨慎，建议在必要的情况下使用。

此外，在获取Wakelock实例时应使用Context.getSystemService(Context.POWER_SERVICE)来获取PowerManager实例，避免内存泄漏问题。

android sleep用法

android sleep用法
Sleep是一个在Android开发中用于暂停当前线程一段时间的方法。

它的用法如下：
1. 在主线程中使用：直接在主线程中调用sleep方法即可暂停当前线程。

```java
try {
Thread.sleep(1000); // 暂停1秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
```
注意：在主线程中睡眠时间过长会导致应用无响应（ANR）问题，不推荐在主线程中使用长时间的睡眠。

2. 在子线程中使用：在子线程中暂停线程需要使用Handler类的postDelayed方法。

```java
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
// 执行需要暂停的任务
}
}, 1000); // 暂停1秒钟
```
这样使用可以避免在子线程中使用sleep方法引起的阻塞，不
会影响主线程的响应。

需要注意的是，sleep方法会捕获InterruptedException异常，如果在睡眠过程中线程被中断，会触发该异常。

因此，在使用sleep方法时，应该捕获InterruptedException异常并处理。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

通过#echo mem > /sys/power/state 让系统进入休眠。

Android休眠与唤醒android是在传统的linux内核电源管理设计的基础上，结合手机设计的实际需求而进化出的一套电源管理系统，其核心内容有：wakelock 、early_suspend与late_resume。

wakelock在Android的电源管理系统中扮演一个核心的角色。

wakelock是一种锁的机制，只要有人拿着这个锁，系统就无法进入休眠，可以被用户态程序和内核获得。

这个锁可以是有超时的或者是没有超时的，超时的锁会在时间过去以后自动解锁。

如果没有锁了或者超时了，内核就会启动休眠的那套机制来进入休眠。

当系统在启动完毕后，会自己去加一把名为“main“的锁，而当系统有意愿去睡眠时则会先去释放这把“main”锁，在android中，在early_suspend的最后一步会去释放“main”锁（wake_unlock: main）。

释放完后则会去检查是否还有其他存在的锁，如果没有则直接进入睡眠过程。

它的缺点是，如果有某一应用获锁而不释放或者因一直在执行某种操作而没时间来释放的话，则会导致系统一直进入不了睡眠状态，功耗过大。

early_suspend：先与linux内核的睡眠过程被调用。

一般在手机系统的设计中对背光的操些在内核中要预先进行处理的事件可以先注册上early_suspend函数，当系统要进入睡眠之前会首先调用这些注册的函数。

本文中，linux kernel版本为linux-2.6.29，android版本为android 2.1与android休眠唤醒主要相关的文件主要有：●linux_source/kernel/power/main.c●linux_source/kernel/power/earlysuspend.c●linux_source/kernel/power/wakelock.c●linux_source/kernel/power/process.c●linux_source/driver/base/power/main.c●linux_source/arch/xxx/mach-xxx/pm.c或linux_source/arch/xxx/plat-xxx/pm.cAndroid 休眠过程如下：当用户读写/sys/power/state时，linux_source/kernel/power/main.c中的state_store()函数会被调用。

其中，android的early_suspend会执行request_suspend_state(state); 而标准的linux休眠则执行error = enter_state(state);static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,const char *buf, size_t n){#ifdef CONFIG_SUSPEND#ifdef CONFIG_EARL YSUSPENDsuspend_state_t state = PM_SUSPEND_ON;#elsesuspend_state_t state = PM_SUSPEND_STANDBY;#endifconst char * const *s;#endifchar *p;int len;int error = -EINV AL;p = memchr(buf, '\n', n);len = p ? p - buf : n;/* First, check if we are requested to hibernate */if (len == 4 && !strncmp(buf, "disk", len)) {error = hibernate();goto Exit;}#ifdef CONFIG_SUSPENDfor (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {if (*s && len == strlen(*s) && !strncmp(buf, *s, len))break;}if (state < PM_SUSPEND_MAX && *s)#ifdef CONFIG_EARL YSUSPENDif (state == PM_SUSPEND_ON || valid_state(state)) {error = 0;request_suspend_state(state);}#elseerror = enter_state(state);#endifExit:return error ? error : n;}在request_suspend_state(state)函数中，会调用early_suspend_work的工作队列，从而进入early_suspend()函数中。

static DECLARE_WORK(early_suspend_work, early_suspend);void request_suspend_state(suspend_state_t new_state){unsigned long irqflags;int old_sleep;spin_lock_irqsave(&state_lock, irqflags);old_sleep = state & SUSPEND_REQUESTED;if (debug_mask & DEBUG_USER_STA TE) {struct timespec ts;struct rtc_time tm;getnstimeofday(&ts);rtc_time_to_tm(_sec, &tm);pr_info("request_suspend_state: %s (%d->%d) at %lld ""(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",requested_suspend_state, new_state,ktime_to_ns(ktime_get()),tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,tm.tm_hour, tm.tm_min, tm.tm_sec, _nsec);}if (!old_sleep && new_state != PM_SUSPEND_ON) {state |= SUSPEND_REQUESTED;queue_work(suspend_work_queue, &early_suspend_work);} else if (old_sleep && new_state == PM_SUSPEND_ON) {state &= ~SUSPEND_REQUESTED;wake_lock(&main_wake_lock);queue_work(suspend_work_queue, &late_resume_work);}requested_suspend_state = new_state;spin_unlock_irqrestore(&state_lock, irqflags);}在early_suspend()函数中，首先要判断当前请求的状态是否还是suspend，若不是，则直接退出了；若是，函数会调用已经注册的early_suspend的函数。

然后同步文件系统，最后释放main_wake_lock。

static void early_suspend(struct work_struct *work){struct early_suspend *pos;unsigned long irqflags;int abort = 0;mutex_lock(&early_suspend_lock);spin_lock_irqsave(&state_lock, irqflags);if (state == SUSPEND_REQUESTED)state |= SUSPENDED;elseabort = 1;spin_unlock_irqrestore(&state_lock, irqflags);if (abort) {if (debug_mask & DEBUG_SUSPEND)pr_info("early_suspend: abort, state %d\n", state);mutex_unlock(&early_suspend_lock);goto abort;}if (debug_mask & DEBUG_SUSPEND)pr_info("early_suspend: call handlers\n");list_for_each_entry(pos, &early_suspend_handlers, link) {if (pos->suspend != NULL)pos->suspend(pos);}mutex_unlock(&early_suspend_lock);if (debug_mask & DEBUG_SUSPEND)pr_info("early_suspend: sync\n");sys_sync();abort:spin_lock_irqsave(&state_lock, irqflags);if (state == SUSPEND_REQUESTED_AND_SUSPENDED)wake_unlock(&main_wake_lock);spin_unlock_irqrestore(&state_lock, irqflags);}在wake_unlock()中，删除链表中wake_lock节点，判断当前是否存在wake_lock，若wake_lock的数目为0，则调用工作队列suspend_work，进入suspend状态。