鳯华 v4.0.0版本的 MD5 值为：e66eea5d0a772ef117f7e252dfbb1dfc

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

package com.fs.chat.socket;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.fs.chat.base.AppManager;
import k4.a;
import o4.n;
public class ConnectHelper {
    private static ConnectHelper connectHelper = null;
    private static String socketUrl = "103.248.152.64";
    private ConnectThread connectThread;
    private volatile ServiceHandler mServiceHandler;
    private a<Boolean> onLineListener;
    private final Handler handler = new Handler(Looper.getMainLooper());
    private final int CHECK = 0;
    private final int CONNECT = 1;
    private final long INTERVAL = 10000;

    public class ConnectThread extends HandlerThread {
        ConnectManager mManager;

        ConnectThread(String str) {
            super(str);
            this.mManager = new ConnectManager(ConnectHelper.socketUrl) {
                @Override
                public void onConnectChanged() {
                    ConnectHelper.this.notifyOnlineState();
                }

                @Override
                public void onSessionOpened() {
                    if (ConnectHelper.this.mServiceHandler != null) {
                        ConnectHelper.this.mServiceHandler.removeCallbacksAndMessages(null);
                        ConnectHelper.this.mServiceHandler.sendEmptyMessage(0);
                    }
                }
            };
        }

        void disConnection() {
            this.mManager.disConnect();
        }

        ConnectManager getManager() {
            return this.mManager;
        }
    }

    public final class ServiceHandler extends Handler {
        ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message message) {
            boolean z9;
            boolean z10;
            int i9 = message.what;
            if (i9 == 0) {
                removeMessages(0);
                try {
                    ConnectManager manager = ConnectHelper.this.connectThread.getManager();
                    if (manager != null && !manager.isSocketConnect()) {
                        sendEmptyMessage(1);
                    }
                } catch (Exception e9) {
                    e9.printStackTrace();
                }
                sendEmptyMessageDelayed(0, 10000L);
            } else if (i9 != 1) {
            } else {
                removeCallbacksAndMessages(null);
                try {
                    ConnectManager manager2 = ConnectHelper.this.connectThread.getManager();
                    z9 = manager2.isSocketConnect();
                    if (!z9) {
                        try {
                            ConnectHelper.this.connectThread.getManager().connect();
                        } catch (Exception e10) {
                            e = e10;
                            e.printStackTrace();
                            z10 = z9;
                            if (z10) {
                            }
                        }
                    }
                    z10 = manager2.isSocketConnect();
                } catch (Exception e11) {
                    e = e11;
                    z9 = false;
                }
                if (z10) {
                    sendEmptyMessageDelayed(1, ConnectManager.ConnectTimeOut);
                } else {
                    sendEmptyMessageDelayed(0, 10000L);
                }
            }
        }
    }

    private ConnectHelper() {
    }

    public static ConnectHelper get() {
        if (connectHelper == null) {
            connectHelper = new ConnectHelper();
        }
        return connectHelper;
    }

    public final void checkConnect() {
        if ((get().isRunning() && get().isConnected()) || AppManager.d().i().t_id == 0) {
            return;
        }
        get().resConnect();
        n.d("checkConnect unconnected");
    }

    public final void checkLogin() {
        if (isConnected()) {
            this.connectThread.mManager.sendLoginMsg();
        }
    }

    public final boolean isConnected() {
        ConnectManager connectManager;
        ConnectThread connectThread = this.connectThread;
        return (connectThread == null || (connectManager = connectThread.mManager) == null || !connectManager.isConnected()) ? false : true;
    }

    public final boolean isRunning() {
        ConnectThread connectThread = this.connectThread;
        return (connectThread == null || !connectThread.isAlive() || this.connectThread.isInterrupted() || this.mServiceHandler == null) ? false : true;
    }

    public final void notifyOnlineState() {
        if (this.onLineListener != null) {
            this.handler.post(new Runnable() {
                @Override
                public void run() {
                    if (ConnectHelper.this.onLineListener != null) {
                        ConnectHelper.this.onLineListener.execute(Boolean.valueOf(ConnectHelper.this.isConnected()));
                    }
                }
            });
        }
    }

    public final synchronized void onDestroy() {
        synchronized (ConnectHelper.class) {
            ConnectThread connectThread = this.connectThread;
            if (connectThread != null) {
                connectThread.disConnection();
                this.connectThread.quitSafely();
                this.connectThread = null;
            }
            if (this.mServiceHandler != null) {
                this.mServiceHandler.removeCallbacksAndMessages(null);
                this.mServiceHandler = null;
            }
        }
    }

    public final void resConnect() {
        if (isConnected()) {
            return;
        }
        synchronized (ConnectHelper.class) {
            if (isConnected()) {
                return;
            }
            n.d("resConnect");
            try {
                if (!isRunning()) {
                    onDestroy();
                    start();
                } else {
                    this.mServiceHandler.sendEmptyMessage(1);
                }
            } catch (Exception e9) {
                e9.printStackTrace();
                onDestroy();
                start();
            }
        }
    }

    public final void setOnLineListener(a<Boolean> aVar) {
        this.onLineListener = aVar;
        notifyOnlineState();
    }

    public void setUrl(String str) {
        ConnectManager connectManager;
        Log.d("-socket-", "setUrl: ");
        socketUrl = str;
        ConnectThread connectThread = this.connectThread;
        if (connectThread == null || (connectManager = connectThread.mManager) == null) {
            return;
        }
        connectManager.setSocketUrl(str);
    }

    public final synchronized void start() {
        if (this.connectThread == null && AppManager.d().i().t_id != 0) {
            synchronized (ConnectHelper.class) {
                if (this.connectThread == null && AppManager.d().i().t_id != 0) {
                    n.d("start mina");
                    ConnectThread connectThread = new ConnectThread("mina");
                    this.connectThread = connectThread;
                    connectThread.start();
                    this.mServiceHandler = new ServiceHandler(this.connectThread.getLooper());
                    this.mServiceHandler.sendEmptyMessage(1);
                }
            }
        }
    }
}