rhodes 5.5.2 → 5.5.15

data/lib/commonAPI/mediacapture/ext/platform/qt/src/Camera_impl.cpp

@@ -0,0 +1,337 @@
+//
+//  CameraImpl.cpp
+#include <Qt>
+#include <QHash>
+#include <QApplication>
+#include <QWindow>
+#include "CCameraData.h"
+#include "common/RhoStd.h"
+#include "common/AutoPointer.h"
+#include "common/RhodesApp.h"
+#include "common/RhoConf.h"
+#include "generated/cpp/CameraBase.h"
+#include "logging/RhoLog.h"
+
+namespace rho {
+    
+    using namespace apiGenerator;
+    using namespace common;
+
+    class CCameraSingletonImpl: public CCameraSingletonBase
+    {
+        QHash<QString, QString> defaultCameras;
+
+    public:
+
+        CCameraSingletonImpl(): CCameraSingletonBase()
+        {
+            qRegisterMetaType<rho::apiGenerator::CMethodResult>("rho::apiGenerator::CMethodResult");
+        }
+
+        virtual ~CCameraSingletonImpl(){
+            QMutexLocker locker(CCameraData::getMutex());
+            CCameraData::cleanAll();
+        }
+        
+        //methods
+        // enumerate Returns the cameras present on your device, allowing you to access your device's front or back camera. 
+        virtual void enumerate(rho::apiGenerator::CMethodResult& oResult) {
+            initCameras();
+            rho::Vector<rho::String> arIDs = oResult.getStringArray();
+            if(!CCameraData::isEmpty()){
+                foreach (QString value, CCameraData::getKeys()) {
+                    arIDs.addElement(value.toStdString());
+                }
+                oResult.set(arIDs);
+            }
+
+        } 
+
+        void initCameras(){
+            QMutexLocker locker(CCameraData::getMutex());
+            if(CCameraData::isEmpty()){
+                foreach (QCameraInfo cameraInfo, QCameraInfo::availableCameras()) {
+                    const CCameraData * data = CCameraData::addNewCamera(cameraInfo);
+                    defaultCameras.insert(data->getCameraType(), data->getCameraID());
+                }
+            }
+        }
+
+        // getCameraByType Returns the camera of requested type if that camera exist - else return nil. 
+        virtual void getCameraByType( const rho::String& cameraType, rho::apiGenerator::CMethodResult& oResult) {
+            oResult.set(defaultCameras.value(QString::fromStdString(cameraType)).toStdString());
+        } 
+        // choosePicture Choose a picture from the album. 
+
+        static void getImageData(rho::Hashtable<String,String> & mapRes, QString fileNameToOpen){
+            CameraDialogView::getImageData(mapRes, fileNameToOpen);
+        }
+
+        virtual void choosePicture( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult) {
+            // RAWLOGC_INFO("choosePicture","Camera");           
+            CCameraData::choosePicture(oResult);
+        } 
+        // copyImageToDeviceGallery Save an image to the device gallery. 
+        virtual void copyImageToDeviceGallery( const rho::String& pathToImage, rho::apiGenerator::CMethodResult& oResult) {
+            // RAWLOGC_INFO("copyImageToDeviceGallery","Camera");
+            QString originalFileName(QString::fromStdString(pathToImage));
+            QFileInfo info(originalFileName);
+            QString newFileName(CameraDialogView::getImageDir().absolutePath() + "/" + info.fileName());
+            QFile::copy(originalFileName, newFileName);
+            oResult.set(newFileName.toStdString());
+        } 
+
+        virtual rho::String getInitialDefaultID(){
+            initCameras();
+            QString defaultId = defaultCameras.value("front");
+            if (!defaultId.isEmpty()) return defaultId.toStdString();
+            else return defaultCameras.value("back").toStdString();
+        }
+
+    };
+    
+    class CCameraImpl : public CCameraBase
+    {
+        CCameraImpl(){}
+        CCameraData * camera;
+    public:
+        virtual ~CCameraImpl() {}
+
+        //methods
+
+        CCameraImpl(const rho::String& strID){
+            camera = CCameraData::getCameraData(QString::fromStdString(strID));
+        }
+
+        virtual void getCameraType(rho::apiGenerator::CMethodResult& oResult) {
+            if (camera != nullptr){oResult.set(camera->getCameraType().toStdString());}
+        } 
+
+        virtual void getMaxWidth(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getMaxHeight(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getSupportedSizeList(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getDesiredWidth(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setDesiredWidth( int desiredWidth, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getDesiredHeight(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setDesiredHeight( int desiredHeight, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getFileName(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setFileName( const rho::String& fileName, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getCompressionFormat(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setCompressionFormat( const rho::String& compressionFormat, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getOutputFormat(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setOutputFormat( const rho::String& outputFormat, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getColorModel(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setColorModel( const rho::String& colorModel, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getEnableEditing(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setEnableEditing( bool enableEditing, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getFlashMode(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setFlashMode( const rho::String& flashMode, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getSaveToDeviceGallery(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setSaveToDeviceGallery( bool saveToDeviceGallery, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getCaptureSound(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setCaptureSound( const rho::String& captureSound, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getPreviewLeft(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setPreviewLeft( int previewLeft, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getPreviewTop(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setPreviewTop( int previewTop, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getPreviewWidth(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setPreviewWidth( int previewWidth, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getPreviewHeight(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setPreviewHeight( int previewHeight, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getUseSystemViewfinder(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setUseSystemViewfinder( bool useSystemViewfinder, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getUseRealBitmapResize(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setUseRealBitmapResize( bool useRealBitmapResize, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getUseRotationBitmapByEXIF(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setUseRotationBitmapByEXIF( bool useRotationBitmapByEXIF, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getAimMode(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setAimMode( const rho::String& aimMode, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void takePicture( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult) {
+            capture(oResult);
+        } 
+
+        virtual void showPreview( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void hidePreview(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void capture(rho::apiGenerator::CMethodResult& oResult) {
+            if (camera == nullptr) {
+                rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+                mapRes["status"] = "error";
+                mapRes["message"] = "Camera is not available";
+                oResult.set(mapRes);
+                return;
+            }
+            camera->showView(oResult);
+        }
+
+        virtual void getProperty( const rho::String& propertyName, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getProperties( const rho::Vector<rho::String>& arrayofNames, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void getAllProperties(rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setProperty( const rho::String& propertyName,  const rho::String& propertyValue, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+        virtual void setProperties( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult) {
+
+        } 
+
+    };
+    
+    ////////////////////////////////////////////////////////////////////////
+    
+    class CCameraFactory: public CCameraFactoryBase    {
+    public:
+        CCameraFactory(){}
+
+        ICameraSingleton* createModuleSingleton()
+        { 
+            static CCameraSingletonImpl * impl = new CCameraSingletonImpl();
+            return impl;
+        }
+        
+        virtual ICamera* createModuleByID(const rho::String& strID){
+            createModuleSingleton();
+            return new CCameraImpl(strID);
+        }
+        
+    };
+    
+}
+
+extern "C" void Init_Camera_extension()
+{
+    rho::CCameraFactory::setInstance( new rho::CCameraFactory() );
+    rho::Init_Camera_API();
+    
+}

data/lib/commonAPI/mediacapture/ext/platform/qt/src/ImageFileNameGetter.h

@@ -0,0 +1,40 @@
+#ifndef IMAGEFILENAMEGETTER_H
+#define IMAGEFILENAMEGETTER_H
+
+#include <QString>
+#include <QList>
+#include <QFileDialog>
+#include <QStandardPaths>
+#include <QImage>
+#include <QTimer>
+#include "ImageFilenameGetterResult.h"
+#include "CameraDialogView.h"
+
+class ImageFileNameGetter : public IExecutable
+{
+    Q_OBJECT
+public:
+    explicit ImageFileNameGetter(QThread * owner, rho::apiGenerator::CMethodResult &oResult, QObject * parent):IExecutable(parent){
+        threadOwner = owner;
+        result = oResult;
+    }
+private:
+    QThread * threadOwner;
+    rho::apiGenerator::CMethodResult result;
+
+signals:
+
+public slots:
+    void execute(){
+        QString fileNameToOpen = QFileDialog::getOpenFileName(0, "Open Image",
+                                                              //QStandardPaths::standardLocations(QStandardPaths::PicturesLocation).last()
+                                                              CameraDialogView::getImageDir().absolutePath()
+                                                              , "Image Files (*.JPG *.PNG *.BMP *.GIF)");
+        ImageFileNameGetterResult * getterResult = new ImageFileNameGetterResult(result, fileNameToOpen, threadOwner);
+        getterResult->execute();
+        deleteLater();
+    }
+
+};
+
+#endif // IMAGEFILENAMEGETTER_H

data/lib/commonAPI/mediacapture/ext/platform/qt/src/ImageFilenameGetterResult.h

@@ -0,0 +1,36 @@
+#ifndef IMAGEFILENAMEGETTERRESULT_H
+#define IMAGEFILENAMEGETTERRESULT_H
+
+#include "../../platform/shared/qt/rhodes/iexecutable.h"
+#include "CameraDialogView.h"
+#include <QDebug>
+
+class ImageFileNameGetterResult : public IExecutable
+{
+    Q_OBJECT
+public:
+    explicit ImageFileNameGetterResult(rho::apiGenerator::CMethodResult &oResult, QString &fileName, QObject * parent):IExecutable(parent){
+        result = oResult;
+        this->fileName = fileName;
+
+    }
+private:
+    rho::apiGenerator::CMethodResult result;
+    QString fileName;
+
+public slots:
+    void execute(){
+        rho::Hashtable<rho::String,rho::String>& mapRes = result.getStringHash();
+        if (!fileName.isEmpty()){
+            CameraDialogView::getImageData(mapRes, fileName);
+        }else{
+            mapRes["status"] = "cancel";
+            mapRes["message"] = "Open file dialog has been canceled";
+        }
+
+        result.set(mapRes);
+        deleteLater();
+    }
+};
+
+#endif // IMAGEFILENAMEGETTERRESULT_H

data/lib/commonAPI/mediacapture/ext/platform/qt/src/cameracrossthreadhalper.h

@@ -0,0 +1,17 @@
+#ifndef CAMERACROSSTHREADHALPER_H
+#define CAMERACROSSTHREADHALPER_H
+
+#include <QObject>
+
+class CameraCrossThreadHalper : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CameraCrossThreadHalper(QObject *parent = 0);
+
+signals:
+
+public slots:
+};
+
+#endif // CAMERACROSSTHREADHALPER_H

data/lib/commonAPI/mediacapture/ext/platform/qt/src/cameradialogview.cpp

@@ -0,0 +1,178 @@
+#include "CameraDialogView.h"
+
+
+CameraDialogView::CameraDialogView(QCameraInfo &info, rho::apiGenerator::CMethodResult &oResult,
+                                   CameraDialogController *controller, QWidget *parent) : QDialog(parent){
+    camera = new QCamera(info, this);
+    this->oResult = oResult;
+    this->controller = controller;
+    imageIsSaved = false;
+
+    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(imageSaved(int, const QString)), this, SLOT(imageSaved(int,const QString)));
+
+    QHBoxLayout * hblay = new QHBoxLayout(this);
+
+    QVBoxLayout * vblay = new QVBoxLayout();
+    videoWidget = new QVideoWidget(this);
+    vblay->addWidget(videoWidget,0,Qt::AlignCenter);
+    videoWidget->setFixedWidth(300);
+    Q_INIT_RESOURCE(mediacapture);
+
+    imageCaptureClose = QIcon(":/mcimages/diaClosed.png");
+
+    imageCaptureOpened = QIcon(":/mcimages/diaOpened.png");
+    imageSave = QIcon(":/mcimages/photoSave.png");
+
+    connect(&timerToRestoreCaptureButtonImage, SIGNAL(timeout()), this, SLOT(restoreCaptureButtonImage()));
+    timerToRestoreCaptureButtonImage.setSingleShot(true);
+
+    buttonCapture = new QPushButton(imageCaptureOpened, "", this);
+    buttonCapture->setFixedSize(50,50);
+    buttonCapture->setIconSize(QSize(40,40));
+    vblay->addWidget(buttonCapture,0,Qt::AlignCenter);
+    connect(buttonCapture, SIGNAL(clicked(bool)), this, SLOT(capture()));
+    connect(imageCapture, SIGNAL(imageCaptured(int,QImage)), this, SLOT(imageCaptured(int,QImage)));
+    hblay->addLayout(vblay);
+
+    vblay = new QVBoxLayout();
+    laPreview = new QLabel(this);
+    vblay->addWidget(laPreview,0,Qt::AlignCenter);
+    QPushButton * buttonSave = new QPushButton(imageSave,"",this);
+    buttonSave->setFixedSize(50,50);
+    buttonSave->setIconSize(QSize(35,35));
+
+    connect(buttonSave, SIGNAL(clicked(bool)), this, SLOT(saveCurrentImage()));
+    vblay->addWidget(buttonSave,0,Qt::AlignCenter);
+    hblay->addSpacing(4);
+    hblay->addLayout(vblay);
+    hblay->setMargin(1);
+    hblay->setSpacing(1);
+
+    currentImage = QImage(640,480,QImage::Format_ARGB32);
+    laPreview->setPixmap(QPixmap::fromImage(currentImage.scaledToWidth(videoWidget->size().width())));
+
+    camera->setCaptureMode(QCamera::CaptureViewfinder);
+    camera->focus()->setFocusMode(QCameraFocus::AutoFocus);
+    camera->exposure()->setExposureMode(QCameraExposure::ExposureAuto);
+    camera->exposure()->setAutoIsoSensitivity();
+
+    camera->setViewfinder(videoWidget);
+
+    connect(this, SIGNAL(rejected()), this, SLOT(error()));
+    connect(this, SIGNAL(rejected()), this, SLOT(deleteLater()), Qt::QueuedConnection);
+    camera->start();
+    camera->searchAndLock();
+
+    setFixedSize(minimumWidth(), minimumHeight());
+}
+
+CameraDialogView::~CameraDialogView()
+{
+    controller->setDialogRejected();
+}
+
+
+void CameraDialogView::imageSaved(int id, const QString &fileName)
+{
+    qDebug() << "IMSaved: " + fileName;
+}
+
+
+void CameraDialogView::error()
+{
+    if (imageIsSaved) return;
+    qDebug() << "Error in Taking Picture";
+
+    rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+    mapRes["status"] = "error";
+    mapRes["message"] = "Dialog canceled without saving";
+    oResult.set(mapRes);
+}
+
+
+void CameraDialogView::capture()
+{
+    buttonCapture->setIcon(imageCaptureClose);
+    imageCapture->capture("dev/null");
+    timerToRestoreCaptureButtonImage.start(300);
+}
+
+void CameraDialogView::imageCaptured(int id, const QImage &preview)
+{
+    currentImage = preview;
+    laPreview->setPixmap(QPixmap::fromImage(currentImage.scaledToWidth(videoWidget->size().width())));
+}
+
+
+void CameraDialogView::saveCurrentImage()
+{
+    imageIsSaved = true;
+    QDir dir = getImageDir();
+
+    QDate date = QDate::currentDate();
+    QTime time = QTime::currentTime();
+    QString fullPath = dir.absolutePath() + "/img" + QString::number(date.year()) +
+        QString::number(date.month()) + QString::number(date.day()) +
+        QString::number(time.hour()) + QString::number(time.minute()) +
+        QString::number(time.second()) + QString::number(time.msec()) + ".jpg";
+    if (currentImage.save(fullPath)){
+        rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+        getImageData(mapRes, fullPath);
+        oResult.set(mapRes);
+        reject();
+    }else{
+        rho::Hashtable<rho::String, rho::String>& mapRes = oResult.getStringHash();
+        mapRes["status"] = "error";
+        mapRes["message"] = "Error in saving image process";
+        oResult.set(mapRes);
+        reject();
+    }
+}
+
+void CameraDialogView::restoreCaptureButtonImage()
+{
+    buttonCapture->setIcon(imageCaptureOpened);
+}
+
+
+void CameraDialogView::getImageData(rho::Hashtable<rho::String, rho::String> &mapRes, const QString &fileNameToOpen){
+    QImage image(fileNameToOpen);
+    if (image.isNull()){
+        mapRes["status"] = "error";
+        mapRes["message"] = "Image loading error";
+        return;
+    }
+    mapRes["status"] = "ok";
+
+    rho::String uri = QDir::current().relativeFilePath(fileNameToOpen).toStdString();
+    rho::String height = QString::number(image.height()).toStdString();
+    rho::String width = QString::number(image.width()).toStdString();
+    rho::String format = (QFileInfo(fileNameToOpen)).suffix().toStdString();
+
+    mapRes["imageUri"] = uri;
+    mapRes["imageHeight"] = height;
+    mapRes["imageWidth"] = width;
+    mapRes["imageFormat"] = format;
+
+    mapRes["image_uri"] = uri;
+    mapRes["image_height"] = height;
+    mapRes["image_width"] = width;
+    mapRes["image_format"] = format;
+}
+
+QDir CameraDialogView::getImageDir()
+{
+    QDir dir = QDir(QDir::current().absolutePath()+"/db/db-files/");
+    if (!dir.exists()) dir.mkpath(dir.absolutePath());
+    return dir;
+}
+
+