rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/BarcodeDialogBuilder.h

@@ -0,0 +1,52 @@
+#ifndef BARCODEDIALOGBUILDER_H
+#define BARCODEDIALOGBUILDER_H
+
+#include "../../platform/shared/qt/rhodes/iexecutable.h"
+#include "../../../../../platform/shared/api_generator/MethodResult.h"
+#include "../../ext/shared/generated/cpp/BarcodeBase.h"
+#include "BarcodeDialogView.h"
+
+class BarcodeDialogBuilder : public IExecutable
+{
+    Q_OBJECT
+private:
+    QCameraInfo info;
+    QWidget * parentWidget;
+    rho::apiGenerator::CMethodResult oResult;
+public:
+    explicit BarcodeDialogBuilder(QCameraInfo info,
+                                 rho::apiGenerator::CMethodResult &oResult, QWidget *parent) : IExecutable(parent){
+        this->info = info;
+        this->oResult = oResult;
+        parentWidget = parent;
+    }
+
+public slots:
+    void execute(){
+        if (!BarcodeDialogView::dialogExists(info)){
+            BarcodeDialogView * dialog = new BarcodeDialogView(info, parentWidget);
+            connect(parentWidget, SIGNAL(destroyed(QObject*)), dialog, SLOT(reject()));
+            connect(parentWidget, SIGNAL(destroyed(QObject*)), dialog, SLOT(deleteLater()));
+            connect(dialog, SIGNAL(rejected()), this, SLOT(rejected()));
+            connect(dialog, SIGNAL(saveResult(QString, QString)), this, SLOT(resultHandler(QString, QString)));
+            connect(dialog, SIGNAL(destroyed(QObject*)), this, SLOT(deleteLater()));
+            dialog->show();
+        }else{
+            deleteLater();
+        }
+    }
+    void resultHandler(QString tag, QString format){
+        rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+        mapRes[rho::barcode::HK_STATUS] = "ok";
+        mapRes[rho::barcode::HK_BARCODE] = tag.toStdString();
+        mapRes["format"] = format.toStdString();
+        oResult.set(mapRes);
+    }
+    void rejected(){
+        rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+        mapRes[rho::barcode::HK_STATUS] = "cancel";
+        oResult.set(mapRes);
+    }
+};
+
+#endif // BARCODEDIALOGBUILDER_H

data/lib/commonAPI/barcode/ext/platform/qt/src/BarcodeDialogView.cpp

@@ -0,0 +1,175 @@
+#include "BarcodeDialogView.h"
+QSet<QString> BarcodeDialogView::keeper;
+
+BarcodeDialogView::BarcodeDialogView(QCameraInfo &info, QWidget *parent) : QDialog(parent){
+
+    this->showFullScreen();
+    this->setStyleSheet("QDialog { background-color: black }");
+
+    camera = nullptr;
+    imageCapture = nullptr;
+    localInfo = info;
+
+    decThread = new DecoderThread(this);
+    connect(decThread, SIGNAL(encoded(QString, QString)), this, SLOT(encoded(QString, QString)));
+    connect(decThread, SIGNAL(scanningProcessMsg()), this, SLOT(scanningProcessMsg()));
+
+    connect(this, SIGNAL(accepted()), this, SLOT(deleteLater()));
+    connect(this, SIGNAL(rejected()), this, SLOT(deleteLater()));
+
+    QVBoxLayout * vblay = new QVBoxLayout(this);
+
+    videoWidget = new QVideoWidget(this);
+    vblay->addWidget(videoWidget,0,Qt::AlignCenter);
+
+    vblay->addSpacing(20);
+
+    laDecodeResult = new QLabel(this);
+    laDecodeResult->setAlignment(Qt::AlignCenter);
+    laDecodeResult->setStyleSheet("QLabel {color : white; }");
+    vblay->addWidget(laDecodeResult,0,Qt::AlignHCenter);
+
+    vblay->addSpacing(20);
+    vblay->setMargin(1);
+    vblay->setSpacing(1);
+    Q_INIT_RESOURCE(barcode);
+    // setFixedSize(minimumWidth(), minimumHeight());
+    QHBoxLayout * hblay = new QHBoxLayout();
+    vblay->addLayout(hblay);
+
+    QIcon iconBack = QIcon(":/barcodeimages/buttonBack.png");
+    QPushButton * buttonBack = new QPushButton(iconBack,"",this);
+    connect(buttonBack, SIGNAL(clicked(bool)), this, SLOT(reject()));
+    hblay->addWidget(buttonBack);
+    buttonBack->setFixedSize(50,50);
+    buttonBack->setIconSize(QSize(40,40));
+
+    QIcon iconRetry = QIcon(":/barcodeimages/buttonRetry.png");
+    QPushButton * buttonRetry = new QPushButton(iconRetry,"",this);
+    connect(buttonRetry, SIGNAL(clicked(bool)), this, SLOT(retry()));
+    connect(this, SIGNAL(enableButtons(bool)), buttonRetry, SLOT(setEnabled(bool)));
+    hblay->addWidget(buttonRetry);
+    buttonRetry->setFixedSize(50,50);
+    buttonRetry->setIconSize(QSize(40,40));
+
+    QIcon iconSave = QIcon(":/barcodeimages/buttonSave.png");
+    QPushButton * buttonSave = new QPushButton(iconSave,"",this);
+    connect(buttonSave, SIGNAL(clicked(bool)), this, SLOT(saveBarcode()));
+    connect(this, SIGNAL(enableButtons(bool)), buttonSave, SLOT(setEnabled(bool)));
+    hblay->addWidget(buttonSave);
+    buttonSave->setFixedSize(50,50);
+    buttonSave->setIconSize(QSize(40,40));
+
+    vblay->addSpacing(20);
+    timer = new QTimer(this);
+    connect(timer, SIGNAL(timeout()), this, SLOT(timeOut()));
+
+    createCamera(localInfo);
+
+    keeper.insert(localInfo.deviceName());
+
+
+    enableButtons(false);
+    retry();
+}
+
+BarcodeDialogView::~BarcodeDialogView()
+{
+    keeper.remove(localInfo.deviceName());
+    if (imageCapture != nullptr){imageCapture->deleteLater();}
+    if (camera != nullptr) {
+        camera->stop();
+        camera->deleteLater();
+    }
+}
+
+bool BarcodeDialogView::dialogExists(QCameraInfo &info)
+{
+    return keeper.contains(info.deviceName());
+}
+
+void BarcodeDialogView::createCamera(QCameraInfo &info)
+{
+    if (imageCapture != nullptr){
+        imageCapture->deleteLater();
+    }
+    if (camera != nullptr) {
+        camera->stop();
+        camera->deleteLater();
+    }
+
+    camera = new QCamera(info, this);
+    camera->focus()->setFocusMode(QCameraFocus::AutoFocus);
+    camera->focus()->setFocusPointMode(QCameraFocus::FocusPointCenter);
+    camera->exposure()->setExposureMode(QCameraExposure::ExposureAuto);
+    camera->exposure()->setAutoIsoSensitivity();
+    camera->setViewfinder(videoWidget);
+
+    imageCapture = new QCameraImageCapture(camera, this);
+    imageCapture->setBufferFormat(QVideoFrame::Format_RGB32);
+
+    imageCapture->setCaptureDestination(QCameraImageCapture::CaptureToBuffer);
+    QImageEncoderSettings settings = imageCapture->encodingSettings();
+    settings.setQuality(QMultimedia::EncodingQuality::VeryHighQuality);
+    imageCapture->setEncodingSettings(settings);
+
+    connect(imageCapture, SIGNAL(imageCaptured(int,QImage)), decThread, SLOT(imageCaptured(int,QImage)));
+
+    camera->start();
+    camera->searchAndLock();
+}
+
+
+void BarcodeDialogView::capture()
+{
+    imageCapture->capture("dev/null");
+}
+
+void BarcodeDialogView::encoded(QString text, QString format)
+{
+    timer->stop();
+    this->text = text;
+    this->format = format;
+    qApp->processEvents();
+    QSound::play(":/barcodesounds/scanner_sound.wav");
+    laDecodeResult->setText(format + " : " + text);
+    qApp->processEvents();  
+    emit enableButtons(true);
+}
+
+
+
+void BarcodeDialogView::timeOut()
+{
+    if (!decThread->isRunning()){capture();}
+}
+
+
+void BarcodeDialogView::scanningProcessMsg()
+{
+    static QString msg = "Scanning";
+    static int msgFirstSize = msg.size();
+
+    if (msg.size() < (msgFirstSize + 10)){
+        msg.append(" .");
+    }else{
+        msg = "Scanning";
+    }
+    laDecodeResult->setText(msg);
+    qApp->processEvents();
+}
+
+void BarcodeDialogView::saveBarcode()
+{
+    timer->stop();
+    emit saveResult(text, format);
+    qApp->processEvents();
+    accept();
+}
+
+void BarcodeDialogView::retry()
+{
+    timer->start(50);
+    emit enableButtons(false);
+}
+

data/lib/commonAPI/barcode/ext/platform/qt/src/BarcodeDialogView.h

@@ -0,0 +1,68 @@
+#ifndef MAINWIDGET_H
+#define MAINWIDGET_H
+
+#include "decoderthread.h"
+#include <QDialog>
+#include <QWidget>
+#include <QCamera>
+#include <QVBoxLayout>
+#include <QDebug>
+#include <QVideoWidget>
+#include <QThread>
+#include <QDebug>
+#include <QFileInfo>
+#include <QCameraFocus>
+#include <QCameraExposure>
+#include <QImageEncoderSettings>
+#include <QDir>
+#include <QCameraImageCapture>
+#include <QCameraInfo>
+#include <QPushButton>
+#include <QImage>
+#include <QPixmap>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QTime>
+#include <QComboBox>
+#include <QTextEdit>
+#include <QVideoRendererControl>
+#include <QTimer>
+#include <QLabel>
+#include <QSet>
+#include <QSound>
+#include <QIcon>
+
+class BarcodeDialogView : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit BarcodeDialogView(QCameraInfo &info, QWidget *parent);
+    ~BarcodeDialogView();
+    static bool dialogExists(QCameraInfo &info);
+
+private:
+    QVideoWidget * videoWidget;
+    QCamera * camera;
+    QCameraImageCapture * imageCapture;
+    QTimer * timer;
+    DecoderThread * decThread;
+    QLabel * laDecodeResult;
+    QCameraInfo localInfo;
+    static QSet<QString> keeper;
+    QString text;
+    QString format;
+signals:
+    void saveResult(QString, QString);
+    void enableButtons(bool);
+public slots:
+    void createCamera(QCameraInfo & info);
+    void capture();
+    void encoded(QString text, QString format);
+    void timeOut();
+    void scanningProcessMsg();
+    void saveBarcode();
+    void retry();
+
+};
+
+#endif // MAINWIDGET_H

data/lib/commonAPI/barcode/ext/platform/qt/src/Barcode_impl.cpp

@@ -0,0 +1,109 @@
+#include "BarcodeController.h"
+#include "../../../shared/generated/cpp/BarcodeBase.h"
+
+namespace rho {
+
+using namespace apiGenerator;
+
+class CBarcodeImpl: public CBarcodeBase
+{
+    QString cameraID;
+public:
+    CBarcodeImpl(const rho::String& strID): CBarcodeBase(){
+        cameraID = QString::fromStdString(strID);
+    }
+
+    void enable( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void registerBluetoothStatus(rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void start(rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void stop(rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void disable(rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void barcode_recognize( const rho::String& imageFilePath, rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void getSupportedProperties(rho::apiGenerator::CMethodResult& oResult){
+        rho::Hashtable<rho::String, rho::String> propsHash = oResult.getStringHash();
+        propsHash.put(barcode::PROPERTY_SCANNER_TYPE, "Camera");
+        propsHash.put(barcode::PROPERTY_FRIENDLY_NAME, QString("Camera"+cameraID).toStdString());
+        oResult.set(propsHash);
+    }
+
+    void take( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult){
+        BarCodeController::openDialog(oResult, cameraID);
+
+    }
+
+    void take_barcode( const rho::String& rubyCallbackURL,  const rho::Hashtable<rho::String,
+                               rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult){
+
+    }
+
+    void commandRemoteScanner( const rho::String& command, rho::apiGenerator::CMethodResult& oResult){
+
+
+    }
+
+};
+
+class CBarcodeSingleton: public CBarcodeSingletonBase
+{
+    ~CBarcodeSingleton(){}
+    virtual rho::String getInitialDefaultID();
+    virtual void enumerate(CMethodResult& oResult);
+};
+
+class CBarcodeFactory: public CBarcodeFactoryBase
+{
+    ~CBarcodeFactory(){}
+    virtual IBarcodeSingleton* createModuleSingleton();
+    virtual IBarcode* createModuleByID(const rho::String& strID);
+};
+
+extern "C" void Init_Barcode_extension()
+{
+    CBarcodeFactory::setInstance( new CBarcodeFactory() );
+    Init_Barcode_API();
+}
+
+IBarcode* CBarcodeFactory::createModuleByID(const rho::String& strID)
+{
+    return new CBarcodeImpl(strID);
+}
+
+IBarcodeSingleton* CBarcodeFactory::createModuleSingleton()
+{
+    BarCodeController::refresh();
+    static IBarcodeSingleton* instance = new CBarcodeSingleton();
+    return instance;
+}
+
+void CBarcodeSingleton::enumerate(CMethodResult& oResult)
+{
+    BarCodeController::getInstance()->enumerate(oResult);
+}
+
+rho::String CBarcodeSingleton::getInitialDefaultID()
+{
+    CMethodResult oRes;
+    enumerate(oRes);
+    rho::Vector<rho::String>& arIDs = oRes.getStringArray();
+    return arIDs[0];
+}
+
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/decoderthread.cpp

@@ -0,0 +1,39 @@
+#include "decoderthread.h"
+
+DecoderThread::DecoderThread(QObject *parent) : QThread(parent)
+{
+    decoder = new QZXing(this);
+    //connect(decoder, SIGNAL(tagFound(QString)), this, SIGNAL(toLog(QString)));
+}
+
+DecoderThread::~DecoderThread()
+{
+
+}
+
+
+void DecoderThread::run()
+{
+    qDebug() << QTime::currentTime().toString() + " : Scanning";
+    QString result = decoder->decodeImage(image, image.width(), image.height());
+    if (!result.isEmpty()){
+        if(codeKeeper.contains(result)){
+            codeKeeper.clear();
+            emit encoded(result, decoder->foundedFormat());
+        }else{
+            codeKeeper.insert(result);
+            emit scanningProcessMsg();
+        }
+    }
+    else{
+        emit scanningProcessMsg();
+    }
+
+}
+
+void DecoderThread::imageCaptured(int id, const QImage &preview)
+{
+    image = preview;
+    start(TimeCriticalPriority);
+}
+

data/lib/commonAPI/barcode/ext/platform/qt/src/decoderthread.h

@@ -0,0 +1,29 @@
+#ifndef DECODERTHREAD_H
+#define DECODERTHREAD_H
+
+#include <QThread>
+#include <QImage>
+#include <QSet>
+#include "qzxing/QZXing.h"
+
+class DecoderThread : public QThread
+{
+    Q_OBJECT
+public:
+    explicit DecoderThread(QObject *parent = 0);
+    ~DecoderThread();
+
+private:
+    QZXing * decoder;
+    QImage image;
+    QSet<QString> codeKeeper;
+signals:
+    void encoded(QString, QString);
+    void scanningProcessMsg();
+public slots:
+    void run();
+    void imageCaptured(int id, const QImage &preview);
+
+};
+
+#endif // DECODERTHREAD_H