基于TCP Socket的Android通信组件
这个组件是很早之前写的了，当时的一个需求是需要实现在Android手机客户端的长连接，所以需要用到socket通信，当时查阅了相关资料，在其他前辈的基础上，整理出这样一个组件，其中肯定还有许多问题，但还是先放出来吧。
实现的原理很简单，开启一个子线程，与服务器通信，并且实现了断线重连，获取到数据以后回调接口，不阻塞主线程。
连接服务器线程类
package org.yong.tcpsocket;
import java.util.Vector;
import android.util.Log;
/**
* 连接服务器线程类
*
* @author Cheng Yong
*/
public class TCPSocketConnect implements Runnable {
private boolean isConnect = false;// 是否连接服务器
private boolean isWrite = false;// 是否发送数据
private static Vector<byte[]> datas = new Vector<byte[]>();// 待发送数据队列
private Object lock = new Object();// 连接锁对象
private TCPSocketFactory mSocket;// socket连接
private WriteRunnable writeRunnable;// 发送数据线程
private String ip = null;
private int port = -1;
/**
* 创建连接
*
* @param callback
* 回调接口
* @param executor
* 线程池对象
*/
public TCPSocketConnect(TCPSocketCallback callback) {
mSocket = new TCPSocketFactory(callback);// 创建socket连接
writeRunnable = new WriteRunnable();// 创建发送线程
}
@Override
public void run() {
if (ip == null || port == -1) {
return;
}
isConnect = true;
while (isConnect) {
synchronized (lock) {
try {
Log.e("TCPSocketConnect",">TCP连接服务器<");
mSocket.connect(ip, port);// 连接服务器
} catch (Exception e) {
try {
Log.e("TCPSocketConnect",">TCP连接服务器失败, 6秒后重新连接<");
resetConnect();// 断开连接
lock.wait(6000);
continue;
} catch (InterruptedException e1) {
continue;
}
}
}
Log.e("TCPSocketConnect",">TCP连接服务器成功<");
isWrite = true;// 设置可发送数据
new Thread(writeRunnable).start();// 在线程池启动发送线程
try {
mSocket.read();// 获取数据
} catch (Exception e) {
Log.e("TCPSocketConnect",">TCP连接异常<", e);
} finally {
Log.e("TCPSocketConnect",">TCP连接中断<");
resetConnect();// 断开连接
}
}
Log.e("TCPSocketConnect",">=TCP结束连接线程=<");
}
/**
* 关闭服务器连接
*/
public void disconnect() {
synchronized (lock) {
isConnect = false;
lock.notify();
resetConnect();
}
}
/**
* 重置连接
*/
public void resetConnect() {
Log.e("TCPSocketConnect",">TCP重置连接<");
writeRunnable.stop();// 发送停止信息
mSocket.disconnect();
}
/**
* 向发送线程写入发送数据
*/
public void write(byte[] buffer) {
writeRunnable.write(buffer);
}
/**
* 设置IP和端口
*
* @param ip
* @param port
*/
public void setAddress(String host, int port) {
this.ip = host;
this.port = port;
}
/**
* 发送数据
*/
private boolean writes(byte[] buffer) {
try {
mSocket.write(buffer);
Thread.sleep(1);
return true;
} catch (Exception e) {
resetConnect();
return false;
}
}
/**
* 发送线程
*
* @author Esa
*/
private class WriteRunnable implements Runnable {
private Object wlock = new Object();// 发送线程锁对象
@Override
public void run() {
Log.e("TCPSocketConnect",">TCP发送线程开启<");
while (isWrite) {
synchronized (wlock) {
if (datas.size() <= 0) {
try {
wlock.wait();// 等待发送数据
} catch (InterruptedException e) {
continue;
}
}
while (datas.size() > 0) {
byte[] buffer = datas.remove(0);// 获取一条发送数据
if (isWrite) {
writes(buffer);// 发送数据
} else {
wlock.notify();
}
}
}
}
Log.e("TCPSocketConnect",">TCP发送线程结束<");
}
/**
* 添加数据到发送队列
*
* @param buffer
* 数据字节
*/
public void write(byte[] buffer) {
synchronized (wlock) {
datas.add(buffer);// 将发送数据添加到发送队列
wlock.notify();// 取消等待
}
}
public void stop() {
synchronized (wlock) {
isWrite = false;
wlock.notify();
}
}
}
}
获取网络数据回调类
package org.yong.tcpsocket;
/**
* 获取网络数据回调类
*
* @author Cheng Yong
*
*/
public abstract interface TCPSocketCallback {
/**
* 断开连接
*/
public static final int TCP_DISCONNECTED = 0;
/**
* 已连接
*/
public static final int TCP_CONNECTED = 1;
/**
* 连接获得数据
*/
public static final int TCP_DATA = 2;
/**
* 当建立连接是的回调
*/
public abstract void tcp_connected();
/**
* 当获取网络数据回调接口
*
* @param buffer
* 字节数据
*/
public abstract void tcp_receive(byte[] buffer);
/**
* 当断开连接的回调
*/
public abstract void tcp_disconnect();
}
Socket连接操作类
package org.yong.tcpsocket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
/**
* Socket连接操作类
*
* @author Cheng Yong
*/
public class TCPSocketFactory {
private Socket mSocket;// socket连接对象
private DataOutputStream out;
private DataInputStream in;// 输入流
private byte[] buffer = new byte[1024*1];// 缓冲区字节数组，信息不能大于此缓冲区
private byte[] tmpBuffer;// 临时缓冲区
private TCPSocketCallback callback;// 信息回调接口
private int timeOut = 1000 * 30;
/**
* 构造方法传入信息回调接口对象
*
* @param sdi
* 回调接口
*/
public TCPSocketFactory(TCPSocketCallback callback) {
this.callback = callback;
}
/**
* 连接网络服务器
*
* @throws UnknownHostException
* @throws IOException
*/
public void connect(String ip, int port) throws Exception {
mSocket = new Socket();
SocketAddress address = new InetSocketAddress(ip, port);
mSocket.connect(address, timeOut);// 连接指定IP和端口
if (isConnected()) {
out = new DataOutputStream(mSocket.getOutputStream());// 获取网络输出流
in = new DataInputStream(mSocket.getInputStream());// 获取网络输入流
if (isConnected()) {
callback.tcp_connected();
}
}
}
public void setTimeOut(int timeOut) {
this.timeOut = timeOut;
}
/**
* 返回连接服是否成功
*
* @return
*/
public boolean isConnected() {
if (mSocket == null || mSocket.isClosed()) {
return false;
}
return mSocket.isConnected();
}
/**
* 发送数据
*
* @param buffer
* 信息字节数据
* @throws IOException
*/
public void write(byte[] buffer) throws IOException {
if (out != null) {
out.write(buffer);
out.flush();
}
}
/**
* 断开连接
*
* @throws IOException
*/
public void disconnect() {
try {
if (mSocket != null) {
if (!mSocket.isInputShutdown()) {
mSocket.shutdownInput();
}
if (!mSocket.isOutputShutdown()) {
mSocket.shutdownOutput();
}
}
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
if (mSocket != null && !mSocket.isClosed()) {// 判断socket不为空并且是连接状态
mSocket.close();// 关闭socket
}
} catch (Exception e) {
e.printStackTrace();
} finally {
callback.tcp_disconnect();
out = null;
in = null;
mSocket = null;// 制空socket对象
}
}
/**
* 读取网络数据
*
* @throws IOException
*/
public void read() throws IOException {
if (in != null) {
int len = 0;// 读取长度
while ((len = in.read(buffer)) > 0) {
tmpBuffer = new byte[len];// 创建临时缓冲区
System.arraycopy(buffer, 0, tmpBuffer, 0, len);// 将数据拷贝到临时缓冲区
callback.tcp_receive(tmpBuffer);// 调用回调接口传入得到的数据
tmpBuffer = null;
}
}
}
}