package com.rockchip.smart.rockhome.softap;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.MacAddress;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.NetworkSpecifier;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiNetworkSpecifier;
import android.os.Build;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.util.Log;

import com.rockchip.smart.rockhome.WifiInfo;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by GJK on 2018/11/14.
 */

public class WifiManager {
    private final String TAG = "WifiManager";
    private Context mContext;
    private android.net.wifi.WifiManager mWifiManager;
    private ConnectivityManager mConnectivityManager;
    private android.net.wifi.WifiManager.WifiLock mWifiLock;
    private ConnectivityManager.NetworkCallback mNetworkCallback;
    private boolean mIsRequestNetwork = false;

    private static volatile WifiManager mInstance;

    public static WifiManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (WifiManager.class) {
                if (mInstance == null) {
                    mInstance = new WifiManager(context);
                }
            }
        }
        return mInstance;
    }

    private WifiManager(Context context) {
        mContext = context;
        mWifiManager = (android.net.wifi.WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        mConnectivityManager = (ConnectivityManager)mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        mWifiLock = mWifiManager.createWifiLock("Rock Home");
        mWifiReceiver = new WifiReceiver();

        mNetworkCallback = new ConnectivityManager.NetworkCallback() {
            @Override
            public void onAvailable(Network network) {
                // do success processing here..
                Log.d(TAG, "onAvailable");
            }

            @Override
            public void onUnavailable() {
                // do failure processing here..
                Log.d(TAG, "onUnavailable");
            }

            @Override
            public void onCapabilitiesChanged(@NonNull Network network,
                                              @NonNull NetworkCapabilities networkCapabilities) {

                Log.d(TAG, "onCapabilitiesChanged");
                if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
                    Log.d(TAG, "NET_CAPABILITY_INTERNET");

                if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED))
                    Log.d(TAG, "NET_CAPABILITY_VALIDATED");
            }
        };
    }

    public void unregisterNetworkCallback() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && mIsRequestNetwork) {
            Log.d(TAG, "unregisterNetworkCallback");
            mConnectivityManager.unregisterNetworkCallback(mNetworkCallback);
            mIsRequestNetwork = false;
        }
    }

    public void acquireWifiLock() {
        if (!mWifiLock.isHeld())
            mWifiLock.acquire();
    }

    public void releaseWifiLock() {
        if (mWifiLock.isHeld())
            mWifiLock.release();
    }

    public boolean isWifiEnabled() {
        return mWifiManager.isWifiEnabled();
    }

    public boolean setWifiEnabled(boolean enable) {
        return mWifiManager.setWifiEnabled(enable);
    }

    public boolean isWifiConnected() {
        NetworkInfo wifiNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        if(wifiNetworkInfo.isConnected()) {
            return true ;
        }
        return false ;
    }

    public String getConnectWifiSsid(){
        android.net.wifi.WifiManager wifiManager = (android.net.wifi.WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        android.net.wifi.WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        return removeQuote(wifiInfo.getSSID());
    }

    private String removeQuote(String value) {
        if (!TextUtils.isEmpty(value)) {
            if (value.startsWith("\"")) {
                value = value.substring(1);
            }
            if (value.endsWith("\"")) {
                value = value.substring(0, value.length() - 1);
            }
            return value;
        }
        return value;
    }

    private Data getType(WifiInfo info) {
        if (info == null || info.getFlags() == null || info.getFlags().isEmpty()) {
            return null;
        }
        String flags = info.getFlags();

        if (flags.contains("WPA2")) {
            return Data.WIFI_CIPHER_WPA2;
        } else if (flags.contains("WPA")) {
            return Data.WIFI_CIPHER_WPA;
        } else if (flags.contains("WPS")) {
            return Data.WIFI_CIPHER_WEP;
        } else {
            return Data.WIFI_CIPHER_NOPASS;
        }
    }

    private int getConnectionNetworkId() {
        if (!isWifiConnected())
            return -1;

        return mWifiManager.getConnectionInfo().getNetworkId();
    }

    private List<ScanResult> scan() {
        mWifiManager.startScan();
        return mWifiManager.getScanResults();
    }

    private List<WifiInfo> transformResults(List<ScanResult> results) {
        List<WifiInfo> list = new ArrayList<>();
        if (results != null) {
            boolean isConnected = isWifiConnected();
            String connectedSsid = "";
            if (isConnected) {
                connectedSsid = getConnectWifiSsid();
            }
            for (ScanResult result : results) {
                if(result.SSID != null)
                    Log.d(TAG, "ScanResult: ssid = " + result.SSID.trim() + ", capabilities = " + result.capabilities);

                if (result.SSID == null || result.SSID.length() == 0 || result.capabilities.contains("[IBSS]")
                        || !result.SSID.trim().startsWith("Rockchip-SoftAp")) {
                    continue;
                }
                WifiInfo info = new WifiInfo();
                info.setConnecting(false);
                info.setSsid(result.SSID);
                info.setSignalLevel("" + result.level);
                info.setFrequency("" + result.frequency);
                info.setBssid("" + result.BSSID);
                info.setConnected(result.SSID.equals(connectedSsid));
                info.setFlags(result.capabilities.toUpperCase());

                list.add(info);
            }
            Collections.sort(list);
        }

        return list;
    }

    public List<WifiInfo> scanWifi() {
        return transformResults(scan());
    }

    public boolean connCustomNetWorkQ(String ssid, String bssid, Data type) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            NetworkSpecifier specifier = new WifiNetworkSpecifier.Builder()
                            .setSsid(ssid)
                            .setBssid(MacAddress.fromString(bssid))
                            .build();

            NetworkRequest request = new NetworkRequest.Builder()
                            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                            .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                            .setNetworkSpecifier(specifier)
                            .build();

            mConnectivityManager.requestNetwork(request, mNetworkCallback);
            mIsRequestNetwork = true;
        }

        return true;
    }

    public boolean connCustomNetWork(String ssid, String pwd, Data type) {
        int netId = -1;
        List<WifiConfiguration> wifiConfigurationList = mWifiManager.getConfiguredNetworks();
        for (WifiConfiguration configuration : wifiConfigurationList) {
            String configId = configuration.SSID.replaceAll("\"", "");
            if (configId.equals(ssid)) {
                netId = configuration.networkId;
                break;
            }
        }

        if (netId != -1) {
            boolean res = mWifiManager.removeNetwork(netId);
            Log.d(TAG, "Wifi had Configuration, remove first. " + netId + "; res:" + res);
            if (!res) {
                return false;
            }
        }

        WifiConfiguration configuration = createWifiConfig(ssid, pwd, type);
        netId = mWifiManager.addNetwork(configuration);
        if (netId == -1) {
            Log.d(TAG, "Add configuration failed...");
            return false;
        }

        Method connectMethod = connectWifiByReflectMethod(netId);
        if (connectMethod == null) {
            Log.d(TAG, "connectWifiByReflectMethod failed...");
            return mWifiManager.enableNetwork(netId, true);
        }
        return  true;
    }

    public boolean connCustomNetWorkBySdk(String ssid, String pwd, String bssid, Data type) {
        Log.d(TAG, "Build.VERSION.SDK_INT: " + Build.VERSION.SDK_INT);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
            return connCustomNetWorkQ(ssid, bssid, type);
        else
            return connCustomNetWork(ssid, pwd, type);
    }

    public void connToAp(String ssid) {
        Log.d(TAG, "connToAp ssid:" + ssid);
        connCustomNetWorkBySdk(ssid, "", "", Data.WIFI_CIPHER_NOPASS);
    }

    /**
     * 断开某一个WiFi网络
     */
    public void disconnectNetWork() {
        if (isWifiConnected()) {
            mWifiManager.disableNetwork(getConnectionNetworkId());
            mWifiManager.removeNetwork(getConnectionNetworkId());
            mWifiManager.disconnect();
        }
    }

    /**
     * 创建WifiConfiguration
     * 三个安全性的排序为：WEP < WPA < WPA2。
     * WEP是Wired Equivalent Privacy的简称，有线等效保密（WEP）协议是对在两台设备间无线传输的数据进行加密的方式，
     * 用以防止非法用户窃听或侵入无线网络
     * WPA全名为Wi-Fi Protected Access，有WPA和WPA2两个标准，是一种保护无线电脑网络（Wi-Fi）安全的系统，
     * 它是应研究者在前一代的系统有线等效加密（WEP）中找到的几个严重的弱点而产生的
     * WPA是用来替代WEP的。WPA继承了WEP的基本原理而又弥补了WEP的缺点：WPA加强了生成加密密钥的算法，
     * 因此即便收集到分组信息并对其进行解析，也几乎无法计算出通用密钥；WPA中还增加了防止数据中途被篡改的功能和认证功能
     * WPA2是WPA的增强型版本，与WPA相比，WPA2新增了支持AES的加密方式
     *
     * @param SSID
     * @param password
     * @param type
     * @return
     **/
    private WifiConfiguration createWifiConfig(String SSID, String password, Data type) {
        Log.d(TAG, "SSID = " + SSID + "; password = " + password + "; type = " + type);
        WifiConfiguration config = new WifiConfiguration();

        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + SSID + "\"";

        if (type == Data.WIFI_CIPHER_NOPASS) {
//            config.wepKeys[0] = "\"" + password + "\"";
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//            config.wepTxKeyIndex = 0;
        } else if (type == Data.WIFI_CIPHER_WEP) {
            config.hiddenSSID = true;
            config.wepKeys[0] = "\"" + password + "\"";
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        } else if (type == Data.WIFI_CIPHER_WPA) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            config.status = WifiConfiguration.Status.ENABLED;
        } else if (type == Data.WIFI_CIPHER_WPA2) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        }

        return config;
    }

    /**
     * 密码加密类型
     */
    public enum Data {
        WIFI_CIPHER_NOPASS(0), WIFI_CIPHER_WEP(1), WIFI_CIPHER_WPA(2), WIFI_CIPHER_WPA2(3);

        private final int value;

        //构造器默认也只能是private, 从而保证构造函数只能在内部使用
        Data(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    /**
     * 通过反射出不同版本的connect方法来连接Wifi
     *
     * @author jiangping.li
     * @param netId
     * @return
     * @since MT 1.0
     *
     */
    private Method connectWifiByReflectMethod(int netId) {
        Method connectMethod = null;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            // 反射方法： connect(int, listener) , 4.2 <= phone's android version
            Log.d(TAG, "1111");
            for (Method methodSub : mWifiManager.getClass().getDeclaredMethods()) {
                if ("connect".equalsIgnoreCase(methodSub.getName())) {
                    Class<?>[] types = methodSub.getParameterTypes();
                    if (types != null && types.length > 0) {
                        if ("int".equalsIgnoreCase(types[0].getName())) {
                            connectMethod = methodSub;
                        }
                    }
                }
            }
            if (connectMethod != null) {
                try {
                    Log.d(TAG, "2222");
                    connectMethod.invoke(mWifiManager, netId, null);
                } catch (Exception e) {
                    Log.d(TAG, "3333" + Log.getStackTraceString(e));
                    e.printStackTrace();
                    return null;
                }
            }
        } else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) {
            // 反射方法: connect(Channel c, int networkId, ActionListener listener)
            // 暂时不处理4.1的情况 , 4.1 == phone's android version
            return null;
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH
                && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
            // 反射方法：connectNetwork(int networkId) ,
            // 4.0 <= phone's android version < 4.1
            for (Method methodSub : mWifiManager.getClass()
                    .getDeclaredMethods()) {
                if ("connectNetwork".equalsIgnoreCase(methodSub.getName())) {
                    Class<?>[] types = methodSub.getParameterTypes();
                    if (types != null && types.length > 0) {
                        if ("int".equalsIgnoreCase(types[0].getName())) {
                            connectMethod = methodSub;
                        }
                    }
                }
            }
            if (connectMethod != null) {
                try {
                    connectMethod.invoke(mWifiManager, netId);
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
        } else {
            // < android 4.0
            return null;
        }
        return connectMethod;
    }


    private static final int WIFI_SEARCH_TIMEOUT = 20; //扫描WIFI的超时时间
    private WifiReceiver mWifiReceiver;
    private Lock mLock;
    private Condition mCondition;
    private Lock mLock1;
    private Condition mCondition1;
    private SearchWifiListener mSearchWifiListener;
    private WifiConnectListener mWifiConnectListener;
    private boolean mIsWifiScanCompleted = false;
    private boolean mIsWifiConnectCompleted = false;
    private boolean mIsWifiReceiverRegisted = false;

    private void registerWifiReceiver(IntentFilter filter) {
        if (mIsWifiReceiverRegisted)
            unregisterWifiReceiver();

        mIsWifiReceiverRegisted = true;
        mContext.registerReceiver(mWifiReceiver, filter);
    }

    private void unregisterWifiReceiver() {
        if (!mIsWifiReceiverRegisted)
            return;

        mIsWifiReceiverRegisted = false;
        mContext.unregisterReceiver(mWifiReceiver);
    }

    public static enum ErrorType {
        SEARCH_WIFI_TIMEOUT, //扫描WIFI超时（一直搜不到结果）
        NO_WIFI_FOUND,       //扫描WIFI结束，没有找到任何WIFI信号
    }

    //扫描结果通过该接口返回给Caller
    public interface SearchWifiListener {
        void onScanStart();
        void onScanFailed(ErrorType errorType);
        void onScanSuccess(List<WifiInfo> results);
    }

    public interface WifiConnectListener {
        void onConnectStart(WifiInfo info);
        void onConnectFailed(WifiInfo info, int error);
        void onConnectSuccess(WifiInfo info, int ip);
    };

    private class WifiReceiver extends BroadcastReceiver {

        private WifiInfo info;

        public WifiReceiver(WifiInfo info) {
            this.info = info;
        }

        public WifiReceiver() {

        }

        public void setInfo(WifiInfo info) {
            this.info = info;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            //Log.d(TAG, "onReceive: " + intent.getAction());
            switch (intent.getAction()) {
                case android.net.wifi.WifiManager.WIFI_STATE_CHANGED_ACTION:
                    handleWifiStateChanged(intent);
                    break;
                case android.net.wifi.WifiManager.SCAN_RESULTS_AVAILABLE_ACTION:
                    handleScanResultsAvailable(intent);
                    break;
                case android.net.wifi.WifiManager.NETWORK_STATE_CHANGED_ACTION:
                    handleNetworkStateChanged(intent);
                    break;
            }
        }

        private void handleWifiStateChanged(Intent intent) {
            int wifiState = intent.getIntExtra(android.net.wifi.WifiManager.EXTRA_WIFI_STATE, 0);
            switch (wifiState) {
                case android.net.wifi.WifiManager.WIFI_STATE_ENABLED:
                    break;
                case android.net.wifi.WifiManager.WIFI_STATE_ENABLING:
                    break;
                case android.net.wifi.WifiManager.WIFI_STATE_DISABLED:
                    break;
                case android.net.wifi.WifiManager.WIFI_STATE_DISABLING:
                    break;
                case android.net.wifi.WifiManager.WIFI_STATE_UNKNOWN:
                    break;
            }
        }

        private void handleScanResultsAvailable(Intent intent) {
            List<String> ssidResults = new ArrayList<String>();
            List<ScanResult> scanResults = mWifiManager.getScanResults();
            for(ScanResult result : scanResults ) {
                ssidResults.add(result.SSID);
            }

            //检测扫描结果
            if( ssidResults.isEmpty() ) {
                if (mSearchWifiListener != null)
                    mSearchWifiListener.onScanFailed(ErrorType.NO_WIFI_FOUND);
            } else {
                if (mSearchWifiListener != null) {
                    mSearchWifiListener.onScanSuccess(transformResults(scanResults));
                }
            }

            mLock.lock();
            mIsWifiScanCompleted = true;
            mCondition.signalAll();
            mLock.unlock();
        }

        private void handleNetworkStateChanged(Intent intent) {
            Log.d(TAG, "handleNetworkStateChanged...");
            NetworkInfo networkInfo = intent.getParcelableExtra(android.net.wifi.WifiManager.EXTRA_NETWORK_INFO);
            if(null != networkInfo)
                Log.d(TAG, "networkInfo state: " + networkInfo.getState());

            if (null != networkInfo && networkInfo.isConnected()) {
                android.net.wifi.WifiInfo wifiInfo = null;

                wifiInfo = intent.getParcelableExtra(android.net.wifi.WifiManager.EXTRA_WIFI_INFO);
                if(wifiInfo == null)
                    wifiInfo = mWifiManager.getConnectionInfo(); //for android 9 and 9+

                if (wifiInfo != null && info != null) {
                    if (wifiInfo.getBSSID().equals(info.getBssid()) && !TextUtils.isEmpty(getConnectWifiSsid())) {
                        if (mWifiConnectListener != null) {
                            mWifiConnectListener.onConnectSuccess(info, wifiInfo.getIpAddress());
                        }

                        mLock1.lock();
                        mIsWifiConnectCompleted = true;
                        mCondition1.signalAll();
                        mLock1.unlock();
                    }
                }
            }
        }
    }

    public void connect(final WifiInfo info, final String pwd, WifiConnectListener connectListener) {
        mWifiConnectListener = connectListener;

        if (mLock1 == null) {
            mLock1 = new ReentrantLock();
            mCondition1 = mLock1.newCondition();
        }
        mWifiReceiver.setInfo(info);

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (mWifiConnectListener != null) {
                    mWifiConnectListener.onConnectStart(info);
                }

                //Log.d(TAG, "isWifiConnected(): " + isWifiConnected());
                //Log.d(TAG, "SSID: " + mWifiManager.getConnectionInfo().getSSID());
                Log.d(TAG, "BSSID: " + mWifiManager.getConnectionInfo().getBSSID() + "; Bssid: " + info.getBssid());
                if (isWifiConnected() && mWifiManager.getConnectionInfo().getBSSID().equals(info.getBssid())) {
                    if (mWifiConnectListener != null) {
                        mWifiConnectListener.onConnectSuccess(info, mWifiManager.getConnectionInfo().getIpAddress());
                    }
                    return;
                }

                Log.d(TAG, "connect registerReceiver " + mWifiReceiver.isOrderedBroadcast());
                registerWifiReceiver(new IntentFilter(android.net.wifi.WifiManager.NETWORK_STATE_CHANGED_ACTION));

                if (!connCustomNetWorkBySdk(info.getSsid(), pwd, info.getBssid(), getType(info))) {
                    unregisterWifiReceiver();
                    if (mWifiConnectListener != null) {
                        mWifiConnectListener.onConnectFailed(info, -1);
                    }
                    return;
                }

                mLock1.lock();
                try {
                    mIsWifiConnectCompleted = false;
                    mCondition1.await(WIFI_SEARCH_TIMEOUT, TimeUnit.SECONDS);
                    if( !mIsWifiConnectCompleted && mWifiConnectListener != null) {
                        mWifiConnectListener.onConnectFailed(info, -2);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mLock1.unlock();

                //删除注册的监听类对象
                Log.d(TAG, "connect unregisterReceiver");
                unregisterWifiReceiver();
            }
        }).start();
    }

    public void search(String reg, SearchWifiListener listener) {
        mSearchWifiListener = listener;
        if (mLock == null) {
            mLock = new ReentrantLock();
            mCondition = mLock.newCondition();
        }

        new Thread(new Runnable() {

            @Override
            public void run() {
                //注册接收WIFI扫描结果的监听类对象
                Log.d(TAG, "search registerReceiver");
                registerWifiReceiver(new IntentFilter(android.net.wifi.WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));

                //开始扫描
                if (mSearchWifiListener != null)
                    mSearchWifiListener.onScanStart();

                mWifiManager.startScan();

                mLock.lock();

                //阻塞等待扫描结果
                try {
                    mIsWifiScanCompleted = false;
                    mCondition.await(WIFI_SEARCH_TIMEOUT, TimeUnit.SECONDS);
                    if( !mIsWifiScanCompleted && mSearchWifiListener != null) {
                        mSearchWifiListener.onScanFailed(ErrorType.SEARCH_WIFI_TIMEOUT);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                mLock.unlock();

                //删除注册的监听类对象
                Log.d(TAG, "search unregisterReceiver");
                unregisterWifiReceiver();
            }
        }).start();
    }
}