高佣联盟 v6.22.57版本的 MD5 值为：0c736d87a62b04809b5a48aa82055f6a

以下内容为反编译后的 Client.java 源代码，内容仅作参考

package cn.bmob.v3.realtime;

import K93XIfXxAzDpKiU1N9o4.lhMtZ7Qw9X3iAdKdqrK3.sl5ZJT6Tn7Of7Nx9kl5t.venwO7KUS7CKDKtOnhem.C1770;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Base64;
import cn.bmob.v3.exception.BmobException;
import cn.bmob.v3.helper.BmobNative;
import cn.bmob.v3.helper.ErrorCode;
import cn.bmob.v3.util.BLog;
import com.google.android.material.badge.BadgeDrawable;
import com.netease.nim.uikit.business.robot.parser.elements.base.ElementTag;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.HashSet;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.WebSocket;
import okhttp3.WebSocketListener;
import okio.ByteString;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.protocol.HTTP;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class Client {
    public static final String ACTION_DELETE_ROW = "deleteRow";
    public static final String ACTION_DELETE_TABLE = "deleteTable";
    public static final String ACTION_UPDATE_ROW = "updateRow";
    public static final String ACTION_UPDATE_TABLE = "updateTable";
    public static final String DEFAULT_REAL_TIME_DATA_HOST = "http://io.codenow.cn:3010/socket.io/1/";
    public static final String DEFAULT_REAL_TIME_DATA_PATH_WEBSOCKET = "websocket/";
    public static final String PROTOCOL_WEBSOCKET = "websocket";
    public static final String TAG = "Client";
    private ClientListener mClientListener;
    private WebSocket mWebSocket;
    public int ackCount = 0;
    private ListenHandler mListenHandler = new ListenHandler();
    private OkHttpClient mOkHttpClient = new OkHttpClient();

    public interface ClientListener {
        void onConnectCompleted(Client client, Exception exc);

        void onDataChange(Client client, JSONObject jSONObject);

        void onDisconnectCompleted(Client client);
    }

    public class ConfigTask extends AsyncTask<Void, Void, String> {
        public ConfigTask() {
        }

        private void handleConfig(String str) {
            if (TextUtils.isEmpty(str)) {
                Client.this.mClientListener.onConnectCompleted(Client.this, new BmobException((int) ErrorCode.E9015, "Get config failed."));
                return;
            }
            String[] split = str.split(":");
            if (split.length == 0 || split.length < 4) {
                ClientListener clientListener = Client.this.mClientListener;
                Client client = Client.this;
                clientListener.onConnectCompleted(client, new BmobException((int) ErrorCode.E9015, "Get config failed:" + str));
                return;
            }
            final String str2 = split[0];
            String str3 = split[1];
            String str4 = split[3];
            if (!"".equals(str3)) {
                int parseInt = Integer.parseInt(str3) / 2;
            }
            if (!new HashSet(Arrays.asList(str4.split(","))).contains(Client.PROTOCOL_WEBSOCKET)) {
                Client.this.mClientListener.onConnectCompleted(Client.this, new BmobException((int) ErrorCode.E9015, "websocket not supported"));
            } else {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Client.this.listenRealTime(str2);
                    }
                }).start();
            }
        }

        @Override
        public String doInBackground(Void... voidArr) {
            try {
                return Client.this.getServerConfiguration();
            } catch (IOException e) {
                return e.getMessage();
            }
        }

        @Override
        public void onPostExecute(String str) {
            super.onPostExecute((ConfigTask) str);
            handleConfig(str);
        }
    }

    public class ListenHandler extends Handler {
        private ListenHandler() {
        }

        @Override
        public void handleMessage(Message message) {
            super.handleMessage(message);
            int i = message.what;
            if (i == -1) {
                Client.this.mClientListener.onConnectCompleted(Client.this, (Exception) message.obj);
            } else if (i == 0) {
                Client.this.mClientListener.onDisconnectCompleted(Client.this);
            } else if (i == 1) {
                Client.this.mClientListener.onConnectCompleted(Client.this, null);
            } else if (i != 5) {
            } else {
                Client.this.mClientListener.onDataChange(Client.this, (JSONObject) message.obj);
            }
        }
    }

    public interface OnNewWebsocketListener {
        void onAck();

        void onChange(JSONObject jSONObject);

        void onConnected(WebSocket webSocket);

        void onDisconnected();

        void onError(String str, String str2);

        void onFailure(Exception exc);

        void onHeartbeat();

        void onJsonMessage();

        void onNoop();

        void onStringMessage();
    }

    private String createSecret() {
        byte[] bArr = new byte[16];
        for (int i = 0; i < 16; i++) {
            bArr[i] = (byte) (Math.random() * 256.0d);
        }
        return Base64.encodeToString(bArr, 0).trim();
    }

    public String expectedKey(String str) {
        try {
            return Base64.encodeToString(MessageDigest.getInstance("SHA-1").digest((str + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes()), 0).trim();
        } catch (NoSuchAlgorithmException unused) {
            return null;
        }
    }

    private JSONObject getArgs(String str, String str2, String str3) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put(C1770.f4506, BmobNative.getAppId());
            jSONObject.put("tableName", str);
            jSONObject.put("objectId", str2);
            jSONObject.put("action", str3);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jSONObject;
    }

    public void handleMessage(WebSocket webSocket, String str, OnNewWebsocketListener onNewWebsocketListener) throws JSONException {
        BLog.e("onMessage：" + str);
        String[] split = str.split(":", 4);
        switch (Integer.parseInt(split[0])) {
            case 0:
                onNewWebsocketListener.onDisconnected();
                return;
            case 1:
                onNewWebsocketListener.onConnected(webSocket);
                return;
            case 2:
                send("2::");
                onNewWebsocketListener.onHeartbeat();
                return;
            case 3:
                onNewWebsocketListener.onStringMessage();
                return;
            case 4:
                new JSONObject(split[3]);
                onNewWebsocketListener.onJsonMessage();
                return;
            case 5:
                JSONObject jSONObject = new JSONObject(split[3]);
                String string = jSONObject.getString(ElementTag.ELEMENT_ATTRIBUTE_NAME);
                JSONArray optJSONArray = jSONObject.optJSONArray("args");
                BLog.e(string);
                if (string.equals("server_pub")) {
                    BLog.e(string);
                    onNewWebsocketListener.onChange(new JSONObject(optJSONArray.getString(0)));
                    return;
                }
                return;
            case 6:
                String[] split2 = split[3].split("\\+", 2);
                JSONArray jSONArray = split2.length == 2 ? new JSONArray(split2[1]) : null;
                String str2 = "";
                if (jSONArray != null) {
                    str2 = "" + BadgeDrawable.DEFAULT_EXCEED_MAX_BADGE_NUMBER_SUFFIX + jSONArray.toString();
                }
                webSocket.send(String.format("6:::%s%s", split[1], str2));
                return;
            case 7:
                onNewWebsocketListener.onError(split[2], split[3]);
                return;
            case 8:
                onNewWebsocketListener.onNoop();
                return;
            default:
                return;
        }
    }

    public void listenRealTime(String str) {
        newWebSocket(str, new OnNewWebsocketListener() {
            @Override
            public void onAck() {
            }

            @Override
            public void onChange(JSONObject jSONObject) {
                BLog.e("onDataChange");
                Message message = new Message();
                message.what = 5;
                message.obj = jSONObject;
                Client.this.mListenHandler.sendMessage(message);
            }

            @Override
            public void onConnected(WebSocket webSocket) {
                Client.this.mWebSocket = webSocket;
                Client.this.mWebSocket.send(String.format("1::%s", ""));
                Message message = new Message();
                message.what = 1;
                Client.this.mListenHandler.sendMessage(message);
            }

            @Override
            public void onDisconnected() {
                Client.this.mWebSocket.send(String.format("0::%s", ""));
                Message message = new Message();
                message.what = 0;
                Client.this.mListenHandler.sendMessage(message);
            }

            @Override
            public void onError(String str2, String str3) {
                Message message = new Message();
                message.what = -1;
                message.obj = new Exception(str2 + ":" + str3);
                Client.this.mListenHandler.sendMessage(message);
            }

            @Override
            public void onFailure(Exception exc) {
                Message message = new Message();
                message.what = -1;
                message.obj = exc;
                Client.this.mListenHandler.sendMessage(message);
            }

            @Override
            public void onHeartbeat() {
                BLog.e("onHeartbeat");
            }

            @Override
            public void onJsonMessage() {
            }

            @Override
            public void onNoop() {
            }

            @Override
            public void onStringMessage() {
            }
        });
    }

    private void newWebSocket(String str, final OnNewWebsocketListener onNewWebsocketListener) {
        Request.Builder builder = new Request.Builder();
        final String createSecret = createSecret();
        BLog.e("key:" + createSecret);
        builder.url("http://io.codenow.cn:3010/socket.io/1/websocket/" + str);
        builder.header(HttpGet.METHOD_NAME, "HTTP/1.1");
        builder.header("Upgrade", PROTOCOL_WEBSOCKET);
        builder.header(HTTP.CONN_DIRECTIVE, "Upgrade");
        builder.header(HTTP.TARGET_HOST, "io.codenow.cn");
        builder.header("Origin", "http://io.codenow.cn");
        builder.header(HTTP.USER_AGENT, "android-websockets-2.0");
        builder.header("Sec-WebSocket-Key", createSecret);
        builder.header("Sec-WebSocket-Version", "13");
        this.mOkHttpClient.newWebSocket(builder.build(), new WebSocketListener() {
            public void onClosed(WebSocket webSocket, int i, String str2) {
                super.onClosed(webSocket, i, str2);
                BLog.e("onClosed：" + str2);
                onNewWebsocketListener.onDisconnected();
            }

            public void onClosing(WebSocket webSocket, int i, String str2) {
                super.onClosing(webSocket, i, str2);
                BLog.e("onClosing：" + str2);
            }

            public void onFailure(WebSocket webSocket, Throwable th, Response response) {
                super.onFailure(webSocket, th, response);
                BLog.e("onFailure：" + th.toString());
                onNewWebsocketListener.onDisconnected();
            }

            public void onMessage(WebSocket webSocket, String str2) {
                super.onMessage(webSocket, str2);
                try {
                    Client.this.handleMessage(webSocket, str2, onNewWebsocketListener);
                } catch (JSONException e) {
                    onNewWebsocketListener.onFailure(e);
                    e.printStackTrace();
                }
            }

            public void onOpen(WebSocket webSocket, Response response) {
                super.onOpen(webSocket, response);
                BLog.e("onOpen：" + response.message());
                Headers headers = response.headers();
                BLog.e("onOpen：" + headers.toString());
                try {
                    BLog.e("onOpen：" + response.body().string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
                String expectedKey = Client.this.expectedKey(createSecret);
                BLog.e("onOpen：" + expectedKey);
            }

            public void onMessage(WebSocket webSocket, ByteString byteString) {
                super.onMessage(webSocket, byteString);
            }
        });
    }

    public void connect(ClientListener clientListener) {
        this.mClientListener = clientListener;
        new ConfigTask().execute(new Void[0]);
    }

    public void emit(String str, JSONArray jSONArray) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put(ElementTag.ELEMENT_ATTRIBUTE_NAME, str);
            jSONObject.put("args", jSONArray);
            emitRaw(5, jSONObject.toString());
        } catch (Exception unused) {
        }
    }

    public void emitRaw(int i, String str) {
        StringBuilder sb = new StringBuilder();
        sb.append("");
        int i2 = this.ackCount;
        this.ackCount = i2 + 1;
        sb.append(i2);
        String sb2 = sb.toString();
        String format = String.format("%d:%s:%s:%s", Integer.valueOf(i), sb2 + BadgeDrawable.DEFAULT_EXCEED_MAX_BADGE_NUMBER_SUFFIX, "", str);
        BLog.e("客户端发送：" + format);
        send(format);
    }

    public String getServerConfiguration() throws IOException {
        Request.Builder builder = new Request.Builder();
        builder.url(DEFAULT_REAL_TIME_DATA_HOST);
        builder.post(RequestBody.create(MediaType.parse("text/plain"), ""));
        builder.header(HTTP.USER_AGENT, "android-websockets-2.0");
        return this.mOkHttpClient.newCall(builder.build()).execute().body().string();
    }

    public void send(String str) {
        BLog.e("send：" + str);
        this.mWebSocket.send(str);
    }

    public void subRowDelete(String str, String str2) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, str2, ACTION_DELETE_ROW).toString());
        emit("client_sub", jSONArray);
    }

    public void subRowUpdate(String str, String str2) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, str2, ACTION_UPDATE_ROW).toString());
        emit("client_sub", jSONArray);
    }

    public void subTableDelete(String str) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, "", ACTION_DELETE_TABLE).toString());
        emit("client_sub", jSONArray);
    }

    public void subTableUpdate(String str) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, "", ACTION_UPDATE_TABLE).toString());
        emit("client_sub", jSONArray);
    }

    public void unsubRowDelete(String str, String str2) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, str2, "unsub_deleteRow").toString());
        emit("client_unsub", jSONArray);
    }

    public void unsubRowUpdate(String str, String str2) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, str2, "unsub_updateRow").toString());
        emit("client_unsub", jSONArray);
    }

    public void unsubTableDelete(String str) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, "", "unsub_deleteTable").toString());
        emit("client_unsub", jSONArray);
    }

    public void unsubTableUpdate(String str) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(getArgs(str, "", "unsub_updateTable").toString());
        emit("client_unsub", jSONArray);
    }
}