chatManagerclass
public class ChatManager implements Runnable {
private static final String TAG = "ChatHandler";
private Socket socket = null;
private final Handler handler;
@Getter @Setter private boolean disable = false; //attribute to stop or start chatmanager
private InputStream iStream;
private OutputStream oStream;
/**
* Constructor of the class
* @param socket Represents the { java.net.Socket} required in order to communicate
* @param handler Represents the Handler required in order to communicate
*/
public ChatManager(@NonNull Socket socket, @NonNull Handler handler) {
this.socket = socket;
this.handler = handler;
}
/**
* Method to execute the {socketmanagers.ChatManager}'s Thread
* To stop the execution, please use ".setDisable(true);".
*/
@Override
public void run() {
Log.d(TAG,"ChatManager started");
try {
iStream = socket.getInputStream();
oStream = socket.getOutputStream();
byte[] buffer = new byte[1024];
int bytes;
//this method's call is used to call handleMessage's case Configuration.FIRSTMESSAGEXCHANGE in the MainActivity.
handler.obtainMessage(Configuration.FIRSTMESSAGEXCHANGE, this).sendToTarget();
while (!disable) { //...if enabled
try {
// Read from the InputStream
if(iStream!=null) {
bytes = iStream.read(buffer);
if (bytes == -1) {
break;
}
//this method's call is used to call handleMessage's case Configuration.MESSAGE_READ in the MainActivity.
handler.obtainMessage(Configuration.MESSAGE_READ, bytes, -1, buffer).sendToTarget();
}
} catch (IOException e) {
Log.e(TAG, "disconnected", e);
}
}
} catch (IOException e) {
Log.e(TAG,"Exception : " + e.toString());
} finally {
try {
iStream.close();
socket.close();
} catch (IOException e) {
Log.e(TAG,"Exception during close socket or isStream", e);
}
}
}
/**
* Method to write a byte array (that can be a message) on the output stream.
* @param buffer byte[] array that represents data to write. For example, a String converted in byte[] with ".getBytes();"
*/
public void write(byte[] buffer) {
try {
oStream.write(buffer);
} catch (IOException e) {
Log.e(TAG, "Exception during write", e);
}
}
}
public class ClientSocketHandler extends Thread {
private static final String TAG = "ClientSocketHandler";
private final Handler handler;
private final InetAddress mAddress; //this is the ip address, NOT THE MACADDRESS!!!
private Socket socket;
/**
* Constructor of the class.
* @param handler Represents the handler required in order to communicate
* @param groupOwnerAddress Represents the ip address of the group owner of this client/peer
*/
public ClientSocketHandler(@NonNull Handler handler, @NonNull InetAddress groupOwnerAddress) {
this.handler = handler;
this.mAddress = groupOwnerAddress;
}
/**
* Method to start the socketmanagers.ChatManager}
*/
@Override
public void run() {
ChatManager chat;
socket = new Socket();
try {
socket.bind(null);
socket.connect(new InetSocketAddress(mAddress.getHostAddress(),
Configuration.GROUPOWNER_PORT), Configuration.CLIENT_PORT);
Log.d(TAG, "Launching the I/O handler");
chat = new ChatManager(socket, handler);
new Thread(chat).start();
} catch (IOException e) {
Log.e(TAG,"IOException throwed by socket", e);
try {
socket.close();
} catch (IOException e1) {
Log.e(TAG,"IOException during close Socket" , e1);
}
}
}
/**
* Method to close the client/peer socket and kill this entire thread.
*/
public void closeSocketAndKillThisThread() {
if(socket!=null && !socket.isClosed()) {
try {
socket.close();
} catch (IOException e) {
Log.e(TAG,"IOException during close Socket" , e);
}
}
//to interrupt this thread, without the threadpoolexecutor
if(!this.isInterrupted()) {
Log.d(TAG,"Stopping ClientSocketHandler");
this.interrupt();
}
}
}
这是群组所有者代码，适用于同时与多个设备聊天我想要的是如何在同一时间向所有连接的用户发送相同的消息我已经搜索了很多但是避难所＆＃ 39; t找到了对这个逻辑的任何具体解释我该怎么做
public class GroupOwnerSocketHandler extends Thread {
private static final String TAG = "GroupOwnerSocketHandler";
private ServerSocket socket = null;
private Handler handler;
@Getter InetAddress ipAddress;
/**
* Class constructor.
* @param handler Represents the Handler required in order to communicate
* @throws IOException Exception throwed by {@link ServerSocket} (SERVERPORT).
*/
public GroupOwnerSocketHandler(@NonNull Handler handler) throws IOException {
try {
socket = new ServerSocket(Configuration.GROUPOWNER_PORT);
this.handler = handler;
Log.d("GroupOwnerSocketHandler", "Socket Started");
} catch (IOException e) {
Log.e(TAG, "IOException during open ServerSockets with port 4545", e);
pool.shutdownNow();
throw e;
}
}
/**
* A ThreadPool for client sockets.
*/
private final ThreadPoolExecutor pool = new ThreadPoolExecutor(
Configuration.THREAD_COUNT, Configuration.THREAD_COUNT,
Configuration.THREAD_POOL_EXECUTOR_KEEP_ALIVE_TIME, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>());
/**
* Method to close the group owner sockets and kill this entire thread.
*/
public void closeSocketAndKillThisThread() {
if(socket!=null && !socket.isClosed()) {
try {
socket.close();
} catch (IOException e) {
Log.e(TAG, "IOException during close Socket", e);
}
pool.shutdown();
}
}
/**
* Method to start the GroupOwnerSocketHandler.
* Attention you can't stop this method, because there is a while(true) inside.
*/
@Override
public void run() {
while (true) {
try {
// A blocking operation. Initiate a ChatManager instance when
// there is a new connection
if(socket!=null && !socket.isClosed()) {
Socket clientSocket = socket.accept(); //because now i'm connected with the client/peer device
pool.execute(new ChatManager(clientSocket, handler));
ipAddress = clientSocket.getInetAddress();
Log.d(TAG, "Launching the I/O handler");
}
} catch (IOException e) {
//if there is an exception, after closing socket and pool, the execution stops with a "break".
try {
if (socket != null && !socket.isClosed()) {
socket.close();
}
} catch (IOException ioe) {
Log.e(TAG, "IOException during close Socket", ioe);
}
pool.shutdownNow();
break; //stop the while(true).
}
}
}
public InetAddress getIpAddress() {
return ipAddress;
}
}