710 lines
26 KiB
C++
710 lines
26 KiB
C++
#include "update.h"
|
|
#include "worker.h"
|
|
#include "utils.h"
|
|
#include "update_dc_event.h"
|
|
#include "mainwindow.h"
|
|
|
|
#include <QCoreApplication>
|
|
#include <QApplication>
|
|
#include <QFile>
|
|
#include <QTemporaryFile>
|
|
#include <QDebug>
|
|
#include <QTextStream>
|
|
#include <QRegularExpression>
|
|
#include <QRegExp>
|
|
#include <QApplication>
|
|
|
|
#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
|
|
#include "unistd.h"
|
|
#endif
|
|
|
|
#include "plugins/interfaces.h"
|
|
|
|
#include <QSharedMemory>
|
|
#include <QScopedPointer>
|
|
#include <QDir>
|
|
#include <QThread>
|
|
#include <QDateTime>
|
|
#include <QPluginLoader>
|
|
#include <QMap>
|
|
|
|
#define UPDATE_OPKG (1)
|
|
#define UPDATE_DC (0)
|
|
|
|
static const QMap<QString, int> baudrateMap = {
|
|
{"1200" , 0}, {"9600" , 1}, {"19200" , 2}, {"38400" , 3},
|
|
{"57600" , 4}, {"115200" , 5}
|
|
};
|
|
|
|
QPluginLoader Update::pluginLoader;
|
|
|
|
hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
|
|
hwinf *hw = nullptr;
|
|
if (plugInDir.exists()) {
|
|
QString pluginLibName(fname);
|
|
pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
|
|
QFileInfo info(pluginLibName);
|
|
if (info.exists()) {
|
|
pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
|
|
pluginLoader.setFileName(pluginLibName);
|
|
// static QPluginLoader pluginLoader(pluginLibName);
|
|
if (!pluginLoader.load()) {
|
|
qCritical() << "in directory" << plugInDir.absolutePath();
|
|
qCritical() << "cannot load plugin" << pluginLoader.fileName();
|
|
qCritical() << pluginLoader.errorString();
|
|
exit(-1);
|
|
}
|
|
|
|
qCritical() << "loadDCPlugin() plugin directory:" << plugInDir.absolutePath();
|
|
qCritical() << "loadDCPlugin() plugin file name:" << pluginLoader.fileName();
|
|
|
|
if (!pluginLoader.isLoaded()) {
|
|
qCritical() << pluginLoader.errorString();
|
|
exit(-2);
|
|
}
|
|
QObject *plugin = pluginLoader.instance();
|
|
if (!plugin) {
|
|
qCritical() << "cannot start instance";
|
|
exit(-3);
|
|
}
|
|
if (! (hw = qobject_cast<hwinf *>(plugin))) {
|
|
qCritical() << "cannot cast plugin" << plugin << "to hwinf";
|
|
exit(-4);
|
|
}
|
|
} else {
|
|
qCritical() << pluginLibName << "does not exist";
|
|
exit(-5);
|
|
}
|
|
} else {
|
|
qCritical() << "plugins directory" << plugInDir.absolutePath()
|
|
<< "does not exist";
|
|
exit(-6);
|
|
}
|
|
return hw;
|
|
}
|
|
|
|
bool Update::unloadDCPlugin() {
|
|
if (pluginLoader.unload()) {
|
|
qCritical() << "unloaded plugin" << pluginLoader.fileName();
|
|
// Note: will re-instantiate the library !
|
|
// QObject *rootObject = pluginLoader.instance();
|
|
// if (rootObject) {
|
|
// qCritical() << "reloaded plugin: root object again available";
|
|
// return false;
|
|
// }
|
|
// qCritical()unloaded plugin: root object gone";
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Update::Update(Worker *worker,
|
|
QString customerRepository,
|
|
QString customerNrStr,
|
|
QString branchName,
|
|
QString plugInDir,
|
|
QString pluginName,
|
|
QString workingDir,
|
|
bool dryRun,
|
|
QObject *parent,
|
|
char const *serialInterface,
|
|
char const *baudrate)
|
|
: QObject(parent)
|
|
, m_hw(loadDCPlugin(QDir(plugInDir), pluginName))
|
|
, m_worker(worker)
|
|
, m_serialInterface(serialInterface)
|
|
, m_baudrate(baudrate)
|
|
, m_customerRepository(customerRepository)
|
|
, m_customerNrStr(customerNrStr)
|
|
, m_branchName(branchName)
|
|
, m_pluginName(pluginName)
|
|
, m_workingDir(workingDir)
|
|
, m_dryRun(dryRun)
|
|
, m_sys_areDCdataValid(false) {
|
|
|
|
//int tries = 20;
|
|
//while ((m_sys_areDCdataValid = m_hw->sys_areDCdataValid()) == false) {
|
|
// must deliver 'true', only then are all data from hwapi valid
|
|
// if (--tries < 0) {
|
|
// qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED";
|
|
// break;
|
|
// }
|
|
// m_hw->dc_autoRequest(true);
|
|
// QThread::msleep(500);
|
|
//}
|
|
|
|
//qCritical() << "UPDATE: m_sys_areDCDataValid ..." << m_sys_areDCdataValid;
|
|
|
|
//qInfo() << "UPDATE: m_serialInterface ..." << m_serialInterface;
|
|
//qInfo() << "UPDATE: m_baudrate ..." << m_baudrate;
|
|
//qInfo() << "UPDATE: m_customerRepository ..." << m_customerRepository;
|
|
//qInfo() << "UPDATE: m_customerNr ..........." << m_customerNrStr;
|
|
//qInfo() << "UPDATE: m_branchName ..........." << m_branchName;
|
|
//qInfo() << "UPDATE: m_pluginName ..........." << m_pluginName;
|
|
//qInfo() << "UPDATE: m_workingDirectory ....." << m_workingDir;
|
|
}
|
|
|
|
Update::~Update() {
|
|
}
|
|
|
|
// br is a index into a table, used for historical reasons.
|
|
bool Update::openSerial(int br, QString baudrate, QString comPort) const {
|
|
qDebug() << "opening serial" << br << baudrate << comPort << "...";
|
|
if (m_hw->dc_openSerial(br, baudrate, comPort, 1) == true) { // 1 for connect
|
|
Utils::printInfoMsg(
|
|
QString("OPENING SERIAL %1").arg(br)
|
|
+ " " + baudrate + " " + comPort + "...OK");
|
|
|
|
// m_hw->dc_autoRequest(true);
|
|
m_hw->dc_autoRequest(false);
|
|
QThread::sleep(1);
|
|
|
|
Utils::printInfoMsg(QString("IS PORT OPEN %1").arg(m_hw->dc_isPortOpen()));
|
|
return true;
|
|
}
|
|
|
|
Utils::printCriticalErrorMsg(
|
|
QString("OPENING SERIAL %1").arg(br)
|
|
+ " " + baudrate + " " + comPort + "...FAILED");
|
|
return false;
|
|
}
|
|
|
|
void Update::closeSerial() const {
|
|
qInfo() << "CLOSED SERIAL" << m_baudrate << m_serialInterface;
|
|
m_hw->dc_closeSerial();
|
|
}
|
|
|
|
bool Update::isSerialOpen() const {
|
|
return m_hw->dc_isPortOpen();
|
|
}
|
|
|
|
/*
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// USING THE DC BOOTLOADER
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
1 : bl_reboot() // send to application, want DC2 to reset (in order to
|
|
// start the bootloader)
|
|
//
|
|
// NOTE: this function is NOT reliable !!! Sometimes it
|
|
// simply does not work, in which case bl_startBL,
|
|
// bl_checkBL and bl_isUp do not work as well.
|
|
// Alas, there is no feedback if bl_reboot worked!
|
|
//
|
|
// NOTE: this function can be called only once per
|
|
// minute, because once called again, the controller
|
|
// performs some self-checks consuming some time.
|
|
//
|
|
// NOTE: after a successful bl_reboot(), the device is
|
|
// waiting about 4 seconds in the bootloader. To stay in
|
|
// the bootloader, we have to send the command
|
|
// bl_startBL(), which is kind of a misnomer, as it
|
|
// should be bl_doNotLeaveBL().
|
|
//
|
|
2 : bl_startBL(): // send within 4s after DC power-on, otherwise
|
|
// bootloader is left.
|
|
//
|
|
// NOTE: a running bootloader is a MUST for the download
|
|
// process of a device controller firmware as it does
|
|
// the actual writing of the memory (the bl_reboot()
|
|
// from above erases the available memory).
|
|
//
|
|
3 : bl_check(): // send command to verify if bl is up
|
|
//
|
|
// NOTE: this command is kind of a request that we want
|
|
// to check if the bootloader is up. The device
|
|
// (actually the bootloader) responds with its version.
|
|
//
|
|
4 : bl_isUp(): // returns true if bl is up and running
|
|
//
|
|
// NOTE: we know what the bootloader version actually is
|
|
// as the bootloader does not change. By comparing the
|
|
// string received in the previous step with this known
|
|
// version string we know if the bootloader is up.
|
|
//
|
|
// NOTE FOR ALL PREVIOUS STEPS: execute them in their
|
|
// own slots each to be sure to receive any possible
|
|
// responds from the device.
|
|
//
|
|
5 : bl_sendAddress(blockNumber)
|
|
// send start address, nr of 64-byte block, start with 0
|
|
// will be sent only for following block-numbers:
|
|
// 0, 1024, 2048, 3072 and 4096, so basically every
|
|
// 64kByte.
|
|
// for other addresses nothing happens
|
|
|
|
6 : bl_wasSendingAddOK()
|
|
// return val: 0: no response by now
|
|
// 1: error
|
|
// 10: OK
|
|
|
|
7 : bl_sendDataBlock()
|
|
// send 64 byte from bin file
|
|
|
|
8 : bl_sendLastBlock()
|
|
// send this command after all data are transferred
|
|
|
|
9 : bl_wasSendingDataOK()
|
|
// return val: 0: no response by now
|
|
// 1: error
|
|
// 10: OK
|
|
|
|
10 : bl_stopBL() // leave bl and start (the new) application
|
|
//
|
|
// NOTE: this function MUST work under all conditions.
|
|
// Alas, there is no direct result for this command, so
|
|
// the only way of knowing it was successful is to ask
|
|
// the device if the bootloader is still running.
|
|
// There is no problem to repeat this command until the
|
|
// bootloader is really not running anymore.
|
|
*/
|
|
bool Update::updateBinary(QString const &fileToSendToDC) {
|
|
qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC;
|
|
|
|
return false;
|
|
|
|
#if 0
|
|
QFile fn(fileToSendToDC);
|
|
if (!fn.exists()) {
|
|
// output via CONSOLE() etc
|
|
return false;
|
|
}
|
|
|
|
bool bl_isUp = false;
|
|
if (m_hw->bl_completeStart()) {
|
|
int cnt = 5;
|
|
while (--cnt > 0) {
|
|
if (m_hw->bl_isUp()) {
|
|
bl_isUp = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bl_isUp) {
|
|
return false;
|
|
}
|
|
|
|
if (!m_hw->bl_storeFirmware(fileToSendToDC)) {
|
|
m_hw->bl_stopBL();
|
|
return false;
|
|
}
|
|
|
|
uint16_t const nrOfFirmwareBlocks = m_hw->bl_getNrOfFirmwareBlocks();
|
|
|
|
for (uint16_t blockNr = 0; blockNr <= nrOfFirmwareBlocks; ++blockNr) {
|
|
m_hw->bl_blockAutoLoad(blockNr);
|
|
|
|
int sleepTime = 0;
|
|
while (1) {
|
|
if (sleepTime > 1500) {
|
|
m_hw->bl_stopBL();
|
|
return false;
|
|
}
|
|
|
|
int8_t const r = m_hw->bl_blockAutoResponse();
|
|
|
|
// after every "bl_blockAutoLoad()" call this until response
|
|
// retval 0: wait 1: OK, blk was sent 2: OK, transfer complete
|
|
// 3: error despite repeating, cancel. probably bin file corrupted
|
|
// Max duration: 3x no response from BL = 900ms
|
|
|
|
switch(r) {
|
|
case 1:
|
|
/* fall through */
|
|
case 2:
|
|
sleepTime = 0;
|
|
break;
|
|
case 0: {
|
|
QThread::msleep(100);
|
|
sleepTime += 100;
|
|
} break;
|
|
case 3:
|
|
m_hw->bl_stopBL();
|
|
return false;
|
|
default:
|
|
m_hw->bl_stopBL();
|
|
return false; // unknown error code
|
|
}
|
|
}
|
|
|
|
m_hw->bl_stopBL();
|
|
}
|
|
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
QString Update::jsonType(enum FileTypeJson type) {
|
|
switch (type) {
|
|
case FileTypeJson::CASH: return "CASH";
|
|
case FileTypeJson::CONFIG: return "CONFIG";
|
|
case FileTypeJson::PRINTER: return "PRINTER";
|
|
case FileTypeJson::SERIAL: return "SERIAL";
|
|
case FileTypeJson::DEVICE: return "DEVICE";
|
|
case FileTypeJson::TIME: return "TIME";
|
|
}
|
|
return "N/A";
|
|
}
|
|
|
|
bool Update::downloadJson(enum FileTypeJson type,
|
|
int templateIdx,
|
|
QString jsFileToSendToDC) const {
|
|
|
|
m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
|
|
qDebug() << "SET AUTO-REQUEST=TRUE";
|
|
QThread::sleep(1); // make sure the auto-request flag is acknowledged
|
|
|
|
bool ready = false;
|
|
int nTry = 25;
|
|
while ((ready = m_hw->sys_ready4sending()) == false) {
|
|
QThread::msleep(200);
|
|
if (--nTry <= 0) {
|
|
Utils::printCriticalErrorMsg("SYS NOT READY FOR SENDING AFTER 5 SECONDS");
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool ret = false;
|
|
if (ready) {
|
|
QFile file(jsFileToSendToDC);
|
|
QFileInfo fi(jsFileToSendToDC); // max. size of template file is 800 bytes
|
|
if (file.exists()) {
|
|
if (file.open(QIODevice::ReadOnly)) {
|
|
if (fi.size() <= 800) {
|
|
QByteArray ba = file.readAll();
|
|
// kindOfFile: 1=config, 2=device, 3=cash, 4=serial, 5=time, 6=printer
|
|
// nrOfTemplate=1...32 if kindOfFile==6
|
|
// content = content of the Json file, max 800byte ascii signs
|
|
if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
|
|
templateIdx,
|
|
(uint8_t *)ba.data())) {
|
|
|
|
/*
|
|
* Note: the machine id is contained in DC2C_conf.json.
|
|
* The idea was to use this to check if the download of
|
|
* the json-file was correct. It did not work, as the
|
|
* update of the PSA (to reflect a change in the
|
|
* machine id) did not happen immediately.
|
|
*
|
|
m_hw->dc_autoRequest(true);
|
|
QThread::msleep(500);
|
|
|
|
// testing
|
|
m_hw->request_ReadbackMachineID();
|
|
QThread::msleep(500);
|
|
|
|
uint8_t data[64];
|
|
memset(data, 0x00, sizeof(data));
|
|
uint8_t length = 0;
|
|
|
|
m_hw->readback_machineIDdata(&length, data);
|
|
|
|
QThread::msleep(500);
|
|
|
|
QByteArray ba((const char*)data, length);
|
|
|
|
qCritical() << length << "MACHINE ID =" << ba.toHex(':');
|
|
*/
|
|
|
|
ret = true;
|
|
}
|
|
} else {
|
|
Utils::printCriticalErrorMsg(
|
|
QString("SIZE OF %1 TOO BIG (%2 BYTES)")
|
|
.arg(jsFileToSendToDC).arg(fi.size()));
|
|
}
|
|
} else {
|
|
Utils::printCriticalErrorMsg(
|
|
QString("CAN NOT OPEN ") + jsFileToSendToDC + " FOR READING");
|
|
}
|
|
} else {
|
|
Utils::printCriticalErrorMsg(
|
|
QString(jsFileToSendToDC) + " DOES NOT EXIST");
|
|
}
|
|
}
|
|
|
|
m_hw->dc_autoRequest(false);
|
|
qDebug() << "SET AUTO-REQUEST=FALSE";
|
|
QThread::sleep(1); // make sure the auto-request flag is acknowledged
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool Update::updatePrinterTemplate(int templateIdx, QString jsFile) const {
|
|
return downloadJson(FileTypeJson::PRINTER, templateIdx, jsFile);
|
|
}
|
|
|
|
bool Update::updateConfig(QString jsFile) {
|
|
return downloadJson(FileTypeJson::CONFIG, 0, jsFile);
|
|
}
|
|
|
|
bool Update::updateCashConf(QString jsFile) {
|
|
return downloadJson(FileTypeJson::CASH, 0, jsFile);
|
|
}
|
|
|
|
bool Update::updateDeviceConf(QString jsFile) {
|
|
return downloadJson(FileTypeJson::DEVICE, 0, jsFile);
|
|
}
|
|
|
|
QStringList Update::split(QString line, QChar sep) {
|
|
QStringList lst;
|
|
QString next;
|
|
int start = 0, end;
|
|
|
|
while ((end = line.indexOf(sep, start)) != -1) {
|
|
next = line.mid(start, end - start).trimmed();
|
|
lst << next;
|
|
start = end + 1;
|
|
}
|
|
next = line.mid(start, end - start).trimmed();
|
|
lst << next;
|
|
|
|
return lst;
|
|
}
|
|
|
|
void Update::readyReadStandardOutput() {
|
|
QProcess *p = (QProcess *)sender();
|
|
QByteArray buf = p->readAllStandardOutput();
|
|
qCritical() << buf;
|
|
}
|
|
|
|
void Update::readyReadStandardError() {
|
|
QProcess *p = (QProcess *)sender();
|
|
QByteArray buf = p->readAllStandardError();
|
|
qCritical() << buf;
|
|
}
|
|
|
|
void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
|
|
QProcess *p = (QProcess *)sender();
|
|
disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput()));
|
|
disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
|
|
}
|
|
|
|
QStringList Update::getDcSoftAndHardWareVersion() {
|
|
m_hw->dc_autoRequest(true);
|
|
QThread::sleep(1); // make sure the timer-slots are active
|
|
|
|
for (int i=0; i < 3; ++i) { // send explicit reuests to get
|
|
// current SW/HW-versions
|
|
m_hw->request_DC2_SWversion();
|
|
m_hw->request_DC2_HWversion();
|
|
QThread::sleep(1);
|
|
}
|
|
|
|
QString const &hwVersion = m_hw->dc_getHWversion().toLower().trimmed();
|
|
QString const &swVersion = m_hw->dc_getSWversion().toLower().trimmed();
|
|
|
|
m_hw->dc_autoRequest(false);
|
|
QThread::sleep(1); // make sure the timer-slots are inactive
|
|
|
|
if (!hwVersion.isEmpty() && !swVersion.isEmpty()) {
|
|
return QStringList() << hwVersion << swVersion;
|
|
}
|
|
|
|
return QStringList() << "DC HW-version not available"
|
|
<< "DC SW-version not available";
|
|
}
|
|
|
|
QString Update::getFileVersion(QString const& jsonFileName) {
|
|
// "version":"15.10.2023 14:55 02.00.06",
|
|
static const QRegularExpression re("^.*(\\\"version\\\":)(.*)$");
|
|
|
|
QString fileVersion;
|
|
QFile inputFile(jsonFileName);
|
|
if (inputFile.open(QIODevice::ReadOnly)) {
|
|
QTextStream in(&inputFile);
|
|
while (!in.atEnd()) {
|
|
QString line = in.readLine();
|
|
|
|
QRegularExpressionMatch match;
|
|
int idx = line.indexOf(re, 0, &match);
|
|
if (idx != -1) {
|
|
fileVersion = match.captured(match.lastCapturedIndex());
|
|
break;
|
|
}
|
|
}
|
|
inputFile.close();
|
|
}
|
|
|
|
return fileVersion;
|
|
}
|
|
|
|
bool Update::checkDownloadedJsonVersions(QStringList const& jsonFileNames) {
|
|
|
|
for (QStringList::size_type i=0; i < jsonFileNames.size(); ++i) {
|
|
|
|
uint8_t jsonNr = 0;
|
|
QFileInfo fInfo(jsonFileNames[i]);
|
|
|
|
if (fInfo.fileName().endsWith("conf.json")) {
|
|
jsonNr = 1;
|
|
} else
|
|
if (fInfo.fileName().endsWith("device.json")) {
|
|
jsonNr = 2;
|
|
} else
|
|
if (fInfo.fileName().endsWith("cash.json")) {
|
|
jsonNr = 3;
|
|
} else {
|
|
QRegularExpressionMatch match;
|
|
static const QRegularExpression re("^(.*print)([0-3][0-9])\\.json\\s*$");
|
|
int idx = fInfo.fileName().indexOf(re, 0, &match);
|
|
if (idx != -1) {
|
|
QString captured = match.captured(match.lastCapturedIndex());
|
|
bool ok = false;
|
|
int n = captured.toInt(&ok);
|
|
if (ok) {
|
|
jsonNr = n + 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (jsonNr != 0) {
|
|
#if 0
|
|
m_hw->sys_requestJsonVersions(jsonNr);
|
|
QThread::msleep(500);
|
|
|
|
char buf[64];
|
|
memset(buf, 0x00, sizeof(buf));
|
|
m_hw->sys_getJsonVersions(jsonNr, buf);
|
|
buf[sizeof(buf)-1] = '\0';
|
|
|
|
QString const installedVersion(buf);
|
|
QString const fileVersion = getFileVersion(jsonFileNames[i]);
|
|
|
|
qCritical() << "installed version:" << installedVersion;
|
|
qCritical() << " file version:" << fileVersion;
|
|
|
|
if (installedVersion == fileVersion) {
|
|
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
qCritical() << "CANNOT FIND JSON-NR FOR" << jsonFileNames[i];
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
|
|
//if (m_sys_areDCdataValid == false) {
|
|
// qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED";
|
|
// return false;
|
|
//}
|
|
|
|
bool res = false;
|
|
QList<QString>::const_iterator it;
|
|
for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
|
|
m_worker->startProgressLoop();
|
|
|
|
QString const &fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + it->trimmed());
|
|
|
|
if (fToWorkOn.contains("dc2c.bin")) {
|
|
bool updateBinaryRes = true;
|
|
|
|
// CONSOLE()
|
|
|
|
m_hw->dc_autoRequest(false);// default: turn auto-request setting off
|
|
QThread::sleep(1); // wait to be sure that there are no more
|
|
// commands sent to dc-hardware
|
|
|
|
if ((updateBinaryRes = updateBinary(fToWorkOn)) == true) {
|
|
|
|
// qCritical() << "downloaded binary" << fToWorkOn;
|
|
|
|
++displayIndex;
|
|
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
|
|
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
|
|
Worker::UPDATE_STEP_DONE);
|
|
}
|
|
|
|
m_hw->dc_autoRequest(true); // turn auto-request setting on
|
|
|
|
// qInfo() << "SET AUTO-REQUEST=TRUE";
|
|
|
|
QStringList const &versions = Update::getDcSoftAndHardWareVersion();
|
|
if (versions.size() >= 2) {
|
|
if (updateBinaryRes == true) {
|
|
qInfo() << "dc-hardware-version (UPDATED)" << versions[0];
|
|
qInfo() << "dc-firmware-version (UPDATED)" << versions[1];
|
|
} else {
|
|
qInfo() << "dc-hardware-version (NOT UPDATED)" << versions[0];
|
|
qInfo() << "dc-firmware-version (NOT UPDATED)" << versions[1];
|
|
}
|
|
}
|
|
|
|
res = updateBinaryRes;
|
|
|
|
} else {
|
|
if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
|
|
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive);
|
|
int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt();
|
|
if ((templateIdx < 1) || (templateIdx > 32)) {
|
|
qCritical() << "WRONG TEMPLATE INDEX" << templateIdx;
|
|
res = false;
|
|
} else {
|
|
if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) {
|
|
Utils::printInfoMsg(
|
|
QString("DOWNLOADED PRINTER TEMPLATE %1 WITH INDEX=%2")
|
|
.arg(fToWorkOn)
|
|
.arg(templateIdx));
|
|
++displayIndex;
|
|
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
|
|
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
|
|
Worker::UPDATE_STEP_DONE);
|
|
}
|
|
}
|
|
} else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive)
|
|
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
if ((res = updateCashConf(fToWorkOn))) {
|
|
Utils::printInfoMsg(QString("DOWNLOADED CASH TEMPLATE %1").arg(fToWorkOn));
|
|
++displayIndex;
|
|
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
|
|
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
|
|
Worker::UPDATE_STEP_DONE);
|
|
}
|
|
} else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive)
|
|
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
if ((res= updateConfig(fToWorkOn))) {
|
|
Utils::printInfoMsg(QString("DOWNLOADED CONFIG TEMPLATE %1").arg(fToWorkOn));
|
|
++displayIndex;
|
|
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
|
|
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
|
|
Worker::UPDATE_STEP_DONE);
|
|
}
|
|
} else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive)
|
|
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
|
|
res = true;
|
|
if ((res = updateDeviceConf(fToWorkOn))) {
|
|
Utils::printInfoMsg(QString("DOWNLOADED DEVICE TEMPLATE %1").arg(fToWorkOn));
|
|
++displayIndex;
|
|
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
|
|
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
|
|
Worker::UPDATE_STEP_DONE);
|
|
}
|
|
} else {
|
|
qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
|
|
res = false;
|
|
}
|
|
}
|
|
|
|
if (res == false) {
|
|
break;
|
|
}
|
|
} // for (it = openLines.cbegin(); it != openLines.end(); ++it) {
|
|
|
|
m_hw->dc_autoRequest(true); // ALWAYS turn autoRequest ON
|
|
qDebug() << "SET AUTO-REQUEST=TRUE";
|
|
|
|
return res;
|
|
}
|