在Android上面如何使用带有心跳检测的Socket

其他 2019-06-11 12:01:35 阅读次数: 0

由于移动设备的网络的复杂性，经常会出现网络断开，如果没有心跳包的检测，客户端只会在需要发送数据的时候才知道自己已经断线，会延误，甚至丢失服务器发送过来的数据。一下简单建立一个带有心跳检测的SocketDemo。

Android 后台Servevice


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
package org.feng.sockettest.server;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.WeakReference;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Arrays;
 
import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
 
public class BackService extends Service {
     private static final String TAG = "BackService" ;
     private static final long HEART_BEAT_RATE = 3 * 1000 ;
 
     public static final String HOST = "192.168.1.101" ; // "192.168.1.21";//
     public static final int PORT = 9800 ;
     
     public static final String MESSAGE_ACTION= "org.feng.message_ACTION" ;
     public static final String HEART_BEAT_ACTION= "org.feng.heart_beat_ACTION" ;
     
     private ReadThread mReadThread;
 
     private LocalBroadcastManager mLocalBroadcastManager;
 
     private WeakReference<Socket> mSocket;
 
     // For heart Beat
     private Handler mHandler = new Handler();
     private Runnable heartBeatRunnable = new Runnable() {
 
         @Override
         public void run() {
             if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
                 boolean isSuccess = sendMsg( "" ); //就发送一个\r\n过去 如果发送失败，就重新初始化一个socket
                 if (!isSuccess) {
                     mHandler.removeCallbacks(heartBeatRunnable);
                     mReadThread.release();
                     releaseLastSocket(mSocket);
                     new InitSocketThread().start();
                 }
             }
             mHandler.postDelayed( this , HEART_BEAT_RATE);
         }
     };
 
     private long sendTime = 0L;
     private IBackService.Stub iBackService = new IBackService.Stub() {
 
         @Override
         public boolean sendMessage(String message) throws RemoteException {
             return sendMsg(message);
         }
     };
 
     @Override
     public IBinder onBind(Intent arg0) {
         return iBackService;
     }
     
     @Override
     public void onCreate() {
         super .onCreate();
         new InitSocketThread().start();
         mLocalBroadcastManager=LocalBroadcastManager.getInstance( this );
         
     }
     public boolean sendMsg(String msg) {
         if ( null == mSocket || null == mSocket.get()) {
             return false ;
         }
         Socket soc = mSocket.get();
         try {
             if (!soc.isClosed() && !soc.isOutputShutdown()) {
                 OutputStream os = soc.getOutputStream();
                 String message = msg + "\r\n" ;
                 os.write(message.getBytes());
                 os.flush();
                 sendTime = System.currentTimeMillis(); //每次发送成数据，就改一下最后成功发送的时间，节省心跳间隔时间
             } else {
                 return false ;
             }
         } catch (IOException e) {
             e.printStackTrace();
             return false ;
         }
         return true ;
     }
 
     private void initSocket() { //初始化Socket
         try {
             Socket so = new Socket(HOST, PORT);
             mSocket = new WeakReference<Socket>(so);
             mReadThread = new ReadThread(so);
             mReadThread.start();
             mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE); //初始化成功后，就准备发送心跳包
         } catch (UnknownHostException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     private void releaseLastSocket(WeakReference<Socket> mSocket) {
         try {
             if ( null != mSocket) {
                 Socket sk = mSocket.get();
                 if (!sk.isClosed()) {
                     sk.close();
                 }
                 sk = null ;
                 mSocket = null ;
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     class InitSocketThread extends Thread {
         @Override
         public void run() {
             super .run();
             initSocket();
         }
     }
 
     // Thread to read content from Socket
     class ReadThread extends Thread {
         private WeakReference<Socket> mWeakSocket;
         private boolean isStart = true ;
 
         public ReadThread(Socket socket) {
             mWeakSocket = new WeakReference<Socket>(socket);
         }
 
         public void release() {
             isStart = false ;
             releaseLastSocket(mWeakSocket);
         }
 
         @Override
         public void run() {
             super .run();
             Socket socket = mWeakSocket.get();
             if ( null != socket) {
                 try {
                     InputStream is = socket.getInputStream();
                     byte [] buffer = new byte [ 1024 * 4 ];
                     int length = 0 ;
                     while (!socket.isClosed() && !socket.isInputShutdown()
                             && isStart && ((length = is.read(buffer)) != - 1 )) {
                         if (length > 0 ) {
                             String message = new String(Arrays.copyOf(buffer,
                                     length)).trim();
                             Log.e(TAG, message);
                             //收到服务器过来的消息，就通过Broadcast发送出去
                             if (message.equals( "ok" )){ //处理心跳回复
                                 Intent intent= new Intent(HEART_BEAT_ACTION);
                                 mLocalBroadcastManager.sendBroadcast(intent);
                             } else {
                                 //其他消息回复
                                 Intent intent= new Intent(MESSAGE_ACTION);
                                 intent.putExtra( "message" , message);
                                 mLocalBroadcastManager.sendBroadcast(intent);
                             }
                         }
                     }
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 
}




在Activity中发送以及接收数据：



?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package org.feng.sockettest;
 
import java.lang.ref.WeakReference;
 
import org.feng.sockettest.server.BackService;
import org.feng.sockettest.server.IBackService;
 
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v4.content.LocalBroadcastManager;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
 
public class MainActivity extends Activity {
     private static final String TAG = "MainActivity" ;
 
     private IBackService iBackService;
     private ServiceConnection conn = new ServiceConnection() {
 
         @Override
         public void onServiceDisconnected(ComponentName name) {
             iBackService = null ;
 
         }
 
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             iBackService = IBackService.Stub.asInterface(service);
         }
     };
 
     private TextView mResultText;
     private EditText mEditText;
     private Intent mServiceIntent;
 
     class MessageBackReciver extends BroadcastReceiver {
         private WeakReference<TextView> textView;
 
         public MessageBackReciver(TextView tv) {
             textView = new WeakReference<TextView>(tv);
         }
 
         @Override
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             TextView tv = textView.get();
             if (action.equals(BackService.HEART_BEAT_ACTION)) {
                 if ( null != tv) {
                     tv.setText( "Get a heart heat" );
                 }
             } else {
                 String message = intent.getStringExtra( "message" );
                 tv.setText(message);
             }
         };
     }
 
     private MessageBackReciver mReciver;
 
     private IntentFilter mIntentFilter;
 
     private LocalBroadcastManager mLocalBroadcastManager;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
 
         mLocalBroadcastManager = LocalBroadcastManager.getInstance( this );
 
         mResultText = (TextView) findViewById(R.id.resule_text);
         mEditText = (EditText) findViewById(R.id.content_edit);
 
         mReciver = new MessageBackReciver(mResultText);
 
         mServiceIntent = new Intent( this , BackService. class );
 
         mIntentFilter = new IntentFilter();
         mIntentFilter.addAction(BackService.HEART_BEAT_ACTION);
         mIntentFilter.addAction(BackService.MESSAGE_ACTION);
 
     }
 
     @Override
     protected void onStart() {
         super .onStart();
         mLocalBroadcastManager.registerReceiver(mReciver, mIntentFilter);
         bindService(mServiceIntent, conn, BIND_AUTO_CREATE);
     }
 
     @Override
     protected void onStop() {
         super .onStop();
         unbindService(conn);
         mLocalBroadcastManager.unregisterReceiver(mReciver);
     }
 
     public void onClick(View view) {
         switch (view.getId()) {
         case R.id.send:
             String content = mEditText.getText().toString();
             try {
                 boolean isSend = iBackService.sendMessage(content); //Send Content by socket
                 Toast.makeText( this , isSend ? "success" : "fail" ,
                         Toast.LENGTH_SHORT).show();
                 mEditText.setText( "" );
             } catch (RemoteException e) {
                 e.printStackTrace();
             }
             break ;
 
         default :
             break ;
         }
     }
}



完整项目带服务器段代码的见：  http://git.oschina.net/fengcunhan/SocketTest.git

猜你喜欢

转载自blog.csdn.net/jianpengxuexikaifa/article/details/39228687
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022