android 长连接通信方案,Android进阶——Socket长连接通信实例

Socket通信在项目中时有用到，把长连接的相关实例分享一下。

如果要保持一个长连接，Socket代码最好写在一个服务内，避免误杀。

public class SocketService extends Service {

/**

* 心跳标记

*/

private boolean heartFlag = false;

/**

* 是否接受服务器消息

*/

private boolean isReceive = true;

/**

* 线程是否启动

*/

private boolean isStarted;

//初始化Socket

private Socket socket;

//定义一个handler

private Handler mHandler = new Handler(){

public void handleMessage(android.os.Message msg) {

handleMsg(msg);

}

};

/**

* Socket的正常通信数据

*/

public final int HANDLER_MSG_TAG = 0x1001;

/**

* 连接异常handler

*/

public final int EXCEPTION_HANDLER_TAG = 0x1002;

/**

* 主界面提示socket异常，点击可以重新连接

*/

public final int EXCEPTION_SOCKET_TAG=0x1003;

/**

* 定义全局的json

*/

public static String jsonmsg="";

@Override

public IBinder onBind(Intent intent) {

// TODO: Return the communication channel to the service.

throw new UnsupportedOperationException("Not yet implemented");

}

@Override

public void onCreate() {

super.onCreate();

startSocketService();

}

private void startSocketService() {

//判断网络链接的情况下

if (NetUtils.isConnected(getApplicationContext())) {

AcceptThread thread = new AcceptThread();

thread.start();

} else {

sendHandler(EXCEPTION_HANDLER_TAG);

}

}

/**

* Handler 发送消息

*/

public void sendHandler(int tag) {

Message msg = new Message();

msg.what = tag;

mHandler.sendMessage(msg);

}

/**

* 新线程 用于Socket长连接

*/

class AcceptThread extends Thread {

@Override

public void run() {

super.run();

Log.e("%%%%%%%%", "-----------socket线程打开");

if (!isStarted) {

try {

socket = new Socket("IP", 7094); //两个参数，IP和端口号

isStarted = true;

isReceive = true;

heartFlag = true;

socket.setKeepAlive(true);

startMsgLooper(socket);

} catch (UnknownHostException e) {

Log.d("exception",

"断开连接-------UnknownHostException-----%%" + e.getMessage());

} catch (IOException e) {

if (e instanceof SocketException) {

Log.d("exception", "-------SocketException-----%%" + e.getMessage());

}

Log.d("exception",

"断开连接-------IOException-----%%" + e.getMessage());

} catch (Exception e) {

Log.d("exception",

"断开连接-------Exception-----%%" + e.getMessage());

}

}

}

}

/**

* @param client 初始化完成的Socket

* @throws IOException

*/

public void startMsgLooper(Socket client) throws IOException {

String msg = "";

// 这个控制需要你来完成,while中的true

while (isReceive) {

//Socket通过服务器返回的消息

msg = receiveMsg(client);

if (msg != null) {

//首次返回，确认连接成功

if ("{\"state\":200,\"type\":\"confirm\"}".equals(msg)) {

// String为需要传入发送给服务的数据

sendMsg("String", client);

LogUtil.e("asker----",msg); //首次心跳返回

startHeartBeatThread(client);

} else if ("heartbeat".equals(msg)) {

// 在没有数据返回时，持续返回心跳

Log.e("%%%------","heartbeat");

} else {

//Hander机制把数据传出来

Message message = new Message();

message.what = HANDLER_MSG_TAG;

Bundle bundle = new Bundle();

bundle.putString("msg", msg);

message.setData(bundle);

mHandler.sendMessage(message);

}

} else {

//没有接收到心跳时候判断

Log.e("%%%------", "----------我心跳异常，我没收到");

CustomToast.showToast("心跳异常");

}

}

}

/**

* 对socket获取的数据进行读取

* @param in

* @return

* @throws IOException

*/

public static String readLine(PushbackInputStream in) throws IOException {

char buf[] = new char[128];

int room = buf.length;

int offset = 0;

int c;

loop:

while (true) {

switch (c = in.read()) {

case -1:

case '\n':

break loop;

case '\r':

int c2 = in.read();

if ((c2 != '\n') && (c2 != -1)) {

in.unread(c2);

}

break loop;

default:

if (--room < 0) {

char[] lineBuffer = buf;

buf = new char[offset + 128];

room = buf.length - offset - 1;

System.arraycopy(lineBuffer, 0, buf, 0, offset);

}

buf[offset++] = (char) c;

//把截取的heartbeat返回

if (String.copyValueOf(buf, 0, offset).equals("heartbeat")) {

break loop;

}

break;

}

}

if ((c == -1) && (offset == 0))

return null;

return String.copyValueOf(buf, 0, offset);

}

//计时器

private Timer heartBeatTimer;

private TimerTask heartBeatTask;

/**

* 启动心跳线程

*/

private void startHeartBeatThread(final Socket client) {

heartBeatTimer = new Timer();

heartBeatTask = new TimerTask() {

@Override

public void run() {

// Log.e("%%%heart", "心跳----------------" + heartFlag); 心跳日志

try {

if (socket != null && heartFlag) {

sendMsg("heartbeat", client);

}

} catch (IOException e) {

Message message = new Message();

message.what = EXCEPTION_SOCKET_TAG;

mHandler.sendMessage(message);

Log.d("exception", "断开连接-------startHeartBeatThread-----%%"

+ e.getMessage());

} catch (Exception e) {

Message message = new Message();

message.what = EXCEPTION_SOCKET_TAG;

mHandler.sendMessage(message);

Log.d("exception",

"断开连接---startHeartBeatThread----Exception-----%%"

+ e.getMessage());

}

}

};

heartBeatTimer.schedule(heartBeatTask, 1000, 5000);

}

/**

* 发送msg的IO流

* @param string

* @param client

* @throws IOException

*/

private void sendMsg(String string, Socket client) throws IOException {

OutputStream outputStream = client.getOutputStream();

outputStream.write(string.getBytes());

outputStream.flush();

}

/**

* 接受msg的IO流

* @param client

* @return

* @throws IOException

*/

private String receiveMsg(Socket client) throws IOException {

InputStream inputStream = client.getInputStream();

PushbackInputStream pushbackInputStream = new PushbackInputStream(

inputStream);

return readLine(pushbackInputStream);

}

/**

* 处理handler发送的异常情况

* @param msg

*/

public void handleMsg(Message msg) {

switch (msg.what) {

//socket 正常的通信数据，通过广播发送到需要数据的地方

case HANDLER_MSG_TAG:

jsonmsg = msg.getData().getString("msg");

Intent intent = new Intent();

intent.setAction("jsonmsg");

sendBroadcast(intent);

break;

/**

* socket异常时的处理

*/

case EXCEPTION_SOCKET_TAG:

stopSocketService();

// startSocketServer();

// showToast("连接已断开");

break;

default:

break;

}

}

@Override

public void onDestroy() {

stopSocketService();

super.onDestroy();

}

/**

* 关闭socket,2016年1月4日 hgb

*/

public void stopSocketService() {

Log.e("%%%%%%%%", "-----------socket线程被关闭");

isStarted = false;

isReceive = false;

heartFlag = false;

if (heartBeatTask != null) {

heartBeatTask.cancel();

}

if (heartBeatTimer != null) {

heartBeatTimer.cancel();

}

try {

if (socket != null) {

socket.close();

socket = null;

Log.e("%%%%%%%%", "-----------socket.close");

}

} catch (IOException e) {

e.printStackTrace();

}

}

}开启服务：

intentSocket = new Intent(this, SocketService.class);

this.startService(intentSocket);

关闭服务：

this.stopService(intentSocket);