myvtm/addin/res/ManagerDesktop/js/guide.js

var CONST = {
    DeployStep_Begin : 0,
    DeployStep_GetTerminalInfo : 1,
    DeployStep_FetchCenterSettings : 2,
    DeployStep_AccessAuthorize : 3,
    DeployStep_MediaConfig : 4,
    DeployStep_Finished : 5,
    DeployStep_AdapterConfig : 6
};

var SETCTION = {
    BEGIN:'start',
    GETTERMINAL_INFO:'init_param',
    CENTERSETTINGS:'sync_centersetting',
    ACCESS_AUTHORIZE:'access_authorize',
    MEDIA_CONFIG:'media_config',
    FINSHED:'finish',
};

var MEDIA_TYPE = {
    CAMERA : 1,
    MICROPHONE : 2,
    LOUNDSPEAKER:4
}

var MEDIA_DETAIL_TYPE = {
    MediaDev_OutSpeaker:1,
    MediaDev_InSpeaker:2,
    MediaDev_OutMicrophone:3,
    MediaDev_InMicrophone:4
}

var VENDOR = {
    KEBA : 'KEBA',
    CW : 'CW',
    GRG : 'GRG',
    NANTIAN : 'NANTIAN',
    GWI : 'GWI'
};

var globalFinishedFlag = false;
var globalInterestRootFlag = false;

var globalAdapterFileNameList = [];
var globalAdapterFileNameStatus = [];
var globalAdapterOpenParamPort = [];
var globalAdapterOpenParamBaudrate = [];

var globalLastRemberAdapterName = '';
var globalLastRemberAdapterConfigState = false;


function clearAdapterSelectedValue()
{
    $('#gui_adapter_config_adapter').empty();
    $('#gui_adapter_config_adapter').attr("value", '');

    $('#guide_adapter_config_port_input').val('');
    $('#guide_adapter_config_baudrate_input').val('');
}


function generateAdapterSelect(devices, status, select_id) {
    var deviceLength = 0;
    if ((devices) instanceof Array) {
        deviceLength = devices.length;
    } else {
        deviceLength = 1
    }
    var devicesHtml = '';
    var selectid = select_id;
    $('#' + selectid).empty();
    for (var loop = 0; loop < deviceLength; loop++) {
        var cur = devices[loop];
        var deviceTemplateData = {
            loop: loop,
            deviceName : cur,
            type: selectid
        };
        var pushHtml = '';
        pushHtml = '<div id="{{type}}_item_{{loop}}" option="{{deviceName}}" class="select_medium hide_with_ellipsis"'
        if(!(status[loop] & 0x1)) {
            pushHtml += ' style="color:#C0C0C0;"'
        } else {
            pushHtml += ' onclick="AdapterSelectChange(\'{{deviceName}}\')"'
        }
        //root.ini 配置
        if((status[loop] & 0x2)) {
            pushHtml += '>{{deviceName}}&nbsp;(当前配置)</div>'
        } else {
            pushHtml += '>{{deviceName}}</div>'
        }
        $('#' +  selectid).secureAppend(pushHtml, deviceTemplateData);
    }
}

function FulfillDevAdapterFileList(device, vendor, root_or_not, flag)
{
    let req = new Request();
    req.root = root_or_not;
    req.adapter=device;
    req.vendor=vendor;
    req.version="";
    req.batch="";

    globalAdapterFileNameList = [];
    globalAdapterFileNameStatus = [];
    globalAdapterOpenParamPort = [];
    globalAdapterOpenParamBaudrate = [];

    RVC.DeviceControlEntityCtrl.GetVendorFileList(req, function(ret) {
        if(ret.errorCode === 0) {
            let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
            if(result.result == 0) {
                
                console.log('=============================');
                for (var n = 0; n < result.filenames.length; n++) {
                    console.log(result.filenames[n] + ' ' + result.status[n] + ' ' + result.port[n] + ' ' + result.baudrate[n]);
                    globalAdapterFileNameList.push(result.filenames[n]);
                    globalAdapterFileNameStatus.push(result.status[n]);
                    globalAdapterOpenParamPort.push(result.port[n]);
                    globalAdapterOpenParamBaudrate.push(result.baudrate[n]);
                    if(globalLastRemberAdapterName !== '' && globalLastRemberAdapterName === globalAdapterFileNameList[n]) {
                        globalLastRemberAdapterConfigState = (globalAdapterFileNameStatus[n] & 0x2);
                    }
                }
                clearAdapterSelectedValue();
                generateAdapterSelect(globalAdapterFileNameList, globalAdapterFileNameStatus, 'gui_adapter_config_adapter_list');
                if(typeof flag !== 'undefined') {
                    utilShowToast("已刷新");
                }

                //test
                if(result.filenames.length == 1 && globalInterestRootFlag && device !== '' && device != '*') {
                    FulfillAdapterCurrentSelect(globalAdapterFileNameList[0], (globalAdapterFileNameStatus[0] & 0x2));
                } else if(globalLastRemberAdapterName !== '') {
                    FulfillAdapterCurrentSelect(globalLastRemberAdapterName, globalLastRemberAdapterConfigState);
                }
                //test_end

            } else if(typeof flag !== 'undefined') {
                utilStartAlertDialog("操作失败：[" + result.result + "] " + result.msg);
            } else {
                console.error("操作失败：[" + result.result + "] " + result.msg);
            }
        } else if(typeof flag !== 'undefined') {
            RVC.DeviceControlEntityCtrl.commErrorCallback(ret);
        } else {
            console.error("操作失败! ErrorCode: " + ErrorCodeStringfy(ret.errorCode));
        }
    });
}

function LoadDeviceAdaptersWithEvent(flag)
{
    var deviceName = $('#gui_adapter_config_device').attr('value');
    var vendorName = $('#gui_adapter_config_vendor').attr('value').toLowerCase();
    FulfillDevAdapterFileList(deviceName, vendorName, globalInterestRootFlag, flag);
}

function AdapterSelectChange(name)
{
    $('#guide_adapter_config_port_input').val('');
    $('#guide_adapter_config_baudrate_input').val('');

    for(var n=0; n < globalAdapterFileNameList.length; n++) {
        if(globalAdapterFileNameList[n] === name) {
            if((globalAdapterFileNameStatus[n] & 0x2) /**root.ini 配置 */) {
                $('#guide_adapter_config_port_input').val('' + globalAdapterOpenParamPort[n]);
                $('#guide_adapter_config_baudrate_input').val('' + globalAdapterOpenParamBaudrate[n]);
            }
            setSaveBtnStatus(!(globalAdapterFileNameStatus[n] & 0x2));
            break;

        }  
    }
}

function FulfillAdapterCurrentSelect(value, configed)
{
    if(value === '') {
        clearAdapterSelectedValue();
    } else {
        if(configed) {
            $('#gui_adapter_config_adapter').html(value + '&nbsp;(当前配置)');
        } else {
            $('#gui_adapter_config_adapter').html(value);
        }
        $('#gui_adapter_config_adapter').attr('value', value);
        AdapterSelectChange(value);
    }
}

//正式环境该参数不可选
function VendorSelectChanged(name)
{
    var deviceName = $('#gui_adapter_config_device').attr('value');
    var vendorName = name.toLowerCase();
    FulfillDevAdapterFileList(deviceName, vendorName, globalInterestRootFlag, true);
}

function DeviceSelectChange(name)
{
    var vendorName = $('#gui_adapter_config_vendor').attr('value').toLowerCase();
    FulfillDevAdapterFileList(name, vendorName, globalInterestRootFlag, true);
}

function setBtnStatus(enable, classID)
{
    if (enable && $('#' + classID).hasClass('btn_disabled')) {
        $('#' + classID).attr('disabled', false);
        $('#' + classID).removeClass('btn_disabled');
    } else if(!enable && !$('#' + classID).hasClass('btn_disabled')) {
        $('#' + classID).attr('disabled', true);
        $('#' + classID).addClass('btn_disabled');
    }
}

function setTestBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_test')
}

function setSaveBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_save')
}

function InterestRootSwitch(flag) 
{
    if ($('#gui_adapter_config_root_interest_switch').hasClass('switch_on')) {
        globalInterestRootFlag = true;
    } else {
        globalInterestRootFlag = false;
    }

    setSaveBtnStatus(!globalInterestRootFlag);

    if(typeof flag == 'undefined')
        LoadDeviceAdaptersWithEvent(true);
    else 
        LoadDeviceAdaptersWithEvent();
}

$(function () {
    
    function ResetDeployConfig() {
        let req = new Request();
        req.preStep = CONST.DeployStep_Begin;
        req.currStep = CONST.DeployStep_Begin;
        req.nextStep = CONST.DeployStep_Begin;
        req.param1 = 1; //重置标识
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.additional = 0;
        req.options = 0;
        req.restartApp = true;
        req.restartPC = false;

        utilStartSubmitDialog();
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    if(req.restartApp || req.restartPC) {
                        RVC.GuideController.hideAllPage();
                        RVC.GuideController.hideAllRebootTipElem();
                        if(req.restartApp) {
                            $('#guide_restart_loading').show();
                        } else if(req.restartPC) {
                            $('#guide_reboot_loading').show();
                        }
                        $('#guide_reboot_page').show();
                    }
                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function IPConnectableTest(ip)
    {
        let req = new Request();
        req.protocol = 1; //Ping
        req.ip = ip;
        req.port = 0;
        req.reserved1 = 0;
        req.reserved2 = '';

        function showErrTips(val) {
            setTimeout(function () {
                $('#text_guide_init_param_ip_tips').addClass('hide');
            }, 3000);
            $('#text_guide_init_param_ip_tips').removeClass('hide')
            .removeClass('guide_input_descript').addClass('guide_error').html(val);
        }

        function showSuccTips(val) {
            setTimeout(function () {
                $('#text_guide_init_param_ip_tips').addClass('hide');
            }, 3000);
            $('#text_guide_init_param_ip_tips').removeClass('hide')
            .removeClass('guide_error').addClass('guide_input_descript').html(val);
        }

        if(!isValidIpAddress(ip)) {
            showErrTips('无效IP格式');
            return;
        }

        RVC.DeviceControlEntityCtrl.TestConnectivity(req, function(ret) {
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    showSuccTips('可正常连通');
                } else {
                    console.log(result.additionalMsg);
                    showErrTips(result.additionalMsg);
                }
            } else {
                let tips = ip + ' 测试连接失败：' + ErrorCodeStringfy(ret.errorCode);
                showErrTips(tips);
            }
        });
    }

    function DeployTerminalWithIPAndPort(server_ip, port, access_flag)
    {
        let req = new Request();
        if(!access_flag) {//下载集中配置
            req.preStep = CONST.DeployStep_MediaConfig;
            req.currStep = CONST.DeployStep_FetchCenterSettings;
            req.nextStep = CONST.DeployStep_AccessAuthorize;
        } else { //准入验证
            req.preStep = CONST.DeployStep_FetchCenterSettings;
            req.currStep = CONST.DeployStep_AccessAuthorize;
            req.nextStep = CONST.DeployStep_Finished;
        }

        req.param1 = parseInt(port, 10);
        req.param2 = 0;
        req.param3 = server_ip;
        req.options = 0;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];

        utilStartSubmitDialog();
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    utilStartAlertDialog("操作成功，进入下一步", function() {
                        RVC.GuideController.gotoPage(result.nextStep);
                    });
                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function InitTemrinalAbout(server_ip, new_terminalno, vendorName)
    {
        let req = new Request();
        req.preStep = CONST.DeployStep_Begin;
        req.currStep = CONST.DeployStep_GetTerminalInfo;
        req.nextStep = CONST.DeployStep_MediaConfig;
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = server_ip;
        req.param4 = new_terminalno + '|' + vendorName;
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 0;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;

        utilStartSubmitDialog();
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    utilStartAlertDialog("操作成功，进入下一步", function() {
                        RVC.GuideController.gotoPage(result.nextStep);
                    });

                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function PreDeployTerminalWithIPAndPort(server_ip, port, access_flag)
    {
        if(!isValidIpAddress(server_ip)) {
            utilStartAlertDialog("无效IP格式");
            return;
        }
        if(!check_port(port)) {
            utilStartAlertDialog("无效端口号");
            return;
        }
        
        DeployTerminalWithIPAndPort(server_ip, port, access_flag);
    }

    function DownloadCenterSetting(ip, port)
    {
        PreDeployTerminalWithIPAndPort(ip, port, false);
    }

    function AuthorizeTerminal(ip, port)
    {
        PreDeployTerminalWithIPAndPort(ip, port, true);
    }

    function generateMediaDeviceSelect(devices, select_id) {
        var deviceLength = 0;
        if ((devices) instanceof Array) {
            deviceLength = devices.length;
        } else {
            deviceLength = 1
        }
        var devicesHtml = '';
        var selectid = select_id;
        $('#' + selectid).empty();
        for (var loop = 0; loop < deviceLength; loop++) {
            var cur = devices[loop];
            var deviceTemplateData = {
                loop: loop,
                deviceName : cur,
                type: selectid
            };
            var pushHtml = '';
            pushHtml = '<div id="{{type}}_item_{{loop}}" option="{{deviceName}}" class="select_medium hide_with_ellipsis">'
            pushHtml += '{{deviceName}}</div>'
            $('#' +  selectid).secureAppend(pushHtml, deviceTemplateData);
        }
    }


    function FulfillMediaDeviceList(flag)
    {
        let req = new Request();
        req.type = 6; //1，2，4不需要摄像头配置
        req.interest = 0;
        req.reserverd1 = 0;
        req.reserverd2 = '';
        req.reserverd2 = '';

        RVC.CameraConfigEntity.GetMediaAvailableList(req, function(ret) {
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                console.log('device count: ' + result.result);
                var microphones = [];
                var loundspeakers = [];
                var cameras = [];
                for (var n = 0; n < result.AvailableList.length; n++) {
                    console.log(result.AvailableList[n] + ' ' + result.ListItemType[n] + ' ' + result.ListItemStatus[n]);
                    if(result.ListItemType[n] == MEDIA_TYPE.MICROPHONE) {
                        microphones.push(result.AvailableList[n]);
                    } else if(result.ListItemType[n] == MEDIA_TYPE.LOUNDSPEAKER) {
                        loundspeakers.push(result.AvailableList[n]);
                    } else if(result.ListItemType[n] == MEDIA_TYPE.CAMERA) {
                        cameras.push(result.AvailableList[n]);
                    }
                }
                generateMediaDeviceSelect(loundspeakers, 'gui_media_config_audio_output_outfree_list');
                generateMediaDeviceSelect(loundspeakers, 'gui_media_config_audio_output_infree_list');
                generateMediaDeviceSelect(microphones, 'gui_media_config_audio_input_outfree_list');
                generateMediaDeviceSelect(microphones, 'gui_media_config_audio_input_infree_list');
                if(typeof flag !== 'undefined') {
                    $('#gui_media_config_audio_input_infree').empty();
                    $('#gui_media_config_audio_input_infree').attr('value', '');

                    $('#gui_media_config_audio_input_outfree').empty();
                    $('#gui_media_config_audio_input_outfree').attr('value', '');

                    $('#gui_media_config_audio_output_infree').empty();
                    $('#gui_media_config_audio_output_infree').attr('value', '');

                    $('#gui_media_config_audio_output_outfree').empty();
                    $('#gui_media_config_audio_output_outfree').attr('value', '');

                    utilShowToast("已刷新");
                }


            } else if(typeof flag !== 'undefined'){
                RVC.CameraConfigEntity.commErrorCallback(ret);
            }
        });
    }

    function SaveMediaDeviceConfig()
    {
        //话筒扬声器
        var output_infree = $('#gui_media_config_audio_output_infree').attr('value');
        //外部扬声器
        var output_outfree = $('#gui_media_config_audio_output_outfree').attr('value');
        //话筒麦克风
        var input_infree = $('#gui_media_config_audio_input_infree').attr('value');
        //外部麦克风
        var input_outfree = $('#gui_media_config_audio_input_outfree').attr('value');

        if(output_outfree === '') {
            utilStartAlertDialog('请选择外部扬声器');
            return;
        } 
        if(output_infree === '') {
            utilStartAlertDialog('请选择话筒扬声器');
            return;
        } 
        if(input_outfree === '') {
            utilStartAlertDialog('请选择外部麦克风');
            return;
        } 
        if(input_infree === '') {
            utilStartAlertDialog('请选择话筒麦克风');
            return;
        } 

        // if(output_infree == output_outfree) {
        //     utilStartAlertDialog('扬声器选取冲突，请重新选择');
        //     return;
        // }
        // if(input_infree == input_outfree) {
        //     utilStartAlertDialog('麦克风选取冲突，请重新选择');
        //     return;
        // }

        let req = new Request();
        req.preStep = CONST.DeployStep_GetTerminalInfo;
        req.currStep = CONST.DeployStep_MediaConfig;
        req.nextStep = CONST.DeployStep_FetchCenterSettings;
        req.additional = 1; //重命名root.ini
        req.options = 0;
        req.restartApp = true;
        req.restartPC = false;
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [MEDIA_DETAIL_TYPE.MediaDev_OutSpeaker, MEDIA_DETAIL_TYPE.MediaDev_InSpeaker, MEDIA_DETAIL_TYPE.MediaDev_OutMicrophone, MEDIA_DETAIL_TYPE.MediaDev_InMicrophone];
        req.array2 = [output_outfree, output_infree, input_outfree, input_infree];

        utilStartSubmitDialog();
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    if(req.restartApp || req.restartPC) {
                        RVC.GuideController.hideAllPage();
                        RVC.GuideController.hideAllRebootTipElem();
                        if(req.restartApp) {
                            $('#guide_restart_loading').show();
                        } else if(req.restartPC) {
                            $('#guide_reboot_loading').show();
                        }
                        $('#guide_reboot_page').show();

                    } else {
                        utilStartAlertDialog("操作成功，进入下一步", function() {
                            RVC.GuideController.gotoPage(result.nextStep);
                        });
                    }

                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });

    }

    function CheckDevAdapterAvailable(adapter, port, baudrate)
    {
        let req = new Request();
        req.filename= adapter;
        req.type = 0;
        req.options = 0;
        req.port = parseInt(port, 10);
        req.baudrate = parseInt(baudrate, 10);
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = "";
        req.param4 = "";

        console.log("check adapter: " + adapter + " " + port + " " + baudrate);

        setTestBtnStatus(false);
        RVC.DeviceControlEntityCtrl.TestAdapterFileAvailable(req, function(ret) {
            setTestBtnStatus(true);
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.status == 0) {
                    utilStartAlertDialog("指定适配器文件成功加载，且尝试打开设备成功！");
                } else {
                    utilStartAlertDialog("验证失败：[" + result.status + "] " + result.msg);
                }
            } else {
                RVC.DeviceControlEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function SaveDevAdapterInfo(adapter, port, baudrate)
    {
        let req = new Request();
        req.preStep = CONST.DeployStep_AdapterConfig;
        req.currStep = CONST.DeployStep_AdapterConfig;
        req.nextStep = CONST.DeployStep_AdapterConfig;
        req.param1 = parseInt(port, 10);
        req.param2 = parseInt(baudrate, 10);
        req.param3 = adapter;
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 0x2;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;

        setSaveBtnStatus(false);
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            setSaveBtnStatus(true);
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    globalLastRemberAdapterName = adapter;
                    utilShowToast('已保存，将重新刷新', 1000, function() {
                        LoadDeviceAdaptersWithEvent(true);
                    });
                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function FinshedDevAdapterConfig()
    {
        let req = new Request();
        req.preStep = CONST.DeployStep_AdapterConfig;
        req.currStep = CONST.DeployStep_AdapterConfig;
        req.nextStep = CONST.DeployStep_AdapterConfig;
        req.param1 = parseInt(port, 10);
        req.param2 = parseInt(baudrate, 10);
        req.param3 = adapter;
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 0;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;

        setSaveBtnStatus(false);
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            setSaveBtnStatus(true);
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    globalLastRemberAdapterName = adapter;
                    utilShowToast('已保存，将重新刷新', 1000, function() {
                        LoadDeviceAdaptersWithEvent(true);
                    });
                } else {
                    utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    RVC.GuideController = RVC.Object.extend({
        hideAllPage: function () {
            $('#guide_start_page').hide();
            $('#guide_init_param_page').hide();
            $('#guide_sync_centersetting_page').hide();
            $('#guide_access_authorize_page').hide();
            $('#guide_media_config_page').hide();
            $('#guide_finish_page').hide();
            $('#guide_reboot_page').hide();
        },
        hideAllRebootTipElem: function() {
            $('#reboot_operate').hide();
            $('#guide_rebootinfo').hide();
            $('#guide_rebootinfo_need_restart').hide();
            $('#guide_rebootinfo_need_reboot').hide();
            $('#guide_reboot_application_button').hide();
            $('#guide_reboot_device_button').hide();
    
            $('#guide_finished_button').hide();
            $('#guide_finish_device_button').hide();
            $('#guide_save_loading').hide();
            $('#guide_reboot_loading').hide();
            $('#guide_restart_loading').hide();
        },
        resizeWindow: function () {
            var winHei = $(window).height();
            var popHeight = 480;
            var adjustHeight = 0;
            var blueBackgroundHeight = 0;
            if (winHei < 860) {
                winHei = 860;
            }
            blueBackgroundHeight = winHei - $('.headcontainer').height() - $('#page_footer').height();
            $('#guide_height').height(blueBackgroundHeight);
            adjustHeight = (blueBackgroundHeight - popHeight) * 0.5;
    
            $('#guide_start_page').css('padding-top', (adjustHeight + 100) + 'px');
            var domWidth = $('body').width();
            var winWidth = $('window').width();
            if (domWidth > winWidth) {
                setTimeout(function () {
                    $('body').scrollTop($('.headcontainer').height() + adjustHeight);
                    $('body').scrollLeft(($('body').width() - $(window).width()) / 2);
                }, 1000)
            }
            $('#guide_init_param_page').css('padding-top', adjustHeight + 'px');
        },
        beginInstall: function() {
            this.gotoPage(CONST.DeployStep_GetTerminalInfo);
        },
        getPage: function(step) {
            var select_page = '';
            switch(step) {
                case CONST.DeployStep_Begin:
                    select_page = 'guide_start_page';
                    break;
                case CONST.DeployStep_GetTerminalInfo :
                    select_page = 'guide_init_param_page';
                    break;
                case CONST.DeployStep_FetchCenterSettings:
                    select_page = 'guide_sync_centersetting_page';
                break;
                case CONST.DeployStep_AccessAuthorize :
                    select_page = 'guide_access_authorize_page';
                break;
                case CONST.DeployStep_MediaConfig :
                    select_page = 'guide_media_config_page';
                break;
                case CONST.DeployStep_AdapterConfig : 
                    select_page = 'guide_adapter_config_page';
                break;
                case CONST.DeployStep_Finished  :
                    select_page = 'guide_finish_page';
                break; 
                default:
                break;
            }
            return select_page;
        },
        checkPageAvailable: function(step) {
            const select_page = this.getPage(step);
            if(select_page !== '') {
                return true;
            } else {
                return false;
            }
        },
        preLoadPage: function(step) {
            this.hideAllPage();
            switch(step) {
                case CONST.DeployStep_MediaConfig:
                    FulfillMediaDeviceList();
                    break;
                case CONST.DeployStep_AdapterConfig:
                    InterestRootSwitch(true);
                    break;
                default:
                    break;
            }
        },
        postLoadPage: function(step) {
            switch(step) {
                case CONST.DeployStep_Finished:
                    globalFinishedFlag = true;
                    break;
                default:
                    break;
            }
        },
        gotoPage: function(nextStep) {
    
            var select_page = this.getPage(nextStep);
    
            if(select_page !== '') {
                this.preLoadPage(nextStep);
                $('#' + select_page).show();
                this.postLoadPage(nextStep);
            } else {
                utilShowToast('无法识别步骤标识：' + nextStep, 3000);
            }
        },
        sectOverPass: function() {
    
        },
        sectNext: function() {
    
        },
        setNavigaBtnAble: function(enable) {
    
        }
    });

    $(document).on('click', '#guide_init_param_ip_check #ip_connect_check', function(){
        var ip = $('#guide_server_ip').val();
        console.log('ip: ' + ip);
        IPConnectableTest(ip);
    });

    $(document).on('click', '#guide_init_param_next', function() {
        const ip = $('#guide_server_ip').val();
        const terminalno = $('#guide_init_param_terminalno').val();
        if(!isValidIpAddress(ip)) {
            utilStartAlertDialog("无效IP格式");
            return;
        }
        if(!IsDigital(terminalno)) {
            utilStartAlertDialog("无效终端号格式");
            return;
        }

        var vendorType = $('#gui_init_param_vendor').attr('value');
        if(vendorType === '' || vendorType === 'None') {
            utilStartAlertDialog("请选择设备厂商");
            return;
        }

        InitTemrinalAbout(ip, terminalno, vendorType);

    });

    $(document).on('click', '#guide_adapter_config_test', function() {

        var adapterName = $('#gui_adapter_config_adapter').attr('value');
        var paramPort = $('#guide_adapter_config_port_input').val();
        var paramBaudrate = $('#guide_adapter_config_baudrate_input').val();

        CheckDevAdapterAvailable(adapterName, paramPort, paramBaudrate);
    });

    $(document).on('click', '#guide_adapter_config_save', function() {

        var adapterName = $('#gui_adapter_config_adapter').attr('value');
        var paramPort = $('#guide_adapter_config_port_input').val();
        var paramBaudrate = $('#guide_adapter_config_baudrate_input').val();

        SaveDevAdapterInfo(adapterName, paramPort, paramBaudrate);
    });

    $(document).on('click', '#guide_adapter_config_next', function() {
        utilStartConfirmDialog("后续步骤依赖【密码键盘】，请确认配置正确且该硬件调用正常！ 确认要进入下一步？", function() {

        });
    });

    $(document).on('click', '#guide_sync_centersetting_next', function() {

        const ip = $('#guide_sync_centersetting_server_ip_content').val();
        var port = $('#guide_sync_centersetting_port_content').val();

        DownloadCenterSetting(ip, port);
    });

    $(document).on('click', '#guide_access_authorize_next', function() {

        const ip = $('#guide_access_authorize_server_ip_content').val();
        var port = $('#guide_access_authorize_port_content').val();

        AuthorizeTerminal(ip, port);
    });

    $(document).on('click', '#guide_media_config_refresh', function() {
        FulfillMediaDeviceList(true);
    });

    $(document).on('click', '#guide_media_config_next', function() {
        SaveMediaDeviceConfig();
    });

    $(document).on('click', '#reset_btn', function() {
        utilStartConfirmDialog("确认要重置当前终端的配置？（操作不可撤销，请慎重！）", function() {
            ResetDeployConfig();
        });
    });

    if (window.addEventListener) {
        window.addEventListener('resize', RVC.GuideController.resizeWindow, false);
    } else {
        window.attachEvent('resize', RVC.GuideController.resizeWindow);
    }

    RVC.CameraConfigEntity.init();

    if (window.location.href.indexOf('guide.html') !== -1) {
        RVC.GuideController.resizeWindow();
        RVC.Scroll.initScroll('#init_param_content');

        $('#header_right #quitpage_btn_div').prop("onclick",null).off("click");;
        $('#header_right #quitpage_btn_div').unbind('click');
        $('#header_right #quitpage_btn_div').bind('click', function() {
            if(!globalFinishedFlag) {
                utilStartConfirmDialog("配置还未完成，确定要退出页面吗？", function() {
                    quitThisPage();
                });
            } else {
                quitThisPage();
            }
        });

        var hash = window.location.href.split('#')[1];
        if(hash && IsDigital(hash)) {
            var step = parseInt(hash, 10);
            if(RVC.GuideController.checkPageAvailable(step)) {
                utilStartAlertDialog('点击<确认>以继续上次的配置', function() {
                    RVC.GuideController.gotoPage(step);
                });
            }
        } else {
            RVC.GuideController.gotoPage(CONST.DeployStep_Begin);
        }
    }

    setTimeout(RVC.GuideController.resizeWindow, 200);

});