Socket长连接以及心跳包机制

Socket长连接以及心跳包机制

1. SocketService服务

public class SocketService extends Service implements ISocketService {
    private WeakReference<Socket> mSocket;  //弱引用 在引用对象的同时允许对垃圾对象进行回收
    private ReadThread mReadThread;  //接收线程
    public String host = "111.111.111.111";
    public int port = 8888;
    private long serverRespondTime = 0L;// 服务器接收数据时间
    private SharedPreferences sharedPreferences = null;
    private Editor editor = null;
    private Handler mHandler = new Handler();
    private static final int MSG_CHECK_QUEUE = 0x01;
    private static final int HEART_DELAYMILLIS = 55000;  //心跳检测时间
    private LocalBinder binder = new LocalBinder();
	
    public class LocalBinder extends Binder {
        public SocketService getService() {
            return SocketService.this;
        }
    }
 
    @Override
    public void onCreate() {
        super.onCreate();
        sharedPreferences = getSharedPreferences("wearable", Context.MODE_PRIVATE); // 私有数据
        editor = sharedPreferences.edit();
        host = sharedPreferences.getString("host", host);
        port = sharedPreferences.getInt("port", port);
        mHandler_Queue.removeMessages(MSG_CHECK_QUEUE);
        mHandler_Queue.sendEmptyMessageDelayed(MSG_CHECK_QUEUE, HEART_DELAYMILLIS);
        if (SocketConfig.isNetworkAvailable(this)) {
            if (System.currentTimeMillis() - serverRespondTime >= HEART_DELAYMILLIS) {
                mHandler.post(statusRunnable);
            }
        }
    }
    
    
    // 初始化socket
    @Override
    public void initSocket() throws UnknownHostException, IOException {
        try {
            LogUtil.e("申请TCP长连接");
            Socket socket = new Socket(host, port);
            mSocket = new WeakReference<Socket>(socket);
            mReadThread = new ReadThread(socket);
            mReadThread.start();
            mHandler.post(loginRunnable);// 初始化成功后，就准备发送心跳包
            LogUtil.e("TCP连接成功,开始登陆");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    // 释放socket
    @Override
    public void releaseLastSocket(Object o) {
        WeakReference<Socket> mSocket = (WeakReference<Socket>) o;
        try {
            if (null != mSocket) {
                Socket sk = mSocket.get();
                if (!sk.isClosed()) {
                    sk.close();
                }
                sk = null;
                mSocket = null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

	// 初始化线程
    class InitSocketThread extends Thread {
        @Override
        public void run() {
            super.run();
            if (SocketConfig.isNetworkAvailable(SocketService.this)) {
                try {
                    initSocket();
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    // 发送数据
    @Override
    public boolean sendMsg(String msg) {
        if (!SocketConfig.isNetworkAvailable(this))
            return false;
        try {
            if (msg.length() == 0) {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        if (null == mSocket || null == mSocket.get()) {
            return false;
        }
        Socket soc = mSocket.get();
        try {
            if (!soc.isClosed() && !soc.isOutputShutdown()) {
                PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(soc.getOutputStream())),true);
                out.println(msg);
                out.flush();
            } else {
                return false;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    
	// 接收线程
    public 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 {
                    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    String encryptStr;
                    while(!socket.isClosed() && !socket.isInputShutdown() && (encryptStr = br.readLine())!=null) {
                        decryptStr = SocketConfig.decrypt(ApiMsgType.KEY, ApiMsgType.INITVECTOR, encryptStr);
                        Log.d("nh", "接收 = " + decryptStr);
                        dataDeal(decryptStr);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
	//心跳包机制
    @SuppressLint("HandlerLeak")
    private Handler mHandler_Queue = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
                case MSG_CHECK_QUEUE:
                    if (SocketConfig.isNetworkAvailable(SocketService.this)) {
                        if (System.currentTimeMillis() - serverRespondTime >= HEART_DELAYMILLIS) {
                            mHandler.post(statusRunnable);
                        }
                    }
                    //55秒检测一次
                    mHandler_Queue.sendEmptyMessageDelayed(MSG_CHECK_QUEUE, HEART_DELAYMILLIS);
                    Log.d("nh","发送心跳包");
                    break;
        	}
        }
    };
                    
    // 发送心跳/状态包
    private Runnable statusRunnable = new Runnable() {
        @Override
        public void run() {
            ExecutorService service = ThreadUtil.getPool();
            service.execute(new Runnable() {
                @Override
                public void run() {
                    boolean isSuccess = sendMsg(MsgManager.getHeartBag());
                    if (!isSuccess) {
                        LogUtil.e("TCP未连接");
                        mHandler.removeCallbacks(statusRunnable);
                        if (mReadThread != null) {
                            mReadThread.release();
                        }
                        releaseLastSocket(mSocket);
                        new InitSocketThread().start();
                    }
                }
            });
        }
    };
    
    // 登入线程
    private Runnable loginRunnable = new Runnable() {
        @Override
        public void run() {
            ExecutorService service = ThreadUtil.getPool();
            service.execute(new Runnable() {
                @Override
                public void run() {
                	//登录接口，自己编写
                    boolean isSuccess = sendMsg(MsgManager.getLogin(SocketService.this));
                    if (!isSuccess) {
                        LogUtil.e("TCP未连接");
                        mHandler.removeCallbacks(loginRunnable);
                        if (mReadThread != null) {
                            mReadThread.release();
                        }
                        releaseLastSocket(mSocket);
                        new InitSocketThread().start();
                    }
                }
            });
        }
    };
	
    //处理接收到的数据
    @Override
    public void dataDeal(String msg) {	
    
	}
        @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }
    
    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mReadThread != null) {
            mReadThread.release();
        }
        releaseLastSocket(mSocket);
    }
}

2. ISocketService接口

public interface ISocketService<T> {

    /**
     * 响应服务器包
     */
     void respondRunnable(T t);

    /**
     * 初始化socket
     */
    void initSocket() throws UnknownHostException,IOException;

    /**
     * 释放socket
     */
    void releaseLastSocket(T t);

    /**
     * 发送数据
     */
    boolean sendMsg(String msg);

    /**
     * 处理接收到的数据
     */
    void dataDeal(String msg);
}

3. MainAcitvity启动服务

Intent intent = new Intent(this, SocketService.class);
startService(intent);