複数端末への一斉送信を実現するsocket通信のやり方(android)

Question

現在socket通信の勉強としてWiFiDirectServiceDiscoveryというサンプルを調べています。
このデモプログラムはwifi-directを用いたp2p通信でのチャットアプリとなっており、実機での動作確認をしたところ1対1のチャットは正常に実行できました。

本題です。今、端末A,B,Cと3つの端末があるとします。端末Aと端末Bが通信を構築した後に、グループオーナーとなった端末(ここでは端末Aとします)に対して端末Cが接続要求を送信したところ端末Aには承認の是非を問うダイアログが表示され、承認すると端末A,C間で通信が構築されました。
このとき、端末B,Cから送信したメッセージは端末Aに受信されることを確認しています。
一方で端末Aからのメッセージは後から接続された端末Cにのみ受信されていました。
このデモプログラムを書き換えることで端末Aからのメッセージを端末B,Cの両方に受信させるにはどのようにすればよいでしょうか。

デバッグのログにはBindException Address Already in Use Androidとあったので、接続ごとに異なるポートやスレッドを用意する必要があるのかなと考えたのですが、お恥ずかしながら知識不足のため実装の検討がつきません。
大変恐縮ではございますが実装案等のご助言をお願い致します。

参考までにデモプログラムでのソケット通信に関係のありそうな部分を以下に示します。

public class GroupOwnerSocketHandler extends Thread {

    ServerSocket socket = null;
    private final int THREAD_COUNT = 10;
    private Handler handler;
    private static final String TAG = "GroupOwnerSocketHandler";

    public GroupOwnerSocketHandler(Handler handler) throws IOException {
        try {
            socket = new ServerSocket(4545);
            this.handler = handler;
            Log.d("GroupOwnerSocketHandler", "Socket Started");
        } catch (IOException e) {
            e.printStackTrace();
            pool.shutdownNow();
            throw e;
        }

    }

    /**
     * A ThreadPool for client sockets.
     */
    private final ThreadPoolExecutor pool = new ThreadPoolExecutor(
            THREAD_COUNT, THREAD_COUNT, 10, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>());

    @Override
    public void run() {
        while (true) {
            try {
                // A blocking operation. Initiate a ChatManager instance when
                // there is a new connection
                pool.execute(new ChatManager(socket.accept(), handler));
                Log.d(TAG, "Launching the I/O handler");

            } catch (IOException e) {
                try {
                    if (socket != null && !socket.isClosed())
                        socket.close();
                } catch (IOException ioe) {

                }
                e.printStackTrace();
                pool.shutdownNow();
                break;
            }
        }
    }

}

public class ClientSocketHandler extends Thread {

    private static final String TAG = "ClientSocketHandler";
    private Handler handler;
    private ChatManager chat;
    private InetAddress mAddress;

    public ClientSocketHandler(Handler handler, InetAddress groupOwnerAddress) {
        this.handler = handler;
        this.mAddress = groupOwnerAddress;
    }

    @Override
    public void run() {
        Socket socket = new Socket();
        try {
            socket.bind(null);
            socket.connect(new InetSocketAddress(mAddress.getHostAddress(),
                    WiFiServiceDiscoveryActivity.SERVER_PORT), 5000);
            Log.d(TAG, "Launching the I/O handler");
            chat = new ChatManager(socket, handler);
            new Thread(chat).start();
        } catch (IOException e) {
            e.printStackTrace();
            try {
                socket.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            return;
        }
    }

    public ChatManager getChat() {
        return chat;
    }

}

public class ChatManager implements Runnable {

    private Socket socket = null;
    private Handler handler;

    public ChatManager(Socket socket, Handler handler) {
        this.socket = socket;
        this.handler = handler;
    }

    private InputStream iStream;
    private OutputStream oStream;
    private static final String TAG = "ChatHandler";

    @Override
    public void run() {
        try {

            iStream = socket.getInputStream();
            oStream = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int bytes;
            handler.obtainMessage(WiFiServiceDiscoveryActivity.MY_HANDLE, this)
                    .sendToTarget();

            while (true) {
                try {
                    // Read from the InputStream
                    bytes = iStream.read(buffer);
                    if (bytes == -1) {
                        break;
                    }

                    // Send the obtained bytes to the UI Activity
                    Log.d(TAG, "Rec:" + String.valueOf(buffer));
                    handler.obtainMessage(WiFiServiceDiscoveryActivity.MESSAGE_READ,
                            bytes, -1, buffer).sendToTarget();
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void write(byte[] buffer) {
        try {
            oStream.write(buffer);
        } catch (IOException e) {
            Log.e(TAG, "Exception during write", e);
        }
    }

}

(追記)
socketをクライアント端末ごとに用意すればいいと考えGroupOwnerSocketHandler内でArrayList<Socket> socketListを作成し、リスト内のすべてのソケットに対してwrite処理をすればよいと考えたのですがどうでしょうか。

public class GroupOwnerSocketHandler extends Thread {
public static ArrayList<Socket> socketList = new ArrayList<Socket>();
--(略)--
    @Override
    public void run() {
        while (true) {
            try {
                //クライアントごとにsocketをリストで管理
                Socket clientSocket = socket.accept();
                socketList.add(clientSocket);
                pool.execute(new ChatManager(clientSocket, handler));
                Log.d(TAG, "Launching the I/O handler");

            } catch (IOException e) {
               --(略)--
            }
        }
    }

}

public class ChatManager implements Runnable {
--(略)--
    public void write(byte[] buffer) {
       //ソケットの数だけwrite
       for(Iterator<Socket> it = GroupOwnerSocketHandler.socketList.iterator(); it.hasNext();) {
            Socket s = it.next();
            try {
               OutputStream os = s.getOutputStream();
               os.write(buffer);
            } catch (IOException e) {
               Log.e(TAG, "Exception during write", e);
            } 
       }
    }
}

このように書き換えたところ、socketListには確かに端末B,Cそれぞれのsocketが別のポートの値で格納されていましたが受信できたのは先に接続した端末Bだけでした。ループ処理も二回実行されていたためwrite自体は2回呼ばれているはずなのですが...

(追記2)

public class GroupOwnerSocketHandler extends Thread {
public static ArrayList<ChatManager> chatList = new ArrayList<ChatManager>();
--(略)--
    @Override
    public void run() {
        while (true) {
            try {
                //クライアントごとにsocketをリストで管理
                Socket clientSocket = socket.accept();
                ChatManager clientChat = new ChatManager(clientSocket, handler);
                chatList.add(clientChat);
                pool.execute(clientChat);
                Log.d(TAG, "Launching the I/O handler");
            } catch (IOException e) {
               --(略)--
            }
        }
    }
}

とすることで複数の端末に送信することができました。
ですが今度は同じ端末に対して一度しか送信がされなくなってしまいました。(端末AからB,Cに対して一度ずつ送信を確認)
ChatManagerを配列として管理したので更新が正常に行われていないのではないかと考えています。
ChatManagerからhandler.obtainMessageを受け取った際のアクティビティの処理は以下のようになっていました。

 @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case MESSAGE_READ:
                byte[] readBuf = (byte[]) msg.obj;
                // construct a string from the valid bytes in the buffer
                String readMessage = new String(readBuf, 0, msg.arg1);
                Log.d(TAG, readMessage);
                (chatFragment).pushMessage("Buddy: " + readMessage);
                break;

            case MY_HANDLE:
                Object obj = msg.obj;
                (chatFragment).setChatManager((ChatManager) obj);

        }
        return true;
    }

public void setChatManager(ChatManager obj) {
        chatManager = obj;
    }

Comments

[jimbe]

まず, 構造が変になってしまっていませんでしょうか.
ChatManager はクライアント毎に生成されていますが, write メソッドは他の ChatManager が対応するはずの Socket まで GroupOwnerSocketHandler.socketList を通じて使ってしまっています. Socket の配列では無く ChatManager の配列で各 write メソッドを呼ぶべきかと思います.
また, ソケットの入出力は Stream ですが, Stream は大抵はバッファがあり, Output においては write した全てがすぐ送られるとは限りません. close() か flash() によってバッファから全て吐き出されますので, write の後は flash を呼ぶようにしたほうが確実かと思います.
Input においては, read が buffer に格納したデータ量は返り値で示されますので, (先の画像の場合もそうでしたが) 送られてくるデータ量を把握して全て受信してから handler を呼んだほうが良いのではないでしょうか.

[Mustard]

おっしゃる通りChatManagerを配列に格納したところ複数通信が実装できました。本当にありがとうございます。
ところが今度は同じ端末に複数回送信することができなくなってしまいまして...
ChatManagerからメッセージを受け取った際アクティビティ側でsetChatManagerが呼び出されChatManagerが貼り直されると解釈しているのですが
public void setChatManager(ChatManager obj) {
chatManager = obj;
}
を
public void setChatManager(int position,ChatManager obj) {
GroupOwnerSocketHandler.chatList.set(position,obj);
}
のように書き換えても再度同じ端末と通信を行うことができませんでした。
なにか見落としがあるのでしょうか。
(追記)
文字の場合同じ端末とも複数回通信できることを確認しました。
画像の場合初回の画像を受信して以降の受信ができません...

[jimbe]

画像と文字列を同じストリームを使って送信しているのでしょうか.
その場合, 受信する側は文字列なのか画像なのかの判断はどのようにされていますか.

[kazoooooo]

失礼します。
自分も複数端末にデータを送信しようとしているのですがこちらは解決したでしょうか？していたらぜひ教えていただきたいです。
よろしくお願いします。