CameraWiFiListActivity.java 源代码

package activity.addCamera;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.TextView;
import base.HiActivity;
import bean.ConCamera;
import bean.MyCamera;
import com.hichip.base.HiLog;
import com.hichip.callback.ICameraIOSessionCallback;
import com.hichip.campro.R;
import com.hichip.content.HiChipDefines;
import com.hichip.control.HiCamera;
import com.hichip.tools.Packet;
import common.Constant;
import common.ConstantCommand;
import common.HiDataValue;
import common.TitleView;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import utils.HiTools;
import utils.MyToast;
import utils.WifiAdmin;

public class CameraWiFiListActivity extends HiActivity implements ICameraIOSessionCallback, AdapterView.OnItemClickListener {
    private BaseAdapter adapter;
    private CountDownTimer countDownTimer;
    ListView lv_wifi_list;
    private ConCamera mEvent;
    private MyCamera mMyCamera;
    private ConnectionChangeReceiver mReceiver;
    private String ssid;
    TitleView titleview;
    private String[] videoApenc;
    private List<HiChipDefines.SWifiAp_Ext> wifi_list_ext = Collections.synchronizedList(new ArrayList());
    private List<HiChipDefines.SWifiAp> wifi_list = Collections.synchronizedList(new ArrayList());
    private boolean isSupportWiFiExt = false;
    private boolean misADD_Q = false;
    private Handler dialogHandler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            super.handleMessage(message);
        }
    };
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            int i = message.what;
            if (i == -1879048191) {
                CameraWiFiListActivity.this.handMsgSessionState(message);
                return;
            }
            if (i != -1879048189) {
                if (i != 119) {
                    return;
                }
                HiDataValue.mwifiConnect_QNorError = true;
                CameraWiFiListActivity.this.handler.removeCallbacksAndMessages(null);
                if (HiDataValue.wifiAdmin == null) {
                    HiDataValue.wifiAdmin = new WifiAdmin(CameraWiFiListActivity.this.getApplicationContext());
                }
                HiDataValue.wifiAdmin.removeNetwork_Q();
                if (CameraWiFiListActivity.this.mMyCamera != null) {
                    CameraWiFiListActivity.this.mMyCamera.disconnect(1);
                    return;
                }
                return;
            }
            if (message.arg2 == 0) {
                byte[] byteArray = message.getData().getByteArray("data");
                int i2 = message.arg1;
                if (i2 != 16645) {
                    if (i2 != 16764) {
                        if (i2 != 61445) {
                            return;
                        }
                        CameraWiFiListActivity.this.mMyCamera.appSetCommandFunction(new ConstantCommand.HI_P2P_FUNCTION_LITE(byteArray));
                        return;
                    }
                    HiChipDefines.HI_P2P_S_WIFI_LIST_EXT hi_p2p_s_wifi_list_ext = new HiChipDefines.HI_P2P_S_WIFI_LIST_EXT(byteArray);
                    int i3 = hi_p2p_s_wifi_list_ext.flag;
                    for (int i4 = hi_p2p_s_wifi_list_ext.u32Num; i4 > 0; i4 += -1) {
                        HiChipDefines.SWifiAp_Ext sWifiAp_Ext = new HiChipDefines.SWifiAp_Ext(byteArray, ((hi_p2p_s_wifi_list_ext.u32Num - i4) * 68) + 8);
                        HiLog.e("" + HiTools.getEncoding(sWifiAp_Ext.strSSID) + "" + ((int) sWifiAp_Ext.EncType));
                        CameraWiFiListActivity.this.wifi_list_ext.add(sWifiAp_Ext);
                    }
                    if (i3 == 1) {
                        if (CameraWiFiListActivity.this.wifi_list_ext.size() > 0) {
                            CameraWiFiListActivity.this.setListView();
                        } else {
                            CameraWiFiListActivity cameraWiFiListActivity = CameraWiFiListActivity.this;
                            MyToast.showToast(cameraWiFiListActivity, cameraWiFiListActivity.getString(R.string.no_wifi));
                        }
                        CameraWiFiListActivity.this.dismissLoadDialog();
                        return;
                    }
                    return;
                }
                if (byteArray == null || byteArray.length <= 0) {
                    return;
                }
                int byteArrayToInt_Little = Packet.byteArrayToInt_Little(byteArray, 0);
                int totalSize = HiChipDefines.SWifiAp.getTotalSize();
                CameraWiFiListActivity.this.wifi_list.clear();
                if (byteArrayToInt_Little > 0 && byteArray.length >= 40) {
                    for (int i5 = 0; i5 < byteArrayToInt_Little; i5++) {
                        byte[] bArr = new byte[32];
                        int i6 = (i5 * totalSize) + 4;
                        System.arraycopy(byteArray, i6, bArr, 0, 32);
                        byte b = byteArray[i6 + 32];
                        byte b2 = byteArray[i6 + 33];
                        byte b3 = byteArray[i6 + 34];
                        byte b4 = byteArray[i6 + 35];
                        String encoding = HiTools.getEncoding(bArr);
                        if (encoding.trim().getBytes().length <= 32) {
                            HiLog.e("" + encoding + "" + ((int) b2));
                            CameraWiFiListActivity.this.wifi_list.add(new HiChipDefines.SWifiAp(encoding.trim().getBytes(), b, b2, b3, b4));
                        }
                    }
                }
                if (CameraWiFiListActivity.this.wifi_list.size() > 0) {
                    CameraWiFiListActivity.this.setListView();
                } else {
                    CameraWiFiListActivity cameraWiFiListActivity2 = CameraWiFiListActivity.this;
                    MyToast.showToast(cameraWiFiListActivity2, cameraWiFiListActivity2.getString(R.string.no_wifi));
                }
                CameraWiFiListActivity.this.dismissLoadDialog();
                return;
            }
            int i7 = message.arg1;
            if (i7 == 16644 || i7 == 16764) {
                CameraWiFiListActivity.this.dismissLoadDialog();
                CameraWiFiListActivity cameraWiFiListActivity3 = CameraWiFiListActivity.this;
                MyToast.showToast(cameraWiFiListActivity3, cameraWiFiListActivity3.getString(R.string.device_not_return));
            }
        }
    };

    @Override
    protected int setLayoutId() {
        return R.layout.activity_camera_wifi_list;
    }

    @Override
    protected void init(Bundle bundle) {
        EventBus.getDefault().register(this);
        registerRece();
        getIntentData();
        initViewAndData();
        this.videoApenc = getResources().getStringArray(R.array.video_apenc);
    }

    private void registerRece() {
        IntentFilter intentFilter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
        ConnectionChangeReceiver connectionChangeReceiver = new ConnectionChangeReceiver();
        this.mReceiver = connectionChangeReceiver;
        registerReceiver(connectionChangeReceiver, intentFilter);
    }

    private void getIntentData() {
        String stringExtra = getIntent().getStringExtra("ssid");
        this.ssid = stringExtra;
        if (TextUtils.isEmpty(stringExtra)) {
            this.ssid = "";
        }
    }

    private void initViewAndData() {
        this.titleview.setButton(0);
        this.titleview.setTitle(getString(R.string.title_select_wifi));
        this.titleview.setNavigationBarButtonListener(new TitleView.NavigationBarButtonListener() {
            @Override
            public void OnNavigationButtonClick(int i) {
                if (i != 0) {
                    return;
                }
                CameraWiFiListActivity.this.finish();
            }
        });
    }

    @Override
    public void onResume() {
        super.onResume();
        if (this.misADD_Q) {
            this.misADD_Q = false;
            return;
        }
        showLoadDialog(getString(R.string.tips_loading) + "...", false, false);
        this.dialogHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                if (CameraWiFiListActivity.this.mLoadDialoging == null || !CameraWiFiListActivity.this.mLoadDialoging.isShowing()) {
                    return;
                }
                CameraWiFiListActivity cameraWiFiListActivity = CameraWiFiListActivity.this;
                MyToast.showToast(cameraWiFiListActivity, cameraWiFiListActivity.getString(R.string.device_not_return));
                CameraWiFiListActivity.this.dismissLoadDialog();
            }
        }, 30000L);
        this.mLoadDialoging.setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface dialogInterface) {
                CameraWiFiListActivity.this.dialogHandler.removeCallbacksAndMessages(null);
            }
        });
        ConCamera conCamera = this.mEvent;
        if (conCamera != null) {
            MyCamera myCamera = conCamera.getMyCamera();
            this.mMyCamera = myCamera;
            if (TextUtils.isEmpty(myCamera.getUsername())) {
                this.mMyCamera.setUsername("admin");
            }
            if (TextUtils.isEmpty(this.mMyCamera.getPassword())) {
                this.mMyCamera.setPassword("admin");
            }
            MyCamera myCamera2 = this.mMyCamera;
            if (myCamera2 != null) {
                myCamera2.registerIOSessionListener(this);
                if (this.mMyCamera.getConnectState() != 4) {
                    this.mMyCamera.connect();
                } else if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_WIFI_LIST_EXT256)) {
                    this.isSupportWiFiExt = true;
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_WIFI_LIST_EXT256, new byte[0]);
                } else {
                    this.isSupportWiFiExt = false;
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_WIFI_LIST, new byte[0]);
                }
            }
        }
        if (HiTools.cameraWhetherNull(this.mMyCamera, this)) {
        }
    }

    private void changePhoneWifiToAP() {
        CountDownTimer countDownTimer = new CountDownTimer(20000L, 4000L) {
            @Override
            public void onFinish() {
            }

            @Override
            public void onTick(long j) {
                CameraWiFiListActivity.this.handConnect();
            }
        };
        this.countDownTimer = countDownTimer;
        countDownTimer.start();
    }

    public void handConnect() {
        if (HiDataValue.wifiAdmin == null) {
            HiDataValue.wifiAdmin = new WifiAdmin(getApplicationContext());
        }
        WifiConfiguration IsExsits = HiDataValue.wifiAdmin.IsExsits(this.ssid);
        WifiConnect(HiDataValue.wifiAdmin);
        if (IsExsits == null) {
            HiDataValue.wifiAdmin.addNetwork(HiDataValue.wifiAdmin.CreateWifiInfo(this.ssid, "01234567", 3));
        }
    }

    private void WifiConnect(WifiAdmin wifiAdmin) {
        WifiManager wifiManager = wifiAdmin.mWifiManager;
        String str = this.ssid;
        WifiConfiguration IsExsits = wifiAdmin.IsExsits(str);
        if (IsExsits == null) {
            wifiManager.enableNetwork(wifiManager.addNetwork(wifiAdmin.CreateWifiInfo(str, "01234567", 3)), true);
        } else {
            wifiManager.enableNetwork(IsExsits.networkId, true);
        }
    }

    public class ConnectionChangeReceiver extends BroadcastReceiver {
        private ConnectionChangeReceiver() {
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            NetworkInfo networkInfo = ((ConnectivityManager) CameraWiFiListActivity.this.getSystemService("connectivity")).getNetworkInfo(1);
            if (networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected()) {
                WifiInfo connectionInfo = ((WifiManager) CameraWiFiListActivity.this.getApplicationContext().getSystemService("wifi")).getConnectionInfo();
                Log.e("test", "CameraWiFiListActivity: onReceive  " + connectionInfo.getSSID());
                if (TextUtils.isEmpty(CameraWiFiListActivity.this.ssid) || !connectionInfo.getSSID().contains(CameraWiFiListActivity.this.ssid) || CameraWiFiListActivity.this.mMyCamera == null) {
                    return;
                }
                CameraWiFiListActivity.this.mMyCamera.connect();
            }
        }
    }

    @Override
    public void receiveIOCtrlData(HiCamera hiCamera, int i, byte[] bArr, int i2) {
        Log.i("tedu", "--receiveIOCtrlData...--");
        if (hiCamera != this.mMyCamera) {
            return;
        }
        Bundle bundle = new Bundle();
        bundle.putByteArray("data", bArr);
        Message obtainMessage = this.handler.obtainMessage();
        obtainMessage.what = HiDataValue.HANDLE_MESSAGE_RECEIVE_IOCTRL;
        obtainMessage.obj = hiCamera;
        obtainMessage.arg1 = i;
        obtainMessage.arg2 = i2;
        obtainMessage.setData(bundle);
        this.handler.sendMessage(obtainMessage);
    }

    @Override
    public void receiveSessionState(HiCamera hiCamera, int i) {
        Log.i("tedu", "-receiveSessionState...--");
        if (this.mMyCamera != hiCamera) {
            return;
        }
        Log.i("tedu", "-receiveSessionState11111...----arg1:" + i);
        Message obtainMessage = this.handler.obtainMessage();
        obtainMessage.what = HiDataValue.HANDLE_MESSAGE_SESSION_STATE;
        obtainMessage.arg1 = i;
        obtainMessage.obj = hiCamera;
        this.handler.sendMessage(obtainMessage);
    }

    @Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
    public void onDataSynEvent(ConCamera conCamera) {
        this.mEvent = conCamera;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
        if (this.mEvent != null) {
            EventBus.getDefault().removeStickyEvent(this.mEvent);
        }
        Handler handler = this.handler;
        if (handler != null) {
            handler.removeCallbacksAndMessages(null);
        }
        Handler handler2 = this.dialogHandler;
        if (handler2 != null) {
            handler2.removeCallbacksAndMessages(null);
        }
        ConnectionChangeReceiver connectionChangeReceiver = this.mReceiver;
        if (connectionChangeReceiver != null) {
            unregisterReceiver(connectionChangeReceiver);
        }
        CountDownTimer countDownTimer = this.countDownTimer;
        if (countDownTimer != null) {
            countDownTimer.cancel();
            this.countDownTimer = null;
        }
        dismissLoadDialog();
    }

    @Override
    public void onPause() {
        super.onPause();
        if (this.misADD_Q) {
            return;
        }
        MyCamera myCamera = this.mMyCamera;
        if (myCamera != null) {
            myCamera.unregisterIOSessionListener(this);
        }
        finish();
    }

    public void handMsgSessionState(Message message) {
        if (message.arg1 != 4) {
            return;
        }
        Log.i("tedu", "--登录成功!--");
        this.mMyCamera.getConnectState();
        if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_WIFI_LIST_EXT256)) {
            this.isSupportWiFiExt = true;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_WIFI_LIST_EXT256, new byte[0]);
        } else {
            this.isSupportWiFiExt = false;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_WIFI_LIST, new byte[0]);
        }
    }

    public void setListView() {
        this.lv_wifi_list.setVisibility(0);
        if (this.isSupportWiFiExt) {
            this.adapter = new WiFiListExtAdapter(this);
        } else {
            this.adapter = new WiFiListAdapter(this);
        }
        this.lv_wifi_list.setAdapter((ListAdapter) this.adapter);
        this.lv_wifi_list.setOnItemClickListener(this);
    }

    @Override
    public void onItemClick(AdapterView<?> adapterView, View view, int i, long j) {
        byte b;
        byte b2;
        String encoding;
        byte[] bArr;
        if (this.isSupportWiFiExt) {
            HiChipDefines.SWifiAp_Ext sWifiAp_Ext = this.wifi_list_ext.get(i);
            b = sWifiAp_Ext.Mode;
            b2 = sWifiAp_Ext.EncType;
            encoding = HiTools.getEncoding(sWifiAp_Ext.strSSID);
            bArr = sWifiAp_Ext.strSSID;
        } else {
            HiChipDefines.SWifiAp sWifiAp = this.wifi_list.get(i);
            b = sWifiAp.Mode;
            b2 = sWifiAp.EncType;
            encoding = HiTools.getEncoding(sWifiAp.strSSID);
            bArr = sWifiAp.strSSID;
        }
        Intent intent = new Intent();
        intent.putExtra(Constant.MODE, (int) b);
        intent.putExtra("type", (int) b2);
        intent.putExtra("configssid", encoding);
        intent.putExtra("configssid_byte", bArr);
        setResult(-1, intent);
        finish();
    }

    public class WiFiListExtAdapter extends BaseAdapter {
        private LayoutInflater mInflater;

        @Override
        public long getItemId(int i) {
            return i;
        }

        public WiFiListExtAdapter(Context context) {
            this.mInflater = LayoutInflater.from(context);
        }

        @Override
        public int getCount() {
            return CameraWiFiListActivity.this.wifi_list_ext.size();
        }

        @Override
        public Object getItem(int i) {
            return CameraWiFiListActivity.this.wifi_list_ext.get(i);
        }

        @Override
        public View getView(int i, View view, ViewGroup viewGroup) {
            ViewHolder viewHolder;
            if (view == null) {
                view = this.mInflater.inflate(R.layout.list_setting_wifi, (ViewGroup) null);
                viewHolder = new ViewHolder();
                viewHolder.txt_ssid = (TextView) view.findViewById(R.id.wifi_setting_item_ssid);
                viewHolder.txt_safety = (TextView) view.findViewById(R.id.wifi_setting_item_safety);
                viewHolder.txt_intensity = (TextView) view.findViewById(R.id.wifi_setting_item_signal_intensity);
                view.setTag(viewHolder);
            } else {
                viewHolder = (ViewHolder) view.getTag();
            }
            if (viewHolder != null && CameraWiFiListActivity.this.wifi_list_ext != null && CameraWiFiListActivity.this.wifi_list_ext.size() > 0 && i <= CameraWiFiListActivity.this.wifi_list_ext.size() - 1) {
                HiChipDefines.SWifiAp_Ext sWifiAp_Ext = (HiChipDefines.SWifiAp_Ext) CameraWiFiListActivity.this.wifi_list_ext.get(i);
                viewHolder.txt_ssid.setText(HiTools.getEncoding(sWifiAp_Ext.strSSID));
                try {
                    viewHolder.txt_safety.setText(CameraWiFiListActivity.this.videoApenc[sWifiAp_Ext.EncType]);
                } catch (Exception unused) {
                    viewHolder.txt_safety.setText(CameraWiFiListActivity.this.videoApenc[0]);
                }
                viewHolder.txt_intensity.setText(((int) sWifiAp_Ext.Signal) + "%");
            }
            return view;
        }

        public final class ViewHolder {
            public TextView txt_intensity;
            public TextView txt_safety;
            public TextView txt_ssid;

            public ViewHolder() {
            }
        }
    }

    public class WiFiListAdapter extends BaseAdapter {
        private LayoutInflater mInflater;

        @Override
        public long getItemId(int i) {
            return i;
        }

        public WiFiListAdapter(Context context) {
            this.mInflater = LayoutInflater.from(context);
        }

        @Override
        public int getCount() {
            return CameraWiFiListActivity.this.wifi_list.size();
        }

        @Override
        public Object getItem(int i) {
            return CameraWiFiListActivity.this.wifi_list.get(i);
        }

        @Override
        public View getView(int i, View view, ViewGroup viewGroup) {
            ViewHolder viewHolder;
            if (view == null) {
                view = this.mInflater.inflate(R.layout.list_setting_wifi, (ViewGroup) null);
                viewHolder = new ViewHolder();
                viewHolder.txt_ssid = (TextView) view.findViewById(R.id.wifi_setting_item_ssid);
                viewHolder.txt_safety = (TextView) view.findViewById(R.id.wifi_setting_item_safety);
                viewHolder.txt_intensity = (TextView) view.findViewById(R.id.wifi_setting_item_signal_intensity);
                view.setTag(viewHolder);
            } else {
                viewHolder = (ViewHolder) view.getTag();
            }
            if (viewHolder != null && CameraWiFiListActivity.this.wifi_list != null && CameraWiFiListActivity.this.wifi_list.size() > 0) {
                HiChipDefines.SWifiAp sWifiAp = (HiChipDefines.SWifiAp) CameraWiFiListActivity.this.wifi_list.get(i);
                viewHolder.txt_ssid.setText(HiTools.getEncoding(sWifiAp.strSSID));
                try {
                    viewHolder.txt_safety.setText(CameraWiFiListActivity.this.videoApenc[sWifiAp.EncType]);
                } catch (Exception unused) {
                    viewHolder.txt_safety.setText(CameraWiFiListActivity.this.videoApenc[0]);
                }
                viewHolder.txt_intensity.setText(((int) sWifiAp.Signal) + "%");
            }
            return view;
        }

        public final class ViewHolder {
            public TextView txt_intensity;
            public TextView txt_safety;
            public TextView txt_ssid;

            public ViewHolder() {
            }
        }
    }
}