Android~WebSocket长连接

基于Java-WebSocke框架：https://github.com/TooTallNate/Java-WebSocket
参考文章：https://www.jianshu.com/p/7b919910c892

1.在 build.gradle引用

    implementation "org.java-websocket:Java-WebSocket:1.5.2"

2.加入网络请求权限

<uses-permission android:name="android.permission.INTERNET" />

3.新建Service，并在AndroidManifest.xml内的application加入

  <service android:name=".service.WebSocketService"/>

服务代码：

public class WebSocketService extends Service {

    public WebSocketClient webSocketClient;
    private ServiceCallBack serviceCallBack;

    @Override
    public void onCreate() {
        if (webSocketClient != null) {
            if (webSocketClient.isClosed()) {
                reconnectWs();
            }
        } else {
            //如果client已为空，重新初始化连接
            webSocketClient = null;
            initSocketClient();
        }
        mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//开启心跳检测
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new Binder();
    }


    public class Binder extends android.os.Binder {
        public WebSocketService getService() {
            return WebSocketService.this;
        }
    }


    /**
     * 打开ws
     */
    private void initSocketClient(){
   		 //长连接地址
   		 URI serverURI = URI.create("ws://xx.xx.xx.xx:xxxx/xxxx");
        webSocketClient = new WebSocketClient(serverURI) {
            @Override
            public void onOpen(ServerHandshake handshakedata) {
                Log.e("webSocket", "onOpen: ");
            }
            @Override
            public void onMessage(String message) {
                Log.e("webSocket", "onMessage: "+message);
                if (serviceCallBack != null) {
                    // 调用接口方法，将需要传递的值作为参数传递
                    serviceCallBack.getServiceData(message);
                }
            }
            @Override
            public void onClose(int code, String reason, boolean remote) {
                Log.e("webSocket", "onClose: ");
            }

            @Override
            public void onError(Exception ex) {
                Log.e("webSocket", "onError: ");
            }
        };
        connect();
    }

    /**
     * 连接websocket
     */
    private void connect() {
        new Thread() {
            @Override
            public void run() {
                try {
                    //connectBlocking多出一个等待操作，会先连接再发送，否则未连接发送会报错
                    webSocketClient.connectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    /**
     * websocket心跳检测
     */
    private static final long HEART_BEAT_RATE = 15 * 1000;//每隔15秒进行一次对长连接的心跳检测
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            Log.e("webSocket", "心跳包检测websocket连接状态");
            if (webSocketClient != null) {
                if (webSocketClient.isClosed()) {
                    reconnectWs();
                }
            } else {
                //如果client已为空，重新初始化连接
                webSocketClient = null;
                initSocketClient();
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };

    /**
     * 开启重连
     */
    private void reconnectWs() {
        mHandler.removeCallbacks(heartBeatRunnable);
        new Thread() {
            @Override
            public void run() {
                try {
                    Log.e("webSocket", "开启重连");
                    webSocketClient.reconnectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


    /**
     * 断开连接
     */
    private void closeConnect() {
        try {
            mHandler.removeCallbacks(heartBeatRunnable);
            if (null != webSocketClient) {
                webSocketClient.close();
                Log.e("webSocket", "断开连接");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            webSocketClient = null;
        }
    }

    @Override
    public void onDestroy() {
        Log.e("webSocket", "onDestroy 断开连接");
        closeConnect();
        super.onDestroy();
    }
    //定义的接口
    public interface ServiceCallBack {
        void getServiceData(String data);
    }

    public void setServiceCallBack(ServiceCallBack serviceCallBack){
        this.serviceCallBack = serviceCallBack;
    }
}

4.服务与activity使用回调通讯

Activity相关代码：

    /**
     * 绑定服务（onCreate调用）
     */
    private void bindService() {
        Intent bindIntent = new Intent(MainActivity.this, WebSocketService.class);
        bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);
    }

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //服务与活动成功绑定
            Log.e("webSocket", "服务与活动成功绑定");
            // 回调获取消息
            WebSocketService.Binder binder = (WebSocketService.Binder) iBinder;
            WebSocketService webSocketService = binder.getService();
            webSocketService.setServiceCallBack(new WebSocketService.ServiceCallBack() {
                @Override
                public void getServiceData(String data) {
                    Log.e("webSocket", "回调数据: "+data );
                    Message handlerMessage = Message.obtain();
                    handlerMessage.obj = data;
                    handler.sendMessage(handlerMessage);
                }
            });
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //服务与活动断开
            Log.e("webSocket", "服务与活动成功断开");
        }
    };

	//handler处理消息
    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            Log.e("webSocket", "服务返回数据: "+msg.obj.toString());
            return true;
        }
    });