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

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

var DeployStepChain = {
    Begin : [DEPLOY.DeployStep_Begin, DEPLOY.DeployStep_Begin, DEPLOY.DeployStep_3rdParty_FontInstall],
    FontInstall  :  [DEPLOY.DeployStep_Begin, DEPLOY.DeployStep_3rdParty_FontInstall,DEPLOY.DeployStep_3rdParty_SogouInstall],
    SogouInstall  :  [DEPLOY.DeployStep_3rdParty_FontInstall, DEPLOY.DeployStep_3rdParty_SogouInstall,DEPLOY.DeployStep_GetTerminalInfo],
    GetTerminalInfo : [DEPLOY.DeployStep_3rdParty_SogouInstall, DEPLOY.DeployStep_GetTerminalInfo,DEPLOY.DeployStep_AdapterConfig],
    AdapterConfig : [DEPLOY.DeployStep_GetTerminalInfo, DEPLOY.DeployStep_AdapterConfig,DEPLOY.DeployStep_MediaConfig],
    MediaConfig : [DEPLOY.DeployStep_AdapterConfig, DEPLOY.DeployStep_MediaConfig,DEPLOY.DeployStep_FetchCenterSettings],
    FetchCenterSettings : [DEPLOY.DeployStep_MediaConfig, DEPLOY.DeployStep_FetchCenterSettings,DEPLOY.DeployStep_AccessAuthorize],
    AccessAuthorize : [DEPLOY.DeployStep_FetchCenterSettings, DEPLOY.DeployStep_AccessAuthorize,DEPLOY.DeployStep_Finished],
    Finished : [DEPLOY.DeployStep_Finished, DEPLOY.DeployStep_Finished,DEPLOY.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','*'];
var VENDOR_ZHCN = ['中钞科堡','恒银金融','广电运通','云南南天','全部'];
var VENDOR_MACHINE_TYPE = [
    ['E1080-L'],['CASH35AG-JR10(G)'],['DT-7000I64A'],['VTM-6200B17FQ']
];

var DEBRANCH_URL = {
    DEV : 'https://rvcgateway.paas.cmbchina.cn',
    ST : 'https://rvcgateway.paasst.cmbchina.cn',
    UAT : 'https://rvcgateway.paasuat.cmbchina.cn',
    PRD : 'https://rvcgateway.paas.cmbchina.cn'    
};

var CENTERSETTING_URL = {
    DEV : '',
    ST : 'http://centerconfig.paasst.cmbchina.cn',
    UAT : '',
    PRD : 'https://centerconfig.paas.cmbchina.com' 
}

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 globalServerUsingHeadOffice = true;

var adapterTestFailedCount = 0;
var apdaterTestAllBefore = 0;


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 InitTerminalRegistInfoUrl()
{

    $('#guide_server_ip').val(DEBRANCH_URL.PRD);

    let req = new Request();
    req.configType = 4; //Config_Shell
    req.section = "TerminalRegistInfoUrl";
    req.option = false;
    req.key = "LAN";
    req.reserved1 = 1;
    req.reserved2 = 0;
    req.reserved3 = '';
    req.reserved4 = '';

    RVC.DeviceControlEntityCtrl.ReadConfigValue(req, function(ret) {
        if (ret.errorCode === 0) {
            let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
            if(result.value !== '') {
                $('#guide_server_ip').val(result.value);
            }
        }
    });
}


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') {
                    if(flag === true) {
                        if(root_or_not) {
                            utilShowToast("已刷新！适配器列表仅显示 root.ini 配置的硬件适配器信息", 5000);
                        } else {
                            utilShowToast("已刷新！适配器列表将显示当前所有能找到的厂商硬件适配器文件", 6000);
                        }
                    } else {
                        utilShowToast('已刷新！');
                    }
                }

                //test
                if(result.filenames.length == 1 && root_or_not && 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 generateDeviceTypeSelect(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 VendorSelectChangedAtInit(name)
{
    var vendorName = name.toLowerCase();
    $('#gui_init_param_device_model').empty();
    $('#gui_init_param_device_model').attr("value", '');

    for(var n=0; n < VENDOR.length; ++n) {
        if(name === VENDOR[n]) {
            var deviceTypes = VENDOR_MACHINE_TYPE[n];
            generateDeviceTypeSelect(deviceTypes, 'gui_init_param_device_model_list');
            if(deviceTypes.length > 0) {
                $('#gui_init_param_device_model').text(deviceTypes[0]);
                $('#gui_init_param_device_model').attr("value", deviceTypes[0]);
            }
        }
    }
}

function BranchTypeSelectChange(widget)
{
    var switchon = false;
    var classlist = $(widget).attr('class');
    if (classlist.indexOf('switch_on_disable') >= 0 || classlist.indexOf('switch_off_disable') >= 0) {
        return;
    }

    if (classlist.indexOf('switch_on') >= 0) {
        switchon = true;
    }

    if(switchon) {
        $('#guide_init_param_server_ip_name').html('总行微服务&nbsp;URL');
        InitTerminalRegistInfoUrl();
    } else {
        $('#guide_init_param_server_ip_name').html('分行服务&nbsp;IP');
        $('#guide_server_ip').val("");
    }
}

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

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

function setInputTextStatus(err, classID)
{
    if (err && $('#' + classID).hasClass('input_normal')) {
        $('#' + classID).removeClass('input_normal');
        $('#' + classID).addClass('input_normal_error');

    } else if(!err && !$('#' + classID).hasClass('input_normal')) {
        $('#' + classID).removeClass('input_normal_error');
        $('#' + classID).addClass('input_normal');
    }
}

function setSelectInputStatus(err, classID)
{
    if (err && $('#' + classID).hasClass('select_on_normal')) {
        $('#' + classID).removeClass('select_on_normal');
        $('#' + classID).addClass('select_on_normal_error');

    } else if(!err && !$('#' + classID).hasClass('select_on_normal')) {
        $('#' + classID).removeClass('select_on_normal_error');
        $('#' + classID).addClass('select_on_normal');
    }
}

var flickInvaliInterval = 0;
function adapeterNameInputFlick()
{
    var flag = ((flickInvaliInterval % 2) == 0);
    flickInvaliInterval += 1;
    setSelectInputStatus(flag, 'gui_adapter_config_adapter');
    setInputTextStatus(flag, 'guide_adapter_config_port_input_div');
    setInputTextStatus(flag, 'guide_adapter_config_baudrate_input_div');
}

function invalidFilck() {
    flickInvaliInterval = 0;
    let clock = 6
    let timer = setInterval(function () {
      clock--
      adapeterNameInputFlick();
      if (clock == 0) {
        clearInterval(timer);
      }
    }, 240)
  }

function rebindBtnClick(classID, callback)
{
    $('#' + classID).prop("onclick",null).off("click");;
    $('#' + classID).unbind('click');
    if(callback) {
        $('#' + '#' + classID).bind('click', callback);
    }
}

function setTestAllBtnStatus(enable) {

    setBtnStatus(enable, 'guide_adapter_config_test')
}

function setTestBtnStatus(enable) {

    setBtnStatus(enable, 'gui_adapter_config_adapter_check_btn')
}

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();

    //setTestAllBtnStatus(globalInterestRootFlag);
}

function MediaDeviceSelectChange(evt)
{
    var obj = evt.parentElement.parentElement;
    var value = evt.textContent;
    var obj_id = obj.id;

    if(obj_id === 'gui_media_config_audio_output_outfree_list') {
        var loundspeakers_in_value = $('#gui_media_config_audio_output_infree').attr('value');
        if(loundspeakers_in_value !== '' && value === loundspeakers_in_value) {
            utilShowToast('该设备已在话筒扬声器中被选择！');
        }
    } else if(obj_id === 'gui_media_config_audio_output_infree_list') {
        var loundspeakers_out_value = $('#gui_media_config_audio_output_outfree').attr('value');
        if(loundspeakers_out_value !== '' && value === loundspeakers_out_value) {
            utilShowToast('该设备已在外部扬声器中被选择！');  
        }
    }else if(obj_id === 'gui_media_config_audio_input_outfree_list') {
        var microphones_in_value = $('#gui_media_config_audio_input_infree').attr('value');
        if(microphones_in_value !== '' && value === microphones_in_value) {
            utilShowToast('该设备已在话筒麦克风中被选择！');
        }
    }else if(obj_id === 'gui_media_config_audio_input_infree_list') {
        var microphones_out_value = $('#gui_media_config_audio_input_outfree').attr('value');
        if(microphones_out_value !== '' && value === microphones_out_value) {
            utilShowToast('该设备已在外部麦克风中被选择！');
        }
    }
}


$(function () {

        function StartBasicHardwareEntity(entityName, sucCallback, failCallback)
        {
            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) {
                            utilShowToast("启动模块" + entityName + "成功！", 3000);
                            sucCallback();
                        }
                    } else {
                        utilShowToast("启动模块" + entityName + "失败：[" + result.result + "] " + result.msg, 5000);
                        if(failCallback) {
                            failCallback();
                        }
                    }
                } else {
                    utilShowToast("请求失败：" + ErrorCodeStringfy(ret.errorCode));
                    if(failCallback) {
                        failCallback();
                    }
                }
            });
        }

    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 UrlConnectableTest(url, err_tip_id, check_btn_id)
    {
        let req = new Request();
        req.protocol = 4; //Http Probe
        req.ip = url;
        req.port = 0;
        req.reserved1 = 0;
        req.reserved2 = '';

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

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

        if(!checkUrl(url)) {
            showErrTips('无效URL格式');
            return;
        }

        showSuccTips('正在连接验证...');
        setBtnStatus(false, check_btn_id);
        RVC.DeviceControlEntityCtrl.TestConnectivity(req, function(ret) {
            setBtnStatus(true, check_btn_id);
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result >= 0) {
                    showSuccTips('可正常连接: ' + result.result);
                } else {
                    console.log(result.additionalMsg);
                    showErrTips('连接失败：' + result.result + ", " + result.additionalMsg);
                }
            } else {
                let tips = url + ' 测试失败：' + ErrorCodeStringfy(ret.errorCode);
                showErrTips(tips);
            }
        });
    }

    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 InitCenterSettingsDownloadUrl()
    {
        $('#guide_sync_centersetting_server_ip_content').val(CENTERSETTING_URL.PRD);

        let req = new Request();
        req.configType = 4; //Config_Shell
        req.section = "CenterSettingsDownloadUrl";
        req.option = false;
        req.key = "LAN";
        req.reserved1 = 1;
        req.reserved2 = 0;
        req.reserved3 = '';
        req.reserved4 = '';

        RVC.DeviceControlEntityCtrl.ReadConfigValue(req, function(ret) {
            if (ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.value !== '') {
                    $('#guide_sync_centersetting_server_ip_content').val(result.value);
                }
            }
        });
    }

    function GetTerminalBaseInfo(callback, 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 = '';

        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];
                        if(callback) {
                            callback();
                        }
                    }
                } 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 InitCenterSettingInputParamSetBranchIP()
    {
        // if(checkUrl(globalServerIP)) {
        //     $('#guide_sync_centersetting_server_ip_content').attr('value', CENTERSETTING_URL.PRD);
        //     $('#sync_centersetting_content_ip_label').html('总行微服务&nbsp;URL');
        //     $('#guide_sync_centersetting_port_text').hide();
        //     $('#guide_sync_centersetting_port_tips').hide();
        // } else if(isValidIpAddress(globalServerIP)) {
        //     $('#sync_centersetting_content_ip_label').html('分行服务&nbsp;IP');
        //     $('#guide_sync_centersetting_port_text').show();
        //     $('#guide_sync_centersetting_port_tips').hide();
        // }
    }

    function InitCenterSettingInputParam()
    {
        $('#guide_sync_centersetting_server_ip_content').attr('value', CENTERSETTING_URL.PRD);
        $('#sync_centersetting_content_ip_label').html('集中配置总行下载&nbsp;URL');
        $('#guide_sync_centersetting_port_text').hide();
        $('#guide_sync_centersetting_port_tips').hide();

        InitCenterSettingsDownloadUrl();
    }

    function TestAllAdapterAvailableOrNot()
    {
        let req = new Request();
        req.filename= '';
        req.type = 1;
        req.options = 1; //遇到一个硬件报错立即返回
        req.port = 0;
        req.baudrate = 0;
        req.param1 = 0;
        req.param2 = 0;
        req.param3 = "";
        req.param4 = "";

        apdaterTestAllBefore = 1;

        if(req.options == 0) {
            req.timeout = 120000;
            utilStartSubmitDialog('涉及到多个硬件模块，此操作将花费较长的时间，请耐心等候...', 'btnCancelAdapterTest', '中断');
            $(document).on('click', '#btnCancelAdapterTest', function() {
                utilStopSubmitDialog();
            });
        } else {
            req.timeout = 60000;
            utilStartSubmitDialog('将逐一加载硬件适配器文件并尝试打开硬件设备，此操作可能需花费较长时间，请耐心等候...');
        }

        EventEmitter.subscribe('AdapterTestResult','TestAllAdapterAvailableOrNot', (evt)=> {
            let result = JSON.parse(evt[RVC.EntityController.sigResponseUUID]);
            console.log(result.result + ";" + result.adapterInfo + ";" + result.errMsg);
            if(0 == result.result) {
                utilShowToast(result.adapterInfo + '验证成功！');
            } else {
                utilShowToast(result.adapterInfo + '验证失败：' + result.errMsg);
                apdaterTestAllBefore = 1;
            }
        });

        RVC.DeviceControlEntityCtrl.TestAdapterFileAvailable(req, function(ret) {
            utilStopSubmitDialog();
            EventEmitter.unsubscribe('AdapterTestResult','TestAllAdapterAvailableOrNot');
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.status == 0) {
                    apdaterTestAllBefore = 2;
                    utilStartConfirmDialog('所有硬件配置验证通过！点击确认进入下一步，取消则不进行任何操作（后续可通过页面上的[跳过]菜单进入下一步）', function() {
                        FinshedDevAdapterConfig();
                    });
                } else {
                    var errmsg = '';
                    var firstAdapterName = '';
                    for (var n = 0; n < result.reserved1.length; n++) {
                        console.log(result.reserved2[n] + ': ' + result.reserved3[n]);
                        if(errmsg !== '') errmsg += '<br>';
                        errmsg += '<strong>' + result.reserved2[n] + '</strong>: ' + result.reserved3[n];
                        if(firstAdapterName === '') firstAdapterName = result.reserved2[n];
                    }

                    if(firstAdapterName !== '') {
                        for(var n=0; n < globalAdapterFileNameList.length; n++) {
                            if(globalAdapterFileNameList[n] === firstAdapterName) {
                                globalLastRemberAdapterName = globalAdapterFileNameList[n];
                                globalLastRemberAdapterConfigState = (globalAdapterFileNameStatus[n] & 0x2);
                                FulfillAdapterCurrentSelect(globalLastRemberAdapterName, globalLastRemberAdapterConfigState);
                                break;
                            }
                        }
                    }

                    var tips = "检测失败！请修改硬件配置或检查硬件是否可用：<br><br><span style='color:red'>" + errmsg +  "</span>";
                    utilStartAlertDialog(tips, function() {
                        invalidFilck();
                    });
                }
            } else {
                if(parseInt(ret.errorCode, 10) == ErrorCodeEnum.Error_NetBroken) {
                    utilStartAlertDialog("请求失败：" + ErrorCodeStringfy(ret.errorCode) + "<br>猜测是验证硬件模块时引起实体进程异常退出，请检查配置或硬件再重试！");
                        setTimeout(function () {
                            StartBasicHardwareEntity("DeviceControl");
                        }, 300);
                } else {
                    utilStartAlertDialog("请求失败：" + ErrorCodeStringfy(ret.errorCode));
                }
            }
        });
    }

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

            });
        } else {
            const vendorZhCnName = DisplayVendorFriendName(globalSelectVendorType);
            $('#gui_adapter_config_vendor').attr('value', globalSelectVendorType);
            $('#gui_adapter_config_vendor').html(vendorZhCnName);
        }

    }

    function InitTemrinalAbout(server_ip, new_terminalno, terminalType, vendorName, deviceModel, deviceSN, headBranchOrNot)
    {
        let req = new Request();
        req.preStep = DeployStepChain.GetTerminalInfo[preStepIndex];
        req.currStep = DeployStepChain.GetTerminalInfo[curStepIndex];
        req.nextStep = DeployStepChain.GetTerminalInfo[nextStepIndex];
        if(headBranchOrNot) req.param1 = 1;
        else req.param1 = 0;
        req.param2 = 0;
        req.param3 = server_ip;
        req.param4 = new_terminalno + '|' + terminalType;
        req.param5 = '';
        req.array1 = [0,0,0];
        req.array2 = [vendorName, deviceModel, deviceSN];
        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, false);
                        });
                    }
                } 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 = 0;
        req.param2 = 0;
        if(typeof port !== 'undefined') {
            req.param1 = parseInt(port, 10);
        } else {
            req.param2 = 1;
        }
        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, false);
                    });
                } 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("获取准入配置信息有误，请检查集中配置文件！", 5000);
                }
            } 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, false);
                    });
                } else {
                    utilStartAlertDialog("操作失败：[0x" + result.result.toString(16) + "] " + 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" onclick=MediaDeviceSelectChange(this)>'
            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 = [];

                const inner_deault = '内置音频';

                var microphones_in_value = $('#gui_media_config_audio_input_infree').attr('value');
                var microphones_in_exist = false;
                var microphones_inner_exist = false;

                var microphones_out_value = $('#gui_media_config_audio_input_outfree').attr('value');
                var microphones_out_exist = false;

                var loundspeakers_in_value = $('#gui_media_config_audio_output_infree').attr('value');
                var loundspeakers_in_exist = false;
                var loundspeakers_inner_exist = false;

                var loundspeakers_out_value = $('#gui_media_config_audio_output_outfree').attr('value');
                var loundspeakers_out_exist = false;


                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]);
                        if(microphones_in_value !== '' && microphones_in_value === result.AvailableList[n]){
                            microphones_in_exist = true;
                        }
                        if(microphones_out_value !== '' && microphones_out_value === result.AvailableList[n]){
                            microphones_out_exist = true;
                        }
                        if(inner_deault === result.AvailableList[n]) {
                            microphones_inner_exist = true;
                        }

                    } else if(result.ListItemType[n] == MEDIA_TYPE.LOUNDSPEAKER) {
                        loundspeakers.push(result.AvailableList[n]);
                        if(loundspeakers_out_value !== '' && loundspeakers_out_value === result.AvailableList[n]){
                            loundspeakers_out_exist = true;
                        }
                        if(loundspeakers_in_value !== '' && loundspeakers_in_value === result.AvailableList[n]){
                            loundspeakers_in_exist = true;
                        }
                        if(inner_deault === result.AvailableList[n]) {
                            loundspeakers_inner_exist = true;
                        }

                    } 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') {

                    if(!microphones_in_exist) {
                        $('#gui_media_config_audio_input_infree').empty();
                        $('#gui_media_config_audio_input_infree').attr('value', '');
                    }

                    if(!microphones_out_exist){
                        $('#gui_media_config_audio_input_outfree').empty();
                        $('#gui_media_config_audio_input_outfree').attr('value', '');
                    }

                    if(!loundspeakers_in_exist){
                        $('#gui_media_config_audio_output_infree').empty();
                        $('#gui_media_config_audio_output_infree').attr('value', '');
                    }

                    if(!loundspeakers_out_exist) {
                        $('#gui_media_config_audio_output_outfree').empty();
                        $('#gui_media_config_audio_output_outfree').attr('value', '');
                    }

                    utilShowToast("已刷新");

                } else {
                    
                    if(microphones_inner_exist) {
                        $('#gui_media_config_audio_input_infree').text(inner_deault);
                        $('#gui_media_config_audio_input_infree').attr('value', inner_deault);
                    }
                    if(loundspeakers_inner_exist) {
                        $('#gui_media_config_audio_output_infree').text(inner_deault);
                        $('#gui_media_config_audio_output_infree').attr('value', inner_deault);
                    }
                }

            } 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, false);
                        });
                    }
                } 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 = "";
        req.timeout = 60000;

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

        utilStartSubmitDialog();
        RVC.DeviceControlEntityCtrl.TestAdapterFileAvailable(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                if(adapterTestFailedCount != 0) {
                    adapterTestFailedCount = 0;
                }
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.status == 0) {
                    utilShowToast("适配器文件成功加载；尝试打开设备成功！", 1500);
                } else {
                    utilStartAlertDialog("验证失败：[" + result.status + "] " + result.msg);
                }
            } else {
                
                if(parseInt(ret.errorCode, 10) == ErrorCodeEnum.Error_NetBroken) {
                    adapterTestFailedCount++;
                    if(adapterTestFailedCount >= 3) {
                        utilStartAlertDialog("检测到多次调用测试通道失败，将尝试重启关联模块", function() {
                            utilShowToast('尝试重启关联模块，请稍后', 5000);
                            setTestBtnStatus(false);
                            StartBasicHardwareEntity("DeviceControl", function(){
                                setTestBtnStatus(true);
                                adapterTestFailedCount = 0;
                            },function(){
                                setTestBtnStatus(true);
                            });
                        });
                    } else {
                        utilStartAlertDialog("请求失败：" + ErrorCodeStringfy(ret.errorCode));
                    }
                } else {
                    utilStartAlertDialog("请求失败：" + ErrorCodeStringfy(ret.errorCode));
                }
            }
        });
    }

    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;
                    console.log('save adapter info');
                    utilShowToast('已保存，将重新刷新', 1000, function() {
                        LoadDeviceAdaptersWithEvent(false);
                    });
                } else {
                    utilStartAlertDialog("保存失败：[" + result.result + "] " + result.additionalMsg);
                }
            } 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) {
                    RVC.GuideController.gotoPage(result.nextStep, false);
                    // utilStartAlertDialog("操作成功，即将进入下一步", function() {
                    // });
                } 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 FontInstallStateSwitch(installState)
    {
        if(installState === 0) {
            $('#guide_font_installed_div').hide();
            $('#guide_font_installed_sample_div').hide();
            $('#guide_font_noinstall_div').show();
            $('#guide_font_confirm_next').hide();
            $('#guide_font_confirm_install').show();
        } else if(installState === 1) {
            var tip = '检测到字体已安装';
            $('#guide_font_installed_content').html(tip);

            $('#guide_font_noinstall_div').hide();
            $('#guide_font_installed_div').show();
            $('#guide_font_installed_sample_div').show();
            $('#guide_font_confirm_install').hide();
            $('#guide_font_confirm_next').show();
        } else if(installState === 2) {
            var tip = '字体安装成功！';
            $('#guide_font_installed_content').html(tip);

            $('#guide_font_noinstall_div').hide();
            $('#guide_font_installed_div').hide();
            $('#guide_font_installed_sample_div').hide();
            $('#guide_font_confirm_install').hide();
            $('#guide_font_confirm_next').show();
            $('#guide_font_install_finished_div').show();
        }
    }
    
    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 = 2;
        req.additional = 0;
        req.restartApp = false;
        req.restartPC = false;
        req.timeout = 60000;

        utilStartSubmitDialog();
        RVC.HealthmanagerEntityCtrl.DeployTerminal(req, function(ret) {
            utilStopSubmitDialog();
            if(ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.result == 0) {
                    FontInstallStateSwitch(2);
                } 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;
        req.timeout = 60000;

        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 DisplayFontInstallState()
    {
        let req = new Request();
        req.preStep = DeployStepChain.FontInstall[curStepIndex];
        req.currStep = DeployStepChain.FontInstall[curStepIndex];
        req.nextStep = DeployStepChain.FontInstall[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) {
                        FontInstallStateSwitch(1);
                    } else {
                        FontInstallStateSwitch(0);
                    }
                } 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);
            }
        });
    }

    function FulfillTerminalBasicInfo(val) {

        let req = new Request();
        RVC.DeviceControlEntityCtrl.QueryHardwareInfo(req, function(ret){
            if (ret.errorCode === 0) {
                let result = JSON.parse(ret[RVC.EntityController.sigResponseUUID])
                if(result.terminalNo === '') {
                    $('#page_footer #termina_no_td').hide();
                } else {
                    $('#page_footer #termina_no_td').show();
                    $('#page_footer #terminal_no').html('终端号：' + result.terminalNo);
                }
                //$('#machineType span').html(result.machineType);
                //$('#deploySite span').html(result.site);
                $('#page_footer #app_version').html('应用版本：' + result.termVersion);
                $('#page_footer #footer_local_ip').html('IP：' + result.ip[0]);
                $('#page_footer #footer_local_mac').html('MAC：' + result.mac[0]);
                $('#page_footer').show();

            } else {
                $('#page_footer').hide();
                utilShowToast("获取终端信息失败：" + ErrorCodeStringfy(ret.errorCode));
            }
        });
    }

    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');
            $('#guide_font_confirm_page').css('padding-top', adjustHeight + 'px');
            $('#guide_sogou_install_page').css('padding-top', adjustHeight + 'px');
            $('#guide_media_config_page').css('padding-top', adjustHeight + 'px');
            $('#guide_adapter_config_page').css('padding-top', adjustHeight + 'px');
            $('#guide_sync_centersetting_page').css('padding-top', adjustHeight + 'px');
            $('#guide_access_authorize_page').css('padding-top', adjustHeight + 'px');
            $('#guide_finish_page,#guide_reboot_page').css('padding-top', adjustHeight + 'px');
        },
        beginInstall: function() {
            this.gotoPage(DEPLOY.DeployStep_3rdParty_FontInstall, true);
        },
        getPage: function(step) {
            var select_page = '';
            switch(step) {
                case DEPLOY.DeployStep_Begin:
                    select_page = 'guide_start_page';
                    break;
                case DEPLOY.DeployStep_GetTerminalInfo :
                    select_page = 'guide_init_param_page';
                    break;
                case DEPLOY.DeployStep_FetchCenterSettings:
                    select_page = 'guide_sync_centersetting_page';
                break;
                case DEPLOY.DeployStep_AccessAuthorize :
                    select_page = 'guide_access_authorize_page';
                break;
                case DEPLOY.DeployStep_MediaConfig :
                    select_page = 'guide_media_config_page';
                break;
                case DEPLOY.DeployStep_AdapterConfig : 
                    select_page = 'guide_adapter_config_page';
                break;
                case DEPLOY.DeployStep_Finished  :
                    select_page = 'guide_finish_page';
                break
                case DEPLOY.DeployStep_3rdParty_SogouInstall:
                    select_page = 'guide_sogou_install_page';
                break; 
                case DEPLOY.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: async function(step, firstRun) {
            this.hideAllPage();
            switch(step) {
                case DEPLOY.DeployStep_MediaConfig:
                    FulfillMediaDeviceList();
                    break;
                case DEPLOY.DeployStep_AdapterConfig:
                    adapterTestFailedCount = 0;
                    InitCurrentVendorSelect();
                    break;
                case DEPLOY.DeployStep_FetchCenterSettings:
                    InitCenterSettingInputParam();
                    break;
                case DEPLOY.DeployStep_AccessAuthorize:
                    //因为无集中配置的原因，导致不能及时走灰度去分行化，所以这里要重启初始化实体
                    if(!firstRun) {
                        StartBasicHardwareEntity("Initializer", function(){
                            utilShowToast("初始化模块成功！", 2000);
                        },function(){
                            utilStartAlertDialog("初始化下一步模块失败，需重启应用尝试，点击确认将重启应用（进度仍保存）", function(){
                                RVC.HealthmanagerEntityCtrl.RestartApp(true);
                                RVC.GuideController.hideAllPage();
                                RVC.GuideController.hideAllRebootTipElem();
                                $('#guide_restart_loading').show();
                                $('#guide_reboot_page').show(); 
                            }, "重启应用");
                        });
                        await SleepMs(2000);
                    }
                    break;
                case DEPLOY.DeployStep_3rdParty_SogouInstall:
                    DisplaySogouInstallState();
                    break;
                case DEPLOY.DeployStep_3rdParty_FontInstall:
                    DisplayFontInstallState();
                    break;
                default:
                    break;
            }
        },
        postLoadPage: function(step, firstRun) {
            switch(step) {
                case DEPLOY.DeployStep_Finished:
                    globalFinishedFlag = true;
                    break;
                case DEPLOY.DeployStep_GetTerminalInfo:
                    InitTerminalRegistInfoUrl();
                    break;
                case DEPLOY.DeployStep_AdapterConfig:
                    InterestRootSwitch(true);
                    $(document).off('keyup change', '#guide_adapter_config_baudrate_input,#guide_adapter_config_port_input');
                    $(document).on('keyup change', '#guide_adapter_config_baudrate_input,#guide_adapter_config_port_input', function () {
                        setSaveBtnStatus(true);
                    });
                    apdaterTestAllBefore = 0;
                    break;
                case DEPLOY.DeployStep_AccessAuthorize:
                    InitAccessAuthParam();
                    break;
                default:
                    break;
            }
        },
        gotoPage: function(nextStep, firstRun) {
            var select_page = this.getPage(nextStep);
    
            if(select_page !== '') {
                this.preLoadPage(nextStep, firstRun);
                $('#' + select_page).show();
                this.postLoadPage(nextStep, firstRun);
            } else {
                utilShowToast('不支持步骤！无法识别：' + nextStep, 5000);
            }
        },
        sectOverPass: function() {
    
        },
        sectNext: function() {
    
        },
        setNavigaBtnAble: function(enable) {
    
        }
    });

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

        if(!isButtonEnable('ip_connect_check')) {
            return;
        }

        var ip = $('#guide_server_ip').val();
        console.log('ip: ' + ip);
        if(swtichStateIsOn('guide_server_type_switch')) {
            UrlConnectableTest(ip,'text_guide_init_param_ip_tips', 'ip_connect_check')
        } else {
            IPConnectableTest(ip);
        }


    });

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

        if(!isButtonEnable('guide_sync_centersetting_server_ip_test')) {
            return;
        }

        var url = $('#guide_sync_centersetting_server_ip_content').val();
        console.log('url: ' + url);
        UrlConnectableTest(url, 'text_guide_sync_centersetting_ip_tips', 'guide_sync_centersetting_server_ip_test');
    });

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

        const debranchOn = swtichStateIsOn('guide_server_type_switch');
        const ip = $('#guide_server_ip').val();
        if(!debranchOn && !isValidIpAddress(ip)) {
            utilStartAlertDialog("无效 IP 格式");
            return;
        } else if(debranchOn && !checkUrl(ip)) {
            utilStartAlertDialog("无效 URL 格式");
            return;
        }

        const terminalType = $('#gui_init_param_machine_type').attr('value');
        if(terminalType === '' || terminalType === 'None') {
            utilStartAlertDialog("请选择所属终端机型");
            return;
        }
        const vendorType = $('#gui_init_param_vendor').attr('value');
        if(vendorType === '' || vendorType === 'None') {
            utilStartAlertDialog("请选择设备厂商");
            return;
        }
        const deviceModel = $('#gui_init_param_device_model').attr('value');
        if(deviceModel === '' || deviceModel === 'None') {
            utilStartAlertDialog("请选择设备型号");
            return;
        }

        var tmp = $('#guide_init_param_device_sn').val();
        const deviceSN = tmp.replace(/^\s*|\s*$/g,"");
        if(deviceSN === '') {
            utilStartAlertDialog("请输入设备序列号");
            return;
        }

        const terminalno = $('#guide_init_param_terminalno').val();
        if(!IsDigital(terminalno)) {
            utilStartAlertDialog("无效终端号格式");
            return;
        }

        utilStartConfirmDialog("<span>基本信息录入后将不可更改，如需重新配置可通过点击页面右上角菜单</span><span><img src=\"./images/clear.png\" style=\"width:20px;height:20px;padding: 0px 2px;\"></span><span>进行重置，请确认是否提交？</span>", function() {
            InitTemrinalAbout(ip, terminalno, terminalType, vendorType, deviceModel, deviceSN, debranchOn);
        });
    });

    $(document).on('click', '#gui_adapter_config_adapter_check_btn', 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_test', function() {
        TestAllAdapterAvailableOrNot();
    });
    

    $(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() {
        
        var tips = '';
        if(apdaterTestAllBefore === 0) {
            tips = '还未进行过【配置有效性检测】，请确认是否要跳过？（首次安装强烈建议至少执行一次配置有效性检测）';
        } else if(apdaterTestAllBefore === 1) {
            tips = '之前检测存在模块未通过验证，请确认是否要跳过？（强烈建议所有模块检测通过后再进入下一步）';
        }

        if(tips !== '') {
            utilStartConfirmDialog(tips, function() {
                FinshedDevAdapterConfig();
            });
        } else {
            FinshedDevAdapterConfig();
        }
    });

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

        const ip = $('#guide_sync_centersetting_server_ip_content').val();
        
        if(!globalServerUsingHeadOffice && !isValidIpAddress(ip)) {
            utilStartAlertDialog("无效IP格式");
            return;
        } else if(globalServerUsingHeadOffice && !checkUrl(ip)) {
            utilStartAlertDialog("无效URL格式");
            return;
        }

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

    $(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(DEPLOY.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(DEPLOY.DeployStep_3rdParty_SogouInstall);
    });
    
    $(document).on('click', '#guide_finish_restart_btn', function() {
        FinshedDeploy();
    });

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


    $('#header_right #quitpage_btn_div').bind('click', function() {
        if(!globalFinishedFlag) {
            utilStartConfirmDialog("配置还未完成，确定要退出当前配置吗？(应用也将退出)", function() {
                AbortDeployConfig();                   
            });
        } else {
            AbortDeployConfig(true);
        }
    });

    $('#header_right #rebootapp_btn_div').bind('click', function() {
        if(!globalFinishedFlag) {
            utilStartConfirmDialog("配置还未完成，确定要重启应用吗？", function() {
                RVC.HealthmanagerEntityCtrl.RestartApp(true);
                RVC.GuideController.hideAllPage();
                RVC.GuideController.hideAllRebootTipElem();
                $('#guide_restart_loading').show();
                $('#guide_reboot_page').show();       
            });
        } else {
            RVC.HealthmanagerEntityCtrl.RestartApp(true);
            RVC.GuideController.hideAllPage();
            RVC.GuideController.hideAllRebootTipElem();
            $('#guide_restart_loading').show();
            $('#guide_reboot_page').show();
        }
    });

    $('#header_right #restartpc_btn_div').bind('click', function() {
        if(!globalFinishedFlag) {
            utilStartConfirmDialog("配置还未完成，确定要重启设备吗？", function() {
                RVC.HealthmanagerEntityCtrl.RestartPC(true);
                RVC.GuideController.hideAllPage();
                RVC.GuideController.hideAllRebootTipElem();
                $('#guide_reboot_loading').show();
                $('#guide_reboot_page').show();       
            });
        } else {
            RVC.HealthmanagerEntityCtrl.RestartPC(true);
            RVC.GuideController.hideAllPage();
            RVC.GuideController.hideAllRebootTipElem();
            $('#guide_reboot_loading').show();
            $('#guide_reboot_page').show();
        }
    });

    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 #header_help_info_div').bind('click', function() {
            //reloadThisPage();
            //RVC.HealthmanagerEntityCtrl.OpenLocalMaintainPage();
            utilStartAlertDialog('功能暂未实现！');
        });


        //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(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, true);
                });
            }
        } else {
            /**
                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
             * 
             */
            RVC.GuideController.gotoPage(DEPLOY.DeployStep_Begin, true);
        }

        FulfillTerminalBasicInfo();
    }

    setTimeout(RVC.GuideController.resizeWindow, 200);

});