0

我正在使用 Kotlin 编写的服务器和 Android 客户端编写一个聊天应用程序。我创建了一个后台服务，它不断地从连接到服务器的套接字中读取数据，并在消息到达时发送通知。一切正常，直到用户点击“x”按钮并关闭应用程序。在执行下面发布的清理代码期间与服务器的连接失败。在服务设法发送 EXIT 请求和关闭流之前，服务器已获得 EOF。然后，重新创建服务，但是当它尝试连接到服务器时，它得到 ConnectException（连接被拒绝）。仅在开启省电模式时才会发生。当它关闭或手机通过 USB 连接到我的笔记本电脑并充电时没有问题。

ss 命令列出了有人在监听指定的端口，所以这不是问题。我尝试循环连接，即尝试每 10 秒连接 5 次，但每次都被拒绝。我试过在两个不同的端口上监听，但即使其中一个以前没有使用过，它们都失败了。文档说默认积压是 50，所以我想也不是这样。我试图在服务器套接字上设置 SO_REUSEADDR 标志，但仍然没有。奇怪的是，当我第二次启动它时从应用程序启动服务时，它可以再次连接。所以我创建了一个广播接收器，它以与应用程序相同的方式启动服务，以防它崩溃，但它也无济于事。

我真的在谷歌上搜索了一个多星期，但这是我第一次尝试同时使用 Kotlin 和套接字，但我的想法已经不多了。如果有人对可能发生的事情有所了解，我将非常感谢一些帮助。

这是服务 onStartCommand：

override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    activeConversation = intent?.getStringExtra(CONV_NAME) ?: ""
    login = intent?.getStringExtra(LOGIN) ?: login
    if (thread?.isAlive != true) {
        thread = thread(start = true) {
                synchronized(lock) {
                    try {
                        socket = Socket(SERVER_IP, SERVICE_PORT)
                        output = ObjectOutputStream(socket?.getOutputStream())
                        input = ObjectInputStream(socket?.getInputStream())
                        output?.writeObject(Request(START_SERVICE, mutableMapOf(LOGIN to login)))
                    } catch (e: IOException) {
                        e.printStackTrace()
                        return@thread
                    }
                }
                handleMessages() //contains input?.readObject() in infinite loop
        }
    }
    return START_STICKY
}

在 onDestory() 和 onTaskRemoved() 我调用这个函数：

 private fun cleanUp() {
    synchronized(lock) {
        thread(start = true) {
            try {
                output?.writeObject(Request(EXIT, mutableMapOf(LOGIN to login)))
                output?.close()
                input?.close()
                socket?.close()
                nullStreams()
                thread?.join()
                println("SERVICE: thread joined")
            } catch(e: IOException) {
                e.printStackTrace()
                return@thread
            } finally {
                println("Service sends broadcast to ask for recreation")
                val restartIntent = Intent(this, ServiceRestarter::class.java)
                restartIntent.putExtra(LOGIN, login)
                sendBroadcast(restartIntent)
            }
        }.join()
    }
}

服务重启器：

class ServiceRestarter : BroadcastReceiver() {

override fun onReceive(context: Context, intent: Intent?) {
    val login = intent?.getStringExtra(LOGIN)
    println("SERVICE RESTARTER: receiving restart request from $login")
    val serviceIntent = Intent(context, MessengerService::class.java)
    serviceIntent.putExtra(LOGIN, login)
    context.startService(serviceIntent)
}}

我的服务器负责监听的部分：

val clientsSocket = ServerSocket(CLIENTS_PORT)
    val serviceSocket = ServerSocket(SERVICE_PORT)
    serviceSocket.setReuseAddress(true)
    println("Server socket ready!")
    println("Service socket port: ${serviceSocket.localPort}")

    thread(start = true) {
            while(true) ClientThread(clientsSocket.accept(), loggedInUsers, pendingRequests).start()
    }
    thread(start = true) {
            while(true) ServiceThread(serviceSocket.accept(), loggedInUsers).start()
    }

和服务线程：

class ServiceThread(val socket: Socket, 
    val loggedInUsers: HashMap<String, UserConnection>) : Thread() {

private var login = ""
private val input = ObjectInputStream(socket.getInputStream())
private val output = ObjectOutputStream(socket.getOutputStream())

override fun run() {

    var request = input.readObject() as Request
    login = request.content[LOGIN] as String 
    var userConn: UserConnection?
    synchronized(loggedInUsers) {
        userConn = loggedInUsers[login]
        if(request.action == START_SERVICE) {
            println("SERVICE THREAD: New socket conn from $login")
            userConn?.run {
                println("SERVICE THREAD: putting $login output to logged in users")
                serviceStream = output
                if(pendingMessage != null) {
                    output.writeObject(Request(SEND,
                        mutableMapOf(RESULT to SUCCESS, DATA to pendingMessage)))
                    pendingMessage = null
                }
            }
        }
    }
    try { request = input.readObject() as Request }
    catch(e: IOException) {
        println(e.printStackTrace())
        cleanUp()
        return@run
    }
    if(request.action == EXIT) { 
        println("SERVICE THREAD: Service of user $login is terminating")
        cleanUp()
    }
}

private fun cleanUp() {

    synchronized(loggedInUsers) { 
        output.close()
        input.close()
        socket.close()
        loggedInUsers[login]?.serviceStream = null
    }
}}
4

0 回答 0