AlarmManageAndNotiActivity.java 源代码


package activity.setting;

import activity.setting.PlanAlarm.PlanAlarmAdvancedActivity;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ArgbEvaluator;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.animation.AccelerateInterpolator;
import android.widget.CompoundButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import android.widget.Toast;
import base.HiActivity;
import bean.MyCamera;
import bean.TimeArrayBean;
import com.hichip.callback.ICameraIOSessionCallback;
import com.hichip.campro.R;
import com.hichip.content.HiChipDefines;
import com.hichip.control.HiCamera;
import com.hichip.push.HiPushSDK;
import com.hichip.tools.Packet;
import com.xiaomi.mipush.sdk.Constants;
import common.CamHiDefines;
import common.ConstantCommand;
import common.HiDataValue;
import common.TitleView;
import custom.SwitchButton;
import custom.dialog.NiftyDialogBuilder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.Locale;
import java.util.regex.Pattern;
import utils.HiLogcatUtil;
import utils.HiTools;
import utils.MyToast;
import utils.TimeUtil;

public class AlarmManageAndNotiActivity extends HiActivity implements CompoundButton.OnCheckedChangeListener, ICameraIOSessionCallback, View.OnClickListener {
    private static final int ANIM_DURATION = 350;
    private static final int HANDLE_MESSAGE_BIND_FAIL = -2147483646;
    private static final int HANDLE_MESSAGE_BIND_SUCCESS = -2147483647;
    private static final int HANDLE_MESSAGE_UNBIND_FAIL = -2147483644;
    private static final int HANDLE_MESSAGE_UNBIND_SUCCESS = -2147483645;
    private static final int HANDLE_MESSAGE_UPDATE_NAME_FAIL = -2147483642;
    private static final int HANDLE_MESSAGE_UPDATE_NAME_SUCCESS = -2147483643;
    private ConstantCommand.HI_P2P_CAPTURE_NUM captureParam;
    private String devName;
    ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hiP2PGetSmartHsrExt;
    ConstantCommand.HI_P2P_SMART_ALARM hiP2PSmartAlarm;
    ConstantCommand.HI_P2P_SMART_SWITCH hi_p2P_smart_switch;
    private ConstantCommand.HI_P2P_SMART_HSR human_alarm_params;
    private boolean isSupportCloud;
    private boolean isSupportHsr;
    ImageView iv_advanced;
    ImageView iv_simple;
    LinearLayout ll_alarm_linkage_content;
    LinearLayout ll_alarm_plan;
    LinearLayout ll_alarm_snap_num;
    LinearLayout ll_content_device_alarm;
    LinearLayout ll_ftp;
    LinearLayout ll_hsr_type;
    LinearLayout ll_human_alarm;
    LinearLayout ll_push_name;
    LinearLayout ll_root_alarm_action;
    LinearLayout ll_root_alarm_linkage;
    private HiChipDefines.ALARMTOSOUND_TYPE mAlarmToSoundType;
    private View mLastView;
    private MyCamera mMyCamera;
    private int mTime;
    private int mVoiceType;
    private HiChipDefines.HI_P2P_S_MD_PARAM md_param;
    private HiChipDefines.HI_P2P_S_MD_PARAM md_param2;
    private HiChipDefines.HI_P2P_S_MD_PARAM md_param3;
    private HiChipDefines.HI_P2P_S_MD_PARAM md_param4;
    private HiChipDefines.HI_P2P_S_ALARM_PARAM param;
    private ConstantCommand.HI_P2P_CLOUDUPLOADSWITCH params;
    private HiChipDefines.HI_P2P_QUANTUM_TIME quantum_time;
    RelativeLayout rl_adjust_hsr_alarm;
    RelativeLayout rl_adjust_human_alarm;
    LinearLayout rl_adjust_vmd;
    RelativeLayout rl_adjust_voice_alarm;
    RelativeLayout rl_advanced;
    RelativeLayout rl_alarm_snap_to_sdcard;
    RelativeLayout rl_alarm_time;
    RelativeLayout rl_alarm_video_to_cloud;
    RelativeLayout rl_alarm_video_to_ftp;
    RelativeLayout rl_alarm_video_to_sdcard;
    RelativeLayout rl_alarm_voice_type;
    RelativeLayout rl_config_email;
    RelativeLayout rl_config_ftp;
    RelativeLayout rl_hsr_alarm;
    RelativeLayout rl_hsr_type;
    RelativeLayout rl_human_alarm;
    RelativeLayout rl_push_open_status;
    RelativeLayout rl_sensitivity;
    RelativeLayout rl_simple;
    RelativeLayout rl_snap_num;
    RelativeLayout rl_switch_email;
    RelativeLayout rl_switch_ftp;
    TextView rl_title_email;
    RelativeLayout rl_voice_alarm;
    ScrollView scrollview;
    private HiChipDefines.HI_P2P_S_SD_INFO sd_info;
    private HiChipDefines.HI_P2P_SNAP_ALARM snapParam;
    SwitchButton switch_alarm_snaptoemail;
    SwitchButton switch_alarm_snaptoftp;
    SwitchButton switch_alarm_snaptosdcard;
    SwitchButton switch_alarm_videotocloud;
    SwitchButton switch_alarm_videotoftp;
    SwitchButton switch_alarm_videotosdcard;
    SwitchButton switch_btn_alarm_linkage;
    SwitchButton switch_btn_push;
    SwitchButton switch_btn_vmd;
    SwitchButton switch_hsr_alarm;
    SwitchButton switch_hsr_alarm_rect;
    SwitchButton switch_human_alarm;
    SwitchButton switch_human_alarm_rect;
    SwitchButton switch_voice_alarm;
    TitleView title;
    TextView tv_advance_set;
    TextView tv_alarm_time;
    TextView tv_device_alarm;
    TextView tv_hint_advance;
    TextView tv_hint_simple;
    TextView tv_hsr_alarm_sensi;
    TextView tv_hsr_sensitivity;
    TextView tv_hsr_type;
    TextView tv_human_alarm_sensi;
    TextView tv_push_name;
    TextView tv_push_tips;
    TextView tv_sensitivity;
    TextView tv_simple_set;
    TextView tv_snap_num;
    TextView tv_voice_alarm_sensi;
    TextView tv_voice_type;
    private String url;
    private HiChipDefines.HI_P2P_S_ALM_PARAM voiceParam;
    private boolean mIsV10V6 = false;
    private boolean mIsHaveSDCard = false;
    private boolean mIsHaveAlarmLinkage = false;
    private boolean mAlarmActionEnable = false;
    private boolean mIsVisiableVMDArea = false;
    private ArrayList<TimeArrayBean> mBeans = new ArrayList<>();
    private SimpleDateFormat sdf = new SimpleDateFormat(TimeUtil.FORMAT_TIME, Locale.getDefault());
    private int aiHeight = 220;
    private int totalNum = 3;
    private int spaceTime = 400;
    private long lastClickTime = 0;
    private MyCamera.OnBindPushResult bindPushResult = new MyCamera.OnBindPushResult() {
        @Override
        public void onBindSuccess(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = -2147483647;
            obtainMessage.obj = myCamera;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onBindFail(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = -2147483646;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onUnBindSuccess(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = AlarmManageAndNotiActivity.HANDLE_MESSAGE_UNBIND_SUCCESS;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onUnBindFail(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = AlarmManageAndNotiActivity.HANDLE_MESSAGE_UNBIND_FAIL;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onUpdatePushNameSuccess(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = AlarmManageAndNotiActivity.HANDLE_MESSAGE_UPDATE_NAME_SUCCESS;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onUpdatePushNameFail(MyCamera myCamera) {
            Message obtainMessage = AlarmManageAndNotiActivity.this.mHandler.obtainMessage();
            obtainMessage.what = AlarmManageAndNotiActivity.HANDLE_MESSAGE_UPDATE_NAME_FAIL;
            AlarmManageAndNotiActivity.this.mHandler.sendMessage(obtainMessage);
        }

        @Override
        public void onBindTokenIsNull(MyCamera myCamera, boolean z) {
            AlarmManageAndNotiActivity.this.setLocationPushuState(z);
        }
    };
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            int i = message.what;
            if (i != -1879048189) {
                switch (i) {
                    case -2147483647:
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        AlarmManageAndNotiActivity alarmManageAndNotiActivity = AlarmManageAndNotiActivity.this;
                        MyToast.showToast(alarmManageAndNotiActivity, alarmManageAndNotiActivity.getString(R.string.open_success));
                        MyCamera myCamera = (MyCamera) message.obj;
                        myCamera.setServerData(myCamera.getCorrectAddress());
                        myCamera.updateInDatabase(AlarmManageAndNotiActivity.this);
                        AlarmManageAndNotiActivity.this.sendServer(myCamera);
                        AlarmManageAndNotiActivity.this.sendRegister();
                        myCamera.setPushDevName(myCamera.getNikeName());
                        AlarmManageAndNotiActivity.this.tv_push_name.setText(myCamera.getPushDevName());
                        return;
                    case -2147483646:
                        AlarmManageAndNotiActivity alarmManageAndNotiActivity2 = AlarmManageAndNotiActivity.this;
                        MyToast.showToast(alarmManageAndNotiActivity2, alarmManageAndNotiActivity2.getString(R.string.tip_open_faild));
                        AlarmManageAndNotiActivity.this.switch_btn_push.setOnCheckedChangeListener(null);
                        AlarmManageAndNotiActivity.this.switch_btn_push.setChecked(false);
                        AlarmManageAndNotiActivity.this.switch_btn_push.setOnCheckedChangeListener(AlarmManageAndNotiActivity.this);
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        AlarmManageAndNotiActivity.this.mMyCamera.updateInDatabase(AlarmManageAndNotiActivity.this);
                        return;
                    case AlarmManageAndNotiActivity.HANDLE_MESSAGE_UNBIND_SUCCESS:
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        AlarmManageAndNotiActivity alarmManageAndNotiActivity3 = AlarmManageAndNotiActivity.this;
                        MyToast.showToast(alarmManageAndNotiActivity3, alarmManageAndNotiActivity3.getString(R.string.close_success));
                        AlarmManageAndNotiActivity.this.sendUnRegister();
                        AlarmManageAndNotiActivity.this.mMyCamera.setPushState(0);
                        AlarmManageAndNotiActivity.this.mMyCamera.updateInDatabase(AlarmManageAndNotiActivity.this);
                        if ("jiguang".equals(AlarmManageAndNotiActivity.this.mMyCamera.getPushName())) {
                            AlarmManageAndNotiActivity.this.mMyCamera.setBindToken("");
                            return;
                        }
                        return;
                    case AlarmManageAndNotiActivity.HANDLE_MESSAGE_UNBIND_FAIL:
                        AlarmManageAndNotiActivity alarmManageAndNotiActivity4 = AlarmManageAndNotiActivity.this;
                        MyToast.showToast(alarmManageAndNotiActivity4, alarmManageAndNotiActivity4.getString(R.string.tip_close_failed));
                        AlarmManageAndNotiActivity.this.switch_btn_push.setOnCheckedChangeListener(null);
                        AlarmManageAndNotiActivity.this.switch_btn_push.setChecked(true);
                        AlarmManageAndNotiActivity.this.switch_btn_push.setOnCheckedChangeListener(AlarmManageAndNotiActivity.this);
                        AlarmManageAndNotiActivity.this.ll_push_name.setAlpha(1.0f);
                        AlarmManageAndNotiActivity.this.ll_push_name.setClickable(true);
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        AlarmManageAndNotiActivity.this.mMyCamera.updateInDatabase(AlarmManageAndNotiActivity.this);
                        return;
                    case AlarmManageAndNotiActivity.HANDLE_MESSAGE_UPDATE_NAME_SUCCESS:
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        if (!TextUtils.isEmpty(AlarmManageAndNotiActivity.this.devName)) {
                            AlarmManageAndNotiActivity.this.mMyCamera.setPushDevName(AlarmManageAndNotiActivity.this.devName);
                            AlarmManageAndNotiActivity.this.tv_push_name.setText(AlarmManageAndNotiActivity.this.devName);
                            if (!AlarmManageAndNotiActivity.this.mMyCamera.getNikeName().equals(AlarmManageAndNotiActivity.this.devName)) {
                                AlarmManageAndNotiActivity.this.mMyCamera.setNikeName(AlarmManageAndNotiActivity.this.devName);
                                AlarmManageAndNotiActivity.this.mMyCamera.updateInDatabase(AlarmManageAndNotiActivity.this);
                            }
                            AlarmManageAndNotiActivity alarmManageAndNotiActivity5 = AlarmManageAndNotiActivity.this;
                            Toast.makeText(alarmManageAndNotiActivity5, alarmManageAndNotiActivity5.getString(R.string.setting_success), 0).show();
                            return;
                        }
                        Toast.makeText(AlarmManageAndNotiActivity.this, "dev name is null", 0).show();
                        return;
                    case AlarmManageAndNotiActivity.HANDLE_MESSAGE_UPDATE_NAME_FAIL:
                        AlarmManageAndNotiActivity.this.dismissjuHuaDialog();
                        AlarmManageAndNotiActivity alarmManageAndNotiActivity6 = AlarmManageAndNotiActivity.this;
                        Toast.makeText(alarmManageAndNotiActivity6, alarmManageAndNotiActivity6.getString(R.string.netword_abnormal), 0).show();
                        return;
                    default:
                        return;
                }
            }
            if (message.arg2 == 0) {
                AlarmManageAndNotiActivity.this.handReceiveIOCTRLSuccess(message);
            } else {
                AlarmManageAndNotiActivity.this.handReceiveIOCTRLFail(message);
            }
        }
    };

    public void handReceiveIOCTRLFail(Message message) {
    }

    @Override
    public void receiveSessionState(HiCamera hiCamera, int i) {
    }

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

    @Override
    protected void init(Bundle bundle) {
        getIntentData();
        initViewAndData();
        setOnListeners();
    }

    @Override
    public void onResume() {
        super.onResume();
        this.voiceParam = null;
        MyCamera myCamera = this.mMyCamera;
        if (myCamera != null) {
            myCamera.registerIOSessionListener(this);
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_MD_PARAM, new HiChipDefines.HI_P2P_S_MD_PARAM(0, new HiChipDefines.HI_P2P_S_MD_AREA(1, 0, 0, 0, 0, 0, 0)).parseContent());
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_MD_PARAM, new HiChipDefines.HI_P2P_S_MD_PARAM(0, new HiChipDefines.HI_P2P_S_MD_AREA(2, 0, 0, 0, 0, 0, 0)).parseContent());
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_MD_PARAM, new HiChipDefines.HI_P2P_S_MD_PARAM(0, new HiChipDefines.HI_P2P_S_MD_AREA(3, 0, 0, 0, 0, 0, 0)).parseContent());
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_MD_PARAM, new HiChipDefines.HI_P2P_S_MD_PARAM(0, new HiChipDefines.HI_P2P_S_MD_AREA(4, 0, 0, 0, 0, 0, 0)).parseContent());
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_ALARM_SCHEDULE, new byte[0]);
        }
    }

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

    private void setOnListeners() {
        this.switch_btn_push.setOnCheckedChangeListener(this);
        this.switch_voice_alarm.setOnCheckedChangeListener(this);
        this.switch_human_alarm.setOnCheckedChangeListener(this);
        this.switch_btn_vmd.setOnCheckedChangeListener(this);
        this.rl_adjust_vmd.setOnClickListener(this);
        this.rl_alarm_voice_type.setOnClickListener(this);
        this.rl_alarm_time.setOnClickListener(this);
        this.rl_config_email.setOnClickListener(this);
        this.rl_config_ftp.setOnClickListener(this);
        this.rl_snap_num.setOnClickListener(this);
        this.rl_adjust_voice_alarm.setOnClickListener(this);
        this.rl_adjust_human_alarm.setOnClickListener(this);
        this.rl_advanced.setOnClickListener(this);
        this.rl_simple.setOnClickListener(this);
        this.rl_adjust_hsr_alarm.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                AlarmManageAndNotiActivity.this.onClick(view);
            }
        });
        this.rl_hsr_type.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                AlarmManageAndNotiActivity.this.onClick(view);
            }
        });
        this.rl_sensitivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                AlarmManageAndNotiActivity.this.onClick(view);
            }
        });
        this.switch_hsr_alarm.setOnCheckedChangeListener(new $$Lambda$_LOqkQl8M6iTR4D1_yJGzIRWbVE(this));
        this.tv_push_tips.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                AlarmManageAndNotiActivity.this.onClick(view);
            }
        });
    }

    private void initViewAndData() {
        initTopView();
        if (this.mMyCamera == null) {
            return;
        }
        this.ll_push_name.setOnClickListener(this);
        if (this.mMyCamera.getPushState() > 0) {
            this.switch_btn_push.setChecked(true);
        } else {
            this.switch_btn_push.setChecked(false);
        }
        this.tv_push_name.setText(TextUtils.isEmpty(this.mMyCamera.getPushDevName()) ? getString(R.string.title_camera_fragment) : this.mMyCamera.getPushDevName());
        if (this.mMyCamera.appGetCommandFunction(16826)) {
            this.ll_ftp.setVisibility(0);
        }
        String uriByPhone = HiTools.getUriByPhone(this, this.mMyCamera.getUid());
        this.url = uriByPhone;
        if (!TextUtils.isEmpty(uriByPhone)) {
            this.tv_push_tips.setVisibility(0);
            this.url = "file:///android_asset/web/" + this.url;
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_FTP) && this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_EMAIL)) {
            this.ll_alarm_snap_num.setVisibility(8);
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_FTP)) {
            this.rl_config_ftp.setVisibility(8);
            this.ll_ftp.setVisibility(8);
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_EMAIL)) {
            this.rl_title_email.setVisibility(8);
            this.rl_switch_email.setVisibility(8);
            this.rl_config_email.setVisibility(8);
        }
    }

    private void initTopView() {
        this.title.setTitle(getString(R.string.alarm_manage_notifi));
        this.title.setButton(0);
        this.title.setNavigationBarButtonListener(new TitleView.NavigationBarButtonListener() {
            @Override
            public void OnNavigationButtonClick(int i) {
                if (i != 0) {
                    return;
                }
                AlarmManageAndNotiActivity.this.finish();
            }
        });
    }

    private void getIntentData() {
        String stringExtra = getIntent().getStringExtra(HiDataValue.EXTRAS_KEY_UID);
        this.isSupportCloud = getIntent().getBooleanExtra("isSupportCloud", false);
        if (!TextUtils.isEmpty(stringExtra)) {
            Iterator<MyCamera> it = HiDataValue.CameraList.iterator();
            while (true) {
                if (!it.hasNext()) {
                    break;
                }
                MyCamera next = it.next();
                if (stringExtra.equals(next.getUid())) {
                    this.mMyCamera = next;
                    break;
                }
            }
        }
        MyCamera myCamera = this.mMyCamera;
        if (myCamera == null) {
            finish();
            return;
        }
        if (myCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_SD_INFO)) {
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_SD_INFO, new byte[0]);
        }
        if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_AUDIO_ALM_PARAM)) {
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_AUDIO_ALM_PARAM, new byte[0]);
        } else {
            this.rl_voice_alarm.setVisibility(8);
            this.rl_adjust_voice_alarm.setVisibility(8);
        }
        if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_ALARMTOSOUND)) {
            this.mIsHaveAlarmLinkage = true;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_ALARMTOSOUND, new byte[0]);
            this.ll_root_alarm_linkage.setVisibility(0);
        }
        if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_ALARM_PARAM)) {
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_ALARM_PARAM, new byte[0]);
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_GET_SMART_SWITCH_PARAM)) {
            this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_GET_SMART_ALARM_PARAM, new byte[0]);
            this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_GET_SMART_HSR_PARAM_EXT, new byte[0]);
            this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_GET_SMART_SWITCH_PARAM, new byte[0]);
            this.rl_hsr_alarm.setVisibility(0);
            this.isSupportHsr = true;
        } else if (this.mMyCamera.appGetCommandFunction(16795)) {
            this.mMyCamera.sendIOCtrl(16795, new byte[0]);
            this.rl_human_alarm.setVisibility(0);
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_GET_CAPTURE_NUM)) {
            this.rl_switch_ftp.setVisibility(8);
            this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_GET_CAPTURE_NUM, null);
        } else if (this.mMyCamera.getChipVersion() == 0 && this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_SNAP_ALARM_PARAM)) {
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_SNAP_ALARM_PARAM, null);
            this.totalNum = 3;
            this.ll_alarm_snap_num.setVisibility(0);
        }
        if (this.isSupportCloud && this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_GET_CLOUDUPLOADSWITCH)) {
            this.rl_alarm_video_to_cloud.setVisibility(0);
            this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_GET_CLOUDUPLOADSWITCH, null);
        }
        if (this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_SET_MD_PARAM_NEW) && !this.mMyCamera.isFishEye()) {
            this.mIsVisiableVMDArea = true;
        } else {
            this.mIsVisiableVMDArea = false;
        }
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_GET_CAPTURE_ALL_MONTH)) {
            this.rl_alarm_snap_to_sdcard.setVisibility(0);
        }
    }

    private boolean handTipAndScroll(boolean z, SwitchButton switchButton) {
        if (this.mAlarmActionEnable) {
            return false;
        }
        showDialog_1();
        switchButton.setChecked(!z);
        return true;
    }

    public boolean isFastClick() {
        long currentTimeMillis = System.currentTimeMillis();
        boolean z = currentTimeMillis - this.lastClickTime <= ((long) this.spaceTime);
        this.lastClickTime = currentTimeMillis;
        return z;
    }

    @Override
    public void onCheckedChanged(CompoundButton compoundButton, final boolean z) {
        HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param;
        ConstantCommand.HI_P2P_CLOUDUPLOADSWITCH hi_p2p_clouduploadswitch;
        if (isFastClick() && compoundButton == this.mLastView) {
            compoundButton.setChecked(!z);
            return;
        }
        this.mLastView = compoundButton;
        int id = compoundButton.getId();
        switch (id) {
            case R.id.switch_alarm_snap_to_sd_card:
                if (!this.mIsHaveSDCard) {
                    this.switch_alarm_snaptosdcard.setChecked(!z);
                    MyToast.showToast(this, getString(R.string.insert_sd_card));
                    return;
                } else {
                    if (handTipAndScroll(z, this.switch_alarm_snaptosdcard) || (hi_p2p_s_alarm_param = this.param) == null) {
                        return;
                    }
                    hi_p2p_s_alarm_param.u32SDSnap = z ? 1 : 0;
                    this.param.u32SDRec = this.switch_alarm_videotosdcard.isChecked() ? 1 : 0;
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
                    return;
                }
            case R.id.switch_alarm_snaptoemail:
                if (handTipAndScroll(z, this.switch_alarm_snaptoemail) || this.param == null) {
                    return;
                }
                handSnapToEmail(z);
                return;
            case R.id.switch_alarm_snaptoftp:
                if (handTipAndScroll(z, this.switch_alarm_snaptoftp)) {
                    return;
                }
                if (z) {
                    if (this.rl_config_ftp.getVisibility() == 8) {
                        animViewDisplay(this.rl_config_ftp, 0, HiTools.dip2px(this, 50.0f));
                    }
                } else if (!this.switch_alarm_videotoftp.isChecked() && this.rl_config_ftp.getVisibility() == 0) {
                    animViewDisplay(this.rl_config_ftp, HiTools.dip2px(this, 50.0f), 0);
                }
                HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param2 = this.param;
                if (hi_p2p_s_alarm_param2 != null) {
                    hi_p2p_s_alarm_param2.u32FtpSnap = z ? 1 : 0;
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
                    return;
                }
                return;
            case R.id.switch_alarm_videotocloud:
                if (handTipAndScroll(z, this.switch_alarm_videotocloud) || (hi_p2p_clouduploadswitch = this.params) == null) {
                    return;
                }
                hi_p2p_clouduploadswitch.u8CloudUploadSwitch = z ? 1 : 0;
                this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_SET_CLOUDUPLOADSWITCH, this.params.parseContent());
                return;
            case R.id.switch_alarm_videotoftp:
                if (handTipAndScroll(z, this.switch_alarm_videotoftp)) {
                    return;
                }
                if (z) {
                    if (!this.mIsV10V6 && !this.switch_alarm_videotosdcard.isChecked()) {
                        final NiftyDialogBuilder niftyDialogBuilder = NiftyDialogBuilder.getInstance(this);
                        niftyDialogBuilder.withMessageLayoutHWrapW(HiTools.dip2px(this, 300.0f));
                        niftyDialogBuilder.withTitle(getString(R.string.tip_reminder)).withMessage(getString(R.string.open_relation_one) + "\n\n" + getString(R.string.open_relation_two));
                        niftyDialogBuilder.withButton1TextColor(getResources().getColor(R.color.color_theme_blue));
                        niftyDialogBuilder.withButton2TextColor(getResources().getColor(R.color.color_pass_word));
                        niftyDialogBuilder.withButton1Text(getString(R.string.cancel)).withButton2Text(getString(R.string.open_two_item));
                        niftyDialogBuilder.isCancelable(false);
                        niftyDialogBuilder.isCancelableOnTouchOutside(false);
                        niftyDialogBuilder.show();
                        niftyDialogBuilder.setButton1Click(new View.OnClickListener() {
                            @Override
                            public void onClick(View view) {
                                niftyDialogBuilder.dismiss();
                                AlarmManageAndNotiActivity.this.switch_alarm_videotoftp.setCheckedNoEvent(false);
                            }
                        });
                        niftyDialogBuilder.setButton2Click(new View.OnClickListener() {
                            @Override
                            public void onClick(View view) {
                                niftyDialogBuilder.dismiss();
                                AlarmManageAndNotiActivity.this.switch_alarm_videotosdcard.setChecked(true);
                                if (AlarmManageAndNotiActivity.this.rl_config_ftp.getVisibility() == 8) {
                                    AlarmManageAndNotiActivity alarmManageAndNotiActivity = AlarmManageAndNotiActivity.this;
                                    alarmManageAndNotiActivity.animViewDisplay(alarmManageAndNotiActivity.rl_config_ftp, 0, HiTools.dip2px(AlarmManageAndNotiActivity.this, 50.0f));
                                }
                                if (AlarmManageAndNotiActivity.this.param != null) {
                                    AlarmManageAndNotiActivity.this.param.u32FtpRec = z ? 1 : 0;
                                    AlarmManageAndNotiActivity.this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, AlarmManageAndNotiActivity.this.param.parseContent());
                                }
                            }
                        });
                        return;
                    }
                    if (this.rl_config_ftp.getVisibility() == 8) {
                        animViewDisplay(this.rl_config_ftp, 0, HiTools.dip2px(this, 50.0f));
                    }
                    HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param3 = this.param;
                    if (hi_p2p_s_alarm_param3 != null) {
                        hi_p2p_s_alarm_param3.u32FtpRec = z ? 1 : 0;
                        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
                        return;
                    }
                    return;
                }
                if (!this.switch_alarm_snaptoftp.isChecked() && this.rl_config_ftp.getVisibility() == 0) {
                    animViewDisplay(this.rl_config_ftp, HiTools.dip2px(this, 50.0f), 0);
                }
                HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param4 = this.param;
                if (hi_p2p_s_alarm_param4 != null) {
                    hi_p2p_s_alarm_param4.u32FtpRec = z ? 1 : 0;
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
                    return;
                }
                return;
            case R.id.switch_alarm_videotosdcard:
                if (!this.mIsHaveSDCard) {
                    this.switch_alarm_videotosdcard.setChecked(!z);
                    MyToast.showToast(this, getString(R.string.insert_sd_card));
                    return;
                }
                if (handTipAndScroll(z, this.switch_alarm_videotosdcard)) {
                    return;
                }
                if (!z && !this.mIsV10V6 && !this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_FTP) && this.switch_alarm_videotoftp.isChecked()) {
                    final NiftyDialogBuilder niftyDialogBuilder2 = NiftyDialogBuilder.getInstance(this);
                    niftyDialogBuilder2.withMessageLayoutHWrapW(HiTools.dip2px(this, 300.0f));
                    niftyDialogBuilder2.withTitle(getString(R.string.tip_reminder)).withMessage(getString(R.string.close_two_item_one) + "\n\n" + getString(R.string.close_two_item_two));
                    niftyDialogBuilder2.withButton1Text(getString(R.string.cancel)).withButton2Text(getString(R.string.close_term));
                    niftyDialogBuilder2.withButton1TextColor(getResources().getColor(R.color.color_theme_blue));
                    niftyDialogBuilder2.withButton2TextColor(getResources().getColor(R.color.color_pass_word));
                    niftyDialogBuilder2.isCancelable(false);
                    niftyDialogBuilder2.isCancelableOnTouchOutside(false);
                    niftyDialogBuilder2.show();
                    niftyDialogBuilder2.setButton2Click(new View.OnClickListener() {
                        @Override
                        public void onClick(View view) {
                            AlarmManageAndNotiActivity.this.switch_alarm_videotoftp.setChecked(false);
                            niftyDialogBuilder2.dismiss();
                        }
                    });
                    niftyDialogBuilder2.setButton1Click(new View.OnClickListener() {
                        @Override
                        public void onClick(View view) {
                            AlarmManageAndNotiActivity.this.switch_alarm_videotosdcard.setChecked(true);
                            niftyDialogBuilder2.dismiss();
                        }
                    });
                }
                HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param5 = this.param;
                if (hi_p2p_s_alarm_param5 != null) {
                    hi_p2p_s_alarm_param5.u32SDSnap = this.switch_alarm_snaptosdcard.isChecked() ? 1 : 0;
                    this.param.u32SDRec = z ? 1 : 0;
                    if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_FTP) && this.switch_alarm_videotoftp.isChecked()) {
                        this.param.u32FtpRec = 0;
                    }
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
                    return;
                }
                return;
            default:
                switch (id) {
                    case R.id.switch_btn_alarm_linkage:
                        if (handTipAndScroll(z, this.switch_btn_alarm_linkage) || this.mAlarmToSoundType == null) {
                            return;
                        }
                        handAlarmLinkAge(z);
                        return;
                    case R.id.switch_btn_push:
                        handSwiBtnPush(z);
                        return;
                    case R.id.switch_btn_vmd:
                        handVMD(z);
                        return;
                    case R.id.switch_voice_alarm:
                        if (z) {
                            if (!this.mAlarmActionEnable) {
                                this.ll_root_alarm_action.setAlpha(1.0f);
                                this.mAlarmActionEnable = true;
                            }
                            animViewDisplay(this.rl_adjust_voice_alarm, 0, HiTools.dip2px(this, 50.0f));
                            if (this.ll_alarm_plan.getVisibility() == 8) {
                                animViewDisplay(this.ll_alarm_plan, 0, HiTools.dip2px(this, 165.0f));
                            }
                        } else {
                            if (this.isSupportHsr) {
                                if (!this.switch_btn_vmd.isChecked() && !this.switch_hsr_alarm.isChecked()) {
                                    this.ll_root_alarm_action.setAlpha(0.5f);
                                    this.mAlarmActionEnable = false;
                                }
                            } else if (!this.switch_btn_vmd.isChecked() && !this.switch_human_alarm.isChecked()) {
                                this.ll_root_alarm_action.setAlpha(0.5f);
                                this.mAlarmActionEnable = false;
                            }
                            animViewDisplay(this.rl_adjust_voice_alarm, HiTools.dip2px(this, 50.0f), 0);
                            if (this.isSupportHsr) {
                                if (!this.switch_hsr_alarm.isChecked() && !this.switch_btn_vmd.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                                    animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
                                }
                            } else if (!this.switch_human_alarm.isChecked() && !this.switch_btn_vmd.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                                animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
                            }
                        }
                        HiChipDefines.HI_P2P_S_ALM_PARAM hi_p2p_s_alm_param = this.voiceParam;
                        if (hi_p2p_s_alm_param != null) {
                            hi_p2p_s_alm_param.enable = z ? 1 : 0;
                            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_AUDIO_ALM_PARAM, this.voiceParam.parseContent());
                            return;
                        }
                        return;
                    default:
                        switch (id) {
                            case R.id.switch_hsr_alarm:
                                handBtnHsr(z);
                                return;
                            case R.id.switch_hsr_alarm_rect:
                                handBtnHsrRect(z);
                                return;
                            case R.id.switch_human_alarm:
                                if (z) {
                                    if (!this.mAlarmActionEnable) {
                                        this.ll_root_alarm_action.setAlpha(1.0f);
                                        this.mAlarmActionEnable = true;
                                    }
                                    animViewDisplay(this.ll_human_alarm, 0, HiTools.dip2px(this, 100.0f));
                                    if (this.ll_alarm_plan.getVisibility() == 8) {
                                        animViewDisplay(this.ll_alarm_plan, 0, HiTools.dip2px(this, 165.0f));
                                    }
                                } else {
                                    if (!this.switch_btn_vmd.isChecked() && !this.switch_voice_alarm.isChecked()) {
                                        this.ll_root_alarm_action.setAlpha(0.5f);
                                        this.mAlarmActionEnable = false;
                                    }
                                    animViewDisplay(this.ll_human_alarm, HiTools.dip2px(this, 100.0f), 0);
                                    if (!this.switch_voice_alarm.isChecked() && !this.switch_btn_vmd.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                                        animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
                                    }
                                }
                                ConstantCommand.HI_P2P_SMART_HSR hi_p2p_smart_hsr = this.human_alarm_params;
                                if (hi_p2p_smart_hsr != null) {
                                    hi_p2p_smart_hsr.u32HSRenable = z ? 1 : 0;
                                    this.mMyCamera.sendIOCtrl(16796, this.human_alarm_params.parseContent());
                                    return;
                                }
                                return;
                            case R.id.switch_human_alarm_rect:
                                ConstantCommand.HI_P2P_SMART_HSR hi_p2p_smart_hsr2 = this.human_alarm_params;
                                if (hi_p2p_smart_hsr2 != null) {
                                    hi_p2p_smart_hsr2.u32DrawRect = z ? 1 : 0;
                                    this.mMyCamera.sendIOCtrl(16796, this.human_alarm_params.parseContent());
                                    return;
                                }
                                return;
                            default:
                                return;
                        }
                }
        }
    }

    private void handBtnHsrRect(boolean z) {
        ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hi_p2p_get_smart_hsr_ext = this.hiP2PGetSmartHsrExt;
        if (hi_p2p_get_smart_hsr_ext == null) {
            return;
        }
        this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_SET_SMART_HSR_PARAM_EXT, ConstantCommand.HI_P2P_SET_SMART_HSR_EXT.parseContent(z ? 1 : 0, hi_p2p_get_smart_hsr_ext.u32Sensitivity, this.hiP2PGetSmartHsrExt.u32IntelligentClassificationType));
    }

    private void handBtnHsr(boolean z) {
        if (z) {
            if (!this.mAlarmActionEnable) {
                this.ll_root_alarm_action.setAlpha(1.0f);
                this.mAlarmActionEnable = true;
            }
            animViewDisplay(this.ll_hsr_type, 0, HiTools.dip2px(this, this.aiHeight));
            if (this.ll_alarm_plan.getVisibility() == 8) {
                animViewDisplay(this.ll_alarm_plan, 0, HiTools.dip2px(this, 165.0f));
            }
        } else {
            if (!this.switch_btn_vmd.isChecked() && !this.switch_voice_alarm.isChecked()) {
                this.ll_root_alarm_action.setAlpha(0.5f);
                this.mAlarmActionEnable = false;
            }
            animViewDisplay(this.ll_hsr_type, HiTools.dip2px(this, this.aiHeight), 0);
            if (!this.switch_voice_alarm.isChecked() && !this.switch_btn_vmd.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
            }
        }
        this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_SET_SMART_SWITCH_PARAM, ConstantCommand.HI_P2P_SMART_SWITCH.parseContent(z ? 1 : 0));
    }

    private void handSnapToEmail(boolean z) {
        if (this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_EMAIL)) {
            return;
        }
        if (z) {
            animViewDisplay(this.rl_config_email, 0, HiTools.dip2px(this, 50.0f));
        } else {
            animViewDisplay(this.rl_config_email, HiTools.dip2px(this, 50.0f), 0);
        }
        this.param.u32EmailSnap = z ? 1 : 0;
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_PARAM, this.param.parseContent());
    }

    private void handAlarmLinkAge(boolean z) {
        if (z) {
            this.ll_alarm_linkage_content.setVisibility(0);
            animViewDisplay(this.ll_alarm_linkage_content, 0, HiTools.dip2px(this, 90.0f));
        } else {
            animViewDisplay(this.ll_alarm_linkage_content, HiTools.dip2px(this, 90.0f), 0);
        }
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARMTOSOUND, HiChipDefines.ALARMTOSOUND_TYPE.parseContent(z ? (byte) 1 : (byte) 0, this.mAlarmToSoundType.SoundType, this.mAlarmToSoundType.SoundType));
    }

    private void handVMD(boolean z) {
        if (z) {
            animViewDisplay(this.rl_adjust_vmd, 0, HiTools.dip2px(this, 50.0f));
            if (!this.mAlarmActionEnable) {
                this.ll_root_alarm_action.setAlpha(1.0f);
                this.mAlarmActionEnable = true;
            }
            if (this.ll_alarm_plan.getVisibility() == 8) {
                animViewDisplay(this.ll_alarm_plan, 0, HiTools.dip2px(this, 165.0f));
            }
        } else {
            animViewDisplay(this.rl_adjust_vmd, HiTools.dip2px(this, 50.0f), 0);
            if (this.isSupportHsr) {
                if (!this.switch_voice_alarm.isChecked() && !this.switch_hsr_alarm.isChecked()) {
                    this.ll_root_alarm_action.setAlpha(0.5f);
                    this.mAlarmActionEnable = false;
                }
                if (!this.switch_hsr_alarm.isChecked() && !this.switch_voice_alarm.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                    animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
                }
            } else {
                if (!this.switch_voice_alarm.isChecked() && !this.switch_human_alarm.isChecked()) {
                    this.ll_root_alarm_action.setAlpha(0.5f);
                    this.mAlarmActionEnable = false;
                }
                if (!this.switch_human_alarm.isChecked() && !this.switch_voice_alarm.isChecked() && this.ll_alarm_plan.getVisibility() == 0) {
                    animViewDisplay(this.ll_alarm_plan, HiTools.dip2px(this, 165.0f), 0);
                }
            }
        }
        HiChipDefines.HI_P2P_S_MD_PARAM hi_p2p_s_md_param = this.md_param;
        if (hi_p2p_s_md_param == null || this.md_param2 == null || this.md_param3 == null || this.md_param4 == null) {
            return;
        }
        hi_p2p_s_md_param.struArea.u32Enable = z ? 1 : 0;
        if (this.mIsVisiableVMDArea) {
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM_NEW, this.md_param.parseContent());
            if (z) {
                return;
            }
            this.md_param2.struArea.u32Enable = 0;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM_NEW, this.md_param2.parseContent());
            this.md_param3.struArea.u32Enable = 0;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM_NEW, this.md_param3.parseContent());
            this.md_param4.struArea.u32Enable = 0;
            this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM_NEW, this.md_param4.parseContent());
            return;
        }
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM, this.md_param.parseContent());
        if (z) {
            return;
        }
        this.md_param2.struArea.u32Enable = 0;
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM, this.md_param2.parseContent());
        this.md_param3.struArea.u32Enable = 0;
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM, this.md_param3.parseContent());
        this.md_param4.struArea.u32Enable = 0;
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_MD_PARAM, this.md_param4.parseContent());
    }

    private void handSwiBtnPush(boolean z) {
        if (z && !this.switch_voice_alarm.isChecked() && !this.switch_btn_vmd.isChecked() && !this.switch_human_alarm.isChecked() && !this.switch_hsr_alarm.isChecked()) {
            this.switch_btn_push.setChecked(false);
            showDialog_1();
        } else {
            showjuHuaDialog();
            this.mMyCamera.bindPushState(this.switch_btn_push.isChecked(), this.bindPushResult);
        }
    }

    private void showDialog_1() {
        if (isFinishing()) {
            return;
        }
        final NiftyDialogBuilder niftyDialogBuilder = NiftyDialogBuilder.getInstance(this);
        niftyDialogBuilder.withTitle(getString(R.string.open_device_alarm)).withMessage(getString(R.string.open_any_king));
        niftyDialogBuilder.withMessageLayoutHWrapW(HiTools.dip2px(this, 280.0f));
        niftyDialogBuilder.withButOnlyOne(getString(R.string.all_right), getResources().getColor(R.color.color_theme_blue), 17);
        niftyDialogBuilder.show();
        niftyDialogBuilder.setButton2Click(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                niftyDialogBuilder.dismiss();
            }
        });
        niftyDialogBuilder.setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface dialogInterface) {
                ObjectAnimator ofInt = ObjectAnimator.ofInt(AlarmManageAndNotiActivity.this.ll_content_device_alarm, "backgroundColor", AlarmManageAndNotiActivity.this.getResources().getColor(R.color.white), Color.parseColor("#5545A7E6"), AlarmManageAndNotiActivity.this.getResources().getColor(R.color.white));
                ofInt.setDuration(1500L);
                ofInt.setEvaluator(new ArgbEvaluator());
                ofInt.setRepeatCount(1);
                ofInt.start();
                AlarmManageAndNotiActivity.this.scrollview.smoothScrollTo(AlarmManageAndNotiActivity.this.scrollview.getScrollX(), AlarmManageAndNotiActivity.this.tv_device_alarm.getScrollY());
            }
        });
    }

    public void setLocationPushuState(boolean z) {
        dismissjuHuaDialog();
        this.switch_btn_push.setChecked(z);
        if (!z) {
            MyToast.showToast(this, getString(R.string.close_success));
            sendUnRegister();
        } else {
            MyToast.showToast(this, getString(R.string.open_success));
        }
        this.mMyCamera.setPushState(z ? 1 : 0);
        this.mMyCamera.updateInDatabase(this);
    }

    private void closePlanRecord(HiChipDefines.HI_P2P_S_REC_AUTO_PARAM hi_p2p_s_rec_auto_param) {
        hi_p2p_s_rec_auto_param.u32Enable = 0;
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_REC_AUTO_PARAM, hi_p2p_s_rec_auto_param.parseContent());
        Toast.makeText(this, getString(R.string.closed_plan_record), 1).show();
    }

    public void handReceiveIOCTRLSuccess(Message message) {
        byte[] byteArray = message.getData().getByteArray("data");
        if (byteArray == null) {
            return;
        }
        switch (message.arg1) {
            case HiChipDefines.HI_P2P_GET_SNAP_ALARM_PARAM:
                this.snapParam = new HiChipDefines.HI_P2P_SNAP_ALARM(byteArray);
                this.tv_snap_num.setText(this.snapParam.u32Number + "");
                HiLogcatUtil.e("HI_P2P_GET_CAPTURE_NUM", "" + this.snapParam.u32Number);
                return;
            case HiChipDefines.HI_P2P_GET_ALARMTOSOUND:
                HiChipDefines.ALARMTOSOUND_TYPE alarmtosound_type = new HiChipDefines.ALARMTOSOUND_TYPE(byteArray);
                this.mAlarmToSoundType = alarmtosound_type;
                this.mVoiceType = alarmtosound_type.SoundType;
                this.mTime = this.mAlarmToSoundType.TimeLast;
                this.switch_btn_alarm_linkage.setChecked(this.mAlarmToSoundType.enable == 1);
                this.switch_btn_alarm_linkage.setOnCheckedChangeListener(this);
                if (this.mAlarmToSoundType.enable == 1) {
                    animViewDisplay(this.ll_alarm_linkage_content, 0, HiTools.dip2px(this, 90.0f));
                }
                int i = this.mVoiceType;
                if (i == 0) {
                    this.tv_voice_type.setText(getString(R.string.alarm_alarm_sound));
                } else if (i == 1) {
                    this.tv_voice_type.setText(getString(R.string.alarm_barking));
                } else if (i == 2) {
                    this.tv_voice_type.setText(getString(R.string.alarm_custom));
                }
                this.tv_alarm_time.setText(((int) this.mAlarmToSoundType.TimeLast) + getString(R.string.sends));
                return;
            case 16795:
                ConstantCommand.HI_P2P_SMART_HSR hi_p2p_smart_hsr = new ConstantCommand.HI_P2P_SMART_HSR(byteArray);
                this.human_alarm_params = hi_p2p_smart_hsr;
                Log.e("==tedu", hi_p2p_smart_hsr.toString());
                this.switch_human_alarm.setChecked(this.human_alarm_params.u32HSRenable == 1);
                this.switch_human_alarm_rect.setChecked(this.human_alarm_params.u32DrawRect == 1);
                this.tv_human_alarm_sensi.setText(this.human_alarm_params.u32Link == 0 ? getString(R.string.single_human_alarm) : getString(R.string.joint_human_alarm));
                this.switch_human_alarm_rect.setOnCheckedChangeListener(this);
                return;
            case ConstantCommand.HI_P2P_GET_CLOUDUPLOADSWITCH:
                ConstantCommand.HI_P2P_CLOUDUPLOADSWITCH hi_p2p_clouduploadswitch = new ConstantCommand.HI_P2P_CLOUDUPLOADSWITCH(byteArray);
                this.params = hi_p2p_clouduploadswitch;
                this.switch_alarm_videotocloud.setChecked(hi_p2p_clouduploadswitch.u8CloudUploadSwitch == 1);
                this.switch_alarm_videotocloud.setOnCheckedChangeListener(this);
                return;
            case ConstantCommand.HI_P2P_GET_SMART_SWITCH_PARAM:
                ConstantCommand.HI_P2P_SMART_SWITCH hi_p2p_smart_switch = new ConstantCommand.HI_P2P_SMART_SWITCH(byteArray);
                this.hi_p2P_smart_switch = hi_p2p_smart_switch;
                this.switch_hsr_alarm.setChecked(hi_p2p_smart_switch.u32HSRenable == 1);
                if (this.hi_p2P_smart_switch.u32HSRenable == 1) {
                    animViewDisplay(this.ll_hsr_type, 0, HiTools.dip2px(this, this.aiHeight));
                    return;
                }
                return;
            case ConstantCommand.HI_P2P_GET_SMART_HSR_PARAM_EXT:
                ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hi_p2p_get_smart_hsr_ext = new ConstantCommand.HI_P2P_GET_SMART_HSR_EXT(byteArray);
                this.hiP2PGetSmartHsrExt = hi_p2p_get_smart_hsr_ext;
                this.switch_hsr_alarm_rect.setChecked(hi_p2p_get_smart_hsr_ext.u32DrawRect == 1);
                this.switch_hsr_alarm_rect.setOnCheckedChangeListener(new $$Lambda$_LOqkQl8M6iTR4D1_yJGzIRWbVE(this));
                if (this.hiP2PGetSmartHsrExt.u32IntelligentClassification == 2 || this.hiP2PGetSmartHsrExt.u32IntelligentClassification == 3 || this.hiP2PGetSmartHsrExt.u32IntelligentClassification == 4) {
                    this.rl_hsr_type.setVisibility(0);
                } else {
                    this.aiHeight -= 50;
                    this.rl_hsr_type.setVisibility(8);
                }
                this.tv_hsr_sensitivity.setText(getString(R.string.sensi) + this.hiP2PGetSmartHsrExt.u32Sensitivity);
                if (this.hiP2PGetSmartHsrExt.u32IntelligentClassificationType == 0) {
                    this.tv_hsr_type.setText(getString(R.string.ai_human));
                    return;
                }
                if (this.hiP2PGetSmartHsrExt.u32IntelligentClassificationType == 1) {
                    this.tv_hsr_type.setText(getString(R.string.ai_human_veh));
                    return;
                } else if (this.hiP2PGetSmartHsrExt.u32IntelligentClassificationType == 2) {
                    this.tv_hsr_type.setText(getString(R.string.ai_human_vem));
                    return;
                } else {
                    this.tv_hsr_type.setText(getString(R.string.ai_human_veh_vem));
                    return;
                }
            case ConstantCommand.HI_P2P_GET_SMART_ALARM_PARAM:
                ConstantCommand.HI_P2P_SMART_ALARM hi_p2p_smart_alarm = new ConstantCommand.HI_P2P_SMART_ALARM(byteArray);
                this.hiP2PSmartAlarm = hi_p2p_smart_alarm;
                this.tv_hsr_alarm_sensi.setText(hi_p2p_smart_alarm.u32Link == 0 ? getString(R.string.single_human_alarm) : getString(R.string.joint_human_alarm));
                return;
            case ConstantCommand.HI_P2P_GET_CAPTURE_NUM:
                ConstantCommand.HI_P2P_CAPTURE_NUM hi_p2p_capture_num = new ConstantCommand.HI_P2P_CAPTURE_NUM(byteArray);
                this.captureParam = hi_p2p_capture_num;
                if (hi_p2p_capture_num.u32Num > 0) {
                    this.rl_switch_ftp.setVisibility(0);
                    this.rl_title_email.setVisibility(0);
                    this.rl_switch_email.setVisibility(0);
                    this.rl_config_email.setVisibility(0);
                } else if (this.captureParam.u32Num == 0 && this.rl_alarm_video_to_ftp.getVisibility() != 0) {
                    this.ll_ftp.setVisibility(8);
                }
                if (this.captureParam.u32Num > 1) {
                    this.ll_alarm_snap_num.setVisibility(0);
                    this.totalNum = this.captureParam.u32Num;
                }
                if (this.captureParam.u32Num > 0 && this.mMyCamera.appGetCommandFunction(HiChipDefines.HI_P2P_GET_SNAP_ALARM_PARAM)) {
                    this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_GET_SNAP_ALARM_PARAM, null);
                }
                HiLogcatUtil.e("HI_P2P_GET_CAPTURE_NUM", "" + this.captureParam.u32Num);
                return;
            case HiChipDefines.HI_P2P_GET_MD_PARAM:
                HiChipDefines.HI_P2P_S_MD_PARAM hi_p2p_s_md_param = new HiChipDefines.HI_P2P_S_MD_PARAM(byteArray);
                if (hi_p2p_s_md_param.struArea.u32Area == 1) {
                    this.md_param = hi_p2p_s_md_param;
                    this.switch_btn_vmd.setChecked(hi_p2p_s_md_param.struArea.u32Enable == 1);
                    this.tv_sensitivity.setText(getString(R.string.sensi) + this.md_param.struArea.u32Sensi);
                    return;
                }
                if (hi_p2p_s_md_param.struArea.u32Area == 2) {
                    this.md_param2 = hi_p2p_s_md_param;
                    return;
                } else if (hi_p2p_s_md_param.struArea.u32Area == 3) {
                    this.md_param3 = hi_p2p_s_md_param;
                    return;
                } else {
                    if (hi_p2p_s_md_param.struArea.u32Area == 4) {
                        this.md_param4 = hi_p2p_s_md_param;
                        return;
                    }
                    return;
                }
            case HiChipDefines.HI_P2P_GET_AUDIO_ALM_PARAM:
                this.voiceParam = new HiChipDefines.HI_P2P_S_ALM_PARAM(byteArray);
                this.tv_voice_alarm_sensi.setText(getString(R.string.sensi) + this.voiceParam.sensi);
                this.switch_voice_alarm.setChecked(this.voiceParam.enable == 1);
                return;
            case HiChipDefines.HI_P2P_GET_ALARM_PARAM:
                HiChipDefines.HI_P2P_S_ALARM_PARAM hi_p2p_s_alarm_param = new HiChipDefines.HI_P2P_S_ALARM_PARAM(byteArray);
                this.param = hi_p2p_s_alarm_param;
                this.switch_alarm_snaptosdcard.setChecked(hi_p2p_s_alarm_param.u32SDSnap == 1);
                this.switch_alarm_videotosdcard.setChecked(this.param.u32SDRec == 1);
                this.switch_alarm_snaptoemail.setChecked(this.param.u32EmailSnap == 1);
                this.switch_alarm_videotoftp.setChecked(this.param.u32FtpRec == 1);
                this.switch_alarm_snaptoftp.setChecked(this.param.u32FtpSnap == 1);
                if (!this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_FTP) && ((this.param.u32FtpRec == 1 || this.param.u32FtpSnap == 1) && this.rl_config_ftp.getVisibility() == 8)) {
                    animViewDisplay(this.rl_config_ftp, 0, HiTools.dip2px(this, 50.0f));
                }
                if (!this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_ALARM_EMAIL) && this.param.u32EmailSnap == 1 && this.rl_config_email.getVisibility() == 8) {
                    animViewDisplay(this.rl_config_email, 0, HiTools.dip2px(this, 50.0f));
                }
                this.switch_alarm_snaptosdcard.setOnCheckedChangeListener(this);
                this.switch_alarm_videotosdcard.setOnCheckedChangeListener(this);
                this.switch_alarm_snaptoemail.setOnCheckedChangeListener(this);
                this.switch_alarm_videotoftp.setOnCheckedChangeListener(this);
                this.switch_alarm_snaptoftp.setOnCheckedChangeListener(this);
                return;
            case HiChipDefines.HI_P2P_GET_ALARM_SCHEDULE:
                ArrayList<TimeArrayBean> arrayList = this.mBeans;
                if (arrayList != null) {
                    arrayList.clear();
                    handData(byteArray);
                    handView();
                    return;
                }
                return;
            case HiChipDefines.HI_P2P_SET_ALARM_SCHEDULE:
                dismissjuHuaDialog();
                return;
            case HiChipDefines.HI_P2P_GET_REC_AUTO_PARAM:
                HiChipDefines.HI_P2P_S_REC_AUTO_PARAM hi_p2p_s_rec_auto_param = new HiChipDefines.HI_P2P_S_REC_AUTO_PARAM(byteArray);
                if (hi_p2p_s_rec_auto_param.u32Enable == 1) {
                    closePlanRecord(hi_p2p_s_rec_auto_param);
                    return;
                }
                return;
            case HiChipDefines.HI_P2P_GET_SD_INFO:
                HiChipDefines.HI_P2P_S_SD_INFO hi_p2p_s_sd_info = new HiChipDefines.HI_P2P_S_SD_INFO(byteArray);
                this.sd_info = hi_p2p_s_sd_info;
                boolean z = hi_p2p_s_sd_info.u32Status == 1;
                this.mIsHaveSDCard = z;
                this.rl_alarm_snap_to_sdcard.setAlpha(z ? 1.0f : 0.5f);
                this.rl_alarm_video_to_sdcard.setAlpha(this.mIsHaveSDCard ? 1.0f : 0.5f);
                if (this.mIsHaveSDCard) {
                    return;
                }
                String string = Packet.getString(this.mMyCamera.getDeciveInfo().aszSystemSoftVersion);
                if (TextUtils.isEmpty(string)) {
                    return;
                }
                String[] split = string.split("\\.");
                if ("V10".equals(split[0]) || "V6".equals(split[0]) || this.mMyCamera.appGetCommandFunction(ConstantCommand.HI_P2P_SUPPORT_FTPUPLOAD)) {
                    this.mIsV10V6 = true;
                    this.rl_alarm_video_to_ftp.setVisibility(0);
                    return;
                } else {
                    this.rl_alarm_video_to_ftp.setVisibility(8);
                    return;
                }
            default:
                return;
        }
    }

    private void handView() {
        Iterator<TimeArrayBean> it = this.mBeans.iterator();
        int i = 0;
        while (it.hasNext()) {
            if (it.next().mIsAllDay) {
                i++;
            }
        }
        this.rl_simple.setSelected(i == 7);
        this.tv_simple_set.setSelected(i == 7);
        this.tv_hint_simple.setSelected(i == 7);
        this.iv_simple.setVisibility(i == 7 ? 0 : 8);
        this.rl_advanced.setSelected(i != 7);
        this.tv_advance_set.setSelected(i != 7);
        this.tv_hint_advance.setSelected(i != 7);
        this.iv_advanced.setVisibility(i == 7 ? 8 : 0);
    }

    private void handData(byte[] bArr) {
        HiChipDefines.HI_P2P_QUANTUM_TIME hi_p2p_quantum_time = new HiChipDefines.HI_P2P_QUANTUM_TIME(bArr);
        this.quantum_time = hi_p2p_quantum_time;
        byte[][] bArr2 = hi_p2p_quantum_time.sDayData;
        boolean z = false;
        for (int i = 0; i < 7; i++) {
            TimeArrayBean timeArrayBean = new TimeArrayBean();
            this.mBeans.add(timeArrayBean);
            timeArrayBean.setTitle(i);
            StringBuffer stringBuffer = new StringBuffer();
            boolean z2 = true;
            for (int i2 = 0; i2 < 48; i2++) {
                if (bArr2[i][i2] == 80) {
                    if (TextUtils.isEmpty(stringBuffer.toString())) {
                        if (i2 == 47) {
                            stringBuffer.append("23:30-23:59");
                            timeArrayBean.arrs.add(stringBuffer.toString());
                        } else {
                            stringBuffer.append(jToStr(i2) + Constants.ACCEPT_TIME_SEPARATOR_SERVER);
                        }
                    }
                    z = true;
                } else if (bArr2[i][i2] == 78) {
                    if (!z) {
                        z2 = false;
                    } else if (TextUtils.isEmpty(stringBuffer.toString())) {
                        z = false;
                        z2 = false;
                    } else {
                        stringBuffer.append(jToStr(i2));
                        timeArrayBean.arrs.add(stringBuffer.toString());
                        z2 = false;
                        stringBuffer = new StringBuffer();
                        z = false;
                    }
                }
            }
            timeArrayBean.mIsAllDay = z2;
        }
        Iterator<TimeArrayBean> it = this.mBeans.iterator();
        while (it.hasNext()) {
            TimeArrayBean next = it.next();
            StringBuffer stringBuffer2 = new StringBuffer();
            Iterator<String> it2 = next.getArrs().iterator();
            while (it2.hasNext()) {
                stringBuffer2.append(it2.next() + "   ");
            }
        }
    }

    private String jToStr(int i) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(11, 0);
        calendar.set(12, 0);
        calendar.set(13, 0);
        return this.sdf.format(new Date(calendar.getTimeInMillis() + (i * 30 * 60 * 1000)));
    }

    protected void sendServer(MyCamera myCamera) {
        if (myCamera.getServerData() == null) {
            myCamera.setServerData("120.24.179.113");
            myCamera.updateServerInDatabase(this);
        }
        if (myCamera.appGetCommandFunction(CamHiDefines.HI_P2P_ALARM_ADDRESS_SET) && myCamera.f987push != null) {
            String[] split = myCamera.f987push.getPushServer().split("\\.");
            if (split.length == 4 && isInteger(split[0]) && isInteger(split[1]) && isInteger(split[2]) && isInteger(split[3])) {
                myCamera.sendIOCtrl(CamHiDefines.HI_P2P_ALARM_ADDRESS_SET, CamHiDefines.HI_P2P_ALARM_ADDRESS.parseContent(myCamera.f987push.getPushServer()));
            }
        }
    }

    public static boolean isInteger(String str) {
        return Pattern.compile("^[-\\+]?[\\d]*$").matcher(str).matches();
    }

    public void sendRegister() {
        if (this.mMyCamera.getPushState() != 1 && this.mMyCamera.appGetCommandFunction(CamHiDefines.HI_P2P_ALARM_TOKEN_REGIST)) {
            this.mMyCamera.sendIOCtrl(CamHiDefines.HI_P2P_ALARM_TOKEN_REGIST, CamHiDefines.HI_P2P_ALARM_TOKEN_INFO.parseContent(0, this.mMyCamera.getPushState(), (int) ((System.currentTimeMillis() / 1000) / 3600), this.mMyCamera.getPushState() <= 0 ? 0 : 1));
        }
    }

    public void sendUnRegister() {
        if (this.mMyCamera.getPushState() != 0 && this.mMyCamera.appGetCommandFunction(CamHiDefines.HI_P2P_ALARM_TOKEN_UNREGIST)) {
            this.mMyCamera.sendIOCtrl(CamHiDefines.HI_P2P_ALARM_TOKEN_UNREGIST, CamHiDefines.HI_P2P_ALARM_TOKEN_INFO.parseContent(0, this.mMyCamera.getPushState(), (int) ((System.currentTimeMillis() / 1000) / 3600), this.mMyCamera.getPushState() > 0 ? 1 : 0));
        }
    }

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

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.ll_push_name:
                Intent intent = new Intent();
                intent.setClass(this, EditPushNameActivity.class);
                intent.putExtra("devName", this.tv_push_name.getText().toString().trim());
                intent.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivityForResult(intent, 120);
                return;
            case R.id.rl_adjust_hsr_alarm:
                if (HiTools.isCustomFastClick(500)) {
                    return;
                }
                Intent intent2 = new Intent(this, (Class<?>) ChooseHumanAlarmTypeActivity.class);
                intent2.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                ConstantCommand.HI_P2P_SMART_ALARM hi_p2p_smart_alarm = this.hiP2PSmartAlarm;
                if (hi_p2p_smart_alarm != null) {
                    intent2.putExtra("type", hi_p2p_smart_alarm.u32Link);
                } else {
                    intent2.putExtra("type", 0);
                }
                intent2.putExtra("vmd_check", this.switch_btn_vmd.isChecked());
                intent2.putExtra("ishsr", true);
                startActivityForResult(intent2, 9899);
                return;
            case R.id.rl_adjust_human_alarm:
                if (HiTools.isCustomFastClick(500)) {
                    return;
                }
                Intent intent3 = new Intent(this, (Class<?>) ChooseHumanAlarmTypeActivity.class);
                ConstantCommand.HI_P2P_SMART_HSR hi_p2p_smart_hsr = this.human_alarm_params;
                if (hi_p2p_smart_hsr != null) {
                    intent3.putExtra("type", hi_p2p_smart_hsr.u32Link);
                } else {
                    intent3.putExtra("type", 0);
                }
                intent3.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                intent3.putExtra("vmd_check", this.switch_btn_vmd.isChecked());
                startActivityForResult(intent3, 9898);
                return;
            case R.id.rl_adjust_vmd:
                Intent intent4 = new Intent(this, (Class<?>) AdjustVMDActivity.class);
                intent4.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivity(intent4);
                return;
            case R.id.rl_adjust_voice_alarm:
                if (this.voiceParam == null) {
                    return;
                }
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                } else {
                    if (HiTools.isCustomFastClick(500)) {
                        return;
                    }
                    Intent intent5 = new Intent(this, (Class<?>) AdjustVoiceAlarmActivity.class);
                    intent5.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                    startActivityForResult(intent5, 9998);
                    return;
                }
            case R.id.rl_advanced:
                Intent intent6 = new Intent(this, (Class<?>) PlanAlarmAdvancedActivity.class);
                intent6.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivity(intent6);
                return;
            case R.id.rl_alarm_time:
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                }
                Intent intent7 = new Intent(this, (Class<?>) AlarmSoundTimeActivity.class);
                intent7.putExtra("mTime", this.mTime);
                startActivityForResult(intent7, 119);
                return;
            case R.id.rl_alarm_voice_type:
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                }
                Intent intent8 = new Intent(this, (Class<?>) AlarmVoiceTypeActivity.class);
                intent8.putExtra("mVoiceType", this.mVoiceType);
                intent8.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivityForResult(intent8, 110);
                return;
            case R.id.rl_config_email:
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                }
                Intent intent9 = new Intent(this, (Class<?>) EmailSettingActivity.class);
                intent9.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivity(intent9);
                return;
            case R.id.rl_config_ftp:
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                }
                Intent intent10 = new Intent(this, (Class<?>) FtpSettingActivity.class);
                intent10.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                startActivity(intent10);
                return;
            case R.id.rl_hsr_type:
                if (HiTools.isCustomFastClick(500)) {
                    return;
                }
                boolean isChecked = this.switch_hsr_alarm_rect.isChecked();
                Intent intent11 = new Intent(this, (Class<?>) ChooseHumanAlarmTypeActivity.class);
                intent11.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                intent11.putExtra("ishsrType", true);
                ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hi_p2p_get_smart_hsr_ext = this.hiP2PGetSmartHsrExt;
                if (hi_p2p_get_smart_hsr_ext != null) {
                    intent11.putExtra("hsr_type", hi_p2p_get_smart_hsr_ext.u32IntelligentClassification);
                    intent11.putExtra("type", this.hiP2PGetSmartHsrExt.u32IntelligentClassificationType);
                    intent11.putExtra("u32DrawRect", isChecked ? 1 : 0);
                    intent11.putExtra("u32Sensitivity", this.hiP2PGetSmartHsrExt.u32Sensitivity);
                } else {
                    intent11.putExtra("type", 0);
                }
                startActivity(intent11);
                return;
            case R.id.rl_sensitivity:
                if (HiTools.isCustomFastClick(500)) {
                    return;
                }
                Intent intent12 = new Intent(this, (Class<?>) AdjustVoiceAlarmActivity.class);
                intent12.putExtra(HiDataValue.EXTRAS_KEY_UID, this.mMyCamera.getUid());
                intent12.putExtra("isHsr", true);
                ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hi_p2p_get_smart_hsr_ext2 = this.hiP2PGetSmartHsrExt;
                if (hi_p2p_get_smart_hsr_ext2 != null) {
                    intent12.putExtra("Sensitivity", hi_p2p_get_smart_hsr_ext2.u32Sensitivity);
                    intent12.putExtra("defSensitivity", this.hiP2PGetSmartHsrExt.u32SensitivityDefault);
                }
                startActivityForResult(intent12, 9999);
                return;
            case R.id.rl_simple:
                if (this.rl_simple.isSelected()) {
                    return;
                }
                final NiftyDialogBuilder niftyDialogBuilder = NiftyDialogBuilder.getInstance(this);
                niftyDialogBuilder.withMessageLayoutHWrapW(HiTools.dip2px(this, 280.0f));
                niftyDialogBuilder.withTitle(getString(R.string.tip_reminder)).withMessage(getString(R.string.confirm_clear_alarm));
                niftyDialogBuilder.withButton1Text(getString(R.string.cancel)).withButton2Text(getString(R.string.confirm));
                niftyDialogBuilder.show();
                niftyDialogBuilder.setButton1Click(new View.OnClickListener() {
                    @Override
                    public void onClick(View view2) {
                        niftyDialogBuilder.dismiss();
                    }
                });
                niftyDialogBuilder.setButton2Click(new View.OnClickListener() {
                    @Override
                    public void onClick(View view2) {
                        niftyDialogBuilder.dismiss();
                        AlarmManageAndNotiActivity.this.handSimpleSet();
                    }
                });
                return;
            case R.id.rl_snap_num:
                if (!this.mAlarmActionEnable) {
                    showDialog_1();
                    return;
                }
                Intent intent13 = new Intent(this, (Class<?>) AlarmSnapNumActivity.class);
                try {
                    intent13.putExtra("num", Integer.parseInt(this.tv_snap_num.getText().toString().trim()));
                    intent13.putExtra("totalNum", this.totalNum);
                    startActivityForResult(intent13, 999);
                    return;
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                    return;
                }
            case R.id.tv_push_tips:
                Intent intent14 = new Intent(this, (Class<?>) PushInstructionsActivity.class);
                intent14.putExtra("url", this.url);
                intent14.putExtra("mUid", this.mMyCamera.getUid());
                startActivity(intent14);
                return;
            default:
                return;
        }
    }

    public void handSimpleSet() {
        if (this.quantum_time == null) {
            return;
        }
        for (int i = 0; i < 7; i++) {
            for (int i2 = 0; i2 < 48; i2++) {
                this.quantum_time.sDayData[i][i2] = 80;
            }
        }
        this.quantum_time.u32QtType = 0;
        showjuHuaDialog();
        this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARM_SCHEDULE, this.quantum_time.parseContent());
        this.rl_simple.setSelected(true);
        this.tv_simple_set.setSelected(true);
        this.tv_hint_simple.setSelected(true);
        this.iv_simple.setVisibility(0);
        this.rl_advanced.setSelected(false);
        this.tv_advance_set.setSelected(false);
        this.tv_hint_advance.setSelected(false);
        this.iv_advanced.setVisibility(8);
    }

    @Override
    public void onActivityResult(int i, int i2, Intent intent) {
        super.onActivityResult(i, i2, intent);
        if (i2 == -1) {
            if (i == 110) {
                int intExtra = intent.getIntExtra("mVoiceType", 0);
                this.mVoiceType = intExtra;
                if (intExtra == 0) {
                    this.tv_voice_type.setText(getString(R.string.alarm_alarm_sound));
                } else if (intExtra == 1) {
                    this.tv_voice_type.setText(getString(R.string.alarm_barking));
                } else if (intExtra == 2) {
                    this.tv_voice_type.setText(getString(R.string.alarm_custom));
                }
                this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARMTOSOUND, HiChipDefines.ALARMTOSOUND_TYPE.parseContent(this.switch_btn_alarm_linkage.isChecked() ? (byte) 1 : (byte) 0, (byte) this.mVoiceType, (byte) this.mTime));
                return;
            }
            if (i == 999) {
                int intExtra2 = intent.getIntExtra("num", 1);
                this.tv_snap_num.setText(intExtra2 + "");
                this.snapParam.u32Number = intExtra2;
                HiChipDefines.HI_P2P_SNAP_ALARM hi_p2p_snap_alarm = this.snapParam;
                hi_p2p_snap_alarm.u32Interval = hi_p2p_snap_alarm.u32Interval >= 5 ? this.snapParam.u32Interval : 5;
                this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_SNAP_ALARM_PARAM, this.snapParam.parseContent());
                return;
            }
            if (i == 119) {
                this.mTime = intent.getIntExtra("mTime", 5);
                this.tv_alarm_time.setText(this.mTime + getString(R.string.sends));
                this.mMyCamera.sendIOCtrl(HiChipDefines.HI_P2P_SET_ALARMTOSOUND, HiChipDefines.ALARMTOSOUND_TYPE.parseContent(this.switch_btn_alarm_linkage.isChecked() ? (byte) 1 : (byte) 0, (byte) this.mVoiceType, (byte) this.mTime));
                return;
            }
            if (i == 120) {
                this.devName = intent.getStringExtra("devName");
                if (this.mMyCamera.getPushState() > 0) {
                    showjuHuaDialog();
                    Log.i("tedu", "devName11: " + this.devName);
                    if (!TextUtils.isEmpty(this.devName)) {
                        if (this.mMyCamera.f987push == null) {
                            MyCamera myCamera = this.mMyCamera;
                            myCamera.f987push = new HiPushSDK(this, myCamera.getBindToken(), this.mMyCamera.getUid(), "camhipro", this.mMyCamera.getPushName(), this.mMyCamera.getNikeName(), this.mMyCamera.pushResult, this.mMyCamera.getServerData());
                        }
                        this.mMyCamera.updateDevName(this.devName, this.bindPushResult);
                        return;
                    }
                    Log.e("tedu", "devName is null");
                    return;
                }
                this.mMyCamera.setPushDevName(this.devName);
                this.tv_push_name.setText(this.devName);
                if (!this.mMyCamera.getNikeName().equals(this.devName)) {
                    this.mMyCamera.setNikeName(this.devName);
                    this.mMyCamera.updateInDatabase(this);
                }
                Toast.makeText(this, getString(R.string.setting_success), 0).show();
                return;
            }
            if (i == 9898) {
                int intExtra3 = intent.getIntExtra("type", 0);
                this.tv_human_alarm_sensi.setText(intExtra3 == 0 ? getString(R.string.single_human_alarm) : getString(R.string.joint_human_alarm));
                ConstantCommand.HI_P2P_SMART_HSR hi_p2p_smart_hsr = this.human_alarm_params;
                if (hi_p2p_smart_hsr != null) {
                    hi_p2p_smart_hsr.u32Link = intExtra3;
                    this.mMyCamera.sendIOCtrl(16796, this.human_alarm_params.parseContent());
                    return;
                }
                return;
            }
            if (i == 9899) {
                int intExtra4 = intent.getIntExtra("type", 0);
                this.tv_hsr_alarm_sensi.setText(intExtra4 == 0 ? getString(R.string.single_human_alarm) : getString(R.string.joint_human_alarm));
                ConstantCommand.HI_P2P_SMART_ALARM hi_p2p_smart_alarm = this.hiP2PSmartAlarm;
                if (hi_p2p_smart_alarm != null) {
                    hi_p2p_smart_alarm.u32Link = intExtra4;
                }
                this.mMyCamera.sendIOCtrl(ConstantCommand.HI_P2P_SET_SMART_ALARM_PARAM, ConstantCommand.HI_P2P_SMART_ALARM.parseContent(intExtra4));
                return;
            }
            if (i == 9998) {
                String stringExtra = intent.getStringExtra("rate");
                if (this.voiceParam != null && stringExtra.length() > 0) {
                    this.voiceParam.sensi = Integer.parseInt(stringExtra);
                }
                this.tv_voice_alarm_sensi.setText(getString(R.string.sensi) + stringExtra);
                return;
            }
            if (i != 9999) {
                return;
            }
            int intExtra5 = intent.getIntExtra("rate", 0);
            this.tv_hsr_sensitivity.setText(getString(R.string.sensi) + intExtra5);
            ConstantCommand.HI_P2P_GET_SMART_HSR_EXT hi_p2p_get_smart_hsr_ext = this.hiP2PGetSmartHsrExt;
            if (hi_p2p_get_smart_hsr_ext != null) {
                hi_p2p_get_smart_hsr_ext.u32Sensitivity = intExtra5;
            }
            handBtnHsrRect(this.switch_hsr_alarm_rect.isChecked());
        }
    }

    public void animViewDisplay(final View view, final int i, int i2) {
        if (i == 0) {
            view.setVisibility(0);
        }
        ValueAnimator ofInt = ValueAnimator.ofInt(i, i2);
        ofInt.setDuration(350L);
        ofInt.setInterpolator(new AccelerateInterpolator());
        ofInt.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                view.getLayoutParams().height = ((Integer) valueAnimator.getAnimatedValue()).intValue();
                view.requestLayout();
            }
        });
        ofInt.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animator) {
                if (i != 0) {
                    view.setVisibility(8);
                }
            }
        });
        ofInt.start();
    }
}