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

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

const preStepIndex = 0;
const curStepIndex = 1;
const nextStepIndex = 2;

var DeployStepChain = {
    Begin : [CONST.DeployStep_Begin, CONST.DeployStep_Begin, CONST.DeployStep_3rdParty_FontInstall],
    FontInstall  :  [CONST.DeployStep_Begin, CONST.DeployStep_3rdParty_FontInstall,CONST.DeployStep_3rdParty_SogouInstall],
    SogouInstall  :  [CONST.DeployStep_3rdParty_FontInstall, CONST.DeployStep_3rdParty_SogouInstall,CONST.DeployStep_GetTerminalInfo],
    GetTerminalInfo : [CONST.DeployStep_3rdParty_SogouInstall, CONST.DeployStep_GetTerminalInfo,CONST.DeployStep_AdapterConfig],
    AdapterConfig : [CONST.DeployStep_GetTerminalInfo, CONST.DeployStep_AdapterConfig,CONST.DeployStep_MediaConfig],
    MediaConfig : [CONST.DeployStep_AdapterConfig, CONST.DeployStep_MediaConfig,CONST.DeployStep_FetchCenterSettings],
    FetchCenterSettings : [CONST.DeployStep_MediaConfig, CONST.DeployStep_FetchCenterSettings,CONST.DeployStep_AccessAuthorize],
    AccessAuthorize : [CONST.DeployStep_FetchCenterSettings, CONST.DeployStep_AccessAuthorize,CONST.DeployStep_Finished],
    Finished : [CONST.DeployStep_Finished, CONST.DeployStep_Finished,CONST.DeployStep_Finished],
}

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','CW','GRG','NANTIAN','GWI','*'];
var VENDOR_ZHCN = ['中钞科堡','恒银金融','广电运通','云南南天','长城信息','全部'];

function DisplayVendorFriendName(abbr)
{
    for(var n=0; n < VENDOR.length; ++n) {
        if(abbr === VENDOR[n]) {
            return VENDOR_ZHCN[n];
        }
    }
    return '';
}

var globalFinishedFlag = false;
var globalInterestRootFlag = false;

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

var globalLastRemberAdapterName = '';
var globalLastRemberAdapterConfigState = false;

var globalTerminalNo = '';
var globalSelectVendorType = '';
var globalServerIP = '';



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 rebindBtnClick(classID, callback)
{
    $('#' + classID).prop("onclick",null).off("click");;
    $('#' + classID).unbind('click');
    if(callback) {
        $('#' + '#' + classID).bind('click', callback);
    }
}

function setTestBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_test')
}

function setSaveBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_save')
}

function setNextBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_next')
}

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 AbortDeployConfig(finished) {
        
        RVC.HealthmanagerEntityCtrl.QuitApp(true);
        RVC.GuideController.hideAllPage();
        RVC.GuideController.hideAllRebootTipElem();
        $('#guide_quit_loading').show();
        $('#guide_reboot_page').show();
    }
    
    function ResetDeployConfig() {
        let req = new Request();
        req.preStep = DeployStepChain.Begin[preStepIndex];
        req.currStep = DeployStepChain.Begin[curStepIndex];
        req.nextStep = DeployStepChain.Begin[nextStepIndex];
        req.param1 = 0; 
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.additional = 0;
        req.options = 1;//重置标识
        req.restartApp = true;
        req.restartPC = false;

        if(req.restartApp) {
            utilStartSubmitDialog("重置成功将会自动重启应用，请耐心等候...");
        } else {
            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.reboot_pagrestartPC) {
                            $('#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');
            }, 2000);
            $('#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');
            }, 2000);
            $('#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 GetTerminalBaseInfo(flag)
    {
        let req = new Request();
        req.preStep = DeployStepChain.GetTerminalInfo[curStepIndex];
        req.currStep = DeployStepChain.GetTerminalInfo[curStepIndex];
        req.nextStep = DeployStepChain.GetTerminalInfo[curStepIndex];
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 1; //获取缓存基本信息
        req.additional =  0;
        req.restartApp = false;
        req.restartPC = false;

        globalTerminalNo = '';
        globalSelectVendorType = '';
        globalServerIP = '';

        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    if(result.array2.length === 3) {
                        globalTerminalNo = result.array2[0];
                        globalSelectVendorType = result.array2[1];
                        globalServerIP = result.array2[2];
                    }
                } else {
                    if(typeof type === 'undefined') {
                        utilStartAlertDialog("操作失败：[" + result.result + "] " + result.additionalMsg);
                    } else {
                        utilShowToast("操作失败：[" + result.result + "] " + result.additionalMsg);
                    }
                }
            } else {
                if(typeof type === 'undefined') {
                    utilStartAlertDialog("操作失败! ErrorCode: " + ErrorCodeStringfy(ret.errorCode));
                } else {
                    utilShowToast("操作失败! ErrorCode: " + ErrorCodeStringfy(ret.errorCode));
                }
            }
        });
    }

    function InitCenterSettingInputParam()
    {
        if(globalServerIP === '') {
            GetTerminalBaseInfo();
        }
        $('#guide_sync_centersetting_server_ip_content').attr('value', globalServerIP);
    }

    function InitCurrentVendorSelect()
    {
        if(globalSelectVendorType === '') {
            GetTerminalBaseInfo();
        }
        const vendorZhCnName = DisplayVendorFriendName(globalSelectVendorType);
        $('#gui_adapter_config_vendor').attr('value', globalSelectVendorType);
        $('#gui_adapter_config_vendor').html(vendorZhCnName);
    }

    function InitTemrinalAbout(server_ip, new_terminalno, vendorName)
    {
        let req = new Request();
        req.preStep = DeployStepChain.GetTerminalInfo[preStepIndex];
        req.currStep = DeployStepChain.GetTerminalInfo[curStepIndex];
        req.nextStep = DeployStepChain.GetTerminalInfo[nextStepIndex];
        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 =  1; //重命名root.ini
        req.restartApp = true;
        req.restartPC = false;
        req.timeout = 60000; //网络连接，延长时间，让实体自身反馈报错

        if(req.restartApp) {
            utilStartSubmitDialog("正在请求，处理成功将会自动执行应用重启，请耐心等候...");
        } else {
            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 DownloadCenterSetting(ip, port)
    {
        let req = new Request();
        req.preStep = DeployStepChain.FetchCenterSettings[preStepIndex];
        req.currStep = DeployStepChain.FetchCenterSettings[curStepIndex];
        req.nextStep = DeployStepChain.FetchCenterSettings[nextStepIndex];
        req.param1 = parseInt(port, 10);
        req.param2 = 0;
        req.param3 = 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 InitAccessAuthParam()
    {
        let req = new Request();
        req.entityName = 'AccessAuthorization'
		req.key = 'Server'

        $('#guide_access_authorize_server_ip_content').val('');
        $('#guide_access_authorize_port_content').val('');

        RVC.DeviceControlEntityCtrl.ReadCenterConfigStr(req, function(ret){
            if(ret.errorCode === 0) {
                console.log('fetch auth addr from centersettins succ.');
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                const addr = result.value.split(' ')[0]
			    const port = result.value.split(' ')[1]
                if(checkIpv4(addr) && check_port(port)) {
                    $('#guide_access_authorize_server_ip_content').val(addr);
                    $('#guide_access_authorize_port_content').val(port);

                    var serveraddr = addr + ':' + port;
                    console.log(serveraddr);

                } else {
                    utilShowToast("获取准入配置信息有误，请检查集中配置文件！");
                }
            } else {
                utilShowToast("获取准入配置信息失败! ErrorCode: " + ErrorCodeStringfy(ret.errorCode));
            }
        });
    }

    function AuthorizeTerminal(ip, port, username, password)
    {
        let req = new Request();
        req.preStep = DeployStepChain.AccessAuthorize[preStepIndex];
        req.currStep = DeployStepChain.AccessAuthorize[curStepIndex];
        req.nextStep = DeployStepChain.AccessAuthorize[nextStepIndex];
        req.param1 = parseInt(port, 10);
        req.param2 = 0;
        req.param3 = ip;
        req.param4 = '';
        req.options = 0;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;
        req.param5 = '';
        req.array1 = [0,0];
        req.array2 = [username, password];
        req.timeout = 65000;

        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 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 = DeployStepChain.MediaConfig[preStepIndex];
        req.currStep = DeployStepChain.MediaConfig[curStepIndex];
        req.nextStep = DeployStepChain.MediaConfig[nextStepIndex];
        req.additional = 0;
        req.options = 1; //0：保存在临时文件，1：保存在root.ini
        req.restartApp = false;
        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);

        utilStartSubmitDialog();
        RVC.DeviceControlEntityCtrl.TestAdapterFileAvailable(req, function(ret) {
            utilStopSubmitDialog();
            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 = DeployStepChain.AdapterConfig[curStepIndex];
        req.currStep = DeployStepChain.AdapterConfig[curStepIndex];
        req.nextStep = DeployStepChain.AdapterConfig[curStepIndex];
        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; //0x1:更新到临时的root.ini; 0x2:更新到root.ini
        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 StartBasicHardwareEntity(entityName, sucCallback)
    {
        let req = new Request();
        req.option = 1; //启动实体
        req.additional = 0;
        req.devId = 0;
        req.entityName = entityName;
        req.force = true;
        req.param = '';
        req.reserved1 = 0;
        req.reserved2 = '';
        req.timeout = 60000;

        RVC.HealthmanagerEntityCtrl.ControlEntityLife(req, function(ret) {
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    if(sucCallback) {
                        sucCallback();
                    }
                } else {
                    utilShowToast("启动模块" + entityName + "失败：[" + result.result + "] " + result.msg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    /**
     * 结束基本硬件配置后的操作
     */
    function FinshedDevAdapterConfig()
    {
        let req = new Request();
        req.preStep = DeployStepChain.AdapterConfig[preStepIndex];
        req.currStep = DeployStepChain.AdapterConfig[curStepIndex];
        req.nextStep = DeployStepChain.AdapterConfig[nextStepIndex];
        req.param1 = 1; //Start
        req.param2 = 1; //Force
        req.param3 = 'PinPad';
        req.param4 = ''; //Start param
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 0x4; //ControlEntity
        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 FinshedDeploy()
    {
        //RVC.HealthmanagerEntityCtrl.ControlTerminalLifeNo(1);
        let req = new Request();
        req.preStep = DeployStepChain.Finished[preStepIndex];
        req.currStep = DeployStepChain.Finished[curStepIndex];
        req.nextStep = DeployStepChain.Finished[nextStepIndex];
        req.param1 = 0; 
        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;

        if(req.restartApp) {
            utilStartSubmitDialog("请求重启应用，请稍后...");
        } else {
            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 SogouInstallStateSwitch(installState)
    {
        if(installState === 0) {
            $('#guide_sogou_installed_div').hide();
            $('#guide_sogou_noinstall_div').show();
            $('#guide_sogou_install_next').hide();
            $('#guide_sogou_install_start').show();
        } else if(installState === 1) {
            $('#guide_sogou_noinstall_div').hide();
            $('#guide_sogou_installed_div').show();
            $('#guide_sogou_install_start').hide();
            $('#guide_sogou_install_next').show();
        } else if(installState === 2) {
            $('#guide_sogou_noinstall_div').hide();
            $('#guide_sogou_installed_div').hide();
            $('#guide_sogou_install_start').hide();
            $('#guide_sogou_install_next').show();
            $('#guide_sogou_install_finished_div').show();
        }
    }

    function InstallSpecifiesFont()
    {
        let req = new Request();
        req.preStep = DeployStepChain.FontInstall[preStepIndex];
        req.currStep = DeployStepChain.FontInstall[curStepIndex];
        req.nextStep = DeployStepChain.FontInstall[nextStepIndex];
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        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) {
                    
                    var tip = '安装成功！强烈建议将当前页面拍照临存以便后续比对！';
                    utilStartCommonDialog(tip, 3000, function() {
                    //utilStartAlertDialog(tip, function() {
                        $('#guide_font_confirm_install').text('请后续确认效果');
                        $('#guide_font_confirm_install').addClass('btn_disabled');
                        rebindBtnClick('guide_font_confirm_install');
                        //$('#guide_font_confirm_install').prop("onclick",null).off("click");;
                        //$('#guide_font_confirm_install').unbind('click');
                        
                        $('#guide_font_confirmed_div').empty();
                        var content = '<div class="pull-left text-left" id="guide_font_confirmed_content"\
                        style="font-family:\'HYQiHei 55S\',\'HYQiHei-55S\',sans-serif;width:540px;padding-top:2px;font-size:60px;border:1px solid #00F;padding: 25px 0px 25px 30px;">\
                           我是，；测试字体！1234\
                       </div>';
                        $('#guide_font_confirmed_div').html(content);

                        $('#guide_font_confirm_next').text('下一步');
                    });
                } else {
                    utilStartAlertDialog("安装失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function InstallSogouInput()
    {
        let req = new Request();
        req.preStep = DeployStepChain.SogouInstall[preStepIndex];
        req.currStep = DeployStepChain.SogouInstall[curStepIndex];
        req.nextStep = DeployStepChain.SogouInstall[nextStepIndex];
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 2; //安装搜狗输入法
        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) {
                    SogouInstallStateSwitch(2);
                    var tip = '安装成功！';
                    if(result.array2.length === 3) {
                        tip += '<br><br>版本：<strong>' + result.array2[0] + '</strong>';
                        tip += '<br>安装时间：<strong>' + result.array2[2] + '</strong>';
                    }
                    $('#guide_sogou_install_finished_content').html(tip);
                } else {
                    utilStartAlertDialog("安装失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    function DisplaySogouInstallState()
    {
        let req = new Request();
        req.preStep = DeployStepChain.SogouInstall[curStepIndex];
        req.currStep = DeployStepChain.SogouInstall[curStepIndex];
        req.nextStep = DeployStepChain.SogouInstall[curStepIndex];
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = '';
        req.param4 = '';
        req.param5 = '';
        req.array1 = [0];
        req.array2 = [''];
        req.options = 1; //检测输入法的安装状态
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;

        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    if(result.param1 === 1) {
                        SogouInstallStateSwitch(1);
                        var tip = '已检测到输入法！';
                        if(result.array2.length === 3) {
                            tip += '<br><br>版本：<strong>' + result.array2[0] + '</strong>';
                            tip += '<br>安装时间：<strong>' + result.array2[2] + '</strong>';
                        }
                        $('#guide_sogou_installed_content').html(tip);
                        console.log(tip);
                    } else {
                        SogouInstallStateSwitch(0);
                    }
                } else {
                    utilStartAlertDialog("查询失败：[" + result.result + "] " + result.additionalMsg);
                }
            } else {
                RVC.HealthmanagerEntityCtrl.commErrorCallback(ret);
            }
        });
    }

    RVC.GuideController = RVC.Object.extend({
        hideAllPage: function () {
            $('#guide_start_page').hide();

            $('#guide_font_confirm_page').hide();
            $('#guide_sogou_install_page').hide();

            $('#guide_init_param_page').hide();
            $('#guide_adapter_config_page').hide();

            $('#guide_media_config_page').hide();
            $('#guide_sync_centersetting_page').hide();
            $('#guide_access_authorize_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_3rdParty_FontInstall);
        },
        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
                case CONST.DeployStep_3rdParty_SogouInstall:
                    select_page = 'guide_sogou_install_page';
                break; 
                case CONST.DeployStep_3rdParty_FontInstall:
                    select_page = 'guide_font_confirm_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:
                    InitCurrentVendorSelect();
                    break;
                case CONST.DeployStep_FetchCenterSettings:
                    InitCenterSettingInputParam();
                    break;
                case CONST.DeployStep_3rdParty_SogouInstall:
                    DisplaySogouInstallState();
                    break;
                default:
                    break;
            }
        },
        postLoadPage: function(step) {
            switch(step) {
                case CONST.DeployStep_Finished:
                    globalFinishedFlag = true;
                    break;
                case CONST.DeployStep_AdapterConfig:
                    InterestRootSwitch(true);
                    break;
                case CONST.DeployStep_AccessAuthorize:
                    InitAccessAuthParam();
                    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, 5000);
            }
        },
        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;
        }

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

        utilStartConfirmDialog("基本信息录入后将不可撤销，如需修改需重置后再配置，请确认是否提交？", function() {
            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() {
        FinshedDevAdapterConfig();
    });

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

        const ip = $('#guide_sync_centersetting_server_ip_content').val();
        const port = $('#guide_sync_centersetting_port_content').val();
        if(!isValidIpAddress(ip)) {
            utilStartAlertDialog("无效IP格式");
            return;
        }
        if(!check_port(port)) {
            utilStartAlertDialog("无效端口号");
            return;
        }
        DownloadCenterSetting(ip, port);
    });

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

        const ip = $('#guide_access_authorize_server_ip_content').val();
        const port = $('#guide_access_authorize_port_content').val();
        const username = $('#guide_access_authorize_username_content').val();
        const psw = $('#guide_access_authorize_password_content').val();
        if(!isValidIpAddress(ip)) {
            utilStartAlertDialog("无效IP格式");
            return;
        }
        if(!check_port(port)) {
            utilStartAlertDialog("无效端口号");
            return;
        }
        if(username === '') {
            utilStartAlertDialog("请输入用户名");
            return;
        }
        if(psw === '') {
            utilStartAlertDialog("请输入密码");
            return;
        }
        AuthorizeTerminal(ip, port, username, psw);
    });

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

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

    $(document).on('click', '#guide_sogou_install_next', function() {
        RVC.GuideController.gotoPage(CONST.DeployStep_GetTerminalInfo);
    });

    $(document).on('click', '#guide_sogou_install_start', function() {
        InstallSogouInput();
    });

    //字体安装按钮
    $(document).on('click', '#guide_font_confirm_install', function() {
        InstallSpecifiesFont();
    });

    //字体安装页面下一步按钮
    $(document).on('click', '#guide_font_confirm_next', function() {
        RVC.GuideController.gotoPage(CONST.DeployStep_3rdParty_SogouInstall);
    });
    
    $(document).on('click', '#guide_finish_restart_btn', function() {
        FinshedDeploy();
    });

    $(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').bind('click', function() {
            if(!globalFinishedFlag) {
                utilStartConfirmDialog("配置还未完成，确定要退出当前配置吗？(应用也将退出)", function() {
                    AbortDeployConfig();                   
                });
            } else {
                AbortDeployConfig(true);
            }
        });
        console.log("href:" + window.location.href);
        console.log("search:" + window.location.search);

        var pageIdx = getQueryStringByName('page');
        var terminalNo = getQueryStringByName('terminalno');
        var vendorAbbr = getQueryStringByName('vendor');
        var serverIP = getQueryStringByName('ip');

        if(terminalNo !== null && terminalNo.length > 0 && terminalNo !== 'null') {
            globalTerminalNo = terminalNo;
        }
        if(vendorAbbr !== null && vendorAbbr.length > 0 && vendorAbbr !== 'null') {
            globalSelectVendorType = vendorAbbr;
        }
        if(serverIP !== null && serverIP.length > 0 && serverIP !== 'null') {
            globalServerIP = serverIP;
        }
        if(pageIdx !== null && pageIdx.length > 0 && pageIdx !== 'null' && IsDigital(pageIdx)) {
            var step = parseInt(pageIdx, 10);
            if(RVC.GuideController.checkPageAvailable(step)) {
                utilStartAlertDialog('请点击确认按钮继续上次的配置', function() {
                    RVC.GuideController.gotoPage(step);
                });
            }
        } else {
            /**
             *     DeployStep_Begin : 0,
                    DeployStep_GetTerminalInfo : 1,
                    DeployStep_FetchCenterSettings : 2,
                    DeployStep_AccessAuthorize : 3,
                    DeployStep_MediaConfig : 4,
                    DeployStep_Finished : 5,
                    DeployStep_AdapterConfig : 6,
                    DeployStep_3rdParty_SogouInstall : 7,
                    DeployStep_3rdParty_FontInstall
             * 
             */
            RVC.GuideController.gotoPage(CONST.DeployStep_Begin);
        }
    }

    setTimeout(RVC.GuideController.resizeWindow, 200);

});