"Android Code snippet eight" monitor whether the Android screen lock screen

Implementation method: 1) through Broadcastreceiver receive broadcast intent.action_screen_on and Intent.action_screen_off can determine whether the screen State lock screen, but only when the screen status changes will be issued broadcast ；

2) If you want to get the screen state before the screen state changes, you can call PowerManager's Isscreenon method through the reflection mechanism.

For specific implementations, see the code:

The implementation of Class screenobserver for screen state monitoring is implemented as follows:

[Java]View Plaincopy

2. Package com.isoft.screen;
6. Import Java.lang.reflect.Method;
10. Import android.app.Activity;
12. Import Android.content.BroadcastReceiver;
14. Import Android.content.Context;
16. Import android.content.Intent;
18. Import Android.content.IntentFilter;
20. Import Android.os.PowerManager;
22. Import Android.util.Log;
26. /**
28. *
30. * @author Zhangyg
32. *
34. */
36. Public class screenobserver{
38. private static String TAG = "Screenobserver";
40. private Context Mcontext;
42. private Screenbroadcastreceiver Mscreenreceiver;
44. private Screenstatelistener Mscreenstatelistener;
46. private static Method mreflectscreenstate;
50. Public Screenobserver (context context) {
52. Mcontext = context;
54. Mscreenreceiver = new Screenbroadcastreceiver ();
56. try {
58. Mreflectscreenstate = PowerManager. Class.getmethod ("Isscreenon",
60. new class[] {});
62. } catch (Nosuchmethodexception nsme) {
64. LOG.D (TAG, "API < 7," + nsme);
66. }
68. }
72. /** 
74. * Screen Status Broadcast recipient
76. * @author Zhangyg
78. *
80. */
82. private class Screenbroadcastreceiver extends broadcastreceiver{
84. private String action = null;
86. @Override
88. public void OnReceive (context context, Intent Intent) {
90. Action = Intent.getaction ();
92. if (Intent.ACTION_SCREEN_ON.equals (ACTION)) {
94. Mscreenstatelistener.onscreenon ();
96. }Else if (Intent.ACTION_SCREEN_OFF.equals (ACTION)) {
98. Mscreenstatelistener.onscreenoff ();
100. }
102. }
104. }
110. /** 
112. * Request a screen status update
114. * @param listener
116. */
118. public void Requestscreenstateupdate (Screenstatelistener listener) {
120. Mscreenstatelistener = listener;
122. Startscreenbroadcastreceiver ();
126. Firstgetscreenstate ();
128. }
132. /** 
134. * Request screen status for the first time
136. */
138. private void Firstgetscreenstate () {
140. PowerManager manager = (PowerManager) mcontext
142. . Getsystemservice (Activity.power_service);
144. if (Isscreenon (manager)) {
146. if (mscreenstatelistener! = null) {
148. Mscreenstatelistener.onscreenon ();
150. }
152. } Else {
154. if (mscreenstatelistener! = null) {
156. Mscreenstatelistener.onscreenoff ();
158. }
160. }
162. }
166. /** 
168. * Stop Screen status update
170. */
172. public void Stopscreenstateupdate () {
174. Mcontext.unregisterreceiver (Mscreenreceiver);
176. }
180. /** 
182. * Start Screen status broadcast receiver
184. */
186. private void Startscreenbroadcastreceiver () {
188. Intentfilter filter = new Intentfilter ();
190. Filter.addaction (intent.action_screen_on);
192. Filter.addaction (Intent.action_screen_off);
194. Mcontext.registerreceiver (mscreenreceiver, filter);
196. }
200. /** 
202. * Screen is open
204. * @param pm
206. * @return
208. */
210. private static boolean Isscreenon (PowerManager pm) {
212. Boolean screenstate;
214. try {
216. Screenstate = (Boolean) mreflectscreenstate.invoke (PM);
218. } catch (Exception e) {
220. Screenstate = false;
222. }
224. return screenstate;
226. }
230. Public interface Screenstatelistener {
232. public void Onscreenon ();
234. public void Onscreenoff ();
236. }
238. }

The example class screenobserveractivity that tests the Screenobserver feature is implemented as follows:

[Java]View Plaincopy

2. Package com.isoft.screen;
6. Import android.app.Activity;
8. Import Android.os.Bundle;
10. Import Android.util.Log;
14. Import Com.isoft.screen.ScreenObserver.ScreenStateListener;
18. Public class Screenobserveractivity extends Activity {
20. private String TAG = "Screenobserveractivity";
22. private Screenobserver Mscreenobserver;
26. @Override
28. public void OnCreate (Bundle savedinstancestate) {
30. super.oncreate (savedinstancestate);
32. Setcontentview (R.layout.main);
36. Mscreenobserver = New Screenobserver (this);
38. Mscreenobserver.requestscreenstateupdate (new Screenstatelistener () {
40. @Override
42. public void Onscreenon () {
44. Dosomethingonscreenon ();
46. }
50. @Override
52. public void Onscreenoff () {
54. Dosomethingonscreenoff ();
56. }
58. });
60. }
64. private void Dosomethingonscreenon () {
66. LOG.I (TAG, "screen was on ");
68. }
72. private void Dosomethingonscreenoff () {
74. LOG.I (TAG, "screen is Off");
76. }
80. @Override
82. protected void OnDestroy () {
84. Super.ondestroy ();
86. //Stop monitoring screen status
88. Mscreenobserver.stopscreenstateupdate ();
90. }
92. }
94. http://blog.csdn.net/m_changgong/article/details/7608911

"Android Code snippet eight" monitor whether the Android screen lock screen