MainActivity.java 源代码

package main;

import account.bean.LoginUserInfo;
import activity.cloud.utils.DesUtils;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Process;
import android.support.v4.app.Fragment;
import android.text.TextUtils;
import android.view.View;
import base.MyApplication;
import bean.GroupBeanSave;
import bean.GroupBeanUse;
import bean.MyCamera;
import cn.hichip.zbar.QrConfig;
import com.bytedance.sdk.openadsdk.TTAdConstant;
import com.githang.statusbar.StatusBarCompat;
import com.heytap.msp.push.HeytapPushManager;
import com.hichip.DesCode.DoDes;
import com.hichip.NVR.HiNVRDev;
import com.hichip.base.HiLog;
import com.hichip.campro.R;
import com.hichip.sdk.HiChipSDK;
import com.meizu.cloud.pushsdk.PushManager;
import com.ss.android.socialbase.downloader.constants.DBDefinition;
import com.vivo.push.PushClient;
import com.xiaomi.mipush.sdk.Constants;
import common.Constant;
import common.DatabaseManager;
import common.HiDataValue;
import custom.drawlayout.SlidingFragmentActivity;
import custom.drawlayout.SlidingMenu;
import java.io.File;
import java.util.Locale;
import main.NVR.adapter.NVRListBean;
import org.greenrobot.eventbus.EventBus;
import utils.AppManager;
import utils.DialogUtils;
import utils.DialogUtilsCamHiPro;
import utils.HiLogcatUtil;
import utils.HiTools;
import utils.SharePreUtils;
import utils.SystemUtils;
import utils.WifiBroadcastReceiver;
import zbar.QrManager;

public class MainActivity extends SlidingFragmentActivity {
    private int listSize;
    private ChangeUserListener listener;
    private Fragment mContent;
    private Dialog mJhLoading;
    WifiBroadcastReceiver mReceiver = null;
    private int num;
    String type;

    public interface ChangeUserListener {
        void onChange();
    }

    static int access$008(MainActivity mainActivity) {
        int i = mainActivity.num;
        mainActivity.num = i + 1;
        return i;
    }

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(R.layout.activity_main);
        HiDataValue.isNeedkillNoMain = false;
        this.type = getIntent().getStringExtra("type");
        AppManager.getInstance().addActivity(this);
        initZxingBar();
        StatusBarCompat.setStatusBarColor((Activity) this, Color.parseColor("#FFFFFF"), true);
        HiDataValue.ANDROID_VERSION = HiTools.getAndroidVersion();
        initSlidingMenu();
        initCamera();
        refreshPushToken();
        initGroup();
        if (!TextUtils.isEmpty(this.type)) {
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    EventBus.getDefault().post("getDevList");
                }
            }, 1500L);
        }
        if (TextUtils.isEmpty(DesUtils.desKey)) {
            DesUtils.desKey = DoDes.GetDESKey();
        }
        LoginUserInfo.getInstance().Token = SharePreUtils.getString(HiDataValue.CACHEACC, this, HiDataValue.gUserToken1);
        HiLog.e(LoginUserInfo.getInstance().Token);
        LoginUserInfo.getInstance().Token = DesUtils.DecryptDoNet(DesUtils.desKey, LoginUserInfo.getInstance().Token);
        if (Build.VERSION.SDK_INT >= 29) {
            HiDataValue.mHi_PhoneSys_Q = true;
        } else {
            HiDataValue.mHi_PhoneSys_Q = false;
        }
        if (HiDataValue.mHi_PhoneSys_Q) {
            IntentFilter intentFilter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
            intentFilter.addAction("android.net.wifi.STATE_CHANGE");
            intentFilter.addAction("android.net.wifi.WIFI_STATE_CHANGED");
            if (this.mReceiver == null) {
                this.mReceiver = new WifiBroadcastReceiver();
            }
            WifiBroadcastReceiver wifiBroadcastReceiver = this.mReceiver;
            if (wifiBroadcastReceiver != null) {
                registerReceiver(wifiBroadcastReceiver, intentFilter);
            }
        }
    }

    private void initZxingBar() {
        QrManager.getInstance().init(new QrConfig.Builder().setDesText(getString(R.string.dimension_content)).setShowDes(true).setShowTitle(false).setNeedCrop(false).setCornerColor(Color.parseColor("#45A7E6")).setCornerSize(12).setCornerLength(50).setLineColor(Color.parseColor("#45A7E6")).setLineSpeed(2000).setScanType(1).setScanViewType(1).setCustombarcodeformat(57).setPlaySound(true).setIsOnlyCenter(false).setShowZoom(false).setAutoZoom(false).setFingerZoom(false).setDoubleEngine(true).setLooperScan(false).setLooperWaitTime(5000).setScanLineStyle(3).setAutoLight(true).setShowVibrator(true).create());
    }

    private void initGroup() {
        Cursor query = new DatabaseManager(this).getReadableDatabase().query(DatabaseManager.TABLE_FOUR_LIVE, new String[]{"groupId", "groupName", "camera1", "camera2", "camera3", "camera4", "user"}, null, null, null, null, null);
        while (query != null) {
            try {
                if (!query.moveToNext()) {
                    break;
                }
                String string = query.getString(0);
                String string2 = query.getString(1);
                String string3 = query.getString(2);
                String string4 = query.getString(3);
                String string5 = query.getString(4);
                String string6 = query.getString(5);
                String string7 = query.getString(6);
                HiLogcatUtil.d(string3 + "");
                HiLogcatUtil.d(string4 + "");
                HiLogcatUtil.d(string5 + "");
                HiLogcatUtil.d(string6 + "");
                if (HiDataValue.userAccount.equalsIgnoreCase(string7) || TextUtils.isEmpty(string7)) {
                    GroupBeanUse groupBeanUse = new GroupBeanUse();
                    groupBeanUse.setGroupId(string);
                    groupBeanUse.setGroupName(string2);
                    groupBeanUse.setUser(string7);
                    MyCamera[] myCameraArr = new MyCamera[4];
                    getCameraList(0, string3, myCameraArr);
                    getCameraList(1, string4, myCameraArr);
                    getCameraList(2, string5, myCameraArr);
                    getCameraList(3, string6, myCameraArr);
                    groupBeanUse.setCameraList(myCameraArr);
                    HiDataValue.groupList.add(groupBeanUse);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        for (GroupBeanUse groupBeanUse2 : HiDataValue.groupList) {
            if (TextUtils.isEmpty(groupBeanUse2.getUser())) {
                GroupBeanSave groupBeanSave = new GroupBeanSave();
                groupBeanSave.setGroupId(groupBeanUse2.getGroupId());
                groupBeanSave.setGroupName(groupBeanUse2.getGroupName());
                HiTools.updateFourLiveGroupUser(this, groupBeanSave);
            }
        }
    }

    private void getCameraList(int i, String str, MyCamera[] myCameraArr) {
        if (TextUtils.isEmpty(str)) {
            return;
        }
        for (MyCamera myCamera : HiDataValue.CameraList) {
            if (myCamera.getUid().equals(str)) {
                myCameraArr[i] = myCamera;
                return;
            }
        }
    }

    private void refreshPushToken() {
        if (Locale.getDefault().getLanguage().equals("zh") && Locale.getDefault().getCountry().equals("CN")) {
            String pushId = PushManager.getPushId(this);
            if (SystemUtils.isMEIZUMobile(this) && !TextUtils.isEmpty(pushId) && HiDataValue.meizuToken == null) {
                HiLogcatUtil.dTag(HiLogcatUtil.TAG_PUSH, "通过api获取魅族token: " + pushId);
                HiDataValue.meizuToken = pushId;
                SharePreUtils.putString(HiDataValue.CACHE, this, Constant.MEIZU_TOKEN, pushId);
            }
            String regId = PushClient.getInstance(this).getRegId();
            if (SystemUtils.isVIVOMobile(this) && !TextUtils.isEmpty(regId) && HiDataValue.vivoToken == null) {
                HiLogcatUtil.dTag(HiLogcatUtil.TAG_PUSH, "通过api获取VIVO token: " + regId);
                HiDataValue.vivoToken = regId;
                SharePreUtils.putString(HiDataValue.CACHE, this, Constant.VIVO_TOKEN, regId);
            }
            String registerID = HeytapPushManager.getRegisterID();
            if (SystemUtils.isOPPOMobile(this) && !TextUtils.isEmpty(registerID) && HiDataValue.oppoToken == null) {
                HiLogcatUtil.dTag(HiLogcatUtil.TAG_PUSH, "通过api获取oppo token: " + registerID);
                HiDataValue.oppoToken = registerID;
                SharePreUtils.putString(HiDataValue.CACHE, this, Constant.OPPO_TOKEN, registerID);
            }
        }
    }

    private void initCamera() {
        SQLiteDatabase sQLiteDatabase;
        Cursor cursor;
        String str;
        String str2;
        String str3;
        boolean z;
        String str4;
        String str5;
        String str6;
        int i;
        int i2;
        String str7 = "ad1m2in3";
        String str8 = "account";
        String str9 = HiDataValue.CACHE;
        int i3 = 0;
        int i4 = 1;
        boolean z2 = SystemUtils.isVIVOMobile(this) && Build.VERSION.SDK_INT > 29 && !SharePreUtils.getBoolean(HiDataValue.CACHE, this, Constant.DEV_IsVivoMedia, false);
        if (TextUtils.isEmpty(DesUtils.desKey)) {
            DesUtils.desKey = DoDes.GetDESKey();
        }
        HiDataValue.userAccount = SharePreUtils.getString(HiDataValue.CACHEACC, this, HiDataValue.gUserAccount1);
        HiDataValue.accountPsw = SharePreUtils.getString(HiDataValue.CACHEACC, this, HiDataValue.gAccountPsw1);
        HiLog.e(HiDataValue.accountPsw);
        HiDataValue.accountPsw = DesUtils.DecryptDoNet(DesUtils.desKey, HiDataValue.accountPsw);
        LoginUserInfo.getInstance().Token = SharePreUtils.getString(HiDataValue.CACHEACC, this, HiDataValue.gUserToken1);
        HiLog.e(LoginUserInfo.getInstance().Token);
        LoginUserInfo.getInstance().Token = DesUtils.DecryptDoNet(DesUtils.desKey, LoginUserInfo.getInstance().Token);
        HiDataValue.userHead = "F5F6F7F8:";
        SQLiteDatabase readableDatabase = new DatabaseManager(this).getReadableDatabase();
        Cursor query = readableDatabase.query("device", new String[]{"dev_nickname", "dev_uid", "view_acc", "view_pwd", "dev_videoQuality", "dev_alarmState", "dev_pushState", "dev_serverData", "user", "camera_level", DBDefinition.ID}, null, null, null, null, null);
        int i5 = 0;
        while (query != null) {
            try {
            } catch (Exception unused) {
                sQLiteDatabase = readableDatabase;
                cursor = query;
            } catch (Throwable th) {
                th = th;
                sQLiteDatabase = readableDatabase;
                cursor = query;
                if (cursor != null) {
                }
                sQLiteDatabase.close();
                throw th;
            }
            if (!query.moveToNext()) {
                break;
            }
            String string = query.getString(i3);
            String handUid = HiTools.handUid(query.getString(i4).toUpperCase());
            if (TextUtils.isEmpty(handUid)) {
                sQLiteDatabase = readableDatabase;
                cursor = query;
                throw new IllegalArgumentException("--UID invalid--");
            }
            if (handUid != null) {
                i5 = Integer.parseInt(handUid.split(Constants.ACCEPT_TIME_SEPARATOR_SERVER)[i4]);
            }
            String string2 = query.getString(2);
            String string3 = query.getString(3);
            int i6 = query.getInt(4);
            int i7 = query.getInt(5);
            int i8 = query.getInt(6);
            String string4 = query.getString(7);
            String string5 = query.getString(8);
            int i9 = query.getInt(9);
            int i10 = query.getInt(10);
            int i11 = SharePreUtils.getInt(str9, this, "position" + HiDataValue.userAccount + handUid);
            try {
                try {
                    if (!HiDataValue.userAccount.equalsIgnoreCase(string5) && !TextUtils.isEmpty(string5)) {
                        z = z2;
                        sQLiteDatabase = readableDatabase;
                        cursor = query;
                        i = 0;
                        str5 = str8;
                        str6 = str9;
                        str4 = str7;
                        i2 = 1;
                        i4 = i2;
                        str7 = str4;
                        str9 = str6;
                        str8 = str5;
                        i3 = i;
                        query = cursor;
                        z2 = z;
                        readableDatabase = sQLiteDatabase;
                    }
                    MyCamera myCamera = new MyCamera(getApplicationContext(), string, handUid, string2, string3);
                    myCamera.setVideoQuality(i6);
                    myCamera.setAlarmState(i7);
                    myCamera.setPushState(i8);
                    myCamera.setTimerFlag(i5);
                    myCamera.snapshot = loadImageFromUrl(this, myCamera);
                    myCamera.snapshot2 = loadImageFromUrlBall(this, myCamera);
                    myCamera.setServerData(string4);
                    myCamera.setPrimaryKey(i10);
                    myCamera.setCameraLevel(i9);
                    myCamera.setUser(string5);
                    myCamera.setPosition(i11);
                    if (z) {
                        myCamera.SetDecodeViVoVideoType(0);
                    }
                    if ((myCamera.getIs_4G() || myCamera.ismIsLE4G()) && !TextUtils.isEmpty(myCamera.getPreICCID()) && myCamera.getPreICCIDType() >= 0 && myCamera.getPreICCIDType() <= 3) {
                        myCamera.setCameraWux(true);
                    }
                    if (HiTools.isNVRDev(handUid)) {
                        str6 = str3;
                        SharePreUtils.putBoolean(str6, this, myCamera.getUid() + "mIsDevNVR", true);
                        myCamera.setIsDevNVR(true);
                        myCamera.mIsReceived_4179 = true;
                        str5 = str2;
                        myCamera.Hi_SetNvrAccount(string2, string3, str5);
                        str4 = str;
                        myCamera.Hi_SetNvrAccount(str5, str4, str5);
                        myCamera.Hi_SetNvrAccount(str5, str4, HiDataValue.userAccount);
                        myCamera.isNvrLoginType = true;
                        myCamera.mhiNvrdev = new HiNVRDev();
                        if (z) {
                            myCamera.mhiNvrdev.SetDecodeViVoVideoType(0);
                        } else {
                            myCamera.mhiNvrdev.SetDecodeViVoVideoType(1);
                        }
                    } else {
                        str4 = str;
                        str5 = str2;
                        str6 = str3;
                    }
                    myCamera.saveInCameraList();
                    i = 0;
                    NVRListBean nVRListBean = new NVRListBean(myCamera, 0, myCamera.getIsDevNVR());
                    nVRListBean.setPosition(i11);
                    nVRListBean.saveInCameraList();
                    myCamera.isWallMounted = SharePreUtils.getBoolean(str6, this, myCamera.getUid() + Constant.ISWALLMOUNTED);
                    if (myCamera.getIsLiteOs()) {
                        myCamera.getMacAddress();
                    } else if (HiTools.isOtherLiteosDev(myCamera.getUid()) || HiTools.is4GLiteOSDev(myCamera.getUid())) {
                        myCamera.setIsLiteOs(true);
                        myCamera.getMacAddress();
                    }
                    if (!myCamera.getIs_4G() && HiTools.is4GLiteOSDev(myCamera.getUid())) {
                        i2 = 1;
                        myCamera.setmIs_4G(true);
                        i4 = i2;
                        str7 = str4;
                        str9 = str6;
                        str8 = str5;
                        i3 = i;
                        query = cursor;
                        z2 = z;
                        readableDatabase = sQLiteDatabase;
                    }
                    i2 = 1;
                    i4 = i2;
                    str7 = str4;
                    str9 = str6;
                    str8 = str5;
                    i3 = i;
                    query = cursor;
                    z2 = z;
                    readableDatabase = sQLiteDatabase;
                } catch (Exception unused2) {
                }
            } catch (Throwable th2) {
                th = th2;
                if (cursor != null) {
                    cursor.close();
                }
                sQLiteDatabase.close();
                throw th;
            }
            sQLiteDatabase = readableDatabase;
            cursor = query;
            str = str7;
            str2 = str8;
            str3 = str9;
            z = z2;
            HiLogcatUtil.e("initCamera: error");
        }
        sQLiteDatabase = readableDatabase;
        cursor = query;
    }

    private void initSlidingMenu() {
        if (this.mContent == null) {
            this.mContent = new CameraFragment();
        }
        getSupportFragmentManager().beginTransaction().replace(R.id.content_frame, this.mContent).commit();
        setBehindContentView(R.layout.menu_frame_left);
        setSlidingActionBarEnabled(false);
        getSupportFragmentManager().beginTransaction().replace(R.id.menu_frame, new LeftFragment()).commit();
        SlidingMenu slidingMenu = getSlidingMenu();
        slidingMenu.setMode(0);
        slidingMenu.setShadowWidthRes(R.dimen.shadow_width);
        slidingMenu.setShadowDrawable((Drawable) null);
        slidingMenu.setBehindOffsetRes(R.dimen.slidingmenu_offset);
        slidingMenu.setFadeDegree(0.0f);
        slidingMenu.setTouchModeAbove(2);
        slidingMenu.setBehindScrollScale(0.5f);
    }

    public Bitmap loadImageFromUrl(Context context, MyCamera myCamera) {
        if (Environment.getExternalStorageState().equals("mounted")) {
            String pathCameraThumbnail = HiDataValue.getPathCameraThumbnail(myCamera.getUid(), context);
            File file = new File(pathCameraThumbnail);
            if (!file.exists()) {
                HiLogcatUtil.i("loadImageFromUrl: " + file.mkdirs());
            }
            File file2 = new File(pathCameraThumbnail + myCamera.getUid());
            if (file2.exists()) {
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inPreferredConfig = Bitmap.Config.RGB_565;
                return BitmapFactory.decodeFile(file2.getAbsolutePath(), options);
            }
        }
        return null;
    }

    public Bitmap loadImageFromUrlBall(Context context, MyCamera myCamera) {
        if (Environment.getExternalStorageState().equals("mounted")) {
            String pathCameraThumbnailBall = HiDataValue.getPathCameraThumbnailBall(myCamera.getUid(), context);
            File file = new File(pathCameraThumbnailBall);
            if (!file.exists()) {
                HiLogcatUtil.i("loadImageFromUrl: " + file.mkdirs());
            }
            File file2 = new File(pathCameraThumbnailBall + myCamera.getUid());
            if (file2.exists()) {
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inPreferredConfig = Bitmap.Config.RGB_565;
                return BitmapFactory.decodeFile(file2.getAbsolutePath(), options);
            }
        }
        return null;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        WifiBroadcastReceiver wifiBroadcastReceiver = this.mReceiver;
        if (wifiBroadcastReceiver != null) {
            unregisterReceiver(wifiBroadcastReceiver);
        }
        AppManager.getInstance().killAllActivity();
        Process.killProcess(Process.myPid());
    }

    @Override
    public void onBackPressed() {
        new DialogUtilsCamHiPro(this).title("").message(getString(R.string.sure_to_exit)).cancelText(getString(R.string.NO)).sureText(getString(R.string.YES)).setSureOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                MainActivity.this.lambda$onBackPressed$0$MainActivity(view);
            }
        }).build().show();
    }

    public void lambda$onBackPressed$0$MainActivity(View view) {
        HiDataValue.CURRENT_CAMERA_UID = "";
        try {
            ((CameraFragment) this.mContent).mDisconnectHandler.removeCallbacksAndMessages(null);
            HiLogcatUtil.i("remove all time");
        } catch (Exception unused) {
            HiLogcatUtil.e("remove all time error");
        }
        MyApplication.getInstance().endFileCutCount();
        HiDataValue.quitAPP = true;
        showLoadingDialog(false);
        moveToBackground();
        unInitSdk();
    }

    private void moveToBackground() {
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.setFlags(268435456);
        intent.addCategory("android.intent.category.HOME");
        startActivity(intent);
        new Handler().postDelayed(new Runnable() {
            @Override
            public final void run() {
                MainActivity.this.lambda$moveToBackground$1$MainActivity();
            }
        }, 10000L);
    }

    public void lambda$moveToBackground$1$MainActivity() {
        if (isFinishing()) {
            return;
        }
        HiLogcatUtil.i("moveToBackground: 10S timeout");
        dismissLoadingDialog();
        finish();
    }

    private void unInitSdk() {
        HiLog.e("");
        this.num = 0;
        HiDataValue.CameraList_copy.clear();
        HiDataValue.CameraList_copy.addAll(HiDataValue.CameraList);
        this.listSize = HiDataValue.CameraList_copy.size();
        for (final MyCamera myCamera : HiDataValue.CameraList_copy) {
            new Thread() {
                @Override
                public void run() {
                    myCamera.Dinit();
                    myCamera.disconnect(1);
                    HiLog.e("" + myCamera.getUid() + ":::" + MainActivity.this.num + ":::::" + myCamera.getConnectState());
                }
            }.start();
        }
        new Thread() {
            @Override
            public void run() {
                HiLog.e("" + HiDataValue.CameraList_copy.size());
                while (true) {
                    if (MainActivity.this.num >= MainActivity.this.listSize) {
                        break;
                    }
                    if (HiDataValue.CameraList_copy.size() <= 0) {
                        HiLog.e(":::" + HiDataValue.CameraList_copy.size() + "::" + MainActivity.this.num + ":::" + MainActivity.this.listSize);
                        break;
                    }
                    HiDataValue.DisconnectCameraList.clear();
                    HiDataValue.DisconnectCameraList.addAll(HiDataValue.CameraList_copy);
                    if (HiDataValue.DisconnectCameraList == null) {
                        HiLog.e(":::" + HiDataValue.CameraList_copy.size() + "::" + MainActivity.this.num + ":::" + MainActivity.this.listSize);
                        break;
                    }
                    for (MyCamera myCamera2 : HiDataValue.DisconnectCameraList) {
                        if (myCamera2.getConnectState() != 4 && myCamera2.getConnectState() != 1) {
                            MainActivity.access$008(MainActivity.this);
                            HiDataValue.CameraList_copy.remove(myCamera2);
                            HiLog.e(myCamera2.getUid() + ":::" + HiDataValue.CameraList_copy.size() + "::" + MainActivity.this.num + ":::" + MainActivity.this.listSize + ":::::" + myCamera2.getConnectState());
                        }
                    }
                    try {
                        Thread.sleep(10L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        HiLog.e(HiDataValue.CameraList_copy.size() + ":::" + MainActivity.this.num + "::::" + MainActivity.this.listSize);
                    }
                }
                HiLog.e(HiDataValue.CameraList_copy.size() + ":::" + MainActivity.this.num + "::::" + MainActivity.this.listSize);
                HiLog.e("");
                HiChipSDK.uninit();
                HiLog.e("");
                HiLogcatUtil.i(" == unInitSdk end == ");
                MainActivity.this.dismissLoadingDialog();
                MainActivity.this.finish();
            }
        }.start();
    }

    @Override
    public void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent.getStringExtra("type") != null) {
            HiDataValue.isFirstIn = true;
            initCamera();
            initGroup();
            if (Build.VERSION.SDK_INT >= 29) {
                HiDataValue.mHi_PhoneSys_Q = true;
            } else {
                HiDataValue.mHi_PhoneSys_Q = false;
            }
            ChangeUserListener changeUserListener = this.listener;
            if (changeUserListener != null) {
                changeUserListener.onChange();
                return;
            }
            return;
        }
        HiDataValue.isFirstIn = false;
    }

    public void showLoadingDialog(boolean z) {
        if (this.mJhLoading == null) {
            this.mJhLoading = DialogUtils.createLoadingDialog(this, z, z);
        }
        if (isFinishing()) {
            return;
        }
        this.mJhLoading.show();
    }

    public void dismissLoadingDialog() {
        if (this.mJhLoading != null && !isFinishing()) {
            this.mJhLoading.dismiss();
        }
        this.mJhLoading = null;
    }

    @Override
    public void onResume() {
        super.onResume();
        HiLogcatUtil.e("CameraFragmentonResume");
        HiDataValue.isNeedkillNoMain = false;
        if (HiDataValue.CameraList.size() == 0) {
            MyApplication.mIsBackgroundTime = 0L;
            return;
        }
        if (MyApplication.mIsBackgroundTime != 0) {
            if (System.currentTimeMillis() - MyApplication.mIsBackgroundTime >= TTAdConstant.AD_MAX_EVENT_TIME) {
                MyApplication.mIsBackgroundTime = 0L;
                Intent intent = new Intent(this, (Class<?>) SplashActivity2.class);
                intent.putExtra("isBackgroundStartup", true);
                startActivity(intent);
                return;
            }
            MyApplication.mIsBackgroundTime = 0L;
        }
    }

    public void setChangeUserListener(ChangeUserListener changeUserListener) {
        this.listener = changeUserListener;
    }

    @Override
    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
        super.onRequestPermissionsResult(i, strArr, iArr);
        boolean z = false;
        if (i != 10010) {
            if (i == 10001) {
                int length = iArr.length;
                int i2 = 0;
                while (true) {
                    if (i2 >= length) {
                        z = true;
                        break;
                    } else if (iArr[i2] != 0) {
                        break;
                    } else {
                        i2++;
                    }
                }
                if (z) {
                    return;
                }
                HiTools.Hi_GoToSetting(strArr, this, this);
                return;
            }
            return;
        }
        int length2 = iArr.length;
        int i3 = 0;
        while (true) {
            if (i3 >= length2) {
                z = true;
                break;
            } else if (iArr[i3] != 0) {
                break;
            } else {
                i3++;
            }
        }
        if (z) {
            Fragment fragment = this.mContent;
            if (fragment != null) {
                ((CameraFragment) fragment).connectCamera();
                return;
            }
            return;
        }
        HiTools.Hi_GoToSetting(strArr, this, this);
    }
}