Android使用service进行socket重连，发送心跳

class SocketService : Service() {
    private var TAG = "SocketService"
    private var isStarted = false
    private var isReConnect = true
    private var mThreadPool: ExecutorService? = null
    private var socket: Socket? = null
    private var outputStream: OutputStream? = null
    private var bufferedOutputStream: BufferedOutputStream? = null
    private var inputStream: InputStream? = null
    private var bufferedInputStream: BufferedInputStream? = null
    private var heartbeatThread: Thread? = null

    companion object {
        fun newSocketService(context: Context, action: String): Intent {
            val intent = Intent(context, SocketService::class.java)
            intent.action = action
            return intent
        }
    }

    override fun onCreate() {
        super.onCreate()
        isStarted = false
        isReConnect = true
        mThreadPool = Executors.newCachedThreadPool()
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        if (intent != null) {
            val action = intent.action
            if (TextUtils.equals(action, "start")) {
                if (isStarted) {
                    return super.onStartCommand(intent, flags, startId)
                }
                mThreadPool?.execute(Runnable {
                    initSocket()
                })
                isStarted = true
                startHeartbeatThread()
                receiveMsg()
            } else if (TextUtils.equals(action, "stop")) {
                if (!isStarted) {
                    return super.onStartCommand(intent, flags, startId)
                }
                isStarted = false
                releaseSocket()
            }
        }
        return super.onStartCommand(intent, flags, startId)
    }

    private fun startHeartbeatThread() {
        heartbeatThread = object : Thread() {
            override fun run() {
                sleep(10000)
                while (isStarted && isReConnect) {
                    if (socket != null && socket!!.isConnected) {
                        try {
                            sendHeartbeat()
                            sleep(10000)
                        } catch (e: IOException) {
                            e.printStackTrace()
                            releaseSocket()
                        } catch (e: InterruptedException) {
                            e.printStackTrace()
                        }
                    }
                }
            }
        }

        heartbeatThread?.start()
    }

    private fun stopHeartbeatThread() {
        heartbeatThread?.interrupt()
        heartbeatThread = null
    }

    private fun sendHeartbeat() {
        if (socket != null && !socket!!.isClosed && socket!!.isConnected) {
            try {
                val heartbeatMessage =
                    "{\"type\":\"heartbeat\",\"uniqueKey\":\"${DeviceUtil.getDeviceSN()}\"}"

                outputStream?.write(heartbeatMessage.toByteArray(Charsets.UTF_8))
                outputStream?.flush()
            } catch (e: IOException) {
                Log.e(TAG, e.stackTraceToString())
                releaseSocket()
            } catch (e: SocketException) {
                Log.e(TAG, e.stackTraceToString())
                releaseSocket()
            }
        }
    }

    override fun onDestroy() {
        isStarted = false
        isReConnect = false
        releaseSocket()
        stopHeartbeatThread()
        super.onDestroy()
    }

    private fun initSocket() {
        try {
            socket = Socket()
            socket?.connect(
                InetSocketAddress(
                    SocketConstant.faceSocketIp, SocketConstant.faceSocketPort
                ), 2000
            )
            sendMsg("{\"type\":\"link\",\"uniqueKey\":\"${DeviceUtil.getDeviceSN()}\"}")
        } catch (e: IOException) {
            when (e) {
                is SocketTimeoutException -> {
                    Log.e(TAG, "连接超时")
                    releaseSocket()
                }

                is NoRouteToHostException -> {
                    Log.e(TAG, "地址不存在")
                    stopSelf()
                }

                is ConnectException -> {
                    Log.e(TAG, "连接异常或被拒绝")
                    releaseSocket()
                }
            }
        }
    }

    private fun releaseSocket() {
        try {
            outputStream?.close()
            inputStream?.close()
            bufferedOutputStream?.close()
            socket?.close()
        } catch (e: IOException) {
            e.printStackTrace()
        }
        outputStream = null
        inputStream = null
        bufferedOutputStream = null
        bufferedInputStream = null
        socket = null
        if (isReConnect) {
            initSocket()
        }
    }

    private fun sendMsg(msg: String) {
        var isConnected = false
        mThreadPool?.execute(Runnable {
            while (!isConnected) {
                if (socket != null && socket!!.isConnected) {
                    try {
                        isConnected = true
                        outputStream = socket?.getOutputStream()
                        bufferedOutputStream = BufferedOutputStream(outputStream, 1024)
                        bufferedOutputStream?.write((msg).toByteArray(charset("utf-8")))
                        bufferedOutputStream?.flush()
                    } catch (e: IOException) {
                        e.printStackTrace()
                        Log.e(TAG, "连接断开")
                        releaseSocket()
                    }
                }
            }
        })
    }

    private fun receiveMsg() {
        mThreadPool?.execute(Runnable {
            while (isStarted && isReConnect) {
                if (socket != null && socket!!.isConnected) {
                    try {
                        inputStream = socket?.getInputStream()
                        val available = inputStream?.available()
                        if (inputStream != null && available != null && available > 0) {
                            bufferedInputStream = BufferedInputStream(inputStream)
                            val buffer = ByteArray(4096)
                            var len = bufferedInputStream?.read(buffer)
                            val message = String(buffer, 0, len!!, Charsets.UTF_8)
                            Log.e("receiveMsg", "$message")
                            if (message == "200") {
                                continue
                            }
                        }
                    } catch (e: IOException) {
                        e.printStackTrace()
                        releaseSocket()
                    } catch (e: SocketException) {
                        e.printStackTrace()
                        releaseSocket()
                    } catch (e: JsonSyntaxException) {
                        e.printStackTrace()
                    }
                }
            }
        })
    }
    
    override fun onBind(intent: Intent?): IBinder? {
        return null
    }
}