modularization/src/tool/IVSysMan/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <iostream>

extern std::string gstrxmlpath;



extern iv::Ivlog  * ivlog;

static bool gbupdate =  false;
static std::string gstrivsyspath;

static iv::Switch::settingsCmd  gsettingcmd;
static bool gbupdatesetting = false;
QMutex gMutexSetting;

bool gbOneThreadRunning = true;
bool gbOneThreadRun = true;


void ListenChange(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    char strxmlpath[256];
    if(nSize > 255)return;
    memcpy(strxmlpath,strdata,nSize);
    strxmlpath[nSize] = 0;
    gstrivsyspath = strxmlpath;
    gbupdate = true;

}

void ListenSysSwitch(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    iv::Switch::settingsCmd x;
    if(!x.ParseFromArray(strdata,nSize))
    {
        std::cout<<"ListenSysSwitch Parse error."<<std::endl;
        return;
    }
    gMutexSetting.lock();
    gsettingcmd.CopyFrom(x);
    gbupdatesetting = true;
    gMutexSetting.unlock();
    (void)&index;
    (void)dt;
    (void)strmemname;

}


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    //从配置文件中读取当前系统包含的所有模块信息-tjc
    mPM = new ProgMon(gstrxmlpath.data());

    connect(mPM,SIGNAL(SigProcStarted(ProgUnit*)),this,SLOT(onProcessStarted(ProgUnit*)));
    connect(mPM,SIGNAL(SigProcStoped(ProgUnit*)),this,SLOT(onProcessEnd(ProgUnit*)));

    setGeometry(0,0,800,600);

    QTabWidget * p = new QTabWidget(ui->centralWidget);
    p->setGeometry(30,30,800,600);

    mTabMain = p;

    CenterView * pcv = new CenterView(p,mPM);
    mpCV = pcv;

    connect(pcv,SIGNAL(ProgClick(ProgUnit*,ProgramViewUnit * ,bool)),this,SLOT(onProgClick(ProgUnit*,ProgramViewUnit * ,bool)));

//    QString path = getenv("HOME");
//    path = path + "/qt/bq/deploy/app/IVSysMan.xml";
    mpSysMan = new SysMan(gstrxmlpath);

    QTimer * timer = new QTimer(this);
    connect(timer,SIGNAL(timeout()),this,SLOT(onTimerState()));
    timer->start(1000);

    QTimer * timer2 = new QTimer(this);
    connect(timer2,SIGNAL(timeout()),this,SLOT(onTimerTestChangeXML()));
//    timer2->start(5000);

    setWindowTitle("IV System Manage");

    int i;
    int nsize = mPM->mvectorprog.size();
    for(i=0;i<nsize;i++)
    {
        ProgUnit * pu = &(mPM->mvectorprog.at(i));
        if(pu->mbautostart)
        {
            mPM->StartProc(pu);
        }
    }

    mPM->start();

    //-----add by tjc
    connect(mPM,SIGNAL(checkExit(ProgUnit * )),mPM,SLOT(onCheckExit(ProgUnit * )));

    //初始化资源调度对象
//    stateCondition = new StateCondition(mPM);

    //测试
//    QTimer *testti = new QTimer(this);
//    connect(testti,SIGNAL(timeout()),mPM,SLOT(StopProcTest()));
//    testti->start(1000 * 30);

    mpivexit = iv::ivexit::RegIVExitCmd();

    mpa = iv::modulecomm::RegisterRecv("ivsyschange",ListenChange);
    mpaswitch = iv::modulecomm::RegisterRecv("sys_switch",ListenSysSwitch);
    QTimer * timerchange = new QTimer(this);
    connect(timerchange,SIGNAL(timeout()),this,SLOT(onTimerChangeXML()));
    timerchange->start(100);

    QTimer * timerswitch = new QTimer(this);
    connect(timerswitch,SIGNAL(timeout()),this,SLOT(onTimerSysSwitch()));
    timerswitch->start(50);
}

MainWindow::~MainWindow()
{

    int i;
    for(i=0;i<mPM->mvectorprog.size();i++)
    {
        mPM->mvectorprog[i].mbautostart = false;
    }
    for(i=0;i<mPM->mvectorprog.size();i++)
    {
        if(mPM->mvectorprog[i].mbRun)
        {
            char strexitcode[255];
            snprintf(strexitcode,255,"adcivexit-%d",mPM->mvectorprog[i].mpid);
            qDebug("pid is %d",mPM->mvectorprog[i].mpid);
            iv::ivexit::ExecIVExitCmd(mpivexit,strexitcode);
            QThread::msleep(5);
        }
    }

    iv::ivexit::ExecIVExitCmd(mpivexit,"adcivexit-test");   // test iv exit code. can comment this line.
    
    mPM->requestInterruption();
    qint64 time;
    time = QDateTime::currentMSecsSinceEpoch();
    mPM->requestInterruption();
    gbOneThreadRun = false;
    while((QDateTime::currentMSecsSinceEpoch() - time)<1500)
    {
        if((mPM->isFinished())&&(gbOneThreadRunning == false))
        {
            qDebug("finish");
            break;
        }
    }


    delete mPM;
    delete mpSysMan;
    delete ui;
//    delete configMan;
//    delete stateCondition;
}

void MainWindow::resizeEvent(QResizeEvent *event)
{
    qDebug("resize");
    QSize sizemain = ui->centralWidget->size();
    qDebug("size x = %d y=%d",sizemain.width(),sizemain.height());

    AdjustWPos(sizemain);

}

void MainWindow::AdjustWPos(QSize sizemain)
{
//    myview->setGeometry(0,30,sizemain.width()-350,sizemain.height());
    mTabMain->setGeometry(0,0,sizemain.width(),sizemain.height());
 //   mgplidar->setGeometry(sizemain.width()-280,30,260,200);
}


//modify tjc
void MainWindow::onProgClick(ProgUnit *pu,ProgramViewUnit * pvu, bool bClick)
{
    qDebug(" %s click is  data is %d",pu->strappname.data(),bClick);

    pu->mbautostart = false; //if click,not need auto start.
    if(bClick == true)
    {
        mPM->StartProc(pu);
//        mPM->restartProc(pu);
//        mPM->restartProc(pu);
//        mPM->restartProc(pu);

    }
    else
    {
        mPM->StopProc(pu);

    }
}

void MainWindow::onProcessStarted(ProgUnit *pu)
{
    mpCV->ProcStarted(pu);
}

void MainWindow::onProcessEnd(ProgUnit *pu)
{

    mpCV->ProcStopted(pu);
}

void MainWindow::onTimerState()
{
    mpCV->UpdateState();
}

void MainWindow::onTimerTestChangeXML()
{
    std::string strpath;
    if(mnTestIndex == 0)
    {
        strpath = "./IVSysMan1.xml";
        mnTestIndex = 1;
    }
    else
    {
        strpath = "./IVSysMan.xml";
        mnTestIndex = 0;
    }

    ChangeXML(strpath);
}

void MainWindow::onTimerChangeXML()
{
    if(gbupdate == false)return;

    gbupdate = false;
    ChangeXML(gstrivsyspath);
}

void MainWindow::ChangeXML(std::string strxmlpath)
{
    mPM->updatexml(strxmlpath);
    mpCV->ResetView();

//    delete mpCV;
//    mpCV = new CenterView(mTabMain,mPM);
//    connect(mpCV,SIGNAL(ProgClick(ProgUnit*,ProgramViewUnit * ,bool)),this,SLOT(onProgClick(ProgUnit*,ProgramViewUnit * ,bool)));

//    QGroupBox * pGroup = new QGroupBox();
//    pGroup->setGeometry(0,0,1800,5000);

//    QScrollArea * pScroll = new QScrollArea();
//    pScroll->setWidget(pGroup);

//    mpCV->mTabMain->addTab(pScroll,"hello");

//    QLabel * pLabel = new QLabel(mpCV->mvectorGropup[0]->mpGroup);
//    pLabel->setText("hihi");
//    pLabel->setGeometry(30,30,100,30);
}

void MainWindow::ProcdataAnalysisCmd(const iv::Switch::dataAnalysisCmd *pdataAnalysisCmd)
{
    if(pdataAnalysisCmd->mwrdataanalysismodule())
    {
        mPM->StartProc("driver_can_nvidia_agx");
    }
    else
    {
        mPM->StopProc("driver_can_nvidia_agx");
    }
    if(pdataAnalysisCmd->lidardataanalysismodule())
    {
        mPM->StartProc("driver_lidar_vlp32c");
        mPM->StartProc("driver_lidar_vlp16","-s vlp16_left.yaml -n driver_lidar_vlp32_l");
        mPM->StartProc("driver_lidar_vlp16","-s vlp16_right.yaml -n driver_lidar_vlp32_r");
    }
    else
    {
        mPM->StopProc("driver_lidar_vlp32c");
        mPM->StopProc("driver_lidar_vlp16","-s vlp16_left.yaml -n driver_lidar_vlp32_l");
        mPM->StopProc("driver_lidar_vlp16","-s vlp16_right.yaml -n driver_lidar_vlp32_r");
    }
    if(pdataAnalysisCmd->gpsimudataanalysismodule())
    {
        mPM->StartProc("detection_state_delphi_ins500d");
    }
    else
    {
        mPM->StartProc("detection_state_delphi_ins500d");
    }
}

void MainWindow::ProcperceptualFusion(const iv::Switch::perceptualFusion *pperceptualFusion)
{
    if(pperceptualFusion->spaceregistrationmodule())
    {
        mPM->StartProc("driver_lidar_merge");
    }
    else
    {
        mPM->StopProc("driver_lidar_merge");
    }
    if(pperceptualFusion->fusionpositioningmodule())
    {
        mPM->StartProc("detection_ndt_matching_gpu_multi");
    }
    else
    {
        mPM->StopProc("detection_ndt_matching_gpu_multi");
    }
    if(pperceptualFusion->lidarandmayconstructmodule())
    {
        mPM->StartProc("adcndtmultimapping");
    }
    else
    {
        mPM->StopProc("adcndtmultimapping");
    }
}

void MainWindow::onTimerSysSwitch()
{
    if(gbupdatesetting == false)return;
    iv::Switch::settingsCmd pswitch;

    gMutexSetting.lock();
    pswitch.CopyFrom(gsettingcmd);
    gbupdatesetting = false;
    gMutexSetting.unlock();

    iv::Switch::fucSetControlCmd xcmd = pswitch.fucsetcontrol();
    ProcdataAnalysisCmd(&xcmd.dataanalysis());
    ProcperceptualFusion(&xcmd.perceptualfusion());
}