Socket.io-android-java-client Nachrichten empfangen und senden von Datei Beispiel

Hallo Hoffe das nach der Umsetzung hilft.Im folgenden ist der manager-Klasse, die Spur hält der alle event-Registrierung. vorbei Rückrufe, erstellen von Verbindungs-etc.

public class  NetworkManager {
    private static NetworkManager mInstance;
    private Socket mSocket;
    private int RECONNECTION_ATTEMPT = 10;
    private long CONNECTION_TIMEOUT = 30000;
    private static NetworkInterface mNetworkInterface;

    public static NetworkManager getInstance(Context context, NetworkInterface interfaces) {
        mNetworkInterface = interfaces;
        if (mInstance == null) {
            mInstance = new NetworkManager();
        }
        return mInstance;
    }

    /**
     * The purpose of this method to create the socket object
     */
    public void connectToSocket() {
        try {
            IO.Options opts = new IO.Options();
            opts.timeout = CONNECTION_TIMEOUT;
            opts.reconnection = true;
            opts.reconnectionAttempts = RECONNECTION_ATTEMPT;
            opts.reconnectionDelay = 1000;
            opts.forceNew = true;
            mSocket = IO.socket(NetworkConstant.SOCKET_CONNECTION_URL, opts);
           /*mSocket = IO.socket(NetworkConstant.SOCKET_CONNECTION_URL);
            mSocket.io().timeout(CONNECTION_TIMEOUT);
            mSocket.io().reconnection(true);
            mSocket.io().reconnectionAttempts(RECONNECTION_ATTEMPT);*/
            makeConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * The purpose of the method is to return the instance of socket
     *
     * @return
     */
    public Socket getSocket() {
        return mSocket;
    }

    /**
     * The purpose of this method is to connect with the socket
     */

    public void makeConnection() {
        if (mSocket != null) {
            mSocket.connect();
            if (mSocket.connected())
                registerConnectionAttributes();
        }
    }

    /**
     * The purpose of this method is to disconnect from the socket interface
     */
    public void disconnectFromSocket() {
        unregisterConnectionAttributes();
        mSocket.disconnect();
        mSocket = null;
        mInstance = null;
    }

    public void registerConnectionAttributes() {
        try {
            if(mSocket.connected()) {
                mSocket.on(Socket.EVENT_CONNECT_ERROR, onConnectionError);
                mSocket.on(Socket.EVENT_CONNECT_TIMEOUT, onConnectionTimeOut);
                mSocket.on(Socket.EVENT_DISCONNECT, onServerDisconnect);
            }} catch (Exception e) {
            e.printStackTrace();
        }

    }

    public void unregisterConnectionAttributes() {
        try {
            mSocket.off(Socket.EVENT_CONNECT_ERROR, onConnectionError);
            mSocket.off(Socket.EVENT_CONNECT_TIMEOUT, onConnectionTimeOut);
            mSocket.off(Socket.EVENT_DISCONNECT, onServerDisconnect);
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * The purpose of this method is to get the call back for any type of connection error
     */
    private Emitter.Listener onConnectionError = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Logger.error("Response", "onConnectionError");
            mNetworkInterface.networkCallReceive(NetworkConstant.SERVER_CONNECTION_ERROR);
        }
    };

    /**
     * The purpose of this method to get the call back for connection getting timed out
     */
    private Emitter.Listener onConnectionTimeOut = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Logger.error("Response", "onConnectionTimeOut");
            mNetworkInterface.networkCallReceive(NetworkConstant.SERVER_CONNECTION_TIMEOUT);
        }
    };
    /**
     * The purpose of this method is to receive the call back when the server get disconnected
     */
    private Emitter.Listener onServerDisconnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Logger.error("Response", "onServerDisconnection");
            mNetworkInterface.networkCallReceive(NetworkConstant.SERVER_DISCONNECTED);
        }
    };

    /**
     * The purpose of this method is register a method on server
     *
     * @param methodOnServer
     * @param handlerName
     */
    public void registerHandler(String methodOnServer, Emitter.Listener handlerName) {
        try {
            if(mSocket.connected())
            mSocket.on(methodOnServer, handlerName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * The purpose of this method is to unregister a method from server
     *
     * @param methodOnServer
     * @param handlerName
     */
    public void unRegisterHandler(String methodOnServer, Emitter.Listener handlerName) {
        try {
            mSocket.off(methodOnServer, handlerName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * The purpose of this method is to send the data to the server
     *
     * @param methodOnServer
     * @param request
     */
    public void sendDataToServer(String methodOnServer, JSONObject request) {
        Logger.error("JSON ", request.toString());
        try {
            if(mSocket.connected())

            {
                mSocket.emit(methodOnServer, request);
            }
            else
                {
                    mNetworkInterface.networkCallReceive(NetworkConstant.SERVER_CONNECTION_ERROR);
                }
            } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public interface NetworkInterface {
        public void networkCallReceive(int responseType);
    }

}

InformationsquelleAutor Amardeep