code_production/app/HGProductionTool/form_burnmode.cpp

#include "form_burnmode.h"
#include "ui_form_burnmode.h"
#include "dialog_setburnsn.h"
#include "hgscanner.h"
#include "mainwindow.h"
#include "analysisjson.h"
#include "base/HGBase.h"
#include "HGUIGlobal.h"
#include "dialog_excepdesc.h"
#include <QMessageBox>
#include <QLineEdit>
#include <QInputDialog>

Form_BurnMode::Form_BurnMode(class MainWindow *mainwnd, const QString &profileName, const QString &accountName, QWidget *parent) :
    QWidget(parent),
    m_curIndex(0),
    m_profileName(profileName),
    m_accountName(accountName),
    m_mainwnd(mainwnd),
    m_hg(nullptr),
    ui(new Ui::Form_BurnMode)
{
    ui->setupUi(this);

    ui->textEdit_target->setReadOnly(true);
    ui->textEdit_curConfig->setReadOnly(true);

    ui->pbtn_enterBurnMode->setEnabled(true);
    ui->pbtn_confirmFinishBurn->setEnabled(false);
    ui->pbtn_checkConfig->setEnabled(false);
    ui->pbtn_complete->setEnabled(false);
    ui->pbtn_abnormal->setEnabled(false);

    connect(this, SIGNAL(testResult(bool)), this, SLOT(on_testResult(bool)), Qt::QueuedConnection);

    initTableWidget();
}

Form_BurnMode::~Form_BurnMode()
{
    delete ui;
}

void Form_BurnMode::addDevice(DeviceManager *devManager)
{
    ui->tableWidget->setRowCount(m_curIndex + 1);
    ui->tableWidget->setItem(m_curIndex, 0, new QTableWidgetItem(QString::number(m_curIndex + 1)));
    ui->tableWidget->item(m_curIndex, 0)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

    QTableWidgetItem *check = new QTableWidgetItem();
    check->setCheckState(Qt::Unchecked);
    ui->tableWidget->setItem(m_curIndex, 1, check);
    ui->tableWidget->item(m_curIndex, 1)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
    ui->tableWidget->setItem(m_curIndex, 2, new QTableWidgetItem(devManager->getDevName()));
    ui->tableWidget->item(m_curIndex, 2)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

    QTableWidgetItem *item = ui->tableWidget->item(m_curIndex, 1);
    QVariant var = QVariant::fromValue((void*)devManager);
    item->setData(Qt::UserRole, var);

    updatetablewidget();
    updateTargetCfg();
    updateCurDeviceCfg();

    m_curIndex++;
}

void Form_BurnMode::deleteDevice(QString devName)
{
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        QTableWidgetItem *item2 = ui->tableWidget->item(i, 2);
        if (devName!= nullptr && item != nullptr)
        {
            if (devName == item2->text())
            {
                DeviceManager *devManager = (DeviceManager*)item->data(Qt::UserRole).value<void*>();
                delete devManager;

                ui->tableWidget->removeRow(i);
                m_curIndex--;
                break;
            }
        }
    }
    updatetablewidget();
    updateTargetCfg();
    updateCurDeviceCfg();
}

DeviceManager *Form_BurnMode::getDevManager()
{
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            DeviceManager *devManager = (DeviceManager*)item->data(Qt::UserRole).value<void*>();
            return devManager;
        }
    }

    return nullptr;
}

void Form_BurnMode::on_testResult(bool setStatus)
{
    //m_mainwnd->releaseTesting();
}

void Form_BurnMode::initTableWidget()
{
    ui->tableWidget->resizeRowsToContents();
    ui->tableWidget->setColumnCount(3);
    ui->tableWidget->horizontalHeader()->setDefaultSectionSize(200);
//    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);

    QStringList header;
    header<< tr("ID") << tr("selected") << tr("device");
    ui->tableWidget->setHorizontalHeaderLabels(header);

    QFont font = ui->tableWidget->horizontalHeader()->font();
    font.setBold(true);
    ui->tableWidget->horizontalHeader()->setFont(font);

    ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
    ui->tableWidget->verticalHeader()->setDefaultSectionSize(10);
    ui->tableWidget->setFrameShape(QFrame::NoFrame);
    ui->tableWidget->setShowGrid(true);
    ui->tableWidget->verticalHeader()->setVisible(false);
//    ui->tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget->horizontalHeader()->setFixedHeight(30);
    ui->tableWidget->clearContents();
}

void Form_BurnMode:: updatetablewidget()
{
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
          ui->tableWidget->setItem(i, 0, new QTableWidgetItem(QString::number(i + 1)));
    }

    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr)
            item->setCheckState(Qt::Checked);
    }
    //ui->cbox_selectAll->setChecked(true);
}

void Form_BurnMode::updateTargetCfg()
{
    ui->textEdit_target->clear();

    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();

    int speedMode = jsonGlobal.speed_mode;
    int sleepTime = jsonGlobal.sleep_time;
    int vid_to = jsonGlobal.vid_to;
    int pid_to = jsonGlobal.pid_to;

    char buf[10];
    sprintf(buf, "%x", vid_to);

    char buf2[10];
    sprintf(buf2, "%x", pid_to);

    QString content;
    content += tr("Target Configration:\n\t");
    content += tr("Speep mode: %1PPM\n\t").arg(QString::number(speedMode));
    content.append(sleepTime > 0 ? tr("Sleep time: %1minute\n\t").arg(QString::number(sleepTime)) : tr("Sleep time: Not sleeping\n\t"));
    content += tr("Vid: %1  Pid: %2\n\t").arg(QString::fromStdString(buf)).arg(QString::fromStdString(buf2));

    ui->textEdit_target->setText(content);
}

void Form_BurnMode::updateCurDeviceCfg()
{
    ui->textEdit_curConfig->clear();

    DeviceManager *devManager = getDevManager();
    if (devManager == nullptr)
        return;

    int speedMode = devManager->getSpeedMode();
    int sleepTime = devManager->getSleepTime();
    int vid_to = devManager->getDevVid();
    int pid_to = devManager->getDevPid();

    char buf[10];
    sprintf(buf, "%x", vid_to);

    char buf2[10];
    sprintf(buf2, "%x", pid_to);

    QString content;
    content.append(tr("Current Configration of device:") + "\n\t");
    content.append(tr("Speep mode: %1PPM").arg(QString::number(speedMode)) + "\n\t");
    content.append(sleepTime > 0 ? tr("Sleep time: %1minute").arg(QString::number(sleepTime)) : tr("Sleep time: Not sleeping") + "\n\t");
    content.append(tr("Vid: %1  Pid: %2").arg(QString::fromStdString(buf)).arg(QString::fromStdString(buf2)) + "\n\t");

    ui->textEdit_curConfig->setText(content);
}

QString Form_BurnMode::getLogPath()
{
    HGChar cachePath[512];
    HGBase_GetDocumentsPath(cachePath, 512);
    HGChar procName[512];
    HGBase_GetProcessName(procName, 512);
    strcat(cachePath, procName);
    strcat(cachePath, "/Test_Log/");

    return getStdFileName(cachePath);
}

void Form_BurnMode::writeTestLog(QString logContent)
{
    QString logPath = getLogPath();
    HGBase_CreateDir(getStdString(logPath).c_str());

    DeviceManager *devManager = getDevManager();
    QString serialNum = devManager->getSerialNum();
    QString fileName = logPath + serialNum + ".log";
    QFile file(fileName);
    if(!file.open(QIODevice::ReadWrite | QIODevice::Append))
    {
        return;
    }

    QDateTime dateTime= QDateTime::currentDateTime();
    QString curTime = dateTime .toString("yyyy-MM-dd hh:mm:ss");
    QString content = "[" + curTime + "]  ";
    content += logContent;

    QTextStream txtOutput(&file);
    txtOutput << content << endl;
    file.close();
}

//void Form_BurnMode::on_cbox_selectAll_stateChanged(int arg1)
//{
//    (void)arg1;
//    bool check = ui->cbox_selectAll->isChecked();

//    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
//    {
//        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
//        if (item != nullptr)
//        {
//            if (check)
//                item->setCheckState(Qt::Checked);
//            else
//                item->setCheckState(Qt::Unchecked);
//        }
//    }
//}

void Form_BurnMode::on_pbtn_enterBurnMode_clicked()
{
    int select = 0;
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            select++;
        }
    }
    if (select == 0)
    {
        QMessageBox::information(this, tr("tips"), tr("Please check a devices at least"));
        return;
    }

    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            DeviceManager *devManager = (DeviceManager*)item->data(Qt::UserRole).value<void*>();
            devManager->setBurnMode();

            ui->pbtn_confirmFinishBurn->setEnabled(true);
            ui->pbtn_checkConfig->setEnabled(false);
            ui->pbtn_complete->setEnabled(false);
            ui->pbtn_abnormal->setEnabled(true);

            m_mainwnd->setLogOutStatus(false);
        }
    }
}

DeviceManager::DeviceManager(class MainWindow *mainwnd, class Form_BurnMode *burnMode, SANE_Handle handle,
                             const QString &profileName, const QString & devName, const QString &serialNum)
{
    m_mainwnd = mainwnd;
    m_burnMode = burnMode;
    m_handle = handle;
    m_profileName = profileName;
    m_devName = devName;
    m_serialNum = serialNum;

    m_hg = new hgscanner(nullptr, m_burnMode, nullptr, m_handle);
}

DeviceManager::~DeviceManager()
{
    delete m_hg;
    m_hg = nullptr;

    sane_close(m_handle);
}

QString DeviceManager::getDevName()
{
    return m_devName;
}

QString DeviceManager::getSerialNum()
{
    return m_serialNum;
}

void DeviceManager::setBurnMode()
{
    const wchar_t *p = L"1";
//    m_mainwnd->addTestingRef();
    func_test_go(HGPDTTOOLDB_NAME_REBOOT_DEVICE, p, m_hg);

}

void DeviceManager::setSpeedMode()
{
    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();
    LPWRITECFG lp = new WRITECFG;

    int speedMode = jsonGlobal.speed_mode;
    lp->cat = WRITE_CAT_SPEED;
    lp->val = (void*)&speedMode;
    func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

    delete lp;
}

void DeviceManager::setSleepTime()
{
    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();
    LPWRITECFG lp = new WRITECFG;

    int sleepTime = jsonGlobal.sleep_time;
    lp->cat = WRITE_CAT_SLEEP;
    lp->val = (void*)&sleepTime;
    func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

    delete lp;
}

void DeviceManager::setVidPid()
{
    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();
    LPWRITECFG lp = new WRITECFG;

    VIDPID vidpid;
    vidpid.VID = jsonGlobal.vid_to;
    vidpid.PID = jsonGlobal.pid_to;
    int vidpidValue = vidpid.Value;
    lp->cat = WRITE_CAT_VID_PID;
    lp->val = (void*)&vidpidValue;
    func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

    delete lp;
}

void DeviceManager::rebootDevice()
{
    const wchar_t *p = L"0";
    func_test_go(HGPDTTOOLDB_NAME_REBOOT_DEVICE, p, m_hg);
}

QString DeviceManager::getDevType()
{
    std::string firmWareNum;
    unsigned int firmWareNumLen = 0;
    if(SANE_STATUS_NO_MEM == sane_io_control(m_handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, nullptr, &firmWareNumLen) && firmWareNumLen)
    {
        firmWareNum.resize(firmWareNumLen);
        sane_io_control(m_handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, &firmWareNum[0], &firmWareNumLen);
    }

    QString str =  QString::fromStdString(firmWareNum.c_str());
    return str.left(2) + "00";
}

int DeviceManager::getSpeedMode()
{
    SANE_Int speedMode = 0;
    unsigned int len = sizeof(SANE_Int);
    sane_io_control(m_handle, IO_CTRL_CODE_GET_SPEED_MODE, &speedMode, &len);

    const wchar_t G100[6] = { 70,80,90,110 };
    const wchar_t G200[6] = { 100,110,120,130 };
    const wchar_t G300[6] = { 40,50,60,70 };
    const wchar_t G400[6] = { 40,50,60,70,80 };

    QString devType = getDevType();
    int speed = 0;

    if ((int)speedMode >= 40)
        speed = (int)speedMode;
    else
    {
        if (devType == "G100")
            speed = G100[(int)speedMode - 1];
        else if (devType == "G200")
            speed = G200[(int)speedMode - 1];
        else if (devType == "G300")
            speed = G300[(int)speedMode - 1];
        else if (devType == "G400")
            speed = G400[(int)speedMode - 1];
    }

    return speed;
}

int DeviceManager::getSleepTime()
{
    int sleepTime = SANE_POWER_FIRST;
    unsigned int len2 = sizeof(int);
    sane_io_control(m_handle, IO_CTRL_CODE_GET_POWER_LEVEL, &sleepTime, &len2);

    if (sleepTime > 99999 || sleepTime == -1)
        return 0;

    return (sleepTime / 60);
}

int DeviceManager::getDevVid()
{
    VIDPID vidpid;
    int vidpid_val;
    unsigned int len = sizeof(int);
    sane_io_control(m_handle, IO_CTRL_CODE_GET_VIDPID, &vidpid_val, &len);
    vidpid.Value = vidpid_val;
    int vid = vidpid.VID;
    return vid;
}

int DeviceManager::getDevPid()
{
    VIDPID vidpid;
    int vidpid_val;
    unsigned int len = sizeof(int);
    sane_io_control(m_handle, IO_CTRL_CODE_GET_VIDPID, &vidpid_val, &len);
    vidpid.Value = vidpid_val;
    int pid = vidpid.PID;
    return pid;
}

void Form_BurnMode::on_tableWidget_itemDoubleClicked(QTableWidgetItem *item)
{
    int row = item->row();
    QTableWidgetItem *item2 = ui->tableWidget->item(row, 1);
    if (item2->checkState() == Qt::Checked)
    {
        item2->setCheckState(Qt::Unchecked);
    }
    else
    {
        item2->setCheckState(Qt::Checked);
    }
}

//void Form_BurnMode::on_pbtn_close_clicked()
//{
//    int select = 0;
//    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
//    {
//        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
//        if (item != nullptr && Qt::Checked == item->checkState())
//        {
//            select++;
//        }
//    }
//    if (select == 0)
//    {
//        QMessageBox::information(this, tr("tips"), tr("Please check a devices at least"));
//        return;
//    }

//    int rowCount = ui->tableWidget->rowCount();
//    for (int i = rowCount - 1; i >= 0; --i)
//    {
//        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
//        if (item != nullptr && Qt::Checked == item->checkState())
//        {
//            DeviceManager *devManager = (DeviceManager*)item->data(Qt::UserRole).value<void*>();
//            delete devManager;

//            ui->tableWidget->removeRow(i);
//            m_curIndex--;
//        }
//    }

//    updatetablewidget();
//}

void Form_BurnMode::on_pbtn_confirmFinishBurn_clicked()
{
    int select = 0;
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            select++;
        }
    }
    if (select == 0)
    {
        QMessageBox::information(this, tr("tips"), tr("Please check a devices at least"));
        return;
    }

    DeviceManager *devManager = getDevManager();
    if (devManager == nullptr)
        return;

    devManager->setSpeedMode();
    devManager->setSleepTime();
    devManager->setVidPid();
    devManager->rebootDevice();

    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();
    int speedMode_to = jsonGlobal.speed_mode;
    int sleepTime_to = jsonGlobal.sleep_time;
    int vid_to = jsonGlobal.vid_to;
    int pid_to = jsonGlobal.pid_to;

    char buf[10];
    sprintf(buf, "%x", vid_to);

    char buf2[10];
    sprintf(buf2, "%x", pid_to);

    QString content;
    content.append(tr("Complete burning and configure device parameters: "));
    content.append(tr("Speep mode: %1PPM").arg(QString::number(speedMode_to)) + "  ");
    content.append(sleepTime_to > 0 ? tr("Sleep time: %1minute").arg(QString::number(sleepTime_to)) : tr("Sleep time: Not sleeping") + "  ");
    content.append(tr("Vid: %1  Pid: %2").arg(QString::fromStdString(buf)).arg(QString::fromStdString(buf2)) + "  ");
    writeTestLog(tr("Tester: %1,  Test item: Burn,  Test contents: %2").arg(m_accountName).arg(content));

    ui->pbtn_checkConfig->setEnabled(true);
}

void Form_BurnMode::on_pbtn_checkConfig_clicked()
{
    int select = 0;
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            select++;
        }
    }
    if (select == 0)
    {
        QMessageBox::information(this, tr("tips"), tr("Please check a devices at least"));
        return;
    }

    AnalysisJson analysisJson(m_profileName);
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();

    int speedMode_to = jsonGlobal.speed_mode;
    int sleepTime_to = jsonGlobal.sleep_time;
    int vid_to = jsonGlobal.vid_to;
    int pid_to = jsonGlobal.pid_to;

    DeviceManager *devManager = getDevManager();
    if (devManager == nullptr)
        return;

    int speedMode = devManager->getSpeedMode();
    int sleepTime = devManager->getSleepTime();
    int vid = devManager->getDevVid();
    int pid = devManager->getDevPid();

    QString item;
    bool right = true;
    LPWRITECFG lp = new WRITECFG;
    if (speedMode_to != speedMode)
    {
        item.append(tr("Speed mode"));
        item.append(" ");
        right = false;
        devManager->setSpeedMode();
    }

    if (sleepTime_to != sleepTime)
    {
        item.append(tr("Sleep time"));
        item.append(" ");
        right = false;
        devManager->setSleepTime();
    }

    if (vid != vid_to || pid != pid_to)
    {
        item.append(tr("Vid and Pid"));
        item.append(" ");
        right = false;
        devManager->setVidPid();
    }

    if (!right)
    {
        QMessageBox::information(this, tr("Prompt"), tr("Inconsistent configuration %1detected, reconfigured, please check again").arg(item));
    }
    else
    {
        QMessageBox::information(this, tr("Prompt"), tr("Consistent configuration"));

        ui->pbtn_complete->setEnabled(true);
    }

    delete lp;

    updateTargetCfg();
    updateCurDeviceCfg();
}

void Form_BurnMode::on_pbtn_complete_clicked()
{
    writeTestLog(tr("Tester: %1,  Test item: Burn,  Test completed").arg(m_accountName));
    ui->pbtn_enterBurnMode->setEnabled(true);
    ui->pbtn_confirmFinishBurn->setEnabled(false);
    ui->pbtn_checkConfig->setEnabled(false);
    ui->pbtn_complete->setEnabled(false);

    m_mainwnd->setLogOutStatus(true);
}

void Form_BurnMode::on_pbtn_abnormal_clicked()
{
    int select = 0;
    for(int i = 0; i < ui->tableWidget->rowCount(); i++)
    {
        QTableWidgetItem *item = ui->tableWidget->item(i, 1);
        if (item != nullptr && Qt::Checked == item->checkState())
        {
            select++;
        }
    }
    if (select == 0)
    {
        QMessageBox::information(this, tr("tips"), tr("Please check a devices at least"));
        return;
    }

    Dialog_ExcepDesc dlg(this);
    if (dlg.exec())
    {
        QString str = dlg.getExcepDesc();
        writeTestLog(tr("Tester: %1,  Test item: Burn,  Test result: Failed!  Reason: %2")
                         .arg(m_accountName).arg(str));
    }

    m_mainwnd->setLogOutStatus(true);
}