rhodes 6.2.0 → 7.1.17

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()
@@ -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

@@ -30,23 +30,38 @@
 
 #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