前提

・Android - Android間の通信をBluetoothSocketを用いて実装しています。
・サーバ側のソケットはクライアント側のソケットをcloseするのと同時にcloseし、BluetoothServerSocket.acceptで次の接続を待ち受ける処理を予定しています。

問題・質問

どちらかのsocketを閉じた時点で「相手が正しくcloseしたか」連絡できなくなってしまうので、相手のcloseを知る方法が無く困っています。
スマートに相手のcloseを検知する方法、または、closeを気にせずとも良い実装方法をご教授ください。

補足

BluetoothSocketにはisConnected()という関数が用意されていますが、これは「過去に接続されたか」という情報しか持っていないようです。

サーバ側（抜粋）

Java
1    private final Runnable mAcceptTask = new Runnable() {
2        public void run(){
3            BluetoothSocket receivedSocket = null;
4            while(true){
5                is_alive = true;
6                try{
7                    receivedSocket = servSock.accept();
8                }catch(IOException e){
9                    break;
10                }
11
12                if(receivedSocket != null){
13                    ReadWriteModel rw = new ReadWriteModel(receivedSocket) {
14                        @Override
15                        public void ReadRW(String msg){
16                            ReadBST(msg);
17                        }
18                    };
19                    rw.start();
20
21                    while(is_alive){
22                        if(is_write){
23                            is_write = false;
24                            rw.WriteRW(write_str);
25                        }
26
27                        if(is_close){
28                            receivedSocket = null;
29                            rw.Disconnect();
30                            is_close = false;
31                            is_alive = true;
32                        }
33
34                        try{
35                            Thread.sleep(10);
36                        }catch (InterruptedException  e2){
37                            e2.printStackTrace();
38                        }
39                    }
40                }
41            }
42        }
43    };
44
45    public void Disconnect(){
46        is_close = true;
47    }

クライアント側（抜粋）

Java
1    private final Runnable mAcceptTask = new Runnable() {
2        public void run() {
3            if (myClientAdapter.isDiscovering()) {
4                myClientAdapter.cancelDiscovery();
5            }
6
7            try {
8                clientSocket.connect();
9            } catch (IOException e) {
10                try {
11                    clientSocket.close();
12                } catch (IOException closeException) {
13                    e.printStackTrace();
14                }
15                CallbackConnectionResult(false, "connection error!");
16                return;
17            }
18
19            ReadWriteModel rw = new ReadWriteModel(clientSocket) {
20                @Override
21                public void ReadRW(String read_str) {
22                    ReadBCT(read_str);
23                }
24            };
25            rw.start();
26            CallbackConnectionResult(true, "connection success!");
27
28
29            while (is_alive) {
30                if (is_write) {
31                    is_write = false;
32                    rw.WriteRW(write_str);
33                }
34
35                if (is_close){
36                    try {
37                        clientSocket.close();
38                    }catch (IOException e){
39                        e.printStackTrace();
40                    }
41                    rw.Disconnect();
42                    is_close = false;
43                    is_alive = false;
44                    threads.shutdown();
45                }
46
47                try {
48                    Thread.sleep(10);
49                } catch (InterruptedException e2) {
50                    e2.getStackTrace();
51                }
52            }
53        }
54    };
55
56    public void Disconnect(){
57        is_close = true;
58    }