Socket + 前台service

package com.example.test;

import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;


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.graphics.BitmapFactory;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v4.content.LocalBroadcastManager;
import android.util.EventLog;
import android.util.Log;

import com.example.demo_play.R;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import org.json.JSONException;
import org.json.JSONObject;

import static android.app.PendingIntent.getActivity;

/**
 * Created by dawish on 2017/7/24.
 * 由于移动设备的网络的复杂性，经常会出现网络断开，如果没有心跳包的检测，
 * 客户端只会在需要发送数据的时候才知道自己已经断线，会延误，甚至丢失服务器发送过来的数据。
 */

public class BackService extends Service {
    private static final String TAG = "info";
    /**
     * 心跳频率
     */
    private static final long HEART_BEAT_RATE = 3 * 1000;
    /**
     * 服务器ip地址
     */
    public static final String HOST = "192.168.1.21";// "192.168.1.21";//
    /**
     * 服务器端口号
     */
    public static final int PORT = 8080;
    /**
     * 服务器消息回复广播
     */
    public static final String MESSAGE_ACTION = "message_ACTION";
    /**
     * 服务器心跳回复广播
     */
    public static final String HEART_BEAT_ACTION = "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) {

                try {
                    JSONObject json = new JSONObject();
                    json.put("a", "1");
                    json.put("b", "2");
                    json.put("c", "3");

                    boolean isSuccess = sendMsg(json.toString());//就发送一个\r\n过去 如果发送失败，就重新初始化一个socket
                    if (!isSuccess) {
                        mHandler.removeCallbacks(heartBeatRunnable);
                        mReadThread.release();
                        releaseLastSocket(mSocket);
                        new InitSocketThread().start();
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };

    private Runnable LoginBeatRunnable = new Runnable() {

        @Override
        public void run() {
            if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {

                try {
                    JSONObject json = new JSONObject();
                    json.put("a", "1");
                    json.put("b", "2");
                    json.put("c", "3");

                    boolean isSuccess = sendMsg(json.toString());//就发送一个\r\n过去 如果发送失败，就重新初始化一个socket
                    if (!isSuccess) {
                        mHandler.removeCallbacks(heartBeatRunnable);
                        mReadThread.release();
                        releaseLastSocket(mSocket);
                        new InitSocketThread().start();
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }


        }
    };

    private Runnable SendBeatRunnable = new Runnable() {
        @Override
        public void run() {
            boolean isSuccess = sendMsg(lastMsgString);//就发送一个\r\n过去 如果发送失败，就重新初始化一个socket
            if (!isSuccess) {
                mHandler.removeCallbacks(heartBeatRunnable);
                mReadThread.release();
                releaseLastSocket(mSocket);
                new InitSocketThread().start();
            }
        }
    };

    private long sendTime = 0L;
//    /**
//     * aidl通讯回调 主要用于与activity 交互 
//     */
//    private IBackService.Stub iBackService = new IBackService.Stub() {
//
//        /**
//         * 收到内容发送消息
//         * @param message 需要发送到服务器的消息
//         * @return
//         * @throws RemoteException
//         */
//        @Override
//        public boolean sendMessage(String message) throws RemoteException {
//            return sendMsg(message);
//        }
//    };

    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "------------------------onCreate");
        new InitSocketThread().start();
        EventBus.getDefault().register(this);
        mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);

    }

    public boolean sendMsg(final String msg) {
        if (null == mSocket || null == mSocket.get()) {
            return false;
        }
        final Socket soc = mSocket.get();
        if (!soc.isClosed() && !soc.isOutputShutdown()) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        OutputStream os = soc.getOutputStream();
                        String message = msg + "\r\n";
                        os.write(message.getBytes());
                        os.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            sendTime = System.currentTimeMillis();//每次发送成数据，就改一下最后成功发送的时间，节省心跳间隔时间
        } else {
            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.post(LoginBeatRunnable);//初始化成功后，就准备登陆socket
            mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//初始化成功后，就准备发送心跳包
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 心跳机制判断出socket已经断开后，就销毁连接方便重新创建连接
     *
     * @param mSocket
     */
    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);
                            //收到服务器过来的消息，就通过EventBus发送出去

                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 在API11之后构建Notification的方式
        Notification.Builder builder = new Notification.Builder(this.getApplicationContext()); //获取一个Notification构造器
        Intent nfIntent = new Intent(this, MainActivity.class);
        builder.setContentIntent(PendingIntent.getActivity(this, 0, nfIntent, 0))
                .setLargeIcon(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_1)) // 设置下拉列表中的图标(大图标)
                .setContentTitle("标题") // 设置下拉列表里的标题
                .setSmallIcon(R.drawable.icon_1)// 设置状态栏内的小图标
                .setContentText("内容") // 设置上下文内容
                .setWhen(System.currentTimeMillis()); // 设置该通知发生的时间

        Notification notification = builder.build(); // 获取构建好的Notification
        notification.defaults = Notification.DEFAULT_SOUND; //设置为默认的声音
        startForeground(110, notification);// 开始前台服务
        return super.onStartCommand(intent, flags, startId);
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        if (EventBus.getDefault().isRegistered(this)) {
            EventBus.getDefault().unregister(this);
        }
        stopForeground(true);// 停止前台服务--参数：表示是否移除之前的通知
        mHandler.removeCallbacks(heartBeatRunnable);
        mReadThread.release();
        releaseLastSocket(mSocket);
        Log.e(TAG, "------------------------onDestroy");
    }
}