devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：小丑西瓜9 | 2024-03-24 10:29:28

赞

踩

updatesuspendblockerlocked

一、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的值，比如30s
  17. 			final int screenOffTimeout = getScreenOffTimeoutLocked();
  18. 			// 屏幕在熄灭前，会先变暗一段时间，这段时间叫DimDuration，计算方式：
  19. 			// SCREEN_DIM_DURATION = 7s，MAXIMUM_SCREEN_DIM_RATIO = 0.2
  20. 			// Math.min(SCREEN_DIM_DURATION, (int)(screenOffTimeout * MAXIMUM_SCREEN_DIM_RATIO))
  21. 			// 4、获取DimDuration的值，30s x 0.2 = 6s
  22. 			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 + 24
  29. 				nextTimeout = mLastUserActivityTime
  30. 						+ screenOffTimeout - screenDimDuration;
  31. 				if (now < nextTimeout) {
  32. 					// now在屏幕Dim之前，说明屏幕亮着，设置flag
  33. 					mUserActivitySummary |= USER_ACTIVITY_SCREEN_BRIGHT;
  34. 				} else {
  35. 					// extTimeout：此处指到屏幕熄灭的时间间隔
  36. 					//7、nextTimeout的时间：BASE + 30 = BASE + 30
  37. 					nextTimeout = mLastUserActivityTime + screenOffTimeout;
  38. 					// 8、now处于屏幕Dim之后、屏幕熄灭之前设置DIM flag
  39. 					if (now < nextTimeout) {
  40. 						mUserActivitySummary |= USER_ACTIVITY_SCREEN_DIM;
  41. 					}
  42. 				}
  43. 			}
  44. 			if (mUserActivitySummary == 0
  45. 					&& mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {
  46. 				nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout;
  47. 				if (now < nextTimeout
  48. 						&& mDisplayPowerRequest.screenState
  49. 								!= DisplayPowerRequest.SCREEN_STATE_OFF) {
  50. 					mUserActivitySummary = mDisplayPowerRequest.screenState
  51. 							== DisplayPowerRequest.SCREEN_STATE_BRIGHT ?
  52. 							USER_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. 	@Override
  73. 	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 new
  84.  * state can be recomputed when the power state is updated.
  85.  */
  86. private void handleUserActivityTimeout() { // runs on handler thread
  87. 	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 sure
  109. 	// 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. 	@Override
  150. 	public void acquire() {
  151. 		synchronized (this) {
  152. 			mReferenceCount += 1;
  153. 			if (mReferenceCount == 1) {
  154. 				nativeAcquireSuspendBlocker(mName);
  155. 			}
  156. 		}
  157. 	}
  158.  
  159. 	@Override
  160. 	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接口
  174. com_android_server_power_PowerManagerService.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. 	@Override
  3. 	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 new
  14.  * state can be recomputed when the power state is updated.
  15.  */
  16. private void handleUserActivityTimeout() { // runs on handler thread
  17. 	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 sure
  15. 	// 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. 	@Override
  56. 	public void acquire() {
  57. 		synchronized (this) {
  58. 			mReferenceCount += 1;
  59. 			if (mReferenceCount == 1) {
  60. 				nativeAcquireSuspendBlocker(mName);
  61. 			}
  62. 		}
  63. 	}
  64.  
  65. 	@Override
  66. 	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接口
  2. com_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. }

 

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

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

  

闽ICP备14008679号