Cleaned up BtGame

Author: henrykvdb

app/src/main/java/com/henrykvdb/sttt/Remote/BtGame.kt renamed to app/src/main/java/com/henrykvdb/sttt/remotebt/BtGame.kt

@@ -16,7 +16,6 @@ import com.henrykvdb.sttt.R
 import com.henrykvdb.sttt.Source
 import org.json.JSONException
 import org.json.JSONObject
-import java.io.Closeable
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
@@ -32,12 +31,15 @@ class BtGame(val callback: RemoteCallback, val res: Resources) : RemoteGame {
     override var state = RemoteState.NONE
 
     //Other
-    private var btThread: CloseableThread? = null
+    private var btThread: Thread? = null
     private var connectedDeviceName: String? = null
     private lateinit var requestState: GameState
-    private var outStream: OutputStream? = null
     private var boards = LinkedList(listOf(Board()))
 
+    private var inStream: InputStream? = null
+    private var outStream: OutputStream? = null
+
+
     override fun listen(gs: GameState) {
         requestState = gs
 
@@ -50,262 +52,213 @@ class BtGame(val callback: RemoteCallback, val res: Resources) : RemoteGame {
 
     override fun connect(adr: String) {
         val device = btAdapter.getRemoteDevice(adr)
-        callback.toast(
-                device?.name?.let { res.getString(R.string.connecting_to, it) } ?: res.getString(R.string.connecting))
-
+        callback.toast(device?.name?.let { res.getString(R.string.connecting_to, it) } ?: res.getString(R.string.connecting))
         close()
-        btThread = device?.let { ConnectingThread(it) }
-        btThread?.start()
+
+        device?.let {
+            btThread = ConnectingThread(it)
+            btThread?.start()
+        }
     }
 
-    override fun close() {
+    override fun close(){
         try {
-            btThread?.close()
-        } catch (e: IOException) {
-            e.printStackTrace()
+            btThread?.interrupt() ?: Unit
+            inStream?.close()
+            outStream?.close()
+        } catch (e:IOException){
+            Log.e(LOG_TAG,"Error closing btGame",e)
         }
-
-        callback.turnLocal()
     }
 
-    abstract class CloseableThread : Thread(), Closeable
-
-    private inner class ListenThread : CloseableThread() {
+    private inner class ListenThread : Thread() {
         private var serverSocket: BluetoothServerSocket? = null
         private var socket: BluetoothSocket? = null
 
         init {
-            this@BtGame.state = RemoteState.LISTENING
-
             try {
+                this@BtGame.state = RemoteState.LISTENING
                 serverSocket = btAdapter.listenUsingRfcommWithServiceRecord("SuperTTT", UUID)
             } catch (e: IOException) {
                 Log.e(LOG_TAG, "listen() failed", e)
+                interrupt()
             }
-
         }
 
         override fun run() {
-            Log.e(LOG_TAG, "BEGIN ListenThread " + this)
+            Log.e(LOG_TAG, "BEGIN ListenThread" + this)
 
-            // Listen to the server socket if we're not connected
             while (this@BtGame.state != RemoteState.CONNECTED && !isInterrupted) {
                 try {
-                    // This is a blocking call and will only return on a successful connection or an exception
-                    socket = serverSocket?.accept()
+                    socket = serverSocket?.accept() //Blocking call
                 } catch (e: IOException) {
                     Log.e(LOG_TAG, "accept() failed", e)
-                    break
+                    interrupt()
                 }
 
-                if (!isInterrupted)
-                    socket?.let { connected(it, true) }
+                if (!isInterrupted) socket?.let { connected(it, true) } //Manage connection, blocking call
             }
 
-            this@BtGame.state = RemoteState.NONE
-            Log.e(LOG_TAG, "END ListenThread")
-        }
+            try {
+                this@BtGame.state = RemoteState.NONE
+                serverSocket?.close()
+                socket?.close()
+            } catch (e: IOException) {
+                Log.e(LOG_TAG, "Could not close sockets when closing ListenThread")
+            }
 
-        @Throws(IOException::class)
-        override fun close() {
-            serverSocket?.close()
-            socket?.close()
+            Log.e(LOG_TAG, "END ListenThread $this")
         }
     }
 
-    private inner class ConnectingThread(device: BluetoothDevice) : CloseableThread() {
+    private inner class ConnectingThread(device: BluetoothDevice) : Thread() {
         private var socket: BluetoothSocket? = null
 
         init {
-            this@BtGame.state = RemoteState.CONNECTING
-
             try {
+                this@BtGame.state = RemoteState.CONNECTING
                 socket = device.createRfcommSocketToServiceRecord(UUID)
             } catch (e: IOException) {
-                e.printStackTrace()
+                throw e
             }
-
         }
 
         override fun run() {
             Log.e(LOG_TAG, "BEGIN connectingThread" + this)
 
-            btAdapter.cancelDiscovery()
-
             try {
-                // This is a blocking call and will only return on a successful connection or an exception
-                socket?.connect()
+                btAdapter.cancelDiscovery()
+                socket?.connect() //Blocking call
 
-                // Manage the connection, returns when the connection is stopped
-                socket?.let { connected(it, false) }
-
-                // No longer connected, close the socket
-                socket!!.close()
+                if (!isInterrupted) {
+                    socket?.let { connected(it, false) } //Manage connection, blocking call
+                }
             } catch (e: IOException) {
-                this@BtGame.state = RemoteState.NONE
                 callback.toast(res.getString(R.string.unable_to_connect))
                 Log.e(LOG_TAG, "Unable to connect to device", e)
+            }
 
-                try {
-                    socket!!.close()
-                } catch (e2: IOException) {
-                    Log.e(LOG_TAG, "unable to interrupt() socket during connection failure", e2)
-                }
-
+            try {
+                this@BtGame.state = RemoteState.NONE
+                socket?.close()
+            } catch (e2: IOException) {
+                Log.e(LOG_TAG, "unable to interrupt() socket during connection failure", e2)
             }
 
             Log.e(LOG_TAG, "END connectingThread" + this)
         }
-
-        @Throws(IOException::class)
-        override fun close() {
-            socket?.close()
-        }
     }
 
     private fun connected(socket: BluetoothSocket, isHost: Boolean) {
-        Log.e(LOG_TAG, "BEGIN connected thread")
-
-        if (Thread.interrupted()) return
-
-        val inStream: InputStream
         try {
             inStream = socket.inputStream
             outStream = socket.outputStream
+
             state = RemoteState.CONNECTED
+            connectedDeviceName = socket.remoteDevice.name
+            callback.toast(res.getString(R.string.connected_to, connectedDeviceName))
+
+            if (isHost) {
+                callback.newGame(requestState)
+                boards = LinkedList(listOf(requestState.board()))
+
+                outStream?.write(JSONObject().apply {
+                    put("message", RemoteMessageType.SETUP.ordinal)
+                    put("start", requestState.players.first == Source.REMOTE)
+                    put("board", requestState.board().toJSON().toString())
+                }.toString().toByteArray(Charsets.UTF_8))
+            }
         } catch (e: IOException) {
             Log.e(LOG_TAG, "connected sockets not created", e)
-            state = RemoteState.NONE
-            return
+            Thread.currentThread().interrupt()
+        } catch (e: JSONException) {
+            e.printStackTrace()
+            Thread.currentThread().interrupt()
         }
 
-        connectedDeviceName = socket.remoteDevice.name
-        Log.e(LOG_TAG, "CONNECTED to $connectedDeviceName")
-        callback.toast(res.getString(R.string.connected_to, connectedDeviceName))
-
         val buffer = ByteArray(1024)
-
-        if (isHost && !Thread.interrupted()) sendSetup()
-
-        // Keep listening to the InputStream while connected
         while (state == RemoteState.CONNECTED && !Thread.interrupted()) {
             try {
-                // Read from the InputStream
-                inStream.read(buffer) //TODO improve
-
+                //TODO improve reading of the stream, replace buffer
+                inStream?.read(buffer)
                 val json = JSONObject(String(buffer, Charsets.UTF_8))
 
-                val message = json.getInt("message")
-
-                Log.e(LOG_TAG, "RECEIVED BTMESSAGE: $message")
-                when(RemoteMessageType.values()[message]){
-                    RemoteMessageType.BOARD_UPDATE->{
+                when (RemoteMessageType.values()[json.getInt("message")]) {
+                    RemoteMessageType.BOARD_UPDATE -> {
                         val newBoard = JSONBoard.fromJSON(JSONObject(json.getString("board")))
-                        val newMove = newBoard.lastMove()!!
-
                         if (isValidBoard(boards.peek(), newBoard)) {
                             Log.e(LOG_TAG, "We received a valid board")
                             boards.push(newBoard)
-                            callback.move(newMove)
+                            callback.move(newBoard.lastMove()!!)
                         } else {
                             callback.toast(res.getString(R.string.desync_message))
                             close()
                         }
                     }
-                    RemoteMessageType.SETUP->{
+                    RemoteMessageType.SETUP -> {
                         val board = JSONBoard.fromJSON(JSONObject(json.getString("board")))
                         boards = LinkedList(listOf(board))
                         callback.newGame(GameState.Builder().bt().board(board).swapped(!json.getBoolean("start")).build())
                     }
-                    RemoteMessageType.UNDO->{
+                    RemoteMessageType.UNDO -> {
                         val force = json.getBoolean("force")
                         callback.undo(force)
-                        if(force) boards.pop()
+                        if (force) boards.pop()
                     }
                 }
             } catch (e: IOException) {
                 Log.e(LOG_TAG, "disconnected", e)
                 callback.toast(res.getString(R.string.connection_lost))
-                break
+                Thread.currentThread().interrupt()
             } catch (e: JSONException) {
                 Log.e(LOG_TAG, "JSON read parsing failed")
-                break
+                callback.toast(res.getString(R.string.json_parsing_failed))
+                Thread.currentThread().interrupt()
             }
         }
 
         state = RemoteState.NONE
         callback.turnLocal()
 
         try {
-            inStream.close()
+            Thread.currentThread().interrupt()
+            inStream?.close()
             outStream?.close()
+            socket.close()
         } catch (e: IOException) {
             e.printStackTrace()
         }
-
-        Log.e(LOG_TAG, "END connected thread")
     }
 
     override fun sendUndo(force: Boolean) {
-        Log.e(LOG_TAG, "Sending undo")
-        if (state != RemoteState.CONNECTED) return
-        if (force) boards.pop()
-
         try {
-            val json = JSONObject()
-            json.put("message", RemoteMessageType.UNDO.ordinal)
-            json.put("force", force)
-            val data = json.toString().toByteArray(Charsets.UTF_8)
-            outStream?.write(data)
+            if (force) boards.pop()
+            outStream?.write(JSONObject().apply {
+                put("message", RemoteMessageType.UNDO.ordinal)
+                put("force", force)
+            }.toString().toByteArray(Charsets.UTF_8))
         } catch (e: IOException) {
-            Log.e(LOG_TAG, "Exception during undo", e)
+            Log.e(LOG_TAG, "Exception in sendUndo", e)
         } catch (e: JSONException) {
             e.printStackTrace()
         }
     }
 
     override fun sendBoard(board: Board) {
-        Log.e(LOG_TAG, "Sending board")
-        boards.push(board)
-
         try {
-            val json = JSONObject()
-
-            json.put("message", RemoteMessageType.BOARD_UPDATE.ordinal)
-            json.put("board", board.toJSON().toString())
-
-            val data = json.toString().toByteArray(Charsets.UTF_8)
-
-            outStream?.write(data)
-        } catch (e: IOException) {
-            Log.e(LOG_TAG, "Exception during boardUpdate", e)
-        } catch (e: JSONException) {
-            e.printStackTrace()
-        }
-    }
-
-    private fun sendSetup() { //TODO only called once: inline
-        callback.newGame(requestState)
-        Log.e(LOG_TAG, "Sending setup, starting: " + requestState.players.first)
-
-        boards = LinkedList(listOf(requestState.board()))
-
-        try {
-            val json = JSONObject()
-            json.put("message", RemoteMessageType.SETUP.ordinal)
-            json.put("start", requestState.players.first == Source.REMOTE)
-            json.put("board", requestState.board().toJSON().toString())
-            val data = json.toString().toByteArray(Charsets.UTF_8)
-
-            outStream?.write(data)
+            boards.push(board)
+            outStream?.write(JSONObject().apply {
+                put("message", RemoteMessageType.BOARD_UPDATE.ordinal)
+                put("board", board.toJSON().toString())
+            }.toString().toByteArray(Charsets.UTF_8))
         } catch (e: IOException) {
-            Log.e(LOG_TAG, "Exception during boardUpdate", e)
+            Log.e(LOG_TAG, "Exception in sendBoard()", e)
         } catch (e: JSONException) {
             e.printStackTrace()
         }
     }
 
     override val localName get() = listOfNotNull(btAdapter.name, btAdapter.address, "ERROR").first()
-    override val remoteName get() =  if (state == RemoteState.CONNECTED) connectedDeviceName else null
+    override val remoteName get() = if (state == RemoteState.CONNECTED) connectedDeviceName else null
     override val lastBoard: Board get() = boards.last
 }

app/src/main/java/com/henrykvdb/sttt/remote/Remote.kt renamed to app/src/main/java/com/henrykvdb/sttt/remotebt/Remote.kt

@@ -48,6 +48,7 @@
     <string name="join_bluetooth_game">Join Bluetooth game</string>
 	<string name="host_bluetooth_game">Host Bluetooth game</string>
 	<string name="desync_message">Games got desynchronized</string>
+	<string name="json_parsing_failed">JSON parsing failed</string>
     <string name="joinable_devices">Joinable devices</string>
 	<string name="new_ai_title">Start a new AI game?</string>
 	<string name="new_local_title">Start a new game?</string>