Сеть через Socket - Программирование Android - Ответ 10336950

public class MyApp extends Application {
 
    @Override
    public void onCreate() {
        super.onCreate();
 
        // Инициализируем класс ClientSocket (Singleton)
        ClientSocket.initInstance();
    }
}

class ClientSocket {
 
    private int numberOfConnections = 5;
    private final String SERVER = "192.168.1.36"; // Пока пробую в локальной сети
    private final int PORT = 8080;
    private SocketData[] sockets = new SocketData[numberOfConnections]; // Ограничение одновременных подключений
    private static ClientSocket instance;
 
    static void initInstance() {
        if (instance == null) {
            instance = new ClientSocket();
 
            // Создаем соединение с сервером
            instance.createConnection(SERVER);
        }
    }
 
    static ClientSocket getInstance() {
        return instance;
    }
 
    void createConnection(String ip){
        CreateConnection createConnection = new CreateConnection();
        createConnection.execute(ip);
    }
 
    void deleteConnection(int index){
        try{
            sockets[index].getStreamRead().cancel(false);
        } catch (Exception e){
            e.printStackTrace();
        }
        sockets[index] = null;
    }
 
    void connected(int index){
        sockets[index].setConnected(); // Подключение установленно
    }
 
    private class CreateConnection extends AsyncTask<String, Void, Void>{
 
        @Override
        protected Void doInBackground(String... params) {
            try {
                final String SERVER = params[0];
 
                // Создаем подключение
                InetAddress serverAddress = InetAddress.getByName(SERVER);
                Socket socket = new Socket(serverAddress, PORT);
 
                // Начинаем слушать соединение
                startRead(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
 
        private void startRead(Socket socket){
 
            // Сохраняем данные о подключении
            for (int i = 0; i < numberOfConnections; i++){
                if (sockets[i] == null){
                    StreamRead stream = new StreamRead();
                    stream.execute(i, socket);
                    sockets[i] = new SocketData(socket, stream);
                    checkConnection(i);
                }
            }
        }
 
        private void checkConnection(int index){
            JSONObject message = new JSONObject();
            try {
                message.put("command", "ping");
                StreamWrite streamWrite = new StreamWrite();
                streamWrite.execute(message, sockets[index].getSocket());
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }
}

class StreamRead extends AsyncTask<Object, Void, Void> {
 
    private int index;
 
    @Override
    protected Void doInBackground(Object... params) {
        try {
            // Получаем номер подключения
            index = (int) params[0];
 
            // Получаем socket
            Socket socket = (Socket) params[1];
 
            // Создаем чтение потока
            ObjectInputStream stream = new ObjectInputStream(socket.getInputStream());
 
            // Слушаем соединение, пока не закрыли его
            while (this.isCancelled()){
                JSONObject message = (JSONObject) stream.readObject();
                if (message != null){
                    readMessage(message);
                }
            }
 
            // Освобождаем ресурсы
            socket.close();
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
 
    private void readMessage(JSONObject message){
        try {
            switch (message.get("command").toString()){
                case "ping":
                    ClientSocket.getInstance().connected(index);
                    break;
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
 
    @Override
    protected void onPostExecute(Void aVoid) {
        ClientSocket.getInstance().deleteConnection(index);
    }

class StreamWrite extends AsyncTask<Object, Void, Void> {
 
    @Override
    protected Void doInBackground(Object... params) {
        try {
            // Json запрос
            final JSONObject message = (JSONObject) params[0];
 
            // Получаем поток для отправки
            final ObjectOutputStream stream =
                    new ObjectOutputStream(((Socket) params[1]).getOutputStream());
 
            // Отправляем
            stream.writeObject(message);
 
            // Закрываем поток отправки
            stream.close();
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}