rhodes 6.2.0 → 7.5.1

data/platform/shared/qt/rhodes/impl/QtSystemImpl.cpp

@@ -30,6 +30,8 @@
 #include "common/RhoFilePath.h"
 #include "logging/RhoLog.h"
 #undef null
+
+#ifndef RHODES_VERSION_LIBRARY
 #include <qglobal.h>
 
 #include <QLocale>
@@ -51,8 +53,12 @@
 #include <QtWebKit/qwebkitversion.h>
 #endif
 #endif
+#endif
 #include "../RhoSimulator.h"
 
+#ifdef RHODES_VERSION_LIBRARY
+#include "common/RhodesApp.h"
+#endif
 using namespace rho;
 using namespace rho::common;
 
@@ -62,7 +68,7 @@ extern "C" {
 
 const char* rho_sys_qt_getWebviewFramework()
 {
-#ifndef OS_SAILFISH
+#if !defined(OS_SAILFISH) && !defined(RHODES_VERSION_LIBRARY)
     if (qt_webview_framework[0] == '\0') {
 
         #if defined(RHODES_VERSION_1)
@@ -94,27 +100,47 @@ static int has_camera()
 
 static double get_screen_ppi_x()
 {
+#ifndef RHODES_VERSION_LIBRARY
     return CMainWindow::getInstance()->getLogicalDpiX();
+#else
+    return 0.0;
+#endif
 }
 
 static double get_screen_ppi_y()
 {
+#ifndef RHODES_VERSION_LIBRARY
     return CMainWindow::getInstance()->getLogicalDpiY();
+#else
+    return 0.0;
+#endif
 }
 
 VALUE rho_sys_get_locale()
 {
+#ifndef RHODES_VERSION_LIBRARY
     return rho_ruby_create_string(QLocale::system().name().left(2).toStdString().c_str());
+#else
+    return rho_ruby_get_NIL();
+#endif
 }
 
 int rho_sys_get_screen_width()
 {
+#ifndef RHODES_VERSION_LIBRARY
     return CMainWindow::getScreenWidth();
+#else
+    return -1;
+#endif
 }
 
 int rho_sys_get_screen_height()
 {
+#ifndef RHODES_VERSION_LIBRARY
     return CMainWindow::getScreenHeight();
+#else
+    return -1;
+#endif
 }
 
 int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
@@ -124,10 +150,12 @@ int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
         return 1;
     }
 
+#ifndef RHODES_VERSION_LIBRARY
     if (strcasecmp("main_window_closed",szPropName) == 0) {
         *resValue = rho_ruby_create_boolean(CMainWindow::mainWindowClosed);
         return 1;
     }
+#endif
 
     if (strcasecmp("has_camera",szPropName) == 0) {
         *resValue = rho_ruby_create_boolean(has_camera());
@@ -154,10 +182,12 @@ int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
         return 1;
     }
 
+#ifndef RHODES_VERSION_LIBRARY
     if (strcasecmp("country",szPropName) == 0) {
         *resValue = rho_ruby_create_string(QLocale::system().name().right(2).toStdString().c_str());
         return 1;
     }
+#endif
 
     if (strcasecmp("device_name",szPropName) == 0) {
         *resValue = rho_ruby_create_string("Qt");
@@ -220,14 +250,20 @@ VALUE rho_sys_has_network()
 
 void rho_sys_app_exit()
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->exitCommand();
+#else
+    exit(0);
+#endif
 }
 
 void rho_sys_open_url(const char* url)
 {
+#ifndef RHODES_VERSION_LIBRARY
     QString sUrl = QString::fromUtf8(url);
     if (sUrl.startsWith("/")) sUrl.prepend("file://");
     QDesktopServices::openUrl(QUrl(sUrl));
+#endif
 }
 
 void rho_sys_run_app(const char *appname, VALUE params)
@@ -238,14 +274,20 @@ void rho_sys_run_app(const char *appname, VALUE params)
 
 void rho_sys_bring_to_front()
 {
+#ifndef RHODES_VERSION_LIBRARY
     // TODO: rho_sys_bring_to_front
     return CMainWindow::getInstance()->bringToFront();
+#endif
 }
 
 void rho_sys_report_app_started()
 {
     // TODO: rho_sys_report_app_started
-    RAWLOGC_INFO("SystemImpl", "rho_sys_report_app_started() has no implementation " RHO_PLATFORM_NAME_AT ".");
+    //RAWLOGC_INFO("SystemImpl", "rho_sys_report_app_started() has no implementation " RHO_PLATFORM_NAME_AT ".");
+#if defined(WINDOWS_PLATFORM)
+    RHODESAPP().notifyAppStared();
+#endif
+
 }
 
 int rho_sys_is_app_installed(const char *appname)
@@ -283,7 +325,7 @@ void rho_sys_set_application_icon_badge(int badge_number)
 
 void rho_sys_impl_exit_with_errormessage(const char* szTitle, const char* szMsg)
 {
-#ifndef OS_SAILFISH
+#if !defined(OS_SAILFISH) && !defined (RHODES_VERSION_LIBRARY)
     QMessageBox::critical(0, QString(szTitle), QString(szMsg));
 #endif
 }
@@ -306,27 +348,37 @@ int SymbolLicence_check(const char* company, const char* licence)
 
 void rho_sys_set_window_frame(int x0, int y0, int width, int height)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->setFrame(x0, y0, width, height);
+#endif
 }
 
 void rho_sys_set_window_position(int x0, int y0)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->setPosition(x0, y0);
+#endif
 }
 
 void rho_sys_set_window_size(int width, int height)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->setSize(width, height);
+#endif
 }
 
 void rho_sys_lock_window_size(int locked)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->lockSize(locked);
+#endif
 }
 
 void rho_symimpl_createMenu()
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->createCustomMenuCommand();
+#endif
 }
 
 } //extern "C"

data/platform/shared/qt/rhodes/impl/RhoClassFactoryImpl.h

@@ -30,6 +30,7 @@
 #include "common/RhoDefs.h"
 #include "common/IRhoClassFactory.h"
 #ifdef OS_WINDOWS_DESKTOP
+#include "SecurityTokenGeneratorImpl.h"
 #include "RhoThreadImpl.h"
 #include "rho/net/NetRequestImpl.h"
 #define CNETREQUESTIMPL new net::CNetRequestImpl()
@@ -48,7 +49,7 @@
 namespace rho {
 namespace common {
 		
-class CRhoClassFactory : public common::IRhoClassFactory
+class CRhoClassFactory : public common::CBaseRhoClassFactory
 {
 public:
     net::INetRequestImpl* createNetRequestImpl()
@@ -70,6 +71,16 @@ public:
 #endif
     }
 
+    const rho::common::ISecurityTokenGenerator* createSecurityTokenGenerator()
+    {
+#if defined (OS_WINDOWS_DESKTOP) && !defined(RHODES_VERSION_LIBRARY)
+        static SecurityTokenGenerator global_generator;
+        return &global_generator;
+#else
+        return nullptr;
+#endif
+    }
+
     IRhoCrypt* createRhoCrypt()
     {
         //TODO: createRhoCrypt

data/platform/shared/qt/rhodes/impl/RhoThreadImpl.cpp

@@ -26,27 +26,42 @@
 
 #include "common/RhoDefs.h"
 
-#ifdef OS_WINDOWS_DESKTOP
+#if defined(OS_WINDOWS_DESKTOP)// || defined(OS_LINUX)
 
 #include "common/RhoPort.h"
 #include "RhoThreadImpl.h"
+#ifndef RHODES_VERSION_LIBRARY
 #include <QApplication>
+#endif
 using namespace rho::common;
 
+
+#ifndef RHODES_VERSION_LIBRARY
 IMPLEMENT_LOGCLASS(CRhoThreadImpl,"RhoThreadQT");
 #define RHOQTPREFIX ("RHOQT " + threadId + " ")
-
-CRhoThreadImpl::CRhoThreadImpl(): m_waitThread(new QtThread())
+#else
+IMPLEMENT_LOGCLASS(CRhoThreadImpl,"RhoThreadSTD");
+#define RHOQTPREFIX ("RHOSTD " + threadId + " ")
+#endif
+
+CRhoThreadImpl::CRhoThreadImpl()
+#ifndef RHODES_VERSION_LIBRARY
+    : m_waitThread(new QtThread())
+#endif
 {
+#ifndef RHODES_VERSION_LIBRARY
     mutex = QSharedPointer<QMutex>(new QMutex());
     mutexWaiter = QSharedPointer<QMutex>(new QMutex());
     threadId = QString::number((quint64)this, 16).prepend("0x").toStdString();
     QObject::connect(qApp, SIGNAL(destroyed(QObject*)), m_waitThread.data(), SLOT(quit()));
+#else
+    threadId = std::to_string(GetThreadId(GetCurrentThread()));
+#endif
 }
 
 CRhoThreadImpl::~CRhoThreadImpl()
 {
-
+#ifndef RHODES_VERSION_LIBRARY
     LOG(TRACE) + RHOQTPREFIX + "CRhoThreadImpl destructor";
     stopWait();
     stop(0);
@@ -62,13 +77,20 @@ CRhoThreadImpl::~CRhoThreadImpl()
         m_Thread = QSharedPointer<QRhoThread>();
         LOG(TRACE) + RHOQTPREFIX + "CRhoThreadImpl destructor after delete m_Thread";
 	}  
-
+#endif
 }
 
 void CRhoThreadImpl::start(IRhoRunnable* pRunnable, IRhoRunnable::EPriority ePriority)
 {
     LOG(TRACE) + RHOQTPREFIX + "start";
-    if (!m_Thread.isNull())
+    LOG(TRACE) + RHOQTPREFIX + "start";
+    if (
+        #ifndef RHODES_VERSION_LIBRARY
+            !m_Thread.isNull()
+        #else
+            m_Thread
+        #endif
+       )
 	{
         LOG(TRACE) + RHOQTPREFIX + "start - m_Thread exists before calling stop";
 		stop(0);
@@ -76,7 +98,8 @@ void CRhoThreadImpl::start(IRhoRunnable* pRunnable, IRhoRunnable::EPriority ePri
     }else{
         LOG(TRACE) + RHOQTPREFIX + "start - m_Thread does not exist do not call stop";
 	}
-    LOG(TRACE) + RHOQTPREFIX + "start - before Qthread start";
+    LOG(TRACE) + RHOQTPREFIX + "start - before thread start";
+#ifndef RHODES_VERSION_LIBRARY
     m_Thread = QSharedPointer<QRhoThread>(new QRhoThread(pRunnable));
 
     QObject::connect(qApp, SIGNAL(destroyed(QObject*)), m_Thread.data(), SLOT(terminate()));
@@ -85,19 +108,37 @@ void CRhoThreadImpl::start(IRhoRunnable* pRunnable, IRhoRunnable::EPriority ePri
     LOG(TRACE) + RHOQTPREFIX + "start - after Qthread start";
     setThreadPriority(ePriority);
     LOG(TRACE) + RHOQTPREFIX + "start - finish aftersetThreadPriority";
-
+#else
+    m_Thread = std::make_shared<QRhoThread>(pRunnable);
+    m_Thread->start();
+    setThreadPriority(ePriority);
+    LOG(TRACE) + RHOQTPREFIX + "start - after thread start";
+#endif
 }
 
 void CRhoThreadImpl::setThreadPriority(IRhoRunnable::EPriority ePriority)
 {
+#ifndef RHODES_VERSION_LIBRARY
     QThread::Priority nPriority = QThread::NormalPriority;
     if ( ePriority == IRhoRunnable::epHigh ) nPriority = QThread::HighestPriority;
     else if (ePriority == IRhoRunnable::epLow) nPriority = QThread::LowestPriority;
     m_Thread.data()->setPriority(nPriority);
+#else
+    int nPriority = THREAD_PRIORITY_NORMAL;
+    if ( ePriority == IRhoRunnable::epHigh )
+        nPriority = THREAD_PRIORITY_HIGHEST;
+    else if (ePriority == IRhoRunnable::epLow)
+        nPriority = THREAD_PRIORITY_LOWEST;
+    else if (ePriority == IRhoRunnable::epCritical)
+        nPriority = THREAD_PRIORITY_TIME_CRITICAL;
+
+    SetThreadPriority(m_Thread->_thr.native_handle(), nPriority);
+#endif
 }
 
 void CRhoThreadImpl::stop(unsigned int nTimeoutToKill)
 {
+#ifndef RHODES_VERSION_LIBRARY
     LOG(TRACE) + RHOQTPREFIX + "stop";
 
     LOG(TRACE) + RHOQTPREFIX + "stop - before enter entering mutex locker";
@@ -130,10 +171,20 @@ void CRhoThreadImpl::stop(unsigned int nTimeoutToKill)
     }
 
     LOG(TRACE) + "RHOQT stop - finish";
+#else
+    if(m_Thread)
+    {
+        stopWait();
+        if(nTimeoutToKill && static_cast<int>(nTimeoutToKill) > 0)
+            m_Thread->wait(nTimeoutToKill);
+        m_Thread.reset();
+    }
+#endif
 }
 
 int CRhoThreadImpl::wait(unsigned int nTimeoutMs)
 {
+#ifndef RHODES_VERSION_LIBRARY
     LOG(TRACE) + RHOQTPREFIX + "wait";
 	bool isVeyBigTimeoutvalue = false; 
     if ((nTimeoutMs == 4294966296)||(nTimeoutMs == 4294967295)){isVeyBigTimeoutvalue = true;}
@@ -164,10 +215,15 @@ int CRhoThreadImpl::wait(unsigned int nTimeoutMs)
 	}
     LOG(TRACE) + RHOQTPREFIX + "wait - finish before return";
     return result;
+#else
+    LOG(TRACE) + RHOQTPREFIX + "wait - before wait for a long time nTimeoutMs:-  "+nTimeoutMs;
+    return m_Thread->wait(nTimeoutMs);
+#endif
 }
 
 void CRhoThreadImpl::stopWait()
 {
+#ifndef RHODES_VERSION_LIBRARY
     LOG(TRACE) + RHOQTPREFIX + "stopWait - before mutex";
     QSharedPointer<QMutex> l_mutexWaiter = mutexWaiter;
     QMutexLocker waitLocker(l_mutexWaiter.data());
@@ -176,11 +232,19 @@ void CRhoThreadImpl::stopWait()
     LOG(TRACE) + RHOQTPREFIX + "stopWait - before quit()";
     m_waitThread.data()->quit();
     LOG(TRACE) + RHOQTPREFIX + "stopWait - after quit()";
+#else
+    m_Thread->stopWait();
+#endif
 }
 
 void CRhoThreadImpl::sleep(unsigned int nTimeout)
 {
+#ifndef RHODES_VERSION_LIBRARY
     QRhoThread::sleep(nTimeout);
+#else
+    std::chrono::duration<uint64_t, std::milli> _timeout (static_cast<uint64_t>(nTimeout));
+    std::this_thread::sleep_for(_timeout);
+#endif
 }
 
 #endif // OS_WINDOWS_DESKTOP

data/platform/shared/qt/rhodes/impl/RhoThreadImpl.h

@@ -27,13 +27,22 @@
 #ifndef RHOTHREADIMPL_H
 #define RHOTHREADIMPL_H
 
-#include <QThread>
 #include "common/IRhoThreadImpl.h"
 #include "logging/RhoLog.h"
+
+#ifndef RHODES_VERSION_LIBRARY
+#include <QThread>
 #include <QSharedPointer>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QTimer>
+#else
+#include <thread>
+#include <mutex>
+#include <memory>
+#include <sstream>
+#include <condition_variable>
+#endif
 
 namespace rho{
 namespace common{
@@ -54,6 +63,9 @@ private:
     void setThreadPriority(IRhoRunnable::EPriority ePriority);
     rho::String threadId;
 private:
+
+
+#ifndef RHODES_VERSION_LIBRARY
     class QtThread: public QThread
     {
     public:
@@ -68,7 +80,6 @@ private:
         }
     };
 
-
     class QRhoThread: public QtThread
     {
     public:
@@ -83,10 +94,76 @@ private:
     QSharedPointer<QtThread> m_waitThread;
     QSharedPointer<QMutex> mutex;
     QSharedPointer<QMutex> mutexWaiter;
+#else
+
+    class QRhoThread
+    {
+        friend CRhoThreadImpl;
+        bool runnig = false;
+        std::mutex waiter;
+        std::condition_variable wait_cond;
+    public:
+        QRhoThread(IRhoRunnable* pRunnable): runnig(false), m_Runnable(pRunnable) {}
+
+        ~QRhoThread()
+        {
+            if (isRunning()){
+                TerminateThread(_thr.native_handle(), 0);
+            }
+        }
+
+        void run() {
+            runnig = true;
+            m_Runnable->runObject();
+            runnig = false;
+        }
 
+        bool wait(unsigned int nTimeout)
+        {
+            try
+            {
+                std::unique_lock<std::mutex> lock(waiter);
+                std::chrono::duration<uint64_t, std::milli> _timeout (static_cast<uint64_t>(nTimeout));
+                wait_cond.wait_for(lock, _timeout);
+                return true;
+            }
+            catch(std::system_error& err)
+            {
+                LOG(ERROR) + err.what();
+                return false;
+            }
+        }
+
+        void stopWait()
+        {
+            wait_cond.notify_one();
+        }
+
+        void start()
+        {
+            _thr = std::thread(&QRhoThread::run, this);
+        }
+
+        static void sleep(unsigned long timeout) {
+            std::chrono::duration<uint64_t, std::milli> _timeout (static_cast<uint64_t>(timeout));
+            std::this_thread::sleep_for(_timeout);
+        }
+        bool isRunning()
+        {
+            return runnig;
+        }
+    private:
+        IRhoRunnable* m_Runnable;
+        std::thread _thr;
+    };
+    std::shared_ptr<QRhoThread> m_Thread;
+    std::mutex mutex;
+
+#endif
 };
 
 }
 }
 
+
 #endif // RHOTHREADIMPL_H

data/platform/shared/qt/rhodes/impl/RhodesImpl.cpp

@@ -1,18 +1,18 @@
 /*------------------------------------------------------------------------
 * (The MIT License)
-* 
+*
 * Copyright (c) 2008-2011 Rhomobile, Inc.
-* 
+*
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
-* 
+*
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
-* 
+*
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -20,7 +20,7 @@
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
-* 
+*
 * http://rhomobile.com
 *------------------------------------------------------------------------*/
 
@@ -29,7 +29,9 @@
 #include "rubyext/WebView.h"
 #include "common/RhoConf.h"
 #include "logging/RhoLog.h"
+#ifndef RHODES_VERSION_LIBRARY
 #include "MainWindowImpl.h"
+#endif
 #include "../RhoSimulator.h"
 
 using namespace std;
@@ -43,12 +45,16 @@ extern "C" {
 
 void rho_conf_show_log()
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->logCommand();
+#endif
 }
 
 void rho_title_change(const int, const char* strTitle)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow::getInstance()->setTitle(strTitle);
+#endif
 }
 
 void rho_net_impl_network_indicator(int active)
@@ -59,7 +65,7 @@ void rho_net_impl_network_indicator(int active)
 
 void rho_map_location(char* query)
 {
-    String url = "http://maps.google.com/?";
+    String url = "https://maps.google.com/?";
     url += query;
     rho_webview_navigate(url.c_str(), 0);
 }
@@ -79,16 +85,20 @@ int rho_net_ping_network(const char* szHost)
 
 void rho_qt_unset_window_proxy()
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow* m_appWindow = CMainWindow::getInstance();
     if (m_appWindow)
         m_appWindow->unsetProxyCommand();
+#endif
 }
 
 void rho_qt_set_window_proxy(const char* host, const char* port, const char* login, const char* password)
 {
+#ifndef RHODES_VERSION_LIBRARY
     CMainWindow* m_appWindow = CMainWindow::getInstance();
     if (m_appWindow)
         m_appWindow->setProxyCommand(host, port, login, password);
+#endif
 }
 
 } //extern "C"

data/platform/shared/qt/rhodes/impl/SecurityTokenGeneratorImpl.cpp

@@ -0,0 +1,37 @@
+#include "SecurityTokenGeneratorImpl.h"
+#include <random>
+#include <stdint.h>
+#include <sstream>
+
+
+namespace rho
+{
+namespace common
+{
+
+    SecurityTokenGenerator::SecurityTokenGenerator()
+    {
+        std::random_device device_engine;
+        std::ostringstream ss;
+        std::uniform_int_distribution<int> dist(0, 254);
+        for(int i = 0; i < 32; i++)
+        {
+            int value = dist(device_engine);
+            ss << std::hex << value;
+        }
+
+         currentTokens = ss.str();
+
+    }
+
+    SecurityTokenGenerator::~SecurityTokenGenerator()
+    {
+    }
+
+    const rho::String& SecurityTokenGenerator::getSecurityToken() const
+    {
+        return currentTokens;
+    }
+
+}
+}

data/platform/shared/qt/rhodes/impl/SecurityTokenGeneratorImpl.h

@@ -0,0 +1,25 @@
+#ifndef SECURITY_TOKEN_GENERATORIMPL_H
+#define SECURITY_TOKEN_GENERATORIMPL_H
+
+#include "logging/RhoLog.h"
+#include "common/ISecurityTokenGenerator.h"
+
+namespace rho {
+namespace common{
+
+class SecurityTokenGenerator : public ISecurityTokenGenerator
+{
+    DEFINE_LOGCLASS;
+public:
+    SecurityTokenGenerator();
+    ~SecurityTokenGenerator();
+    virtual const rho::String& getSecurityToken() const override;
+
+private:
+    mutable rho::String currentTokens;
+};
+
+}
+}
+
+#endif // SECURITY_TOKEN_GENERATORIMPL_H

data/platform/shared/qt/rhodes/impl/SignatureImpl.cpp

@@ -27,7 +27,9 @@
 #include "common/RhoPort.h"
 #include "ext/rho/rhoruby.h"
 #include "common/RhodesApp.h"
+#ifndef RHODES_VERSION_LIBRARY
 #include "MainWindowImpl.h"
+#endif
 
 extern "C" {