Android休眠式快速开机设计讲座.doc

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休眠与唤醒驱动流程分析标准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熄屏与亮屏控制目前做一个电子班牌的项目，需要做到熄屏与亮屏，网上找了很多，都是利用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.发现的问题如果手机有屏保，熄屏后再亮屏会显示屏保。

Android自动开关机实现

Android 自动开关机的实现精讲Android 自动动开机，网上的介绍就比较少了，因为它需要底层rtc时钟的支持。

前段时间根据客户需求实现了自动开关机。

在这里分享一下。

1. 简介我的实现是在设置程序里面增加一个接口，让用户设置自动开关机，这个自动开关机的设置可以参照闹钟的设置。

关于自动关机，考虑到关机的时候，用户可能正有一些重要的操作，那么应该给用户一个机会去取消当前的关机。

1）一个BroadcastReceiver, 接收如下信息：a) 自定义的ACTION_REQUEST_POWER_OFF：设置auto power off时，通过AlarmManager设置的一个RTC_WAKEUP时钟。

当到设置的关机时间时，之前设置到AlarmManager的这个action会被广播。

我们实现的这个BroadcastReceiver接收到这个消息后，就要开始power off流程b) 自定义的ACTION_REQUEST_POWER_ON：设置auto power on时，通过AlarmManager设置的一个RTC_WAKEUP时钟。

我们知道power on的应该设置一个rtc的alarm，那么这个RTC_WAKEUP的alarm是做什么的呢？其实当用户设置自动关机的时候，我设置了2个时钟，一个是RTC时钟，用于关机状态下开机；还有一个就是这个RTC_WAKEUP时钟。

之所以设置这个时钟，其实是这样的，比如说你设置了周一到周五每天7点半自动开机，而周四早上你7点就打开了手机，这样到7点半的时候，之前设置的时钟就过期了，如果不重新设置的话，周五早上是不会自动开机的。

所以这个时候，之前设置的RTC_WAKEUP就接收到了这样的信息，在重新设置下次自动开机的时钟。

c) BOOT_COMPLETE和TIMEZONE changed, Time set等时间相关的action：当系统开机完成或时间、时区发生改变时，都需要重新设置alarm。

Android(安卓系统)系统手机使用技巧

Android（安卓系统）系统手机使用技巧快速查看手机充电情况方法1：通过待机屏幕查看，众所周知Android系统设计了自动锁屏功能，当手机处于一段时间不使用的情况下就会自动熄灭背景灯，如果需要激活的话就需要按下手机的Menu键两次，但是当按下第一次之后会显示出待机界面，里面就会显示目前的手机电池充电情况。

方法2：在Android系统中的About Phone选项中的“Status”选项，里面能够看到Battery Level的选项，这就是当前手机的充电情况显示。

方法3：通过第三方软件查看，由于Android系统中并没有专门的这类软件，所以如果想要详细的查看目前手机充电情况的话就是用一款第三方的电池查看软件吧教你设置输入密码不可见用过某些需要登录的应用程序的朋友相信都知道在输入账户密码默认情况下是显示出来已经输入的密码，为了安全起见都不想旁边的人看到自己的密码，那么怎样才能设置Android手机不可见已经输入的密码呢?教你设置输入密码不显示。

关于密码的设置当然是在SecurityLocation中了，所以我们先在主屏界面上按下Menu菜单键，在弹出的进阶菜单中选择最后一项“Settings”；进入设置菜单后将滚动条向下滑动，找到“SecurityLocation”的分类，点击进入；在安全性和位置分类菜单中找到Passwords分类，其中将“Visible passwords”选项后面的勾去掉即可。

摩托罗拉BLUR账户设置二代账户设置步骤，有兴趣的朋友可以看看。

首次BLUR账户设置是在ME600等手机首次启动的时候，只要将MOTOBLUR账户绑定一个邮箱即可，当然在此之前需要进行APN网络接入点的设置。

如果在Android手机首次开机的时候将MOTOBLUR账户设置过程跳过，那么只能从其他地方进行设置。

在主屏幕中按下Menu菜单键，选择最后一项设置，在设置选项中选择MOTOBLUR账户进入下一步设置。

Android实现关机与重启的几种方式（推荐）

Android实现关机与重启的⼏种⽅式（推荐）下⾯我们来探究Android如何实现关机，重启；在Android中这种操作往往需要管理员级别，或者rootAndroid实现的⽅式如下⼏种：默认的SDK并没有提供应⽤开发者直接的Android系统关机或重启的API接⼝，⼀般来讲，实现Android系统的关机或重启，需要较⾼的权限（系统权限甚⾄Root权限）。

所以，在⼀般的APP中，如果想要实现关机或重启功能，要么是在App中声明系统权限，要么是通过某种“间接”的⽅式，⽐如⼴播或反射，来间接实现系统关机或重启。

再者，就是放在源码环境中进⾏编译，这样做有⼀个好处，就是可以直接调⽤Android中不公开的API，这是Eclipse＋SDK没法达到的效果。

下⾯是我⾃⼰尝试的⼏种⽅式：⼀. 发送⼴播⽅式Broadcast是Android的四⼤基本组件之⼀，也就是我们常说的⼴播。

Android系统本⾝就包含了许多⼴播，时时刻刻在监听着系统中注册的每⼀个⼴播并随时准备响应操作。

其中，就有关于关机或重启的⼴播：Intent.ACTION_REQUEST_SHUTDOWN和Intent.ACTION_REBOOT，通过发送这两个⼴播，Android就能⾃动接收⼴播，并响应关机或重启的操作。

ACTION_REQUEST和ACTION_REBOOT是Intent.java是声明的两个字符串常量public static final String ACTION_REBOOT = "android.intent.action.REBOOT"; public static final String ACTION_REQUEST_SHUTDOWN = "android.intent.action.ACTION_REQUEST_SHUTDOWN";Intent.java位于源码/frameworks/base/core/java/android/content/Intent.java下⾯。

系统休眠设计方案

系统休眠设计方案一、为啥要有系统休眠？咱先说说为啥要搞这个系统休眠。

就好比人累了要睡觉一样，系统一直干活也会累呀。

一直开着不仅费电（如果是用电设备的话），还可能因为长时间运行出现各种小毛病，就像人一直不休息容易生病似的。

所以呢，给系统安排个休眠模式，就像是给它一个舒服的小床，让它能休息休息，等需要的时候再精神抖擞地起来干活。

二、什么时候让系统休眠？1. 根据使用时间。

我们可以设定一个时间规则。

比如说，如果系统在一段时间内（像30分钟或者1个小时，这个时间可以根据具体情况调整）没有任何操作，就像你把电脑放在那啥也不干，那它就可以进入休眠了。

这就好比你坐在那发呆好久，也该去睡个觉了。

2. 根据特定任务完成情况。

3. 根据系统负载。

要是系统的负载特别低，低到就像你在空转一个大机器，只消耗能量没干啥实事。

比如说CPU使用率低于5%，内存占用也很少，那这个时候系统就可以考虑休眠了。

这就好比一个大工厂里只有几个人在慢悠悠地打扫卫生，那还不如先把工厂关了休息会儿呢。

三、系统休眠前要做啥？1. 保存当前状态。

这就像你睡觉前要把东西都收拾好一样。

系统得把正在处理的东西，比如说打开的文件呀，正在运行的小程序呀，都记录下来。

这样当它醒来的时候，就能知道自己之前在干啥，然后接着干。

就像你睡觉前把书放在哪做个记号，醒来就能接着看。

2. 通知相关设备或程序。

如果这个系统和其他设备或者程序有联系，得告诉它们“我要休眠啦”。

就像你要睡觉了，得跟家人说一声一样。

比如说这个系统连着一个打印机，那得告诉打印机“我要休眠了，你也歇着吧，等我醒了咱们再继续合作”。

3. 关闭不必要的硬件设备（如果适用）有些系统连着一些硬件，像电脑连着摄像头或者外接硬盘。

如果这些硬件在系统休眠的时候不需要工作，那就把它们关掉。

这就好比你睡觉前把房间里不用的电器插头拔掉，安全又省电。

四、系统怎么从休眠中醒来？1. 外部唤醒事件。

可以设置一些外部的东西来叫醒系统。

Android系统的休眠

/2010/04/18/suspend-cn.html
2010/5/13
w
页码，5/13(W)
当所有的设备休眠以后, suspend_ops->prepare()会被调用, 这个函数通常会作一些准备工作来让板机进入休眠. 接下来Linux,在多核的CPU中的非启动CPU会被关掉, 通过注释看到是避免这些其他的CPU造成race condion,接下来的以后只有一个CPU在运行了.
四月 18th, 2010 0 Comments/155 hits
Table of Contents
z 简介 z 国际化 z 版本信息 z 对于休眠(suspend)的简单介绍 z Linux Suspend 的流程
{ 相关的文件: { 准备, 冻结进程 { 让外设进入休眠 { Resume z Android 休眠(suspend) { 涉及到的文件: { 特性介绍
pr_debug("PM: free some memory\n");
shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
if (nr_free_pages() < FREE_PAGE_NUMBER) {
error = -ENOMEM;
printk(KERN_ERR "PM: No enough memory\n");
Early Suspend Late Resume Wake Lock { Android Suspend { Early Suspend { Late Resume { Wake Lock { Suspend { Android于标准Linux休眠的区别
简介

android的休眠和唤醒流程

android的休眠和唤醒流程android休眠唤醒流程:power按键事件上报给android系统,最终由windownmanager接收到,当有按键事件时判断是否需要休眠后唤醒系统,然后调⽤powermanager 系统服务去写/sys/power/state节点.此节点的写函数⾥判断收到的内容,来执⾏android的休眠early_suspend/唤醒late_resume流程.android层:private int setScreenStateLocked(boolean on) 电源管理服务:frameworks/base/services/java/com/android/server/PowerManagerService.javaint err = Power.setScreenState(on);在⽂件frameworks/base/core/java/android/os/Power.java定义79 public static native int setScreenState(boolean on);具体实现在:frameworks/base/core/jni/android_os_Power.cppstatic int setScreenState(JNIEnv *env, jobject clazz, jboolean on);set_screen_state(on); 在⽂件hardware/libhardware_legacy/power/power.c中定义并实现write(g_fds[REQUEST_STATE], buf, len); 写/sys/power/state节点内核层:向节点写内容会调⽤kernel/power/main.c的写函数:static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,const char *buf, size_t n)request_suspend_state(state); 调⽤此函数: 具体实现在./kernel/power/earlysuspend.c中state: 为休眠则调⽤early_suspend_work android early_suspen⼯作队列为唤醒则调⽤late_resume_work android late_resume_work⼯作队列drivers/video/samsung/s3cfb_main.c中早已经注册屏幕开关register_early_suspend(&fbdev[i]->early_suspend);所以为休眠则调⽤early_suspend_work中的屏幕休眠函数:s3cfb_early_suspend()backlight_on()---->s3cfb_backlight_on() 在⽂件arch/arm/plat-s5p/dev-fimd-s5p.c中定义 npd->backlight_on = s3cfb_backlight_on;s3cfb_backlight_on中直接操作⽤来控制lcd的gpio关闭屏幕 arch/arm/mach-exynos/setup-fb-s5p.c为唤醒时调⽤late_resume_work中的屏幕唤醒函数:s3cfb_late_resume()backlight_off()---->s3cfb_backlight_off() 在⽂件arch/arm/plat-s5p/dev-fimd-s5p.c中定义 npd->backlight_off =s3cfb_backlight_off;s3cfb_backlight_off中直接操作⽤来控制lcd的gpio使能屏幕执⾏完所有的early_suspend后执⾏解锁main_wake_lock,以便休眠.wake_unlock(&main_wake_lock);mod_timer(&expire_timer, jiffies + has_lock); 在⽂件/kernel/power/wakelock.c中此函数将启⽤expire_timer定时器,定时器内容即expire_wake_locks340 static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);有四种⽅式可以引起休眠①在wake_unlock()中, 如果发现解锁以后没有任何其他的wake lock了, 就开始休眠②在定时器到时间以后, 定时器的回调函数会查看是否有其他的wake lock, 如果没有, 就在这⾥让系统进⼊睡眠③在wake_lock() 中, 对⼀个wake lock加锁以后, 会再次检查⼀下有没有锁, 刚加上锁,为什么要检查,有⽤吗④按power键,调⽤earlysuspend.使系统或应⽤程序释放锁.从⽽调⽤上述三个函数进⼊休眠if(has_lock ==0)queue_work(suspend_work_queue,&suspend_work); 由DECLARE_WORK(suspend_work, suspend);知道,队列中的内容即suspend 函数.suspend(); kernel/power/wakelock.cpm_suspend(requested_suspend_state);enter_state(state); kernel/power/suspend.csuspend_devices_and_enter(state);suspend_enter(state);suspend_ops->enter(state); -->调⽤平台相关的休眠函数，定义在中arch/arm/plat-samsung/pm.c:379:static const struct platform_suspend_ops s3c_pm_ops 即s3c_pm_enter s3c_pm_arch_stop_clocks() --> 休眠时执⾏的的最后⼀个函数.系统停在此处,等待中断或rtc等唤醒源唤醒.从此处开始唤醒流程enable_nonboot_cpus();suspend_test_start(); ---------->kernel已经被唤醒,当按键或中断来临后可以执⾏中断函数,上报唤醒事件.对于外部中断来说,上报power按键事件.pm_restore_gfp_mask(); kernel/power/suspend.center_state(state);pm_suspend(suspend_state_t state);suspend(); kernel/power/wakelock.c。

Android的屏幕禁止休眠和锁屏的方法

R.string.def_airplane_mode_radios）;
loadStringSetting（stmt中，Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS，
R.string.airplane_mode_toggleable_radios）;
/ /设置默认的CDMA紧急调
loadSetting（stmt中，Settings.System.EMERGENCY_TONE，0）;
/ /设置默认CDMA呼叫自动重试
loadSetting（stmt中，Settings.System.CALL_AUTO_RETRY，0）;
/ /设置默认的CDMA双音多频式
mExternallyEnabled =启用;
如果（！启用＆mShowing）{
如果（mExitSecureCallback！=空）{
如果（调试）Log.d（没错，“在verifyUnlock请求的过程中，无视”）;
/ /我们在处理一个请求，以验证用户进程
/ /可以得到过去的键盘锁。忽略多余的要求禁用/重新启用
该文件中有一个变量定义如下：
/ **
*外部应用程序（如手机应用程序）可以告诉我们，以禁用keygaurd。
* /
私人布尔mExternallyEnabled =真;
mExternallyEnabled是用来管理是否开启屏幕锁的关键。默认值是打开屏锁，根据注释可以知道他是希望应用程序来修改这个值。但是经过加打印信息发现开机的时候没有任何应用程序会修改它。修改这个值调用如下函数：
但是怎样才能开机之后不进入锁屏状态呢？这个是个非常费思量的问题。经过去，我知道锁屏的代码在LockScreen.java中，然后顺藤摸瓜，终于找到了可以设置锁屏功能开关的位置。代码位于：

Android休眠流程总结

Android休眠流程总结1. framework层1.1 java层休眠流程中上层有很多种，⽐如按power key进⼊休眠流程，还是就是settings下⾯的⾃动息屏流程。

1.1.1 power key休眠流程当⽤户按下power key的时候，PhoneWindowManager类下的interceptBeforeQueueing, 在handle special key流程中，会命中KeyEvent.KEYCODE_POWER.其业务逻辑⾥⾯就会调⽤到inteceptPowerKeyDown和interceptPowerKeyUp, ⽽休眠流程的起始条件，灭屏流程就是从这个interceptPowerKeyUp开始的。

之后会就interceptPowerKeyUp展开，但我们先来看下从key event发出后，怎么⾛到interceptBeforeQueueing的，这⾥主要看下framework层的获得key event事件后响应流程，⾄于key event事件怎么分发的和怎么获得的需要InuptDispatcher(inputFlinger)部分来分析，之后有时间再补充。

com_android_server_input_InputManagerService.cpp在收到InputDispatcher分发的出来PowerKey 事件之后，就会⾛到NativeInputManager::dispatchUnhandledKey⽅法，这⾥⽅法⾥通过回调的机制回调到InputManagerService.java下⾯的native⽅法dispatchUnhandleKey，注意这个⽅法是回调⽅法。

然后在调到InputManagerCallback下⾯的dispatchUnhandleKey，然后再调到PhoneWindowManager下⾯的dispatchUnhandleKey⽅法，然后调到interceptFallback⽅法，最终从这⾥⾯调到interceptBeforeQueueing这个⽅法。

Android休眠suspend_console_kernel_log

Android休眠suspend_console_kernel_log休眠唤醒打开log调试：Kernel/power/suspend.cint suspend_devices_and_enter(suspend_state_t state) --> suspend_console();void suspend_console(void){if (!console_suspend_enabled) 注释这一行，可以看到休眠后printk的打印return;printk("Suspending console(s) (use no_console_suspend to debug)\n");console_lock();console_suspended = 1;up(&console_sem);}Kernel/drivers/base/power/main.cint dpm_suspend_start(pm_message_t state){int error;error = dpm_prepare(state);if (!error)error = dpm_suspend(state);return error;}dpm_suspend() --> device_suspend() --> __device_suspend() static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info){dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?", may wakeup" : "");}改成static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info){dev_printk(KERN_ERR,dev, "%s%s%s\n", info, pm_verb(state.event), ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?", may wakeup" : "");}这样log如下：[ 220.430358] msm-mvs-audio msm-mvs-audio.0: suspend [ 220.435211] msm-cpu-dai msm-cpu-dai.0: suspend[ 220.439544] msm-codec-dai msm-codec-dai.0: suspend[ 220.444335] msm-dsp-audio msm-dsp-audio.0: suspend [ 220.449340] proccomm-regulator proccomm-regulator: suspend[ 220.454559] msm_serial msm_serial.1: suspend（suspend 过程出现resume，停止休眠）[ 220.460540] msm_otg_resume: usb exited from low power mode （问题所在）[ 220.464447] android_work: did not send uevent (0 0 (null)) [ 220.538238] proccomm-regulator proccomm-regulator: resume（开始resume）[ 220.538452] msm-dsp-audio msm-dsp-audio.0: resume[ 220.538574] msm-codec-dai msm-codec-dai.0: resume[ 220.538726] msm-cpu-dai msm-cpu-dai.0: resume[ 220.538848] msm-mvs-audio msm-mvs-audio.0: resume[ 220.538970] mvs-codec-dai mvs-codec-dai.0: resume[ 220.539093] mvs-cpu-dai mvs-cpu-dai.0: resume[ 220.539215] msm_smd msm_smd: resume[ 220.539306] msm_dmov msm_dmov: resume[ 220.539428] platform smc91x.0: resumelate_resume函数中加logout/target/product/phs300$ vim obj/KERNEL_OBJ/System.maplist_for_each_entry_reverse(pos, &early_suspend_handlers, link)if (pos->resume != NULL) {pos->resume(pos);printk("late_resume: func %p\n",pos->resume);}下面是跟踪log方法，可以调试suspend,resume,earlysuspend lateresume 等方面的问题，如哪一过程时间过长，跟踪log才可以很好定位问题，解决问题。

【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系统永不锁屏永不休眠的⽅法在进⾏Android系统开发的时候，有些特定的情况需要设置系统永不锁屏，永不休眠。

本篇⽂章给⼤家介绍Android 永不锁屏，开机不锁屏，删除设置中休眠时间选项，需要的朋友⼀起学习吧。

Android 6.0.1Create:2016-02-291.Settings 删掉屏幕待机选项packages/apps/Settings/res/xml/display_settings.xml注释掉这个ListPreferencepackages/apps/Settings/src/com/android/settings/DisplaySettings.java添加if条件，如果没有找到这个preference就不执⾏相关操作；具体可以参考被隐藏的 night_modemScreenTimeoutPreference = (ListPreference) findPreference(KEY_SCREEN_TIMEOUT);if (mScreenTimeoutPreference !=null ) {final long currentTimeout = Settings.System.getLong(resolver, SCREEN_OFF_TIMEOUT,FALLBACK_SCREEN_TIMEOUT_VALUE);mScreenTimeoutPreference.setValue(String.valueOf(currentTimeout));mScreenTimeoutPreference.setOnPreferenceChangeListener(this);disableUnusableTimeouts(mScreenTimeoutPreference);updateTimeoutPreferenceDescription(currentTimeout);}2.禁⽌锁屏frameworks/base/packages/SettingsProvider/res/values/defaults.xml<bool name="def_lockscreen_disabled">false</bool> 改为 true；即默认禁⽌锁屏frameworks/base/core/res/res/values/config.xml<integer name="config_multiuserMaximumUsers">1</integer> 不允许多⽤户；即最⼤⽤户数为1分别编译frameworks/base/packages/SettingsProvider 与 frameworks/base编译后push 到 system/priv-app/SettingsProvider/SettingsProvider.apk system/framework/framework.jar删去机器中对应的oat⽬录。

Android手机防止休眠的两种实现方法

Android⼿机防⽌休眠的两种实现⽅法
Android ⼿机防⽌休眠的两种实现⽅法
实现这⼀功能的⽅法有两种，
⼀种是在Manifest.xml⽂件⾥⾯声明。

⼀种是在代码⾥⾯修改LayoutParams的标志位。

具体如下：
1、在Manifest.xml⽂件⾥⾯⽤user-permission声明。

代码如下：
< uses-permission android:name=”android.permission.WAKE_LOCK” >
< /uses-permission >
这种⽅法，在安装apk时，系统会提⽰安装⼈是否允许使⽤禁⽌休眠功能。

2、在程序中⽤代码实现。

代码如下：
getWindow().setFlags(youtParams.FLAG_KEEP_SCREEN_ON, youtParams.FLAG_KEEP_SCREEN_ON);
把这段代码加在setContentView(yout.main)之前即可
这种⽅法，安装时，不会提⽰安装⼈是否允许使⽤禁⽌休眠功能
感谢阅读，希望能帮助到⼤家，以上就是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 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异常并处理。