WeatherSense v1.8.9 - DeviceAPConnector.java 源代码

package com.emax.weather.utils;

import android.content.Context;
import android.os.Handler;
import android.text.TextUtils;
import android.util.Log;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public class DeviceAPConnector {
    private String bindDevice;
    private OnConnectCallback callback;
    private String keyStr;
    private Handler mHandler;
    private Thread mThread;
    private DatagramSocket socket;
    private String ssidStr;
    private boolean loop = true;
    private final int STATE_CONNECT = 0;
    private final int STATE_SET_SSID = 1;
    private final int STATE_SET_KEY = 2;
    private int state = 0;
    private int retry = 0;
    private int maxRetry = 3;

    public interface OnConnectCallback {
        void onFail();

        void onNotResponse();

        void onSuccess(String bindDevice);
    }

    public DeviceAPConnector(Context context) {
        this.mHandler = new Handler(context.getMainLooper());
    }

    public void setSsidAndKeyStr(String ssidStr, String keyStr) {
        this.ssidStr = ssidStr;
        this.keyStr = keyStr;
    }

    public void initSocket() {
        Log.d("DeviceAPConnector", "initSocket socket before:" + this.socket);
        try {
            if (this.socket == null) {
                DatagramSocket datagramSocket = new DatagramSocket((SocketAddress) null);
                this.socket = datagramSocket;
                datagramSocket.setReuseAddress(true);
                this.socket.setBroadcast(true);
                this.socket.bind(new InetSocketAddress(8800));
            }
            startRevice();
        } catch (Exception e) {
            e.printStackTrace();
            closeSocket();
        }
        Log.d("DeviceAPConnector", "initSocket socket after:" + this.socket);
    }

    private void closeSocket() {
        Log.d("DeviceAPConnector", "closeSocket");
        this.loop = false;
        try {
            DatagramSocket datagramSocket = this.socket;
            if (datagramSocket != null) {
                datagramSocket.close();
                this.socket = null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            this.socket = null;
        }
        try {
            Thread thread = this.mThread;
            if (thread != null) {
                thread.interrupt();
                this.mThread = null;
            }
        } catch (Exception e2) {
            e2.printStackTrace();
            this.mThread = null;
        }
    }

    public void start() {
        Log.d("DeviceAPConnector", "start");
        this.retry = 0;
        initSocket();
        startConnect();
    }

    private void startRevice() {
        if (this.mThread == null) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    while (DeviceAPConnector.this.loop) {
                        byte[] bArr = new byte[1024];
                        try {
                            DatagramPacket datagramPacket = new DatagramPacket(bArr, 1024);
                            DeviceAPConnector.this.socket.receive(datagramPacket);
                            String str = new String(bArr, datagramPacket.getOffset(), datagramPacket.getLength(), "UTF-8");
                            Log.d("APConnectFragment", "receiveDataStr :" + str);
                            DeviceAPConnector.this.mHandler.removeMessages(0);
                            DeviceAPConnector.this.checkResult(str);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            this.mThread = thread;
            thread.start();
        }
    }

    private void addTimeout() {
        this.mHandler.postDelayed(new Runnable() {
            @Override
            public final void run() {
                DeviceAPConnector.this.lambda$addTimeout$0$DeviceAPConnector();
            }
        }, 15000L);
    }

    private void startConnect() {
        Log.d("DeviceAPConnector", "startConnect");
        addTimeout();
        this.state = 0;
        sendData("LSD_WIFI");
    }

    private void setDeviceSSid() {
        addTimeout();
        this.state = 1;
        sendData(this.ssidStr);
    }

    private void setDeviceKey() {
        addTimeout();
        this.state = 2;
        sendData(this.keyStr);
    }

    private void performCallbackFail() {
        closeSocket();
        this.mHandler.post(new Runnable() {
            @Override
            public final void run() {
                DeviceAPConnector.this.lambda$performCallbackFail$1$DeviceAPConnector();
            }
        });
    }

    public void lambda$performCallbackFail$1$DeviceAPConnector() {
        OnConnectCallback onConnectCallback = this.callback;
        if (onConnectCallback != null) {
            onConnectCallback.onFail();
        }
    }

    public void lambda$addTimeout$0$DeviceAPConnector() {
        int i = this.retry;
        if (i < this.maxRetry) {
            this.retry = i + 1;
            Log.d("DeviceAPConnector", "callbackNotResponse retry :" + this.retry);
            closeSocket();
            initSocket();
            startConnect();
            return;
        }
        performCllbackNotResponse();
    }

    private void performCllbackNotResponse() {
        closeSocket();
        OnConnectCallback onConnectCallback = this.callback;
        if (onConnectCallback != null) {
            onConnectCallback.onNotResponse();
        }
    }

    public void callbackFail() {
        int i = this.retry;
        if (i < this.maxRetry) {
            this.retry = i + 1;
            closeSocket();
            initSocket();
            startConnect();
            return;
        }
        performCallbackFail();
    }

    private void callbackSuccess() {
        closeSocket();
        this.mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (DeviceAPConnector.this.callback != null) {
                    DeviceAPConnector.this.callback.onSuccess(DeviceAPConnector.this.bindDevice);
                }
            }
        });
    }

    public void checkResult(String receiveDataStr) {
        int i = this.state;
        if (i == 0) {
            if (!TextUtils.isEmpty(receiveDataStr)) {
                String[] split = receiveDataStr.split(",");
                if (split != null && split.length == 2) {
                    this.bindDevice = split[0];
                    setDeviceSSid();
                    return;
                } else {
                    callbackFail();
                    return;
                }
            }
            callbackFail();
            return;
        }
        if (i == 1) {
            if (receiveDataStr.contains("+ok")) {
                setDeviceKey();
                return;
            } else {
                callbackFail();
                return;
            }
        }
        if (i != 2) {
            return;
        }
        if (receiveDataStr.contains("+ok")) {
            callbackSuccess();
        } else {
            callbackFail();
        }
    }

    private void sendData(final String text) {
        new Thread() {
            @Override
            public void run() {
                try {
                    byte[] bytes = text.getBytes("UTF-8");
                    DeviceAPConnector.this.socket.send(new DatagramPacket(bytes, bytes.length, InetAddress.getByName("11.11.11.254"), 8800));
                    Log.d("DeviceAPConnector", "send");
                } catch (Exception e) {
                    try {
                        Thread.sleep(3000L);
                    } catch (InterruptedException e2) {
                        e2.printStackTrace();
                    }
                    DeviceAPConnector.this.callbackFail();
                    e.printStackTrace();
                }
            }
        }.start();
    }

    public void setOnConnectCallback(OnConnectCallback callback) {
        this.callback = callback;
    }
}