Android 设备间的双向通信

因此，当我试图通过TCP与我的两台平板电脑和一台支持Wifi的外部设备进行通信时，我遇到了一个奇怪的问题

我会尽力描述这个问题。系统工作如下（所有通信通过无线网络进行）：

• 设备向平板电脑a发送TCP通信
• 平板电脑A（主屏幕）显示消息并将消息重复到平板电脑B（从屏幕）-此操作正常
• 平板电脑A向平板电脑B发送另一条消息（行动消息），平板电脑B接收到该消息后，不会出现问题
• 当平板电脑B执行一项操作时，它会向平板电脑A发送一条操作消息-问题是，即使发送了消息，该消息也不会被消费。如果我移动到另一个

  活动

  并返回到上一个活动，则消息已被消耗

这种情况发生在运行安卓6.0.1的联想YT3平板电脑上

SocketListenerService

private var thread: Thread? = null
private var socketListener: SocketListener? = null
private var broadcastManager: LocalBroadcastManager? = null
val listener = object : SimpleServer.ServerReceivedListener {

    override fun onLineReceived(line: String) {

        val response = Intent(SOCKET_RESPONSE)
        response.putExtra(RESPONSE_MESSAGE, line)

        broadcastManager!!.sendBroadcast(response)

    }

}

private val incomingServer = SimpleServer(listener)

override fun onCreate() {

    super.onCreate()

    broadcastManager = LocalBroadcastManager.getInstance(this)

}

override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {

    if (intent != null) {

        socketListener = SocketListener()
        thread = Thread(socketListener)
        thread!!.start()

    }

    return super.onStartCommand(intent, flags, startId)

}

override fun onDestroy() {

    super.onDestroy()

    socketListener!!.shutDown()
    thread!!.interrupt()
    incomingServer.closeServer()

}

override fun onBind(intent: Intent): IBinder? {

    return null

}

private inner class SocketListener : Runnable {

    @Volatile private var done = false

    internal fun shutDown() {

        done = true

    }

    override fun run() {

        while (!done) {

            incomingServer.serve()

        }

    }

}

companion object {

    val SOCKET_RESPONSE = "socket_response"
    val RESPONSE_MESSAGE = "response_message"

    val port = 9888

}

SimpleServer

interface ServerReceivedListener {

    fun onLineReceived(line: String)

}

private var server: ServerSocket? = null
private var client: Socket? = null
private var listener: ServerReceivedListener? = null

init {

    try {

        server = ServerSocket(SocketListenerService.port)
        this.listener = listener

    } catch (err: Exception) {

        err.printStackTrace()

    }

}

fun serve() {

    var line: String?

    try {

        if (!server!!.isClosed) {

            client = server?.accept()

            val r = BufferedReader(InputStreamReader(client!!.getInputStream(), "UTF-8"))
            line = r.readLine()

            while (line != null) {

                if (line.length >= 4)
                    listener!!.onLineReceived(line)
                else
                    listener!!.onLineReceived("@")
                line = r.readLine()

            }

        }

    } catch (e: IOException) {

        if (!e.message!!.contains("Socket closed"))
            e.printStackTrace()

    }

}

fun closeServer() {

    try {

        if (client != null)
            client!!.close()
        server!!.close()

    } catch (e: IOException) {

        e.printStackTrace()

    }

}

BroadcastBeceiver

依次从intent获取消息，并使用接口将其发送到

活动

---

我似乎无法理解为什么当消费

活动重新启动时，从机的通信只会被主机消费（？）
这是一个套接字问题。现在我有两个线程在两个端口上侦听，通信工作正常
这是一个套接字问题。现在我有两个线程在两个端口上监听，通信工作正常