android foregound service 锁屏后网络连接 安卓锁屏后断网

关于Android休眠之后网络连接工作情况的研究

几个问题：

1. 当Android设备休眠后，网络连接会断开吗？
2. 如果网络连接不断开收到数据包后Android设备会被唤醒吗？

Android设备休眠后，网络连接是否断开

这个问题其实很好验证，按如下步骤做一个实验：

• 步骤

2. 下载一个TCP调试软件（做为一个TCP Server）;



3. 写一个Android平台的TCP Client, 用一个Timer来向Server发送心跳;
4. 连接TcpServer, 这时候Tcp调试助手会收到来自Android手机的心跳;
5. 关闭手机屏幕，让手机休眠;

• 结论

熄灭屏幕后，很快你就会发现心跳没了，但是连接还在。证明了CPU休眠了但连接不会断。

收到数据包是否唤醒设备

同样做一个实验来验证收到数据包是否能唤醒设备

• 步骤

1. Tcp连接建立后, 让手机进入休眠;
2. 通过Tcp调试助手发送一条消息给Android客户端;
3. 打开手机屏幕, 看Client端是否收到消息;

• 结论

看到Server端发送过去的消息被打印在了屏幕上。

Android Client端代码

基于Netty网络框架

MainActivity.java

1. publicclassMainActivityextendsAppCompatActivityimplementsView.OnClickListener,
2. TcpClient.TcpClientListener{
3. 
   
4. privateEditText edtMain;
5. privateButton btnConnect;
6. privateTcpClient tcpClient;
7. 
   
8. @Override
9. protectedvoid onCreate(Bundle savedInstanceState){
10. super.onCreate(savedInstanceState);
11. setContentView(R.layout.activity_main);
12. edtMain =(EditText) findViewById(R.id.edt_main);
13. btnConnect =(Button) findViewById(R.id.btn_Connect);
14. tcpClient =newTcpClient();
15. edtMain.append("onCreate<<<<<<<<<<<<<<<<<");
16. 
    
17. //Heart beat
18. newTimer().schedule(newTimerTask(){
19. @Override
20. publicvoid run(){
21. finalCharSequence time =DateFormat.format("hh:mm:ss",System.currentTimeMillis());
22. if(tcpClient.isConnected()){
23. tcpClient.send((time +"\r\n").toString().getBytes());
24. }
25. runOnUiThread(newRunnable(){
26. @Override
27. publicvoid run(){
28. edtMain.append(time +"\n");
29. }
30. });
31. }
32. },0,2000);
33. 
    
34. btnConnect.setOnClickListener(this);
35. tcpClient.setTcpClentListener(this);
36. }
37. 
    
38. @Override
39. protectedvoid onDestroy(){
40. edtMain.append("onDestroy>>>>>>>>>>>>>>>>");
41. super.onDestroy();
42. }
43. 
    
44. @Override
45. publicvoid onClick(View v){
46. tcpClient.connect("10.1.1.86",3008);
47. }
48. 
    
49. @Override
50. publicvoid received(finalbyte[] msg){
51. runOnUiThread(newRunnable(){
52. @Override
53. publicvoid run(){
54. edtMain.append("received ============= "+newString(msg));
55. }
56. });
57. }
58. 
    
59. @Override
60. publicvoid sent(byte[] sentData){
61. 
    
62. }
63. 
    
64. @Override
65. publicvoid connected(){
66. runOnUiThread(newRunnable(){
67. @Override
68. publicvoid run(){
69. btnConnect.setText("Connected");
70. }
71. });
72. }
73. 
    
74. @Override
75. publicvoid disConnected(int code,String msg){
76. runOnUiThread(newRunnable(){
77. @Override
78. publicvoid run(){
79. btnConnect.setText("Connect");
80. }
81. });
82. }
83. }

TcpClient.java

1. publicclassTcpClient{
2. //Disconnect code
3. publicstaticfinalint ERR_CODE_NETWORK_INVALID =0;
4. publicstaticfinalint ERR_CODE_TIMEOUT =1;
5. publicstaticfinalint ERR_CODE_UNKNOWN =2;
6. publicstaticfinalint ERR_CODE_DISCONNECTED =3;
7. 
   
8. privateEventLoopGroup mGroup;
9. privateBootstrap mBootstrap;
10. privateTcpClientListener mListener;
11. privateChannelFuture mChannelFuture;
12. privateboolean isConnected =false;
13. 
    
14. publicTcpClient(){
15. mGroup =newNioEventLoopGroup();
16. mBootstrap =newBootstrap();
17. mBootstrap.group(mGroup)
18. .channel(NioSocketChannel.class)
19. .option(ChannelOption.TCP_NODELAY,true)
20. .handler(newChannelInitializer<SocketChannel>(){
21. @Override
22. protectedvoid initChannel(SocketChannel ch)throwsException{
23. ch.pipeline().addLast("decoder",newFrameDecoder());
24. ch.pipeline().addLast("handler",newMsgHandler());
25. }
26. });
27. }
28. 
    
29. publicboolean isConnected(){
30. return isConnected;
31. }
32. 
    
33. /**
34. * 建立连接
35. * @author swallow
36. * @createTime 2016/2/16
37. * @lastModify 2016/2/16
38. * @param host Server host
39. * @param port Server port
40. * @return
41. */
42. publicvoid connect(finalString host,finalint port){
43. try{
44. mChannelFuture = mBootstrap.connect(host, port);
45. // mChannelFuture.sync();
46. // mChannelFuture.channel().closeFuture();
47. }catch(Exception e){
48. mGroup.shutdownGracefully();
49. if(mListener !=null)
50. mListener.disConnected(ERR_CODE_TIMEOUT, e.getMessage());
51. e.printStackTrace();
52. }
53. }
54. 
    
55. /**
56. * 断开连接
57. * @author swallow
58. * @createTime 2016/1/29
59. * @lastModify 2016/1/29
60. * @param
61. * @return
62. */
63. publicvoid disConnect(){
64. if(mChannelFuture ==null)
65. return;
66. if(!mChannelFuture.channel().isActive())
67. return;
68. mChannelFuture.channel().close();
69. mChannelFuture.channel().closeFuture();
70. mGroup.shutdownGracefully();
71. }
72. 
    
73. /**
74. * 消息发送
75. * @param
76. * @return
77. * @author swallow
78. * @createTime 2016/1/29
79. * @lastModify 2016/1/29
80. */
81. publicvoid send(finalbyte[] data){
82. finalByteBuf byteBuf =Unpooled.copiedBuffer(data);
83. mChannelFuture.channel()
84. .writeAndFlush(byteBuf)
85. .addListener(
86. newChannelFutureListener(){
87. @Override
88. publicvoid operationComplete(ChannelFuture future)throwsException{
89. if(mListener !=null)
90. mListener.sent(data);
91. }
92. }
93. );
94. }
95. 
    
96. /**
97. * 设置TcpClient监听
98. * @author swallow
99. * @createTime 2016/1/29
100. * @lastModify 2016/1/29
101. * @param
102. * @return
103. */
104. publicvoid setTcpClentListener(TcpClientListener listener){
105. this.mListener = listener;
106. }
107. 
     
108. /**
109. * @className: FrameDecoder
110. * @classDescription: Decode to frames
111. * @author: swallow
112. * @createTime: 2015/11/23
113. */
114. privateclassFrameDecoderextendsByteToMessageDecoder{
115. @Override
116. protectedvoid decode(ChannelHandlerContext ctx,ByteBufin,List<Object>out)throwsException{
117. byte[] data =newbyte[in.readableBytes()];
118. in.readBytes(data);
119. out.add(data);
120. // // 不够4个字节则不予解析
121. // if (in.readableBytes() < 4) {
122. // return;
123. // }
124. // in.markReaderIndex(); // mina in.mark();
125. //
126. // // 获取帧长度
127. // byte[] headers = new byte[4];
128. // in.readBytes(headers);
129. // int frameLen = Utils.bytesToInt(headers);
130. // if (frameLen > in.readableBytes()) {
131. // in.resetReaderIndex();
132. // return;
133. // }
134. //
135. // //获取一个帧
136. // byte[] data = new byte[frameLen];
137. // in.readBytes(data);
138. // out.add(data);
139. }
140. }
141. 
     
142. 
     
143. /**
144. * @className: MsgHandler
145. * @classDescription: 经过FrameDecoder的消息处理器
146. * @author: swallow
147. * @createTime: 2015/11/23
148. */
149. privateclassMsgHandlerextendsSimpleChannelInboundHandler<byte[]>{
150. 
     
151. @Override
152. protectedvoid channelRead0(ChannelHandlerContext ctx,byte[] msg)throwsException{
153. if(mListener !=null)
154. mListener.received(msg);
155. }
156. 
     
157. @Override
158. publicvoid channelActive(ChannelHandlerContext ctx)throwsException{
159. if(mListener !=null){
160. isConnected =true;
161. mListener.connected();
162. }
163. }
164. 
     
165. @Override
166. publicvoid channelInactive(ChannelHandlerContext ctx)throwsException{
167. if(mListener !=null){
168. isConnected =false;
169. mListener.disConnected(ERR_CODE_DISCONNECTED,"The connection is disconnected!");
170. }
171. }
172. 
     
173. @Override
174. publicvoid exceptionCaught(ChannelHandlerContext ctx,Throwable cause)throwsException{
175. super.exceptionCaught(ctx, cause);
176. }
177. }
178. 
     
179. /**
180. * @className: TcpClientListener
181. * @classDescription: The client listener
182. * @author: swallow
183. * @createTime: 2015/11/25
184. */
185. publicinterfaceTcpClientListener{
186. void received(byte[] msg);
187. 
     
188. void sent(byte[] sentData);
189. 
     
190. void connected();
191. 
     
192. void disConnected(int code,String msg);
193. }
194. }

activity_main.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"
3. xmlns:tools="http://schemas.android.com/tools"
4. android:layout_width="match_parent"
5. android:layout_height="match_parent"
6. android:paddingBottom="@dimen/activity_vertical_margin"
7. android:paddingLeft="@dimen/activity_horizontal_margin"
8. android:paddingRight="@dimen/activity_horizontal_margin"
9. android:paddingTop="@dimen/activity_vertical_margin"
10. tools:context="cn.ecpark.devicesleep.MainActivity">
11. 
    
12. <Button
13. android:id="@+id/btn_Connect"
14. android:layout_width="match_parent"
15. android:layout_height="wrap_content"
16. android:layout_alignParentBottom="true"
17. android:text="Connect"/>
18. 
    
19. <ScrollView
20. android:layout_width="match_parent"
21. android:layout_height="match_parent"
22. android:layout_above="@+id/btn_Connect">
23. 
    
24. <EditText
25. android:id="@+id/edt_main"
26. android:layout_width="match_parent"
27. android:layout_height="match_parent"
28. android:editable="false"/>
29. 
    
30. </ScrollView>
31. 
    
32. </RelativeLayout>

原理

如果一开始就对Android手机的硬件架构有一定的了解，设计出的应用程序通常不会成为待机电池杀手，而要设计出正确的通信机制与通信协议也并不困难。但如果不去了解而盲目设计，可就没准了。

首先Android手机有两个处理器，一个叫Application Processor（AP），一个叫Baseband Processor（BP）。AP是ARM架构的处理器，用于运行Linux+Android系统；BP用于运行实时操作系统（RTOS），通讯协议栈运行于BP的RTOS之上。非通话时间，BP的能耗基本上在5mA左右，而AP只要处于非休眠状态，能耗至少在50mA以上，执行图形运算时会更高。另外LCD工作时功耗在100mA左右，WIFI也在100mA左右。一般手机待机时，AP、LCD、WIFI均进入休眠状态，这时Android中应用程序的代码也会停止执行。

Android为了确保应用程序中关键代码的正确执行，提供了Wake Lock的API，使得应用程序有权限通过代码阻止AP进入休眠状态。但如果不领会Android设计者的意图而滥用Wake Lock API，为了自身程序在后台的正常工作而长时间阻止AP进入休眠状态，就会成为待机电池杀手。比如前段时间的某应用，比如现在仍然干着这事的某应用。

首先，完全没必要担心AP休眠会导致收不到消息推送。通讯协议栈运行于BP，一旦收到数据包，BP会将AP唤醒，唤醒的时间足够AP执行代码完成对收到的数据包的处理过程。其它的如Connectivity事件触发时AP同样会被唤醒。那么唯一的问题就是程序如何执行向服务器发送心跳包的逻辑。你显然不能靠AP来做心跳计时。Android提供的Alarm Manager就是来解决这个问题的。Alarm应该是BP计时（或其它某个带石英钟的芯片，不太确定，但绝对不是AP），触发时唤醒AP执行程序代码。那么Wake Lock API有啥用呢？比如心跳包从请求到应答，比如断线重连重新登陆这些关键逻辑的执行过程，就需要Wake Lock来保护。而一旦一个关键逻辑执行成功，就应该立即释放掉Wake Lock了。两次心跳请求间隔5到10分钟，基本不会怎么耗电。除非网络不稳定，频繁断线重连，那种情况办法不多。

网上有说使用AlarmManager，因为AlarmManager 是Android 系统封装的用于管理 RTC 的模块，RTC (Real Time Clock) 是一个独立的硬件时钟，可以在 CPU 休眠时正常运行，在预设的时间到达时，通过中断唤醒 CPU。