package com.ifpdos.factorytest;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.AssetFileDescriptor;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import androidx.core.internal.view.SupportMenu;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.vectordrawable.graphics.drawable.PathInterpolatorCompat;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.ifpdos.factorytest.util.WifiUtil;
import com.ifpdos.factorytest.util.WiredNetworkUtil;
import com.seewo.sdk.OpenSDK;
import com.seewo.vcommons.constants.SeewoIntent;
import com.seewo.vcommons.utils.reflect.Reflect;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public class WifiTestActivity extends Activity {
    private static final String ACTION_START_WIFI_TEST = "com.ifpdos.intent.action.START_WIFI_TEST";
    private static final String ACTION_WIFI_TEST_COMPLETED = "com.ifpdos.intent.action.WIFI_TEST_COMPLETED";
    private static final String CONFIG_FILE = "wifi.json";
    private static final String DFT_CONFIG_DIR = "dft_config";
    private static String ETHERNET_SERVICE = "ethernet";
    private static final int STRENGTH_NOT_FOUND = Integer.MIN_VALUE;
    private static final String TAG = "WifiTestActivity";
    private Reflect mEthManager;
    private Handler mHandler;
    private RecyclerViewAdapter mRecyclerViewAdapter;
    private WifiManager mWifiManager;
    private boolean orgWifiEnable;
    private boolean orgWiredEnable;
    private boolean originHotspotEnable;
    TextView tipsView;
    private int scanDelay = PathInterpolatorCompat.MAX_NUM_POINTS;
    private HandlerThread mHandlerThread = new HandlerThread("ScanThread");
    private int retry_count_max = 6;
    private int success_count_max = 1;
    private boolean autoTest = false;
    private final BroadcastReceiver mWifiScanReceiver = new BroadcastReceiver() { // from class: com.ifpdos.factorytest.WifiTestActivity.1
        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if (intent.getBooleanExtra("resultsUpdated", false)) {
                Log.d(WifiTestActivity.TAG, "WiFi扫描完成，获取扫描结果");
                if (WifiTestActivity.this.autoTest) {
                    RecyclerViewAdapter recyclerViewAdapter = WifiTestActivity.this.mRecyclerViewAdapter;
                    WifiTestActivity wifiTestActivity = WifiTestActivity.this;
                    recyclerViewAdapter.checkForAutoTest(wifiTestActivity.toMap(wifiTestActivity.mWifiManager.getScanResults()));
                }
                RecyclerViewAdapter recyclerViewAdapter2 = WifiTestActivity.this.mRecyclerViewAdapter;
                WifiTestActivity wifiTestActivity2 = WifiTestActivity.this;
                recyclerViewAdapter2.updateWifiStrength(wifiTestActivity2.toMap(wifiTestActivity2.mWifiManager.getScanResults()));
                return;
            }
            Log.d(WifiTestActivity.TAG, "WiFi扫描失败");
        }
    };

    @Override // android.app.Activity
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(R.layout.activity_wifi_test);
        this.mWifiManager = (WifiManager) getApplicationContext().getSystemService("wifi");
        this.orgWiredEnable = WiredNetworkUtil.getEthernetEnable(this);
        this.orgWifiEnable = WifiUtil.getWifiManager().isWifiEnabled();
        boolean zBooleanValue = HotSpotTest.getHotspotEnable().booleanValue();
        this.originHotspotEnable = zBooleanValue;
        if (zBooleanValue) {
            HotSpotTest.closeHotspot();
        }
        initUi();
        this.mHandlerThread.start();
        this.mHandler = new Handler(this.mHandlerThread.getLooper());
    }

    @Override // android.app.Activity
    protected void onResume() {
        super.onResume();
    }

    @Override // android.app.Activity
    protected void onStart() {
        super.onStart();
        if (ACTION_START_WIFI_TEST.equals(getIntent().getAction())) {
            this.autoTest = true;
            OpenSDK.getInstance().connect(this);
        }
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.wifi.SCAN_RESULTS");
        registerReceiver(this.mWifiScanReceiver, intentFilter);
        startScanWifi();
    }

    @Override // android.app.Activity
    protected void onDestroy() {
        super.onDestroy();
        if (this.autoTest) {
            OpenSDK.getInstance().disconnect();
        }
        WiredNetworkUtil.setEthernetEnable(this, this.orgWiredEnable);
        WifiUtil.getWifiManager().setWifiEnabled(this.orgWifiEnable);
        if (this.originHotspotEnable != HotSpotTest.getHotspotEnable().booleanValue()) {
            HotSpotTest.setHotspotEnable(Boolean.valueOf(this.originHotspotEnable));
        }
        try {
            unregisterReceiver(this.mWifiScanReceiver);
        } catch (IllegalArgumentException e) {
            Log.d(TAG, "广播接收器可能已经注销: " + e.getMessage());
        }
    }

    private void initUi() {
        this.tipsView = (TextView) findViewById(R.id.wifi_tips);
        this.mRecyclerViewAdapter = new RecyclerViewAdapter(this, getConfig(), this.retry_count_max, this.success_count_max);
        RecyclerView recyclerView = (RecyclerView) findViewById(R.id.list);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        recyclerView.setAdapter(this.mRecyclerViewAdapter);
        ((Button) findViewById(R.id.pass)).setOnClickListener(new View.OnClickListener() { // from class: com.ifpdos.factorytest.WifiTestActivity$$ExternalSyntheticLambda2
            @Override // android.view.View.OnClickListener
            public final void onClick(View view) {
                this.f$0.lambda$initUi$0(view);
            }
        });
        ((Button) findViewById(R.id.fail)).setOnClickListener(new View.OnClickListener() { // from class: com.ifpdos.factorytest.WifiTestActivity$$ExternalSyntheticLambda3
            @Override // android.view.View.OnClickListener
            public final void onClick(View view) {
                this.f$0.lambda$initUi$1(view);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$initUi$0(View view) {
        if (!this.autoTest) {
            setResult(1);
        }
        finish();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$initUi$1(View view) {
        if (!this.autoTest) {
            setResult(2);
        }
        finish();
    }

    private void startScanWifi() {
        if (this.autoTest && this.mWifiManager == null) {
            sendWifiManagerNull(false);
        }
        Reflect reflectOn = Reflect.on(getApplicationContext().getSystemService(ETHERNET_SERVICE));
        this.mEthManager = reflectOn;
        try {
            reflectOn.call("enableEthernet", false);
            if (this.mWifiManager.getWifiState() != 3) {
                this.mWifiManager.setWifiEnabled(true);
            }
        } catch (Exception e) {
            Log.e(TAG, "" + e);
        }
        scanWifi();
    }

    private void sendWifiManagerNull(boolean z) {
        Intent intent = new Intent(ACTION_WIFI_TEST_COMPLETED);
        intent.putExtra(SeewoIntent.EXTRA_TOUCH_TEST_RESULT, z);
        Log.e(TAG, "WifiManager为空: ");
        intent.putExtra("max_5G", Integer.MIN_VALUE);
        intent.putExtra("max_24G", Integer.MIN_VALUE);
        sendBroadcast(intent);
        finish();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void scanWifi() {
        if (isFinishing()) {
            return;
        }
        runOnUiThread(new Runnable() { // from class: com.ifpdos.factorytest.WifiTestActivity$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                this.f$0.doScanWifiInfo();
            }
        });
        this.mHandler.postDelayed(new Runnable() { // from class: com.ifpdos.factorytest.WifiTestActivity$$ExternalSyntheticLambda1
            @Override // java.lang.Runnable
            public final void run() {
                this.f$0.scanWifi();
            }
        }, this.scanDelay);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private List<WifiConfig> getConfig() throws Throwable {
        InputStream fileInputStream;
        IOException e;
        File file = new File(new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), DFT_CONFIG_DIR), CONFIG_FILE);
        if (file.exists()) {
            AssetFileDescriptor.AutoCloseInputStream autoCloseInputStream = 0;
            try {
                try {
                    fileInputStream = new FileInputStream(file);
                    try {
                        List<WifiConfig> list = parserConfig(fileInputStream);
                        safeClose(fileInputStream);
                        return list;
                    } catch (IOException e2) {
                        e = e2;
                        Log.d(TAG, "IO error: " + e.getMessage());
                        safeClose(fileInputStream);
                        return getDefaultConfig();
                    }
                } catch (Throwable th) {
                    th = th;
                    autoCloseInputStream = CONFIG_FILE;
                    safeClose(autoCloseInputStream);
                    throw th;
                }
            } catch (IOException e3) {
                fileInputStream = null;
                e = e3;
            } catch (Throwable th2) {
                th = th2;
                safeClose(autoCloseInputStream);
                throw th;
            }
        }
        return getDefaultConfig();
    }

    private List<WifiConfig> parserConfig(InputStream inputStream) throws Throwable {
        InputStreamReader inputStreamReader;
        ArrayList arrayList = new ArrayList();
        WifiConfig wifiConfig = new WifiConfig();
        WifiConfig wifiConfig2 = new WifiConfig();
        Closeable closeable = null;
        try {
            try {
                inputStreamReader = new InputStreamReader(inputStream);
            } catch (Exception e) {
                e = e;
            }
        } catch (Throwable th) {
            th = th;
        }
        try {
            JsonElement jsonElement = new JsonParser().parse(inputStreamReader);
            JsonArray asJsonArray = jsonElement.getAsJsonObject().get("wifi").getAsJsonArray();
            for (int i = 0; i < asJsonArray.size(); i++) {
                JsonObject asJsonObject = asJsonArray.get(i).getAsJsonObject();
                String configJsonValue = getConfigJsonValue(asJsonObject, "ssid");
                String configJsonValue2 = getConfigJsonValue(asJsonObject, "min_dbm");
                String configJsonValue3 = getConfigJsonValue(asJsonObject, "max_dbm");
                if (configJsonValue.contains("5G")) {
                    wifiConfig.setSsid(configJsonValue);
                    wifiConfig.setMinStrength(Integer.parseInt(configJsonValue2));
                    wifiConfig.setMaxStrength(Integer.parseInt(configJsonValue3));
                } else {
                    wifiConfig2.setSsid(configJsonValue);
                    wifiConfig2.setMinStrength(Integer.parseInt(configJsonValue2));
                    wifiConfig2.setMaxStrength(Integer.parseInt(configJsonValue3));
                }
            }
            this.retry_count_max = jsonElement.getAsJsonObject().get("retry_count").getAsJsonObject().get("value").getAsInt();
            Log.d(TAG, "retry_count_max: " + this.retry_count_max);
            this.success_count_max = jsonElement.getAsJsonObject().get("success_count").getAsJsonObject().get("value").getAsInt();
            Log.d(TAG, "success_count_max: " + this.success_count_max);
            arrayList.add(wifiConfig);
            arrayList.add(wifiConfig2);
            JsonElement jsonElement2 = jsonElement.getAsJsonObject().get("wifi_scan_interval");
            if (jsonElement2 != null) {
                Log.d(TAG, "set wifi_scan_interval from wifi.json: " + jsonElement2);
                this.scanDelay = jsonElement2.getAsJsonObject().get("value").getAsInt();
            }
            JsonElement jsonElement3 = jsonElement.getAsJsonObject().get("wifi_country_code");
            if (jsonElement3 != null) {
                JsonObject asJsonObject2 = jsonElement3.getAsJsonObject();
                String asString = asJsonObject2.get("value").getAsString();
                Log.d(TAG, "set wifi country code from wifi.json: " + asJsonObject2);
                setWifiCountryCode(asString);
            }
            safeClose(inputStreamReader);
            return arrayList;
        } catch (Exception e2) {
            e = e2;
            closeable = inputStreamReader;
            Log.d(TAG, "读取配置文件出错：" + e.getMessage());
            this.tipsView.setVisibility(0);
            List<WifiConfig> defaultConfig = getDefaultConfig();
            safeClose(closeable);
            return defaultConfig;
        } catch (Throwable th2) {
            th = th2;
            closeable = inputStreamReader;
            safeClose(closeable);
            throw th;
        }
    }

    private void setWifiCountryCode(String str) {
        try {
            WifiManager.class.getDeclaredMethod("setOverrideCountryCode", String.class).invoke(this.mWifiManager, str);
            Log.d(TAG, "Successfully set WiFi country code to: " + str);
        } catch (Exception e) {
            Log.e(TAG, "Failed to set WiFi country code: " + e.getMessage(), e);
        }
    }

    private String getConfigJsonValue(JsonObject jsonObject, String str) {
        return jsonObject.get(str).getAsJsonObject().get("value").getAsString();
    }

    private List<WifiConfig> getDefaultConfig() {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new WifiConfig("factorytest_5G", -45, 0));
        arrayList.add(new WifiConfig("factorytest_2.4G", -45, 0));
        return arrayList;
    }

    private void safeClose(Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (IOException unused) {
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doScanWifiInfo() {
        Log.e(TAG, "getWifiState: " + this.mWifiManager.getWifiState());
        if (this.mWifiManager.getWifiState() != 3) {
            return;
        }
        this.mWifiManager.startScan();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Map<String, ScanResult> toMap(List<ScanResult> list) {
        HashMap map = new HashMap();
        if (list == null) {
            return map;
        }
        for (ScanResult scanResult : list) {
            if (map.containsKey(scanResult.SSID)) {
                int i = ((ScanResult) Objects.requireNonNull((ScanResult) map.get(scanResult.SSID))).level;
                Log.d(TAG, "same ssid in map: " + scanResult.SSID + ",map level: " + i + ",result level: " + scanResult.level);
                if (i >= scanResult.level) {
                    Log.d(TAG, "same ssid and less level,ignore");
                }
            }
            map.put(scanResult.SSID, scanResult);
        }
        return map;
    }

    private static class RecyclerViewAdapter extends RecyclerView.Adapter<ViewHolder> {
        static final /* synthetic */ boolean $assertionsDisabled = false;
        private Context mContext;
        private LayoutInflater mLayoutInflater;
        private int retry_count_max;
        private int success_count_max;
        private List<WifiInfo> mWifiList = new ArrayList();
        private Map<String, WifiConfig> mConfigMap = new HashMap();
        private int retry_count_now = 0;
        private int success_count_now = 0;
        private List<Integer> result_5G = new ArrayList();
        private List<Integer> result_24G = new ArrayList();

        RecyclerViewAdapter(Context context, List<WifiConfig> list, int i, int i2) {
            this.mLayoutInflater = LayoutInflater.from(context);
            this.mContext = context;
            for (WifiConfig wifiConfig : list) {
                this.mWifiList.add(new WifiInfo(wifiConfig.ssid));
                this.mConfigMap.put(wifiConfig.ssid, wifiConfig);
            }
            this.retry_count_max = i;
            this.success_count_max = i2;
        }

        @Override // androidx.recyclerview.widget.RecyclerView.Adapter
        public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
            return new ViewHolder(this.mLayoutInflater.inflate(R.layout.list_item_wifi_test, viewGroup, false));
        }

        @Override // androidx.recyclerview.widget.RecyclerView.Adapter
        public void onBindViewHolder(ViewHolder viewHolder, int i) {
            WifiInfo wifiInfo = this.mWifiList.get(i);
            WifiConfig wifiConfig = this.mConfigMap.get(wifiInfo.ssid);
            viewHolder.updateRange(wifiConfig.minStrength, wifiConfig.maxStrength);
            viewHolder.setSsid(wifiInfo.ssid);
            viewHolder.setType(wifiInfo.type);
            viewHolder.setStrength(wifiInfo.curStrength);
        }

        @Override // androidx.recyclerview.widget.RecyclerView.Adapter
        public int getItemCount() {
            return this.mWifiList.size();
        }

        void updateWifiStrength(Map<String, ScanResult> map) {
            for (int i = 0; i < this.mWifiList.size(); i++) {
                WifiInfo wifiInfo = this.mWifiList.get(i);
                ScanResult scanResult = map.get(wifiInfo.ssid);
                if (scanResult == null) {
                    wifiInfo.curStrength = Integer.MIN_VALUE;
                    wifiInfo.type = WifiType.UNKNOWN;
                } else {
                    wifiInfo.curStrength = scanResult.level;
                    wifiInfo.type = WifiType.getForFrequency(scanResult.frequency);
                }
                notifyItemChanged(i);
            }
        }

        void checkForAutoTest(Map<String, ScanResult> map) {
            int i = this.retry_count_now + 1;
            this.retry_count_now = i;
            if (i > this.retry_count_max) {
                Log.e(WifiTestActivity.TAG, "尝试次数超过" + (this.retry_count_now - 1));
                sendAutoTestResult(false);
            }
            WifiInfo wifiInfo = this.mWifiList.get(0);
            WifiInfo wifiInfo2 = this.mWifiList.get(1);
            ScanResult scanResult = map.get(wifiInfo.ssid);
            ScanResult scanResult2 = map.get(wifiInfo2.ssid);
            WifiConfig wifiConfig = this.mConfigMap.get(wifiInfo.ssid);
            WifiConfig wifiConfig2 = this.mConfigMap.get(wifiInfo.ssid);
            if (scanResult == null) {
                this.result_5G.add(Integer.MIN_VALUE);
            } else {
                this.result_5G.add(Integer.valueOf(scanResult.level));
            }
            if (scanResult2 == null) {
                this.result_24G.add(Integer.MIN_VALUE);
            } else {
                this.result_24G.add(Integer.valueOf(scanResult2.level));
            }
            if (scanResult == null || scanResult2 == null) {
                return;
            }
            if (scanResult.level <= wifiConfig.maxStrength && scanResult.level >= wifiConfig.minStrength && scanResult2.level <= wifiConfig2.maxStrength && scanResult2.level >= wifiConfig2.minStrength) {
                this.success_count_now++;
                Log.d(WifiTestActivity.TAG, "success_count_now: " + this.success_count_now);
            }
            int i2 = this.retry_count_now;
            int i3 = this.retry_count_max;
            if (i2 <= i3 && this.success_count_now == this.success_count_max) {
                sendAutoTestResult(true);
                Log.d(WifiTestActivity.TAG, "checkForAutoTest: 自动化测试成功");
            } else if (i2 > i3) {
                Log.d(WifiTestActivity.TAG, "尝试次数" + this.retry_count_now);
                sendAutoTestResult(false);
            }
        }

        private void sendAutoTestResult(boolean z) {
            Intent intent = new Intent(WifiTestActivity.ACTION_WIFI_TEST_COMPLETED);
            intent.putExtra(SeewoIntent.EXTRA_TOUCH_TEST_RESULT, z);
            for (int i = 0; i < this.result_5G.size(); i++) {
                Log.d(WifiTestActivity.TAG, "i: " + i);
                Log.d(WifiTestActivity.TAG, "5G_result: " + this.result_5G.get(i) + " 2.4G_result:" + this.result_24G.get(i));
            }
            Collections.sort(this.result_5G);
            Collections.sort(this.result_24G);
            Log.e(WifiTestActivity.TAG, new StringBuilder("搜索过程中5G最大信号强度: ").append(this.result_5G.get(r1.size() - 1)).toString());
            Log.e(WifiTestActivity.TAG, new StringBuilder("搜索过程中2.4G最大信号强度: ").append(this.result_24G.get(r1.size() - 1)).toString());
            intent.putExtra("max_5G", this.result_5G.get(r5.size() - 1).intValue());
            intent.putExtra("max_24G", this.result_24G.get(r5.size() - 1).intValue());
            this.mContext.sendBroadcast(intent);
            ((WifiTestActivity) this.mContext).finish();
        }
    }

    private static class ViewHolder extends RecyclerView.ViewHolder {
        private TextView mSsid;
        private TextView mStrength;
        private TextView mType;
        private int max_strength;
        private int standard_strength;

        ViewHolder(View view) {
            super(view);
            this.mSsid = (TextView) view.findViewById(R.id.ssid);
            this.mType = (TextView) view.findViewById(R.id.type);
            this.mStrength = (TextView) view.findViewById(R.id.strength);
        }

        void updateRange(int i, int i2) {
            this.standard_strength = i;
            this.max_strength = i2;
        }

        void setStrength(int i) {
            Log.d(WifiTestActivity.TAG, "mSsid: " + ((Object) this.mSsid.getText()) + " mType: " + ((Object) this.mType.getText()) + " strength: " + i);
            if (i >= this.standard_strength) {
                this.mStrength.setTextColor(-16711936);
            } else {
                Log.e(WifiTestActivity.TAG, "setStrength: wifi未通过 类型：" + ((Object) this.mType.getText()));
                this.mStrength.setTextColor(SupportMenu.CATEGORY_MASK);
            }
            if (i == Integer.MIN_VALUE) {
                this.mStrength.setText(R.string.wifi_test_strength_not_found);
            } else {
                this.mStrength.setText(String.valueOf(i));
            }
        }

        void setType(WifiType wifiType) {
            int i = AnonymousClass2.$SwitchMap$com$ifpdos$factorytest$WifiTestActivity$WifiType[wifiType.ordinal()];
            if (i == 1) {
                this.mType.setText(R.string.wifi_test_type_24_g);
            } else if (i == 2) {
                this.mType.setText(R.string.wifi_test_type_5_g);
            } else {
                if (i != 3) {
                    return;
                }
                this.mType.setText(R.string.wifi_test_type_unknown);
            }
        }

        void setSsid(String str) {
            this.mSsid.setText(str);
        }
    }

    /* JADX INFO: renamed from: com.ifpdos.factorytest.WifiTestActivity$2, reason: invalid class name */
    static /* synthetic */ class AnonymousClass2 {
        static final /* synthetic */ int[] $SwitchMap$com$ifpdos$factorytest$WifiTestActivity$WifiType;

        static {
            int[] iArr = new int[WifiType.values().length];
            $SwitchMap$com$ifpdos$factorytest$WifiTestActivity$WifiType = iArr;
            try {
                iArr[WifiType.TYPE_24G.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$ifpdos$factorytest$WifiTestActivity$WifiType[WifiType.TYPE_5G.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$com$ifpdos$factorytest$WifiTestActivity$WifiType[WifiType.UNKNOWN.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    private static class WifiInfo {
        String ssid;
        int curStrength = Integer.MIN_VALUE;
        WifiType type = WifiType.UNKNOWN;

        WifiInfo(String str) {
            this.ssid = str;
        }
    }

    private static class WifiConfig {
        int maxStrength;
        int minStrength;
        String ssid;

        WifiConfig() {
        }

        WifiConfig(String str, int i, int i2) {
            this.ssid = str;
            this.minStrength = i;
            this.maxStrength = i2;
        }

        public String getSsid() {
            return this.ssid;
        }

        public void setSsid(String str) {
            this.ssid = str;
        }

        public int getMinStrength() {
            return this.minStrength;
        }

        public void setMinStrength(int i) {
            this.minStrength = i;
        }

        public int getMaxStrength() {
            return this.maxStrength;
        }

        public void setMaxStrength(int i) {
            this.maxStrength = i;
        }
    }

    private enum WifiType {
        TYPE_24G,
        TYPE_5G,
        UNKNOWN;

        static WifiType getForFrequency(int i) {
            if (i > 5000) {
                return TYPE_5G;
            }
            return TYPE_24G;
        }
    }
}