rho-tau-extensions 5.5.17

data/libs/nodejs/ext/shared/jxcore/jx_result.h

@@ -0,0 +1,221 @@
+// Copyright & License details are available under JXCORE_LICENSE file
+
+#ifndef SRC_PUBLIC_JX_RESULT_H
+#define SRC_PUBLIC_JX_RESULT_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#ifdef _WIN32
+#define JXCORE_EXTERN(x) __declspec(dllexport) x
+#else
+#define JXCORE_EXTERN(x) x
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum _JXType {
+  RT_Int32 = 1,
+  RT_Double = 2,
+  RT_Boolean = 3,
+  RT_String = 4,
+  RT_Object = 5,
+  RT_Buffer = 6,
+  RT_Undefined = 7,
+  RT_Null = 8,
+  RT_Error = 9,
+  RT_Function = 10
+};
+
+typedef enum _JXType JXResultType;
+typedef enum _JXType JXValueType;
+
+struct _JXValue {
+  // internal use only
+  void *com_;
+  bool persistent_;
+  bool was_stored_;
+
+  void *data_;
+  size_t size_;
+  JXValueType type_;
+};
+
+typedef struct _JXValue JXResult;
+typedef struct _JXValue JXValue;
+
+JXCORE_EXTERN(bool)
+JX_CallFunction(JXValue *fnc, JXValue *params, const int argc, JXValue *out);
+
+JXCORE_EXTERN(bool)
+JX_MakePersistent(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_ClearPersistent(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsFunction(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsError(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsInt32(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsDouble(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsBoolean(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsString(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsJSON(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsBuffer(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsUndefined(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsNull(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsNullOrUndefined(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_IsObject(JXValue *value);
+
+JXCORE_EXTERN(int32_t)
+JX_GetInt32(JXValue *value);
+
+JXCORE_EXTERN(double)
+JX_GetDouble(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_GetBoolean(JXValue *value);
+
+// for String, JSON, Error
+// call free on return value when you are done with it
+JXCORE_EXTERN(char *)
+JX_GetString(JXValue *value);
+
+JXCORE_EXTERN(int32_t)
+JX_GetDataLength(JXValue *value);
+
+// for Buffer, it returns a direct pointer to the underlying data. no copying
+// involved
+// don't hold to it longer than necessary, it may be gc'd away
+JXCORE_EXTERN(char *)
+JX_GetBuffer(JXValue *value);
+
+JXCORE_EXTERN(void)
+JX_SetInt32(JXValue *value, const int32_t val);
+
+JXCORE_EXTERN(void)
+JX_SetDouble(JXValue *value, const double val);
+
+JXCORE_EXTERN(void)
+JX_SetBoolean(JXValue *value, const bool val);
+
+#ifdef __cplusplus
+JXCORE_EXTERN(void)
+JX_SetString(JXValue *value, const char *val, const int32_t length = 0);
+#else
+JXCORE_EXTERN(void)
+JX_SetString(JXValue *value, const char *val, const int32_t length);
+#endif
+
+#ifdef __cplusplus
+JXCORE_EXTERN(void)
+JX_SetUCString(JXValue *value, const uint16_t *val, const int32_t length = 0);
+#else
+JXCORE_EXTERN(void)
+JX_SetUCString(JXValue *value, const uint16_t *val, const int32_t length);
+#endif
+
+#ifdef __cplusplus
+JXCORE_EXTERN(void)
+JX_SetJSON(JXValue *value, const char *val, const int32_t length = 0);
+#else
+JXCORE_EXTERN(void)
+JX_SetJSON(JXValue *value, const char *val, const int32_t length);
+#endif
+
+#ifdef __cplusplus
+JXCORE_EXTERN(void)
+JX_SetError(JXValue *value, const char *val, const int32_t length = 0);
+#else
+JXCORE_EXTERN(void)
+JX_SetError(JXValue *value, const char *val, const int32_t length);
+#endif
+
+#ifdef __cplusplus
+JXCORE_EXTERN(void)
+JX_SetBuffer(JXValue *value, const char *val, const int32_t length = 0);
+#else
+JXCORE_EXTERN(void)
+JX_SetBuffer(JXValue *value, const char *val, const int32_t length);
+#endif
+
+JXCORE_EXTERN(void)
+JX_SetUndefined(JXValue *value);
+
+JXCORE_EXTERN(void)
+JX_SetNull(JXValue *value);
+
+JXCORE_EXTERN(void)
+JX_SetObject(JXValue *host, JXValue *val);
+
+// do not use this for method parameters, jxcore cleanups them
+// Beware JX_Evaluate, this methods needs to be called to cleanup JXResult
+JXCORE_EXTERN(void)
+JX_Free(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_New(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_CreateEmptyObject(JXValue *value);
+
+JXCORE_EXTERN(bool)
+JX_CreateArrayObject(JXValue *value);
+
+JXCORE_EXTERN(void)
+JX_SetNamedProperty(JXValue *object, const char *name, JXValue *prop);
+
+JXCORE_EXTERN(void)
+JX_SetIndexedProperty(JXValue *object, const unsigned index, JXValue *prop);
+
+JXCORE_EXTERN(void)
+JX_GetNamedProperty(JXValue *object, const char *name, JXValue *out);
+
+JXCORE_EXTERN(void)
+JX_GetIndexedProperty(JXValue *object, const int index, JXValue *out);
+
+// if you have a JXValue around, this method brings threadId much faster
+JXCORE_EXTERN(int)
+JX_GetThreadIdByValue(JXValue *value);
+
+JXCORE_EXTERN(void)
+JX_GetGlobalObject(JXValue *out);
+
+JXCORE_EXTERN(void)
+JX_GetProcessObject(JXValue *out);
+
+JXCORE_EXTERN(void)
+JX_WrapObject(JXValue *object, void *ptr);
+
+JXCORE_EXTERN(void *)
+JX_UnwrapObject(JXValue *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // SRC_PUBLIC_JX_RESULT_H

data/libs/nodejs/ext/shared/jxcoretau.cpp

@@ -0,0 +1,454 @@
+
+#include "jxcoretau.h"
+#include "jxcore/jx.h"
+#include "jxcore/jx_result.h"
+
+
+
+#include "common/RhoStd.h"
+#include "logging/RhoLog.h"
+#include "common/RhoThread.h"
+#include "common/ThreadQueue.h"
+
+#include "common/RhodesApp.h"
+#include "common/RhoFile.h"
+#include "common/RhoFilePath.h"
+#include "common/RhoConf.h"
+
+#include "api_generator/js_helpers.h"
+
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "jxCoreTAU"
+
+
+//extern "C" void do_test_extension();
+
+//extern rho::String js_jxCore_entry_point(const char* szJSON);
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+void jxcoretau_start(const char* main_filename, const char* xjcore_folderpath, const char* user_folderpath);
+
+void jxcoretau_start_app(const char* filename);
+    
+#ifdef __cplusplus
+};
+#endif //__cplusplus
+    
+
+
+
+static bool our_is_http_server_started = false;
+
+static void callback(JXValue *results, int argc) { }
+
+
+static void call_js_entry_point(JXValue *results, int argc) {
+    
+    const char *data = JX_GetString(results+0);
+
+    rho::String result = rho::apiGenerator::js_entry_point(data);
+    
+    
+    
+    
+    int o;
+    o = 9;
+    
+    JXValue eval_res;
+    
+    
+    rho::String script = "global.RhomobileEngine.tau_js_entry_point_result="+result+";";
+    
+    bool is_ok = JX_Evaluate(script.c_str(), NULL, &eval_res);
+
+    o = 10;
+    
+}
+
+
+static void callServerStarted(JXValue *results, int argc) {
+    our_is_http_server_started = true;
+}
+
+static void callJXcoreNative(JXValue *results, int argc) {
+    // registered callJXcoreNative extension - JS code call to Native
+    
+    char *data = JX_GetString(results+0);
+    
+    
+    int o;
+    o = 9;
+    
+    /*
+     
+     if (argc < 2 || !JX_IsString(results + 0) || !JX_IsString(results+(argc-1))) {
+     NSLog(@"Unknown call received to callJXcoreNative. First and last parameters have to be string\n");
+     return;
+     }
+     
+     NSMutableArray *params = [[NSMutableArray alloc] init];
+     
+     char *dt_name = JX_GetString(results + 0);
+     NSString *name = [NSString stringWithUTF8String:dt_name];
+     free(dt_name);
+     
+     dt_name = JX_GetString(results + (argc-1));
+     NSString *callbackId = [NSString stringWithUTF8String:dt_name];
+     free(dt_name);
+     
+     ConvertParams(results+1, argc-1, params);
+     
+     NSObject *obj = [natives valueForKey:name];
+     
+     if (obj != nil) {
+     if ([obj isKindOfClass:[CPPWrapper class]])
+     {
+     CPPWrapper *cpp = [natives valueForKey:name];
+     if (cpp != nil) {
+     JXcoreNative callback = [cpp getCallback];
+     callback(params, callbackId);
+     }
+     } else {
+     void (^code_block)(NSArray*, NSString*);
+     code_block = (void(^)(NSArray*, NSString*))obj;
+     code_block(params, callbackId);
+     }
+     
+     return;
+     }
+     
+     NSLog(@"Native method %@ not found.", name);
+     */
+}
+
+
+JXValue pingEvent;
+JXValue startApp;
+int fnc_count = 0;
+
+static void defineEventCB(JXValue *params, int argc) {
+    
+    // registered defineEventCB extension for register some events from JS in Native for call events from Bative to JS !
+    
+    
+    JXValue *fnc1 = params + 1;
+    //JXValue *fnc2 = params + 2;
+    
+    
+    char *data = JX_GetString(params+0);
+    
+    if (fnc_count == 0) {
+        fnc_count++;
+        JX_MakePersistent(fnc1);
+        pingEvent = *fnc1;
+        
+    }
+    else {
+        JX_MakePersistent(fnc1);
+        startApp = *fnc1;
+    }
+    
+    
+    int o;
+    o = 9;
+    /*
+     if (argc < 2 || !JX_IsFunction(params+1) || !JX_IsString(params+0)) {
+     NSLog(@"defineEventCB expects a function");
+     return;
+     }
+     
+     CPPWrapper *cpp = [[CPPWrapper alloc] init];
+     JXValue *fnc = params + 1;
+     JX_MakePersistent(fnc);
+     [cpp setFunction:fnc];
+     
+     char *data = JX_GetString(params+0);
+     NSString *name = [NSString stringWithUTF8String:data];
+     free(data);
+     
+     [natives setObject:cpp forKey:name];
+     */
+}
+
+
+void callEventCallback_with_JSON(const char* event_name, const char* json) {
+    
+    JXValue* fnc = &startApp;
+    
+    JXValue arr[2];
+    
+    const char* event_str = event_name;
+    int ln_event_str = (int)strlen(event_name);
+    JX_New(&arr[0]);
+    JX_SetString(&arr[0], event_str, ln_event_str);
+    
+    if (!JX_CreateArrayObject(&arr[1])) {
+        //NSLog(@"Wasnt able to create a new array object on JXcore callEventCallback. No memory left?");
+        return;
+    }
+    
+    JXValue value;
+    JX_New(&value);
+    
+    //JX_SetJSON(&value, json, (int)strlen(json));
+    JX_SetString(&value, json, (int)strlen(json));
+    
+    JX_SetIndexedProperty(&arr[1], 0, &value);
+    //JX_Free(&value);
+    
+    
+    JXValue ret_val;
+    JX_CallFunction(fnc, &value, 1, &ret_val);
+    
+    JX_Free(&value);
+    
+    
+    JX_Free(&ret_val);
+
+    
+    
+}
+
+
+
+
+
+
+
+
+
+void jxcoreLoop(int n) {
+    int result = JX_LoopOnce();
+}
+
+
+
+
+
+
+class CjxCoreQueue : public rho::common::CThreadQueue
+{
+public:
+    CjxCoreQueue() : CThreadQueue() {
+        setPollInterval(QUEUE_POLL_INTERVAL_INFINITE);
+    }
+
+    virtual void run()
+    {
+        if(__rhoCurrentCategory.getName() == "NO_LOGGING")
+            m_logThreadId = getThreadID();
+        
+        LOG(INFO) + "Starting main routine...";
+
+        
+        int result = 1;
+        
+        while( !isStopping() )
+        {
+            while (!m_bNoThreaded && !isStopping() && isNoCommands()) {
+                int waitInterval = (result == 0 ? 0.05 : 0.001);
+                if ( wait(waitInterval) == 1 ) {
+                    onTimeout();
+                }
+                result = JX_LoopOnce();
+            }
+            if ( !m_bNoThreaded && !isStopping() ) {
+                processCommands();
+            }
+        }
+        LOG(INFO) + "Thread shutdown";
+    }
+};
+
+class CjxCoreQueue_Command_startJXCore: public rho::common::CThreadQueue::IQueueCommand
+{
+public:
+    CjxCoreQueue_Command_startJXCore( const rho::String& main_filename, const rho::String& xjcore_folderpath, const rho::String& user_folderpath ) : mMainFilepath(main_filename), mJxCoreFolderpath( xjcore_folderpath ), mUserFolderpath(user_folderpath){}
+    virtual ~CjxCoreQueue_Command_startJXCore(){};
+    virtual bool equals(const IQueueCommand& cmd)
+    {
+        return false;
+    }
+    virtual rho::String toString()
+    {
+        return "CjxCoreQueue_Command_startJXCore";
+    }
+    virtual void cancel(){}
+    
+    virtual void execute()
+    {
+        
+        rho::common::CRhoFile main_file;
+        bool isOpened = main_file.open(mMainFilepath.c_str(), rho::common::CRhoFile::EOpenModes::OpenReadOnly);
+        rho::String mainContents;
+        main_file.readString(mainContents);
+        main_file.close();
+        
+        
+        rho::String frm_str = "process.setPaths = function() {\n"
+                                  "  process.userPath='%s'; "
+                                  "  var node_module = require('module');\n"
+                                  "  var pathModule = require('path');\n"
+                                  "  // ugly patching\n"
+                                  "  process.cwd = function () {\n"
+                                  "    if (arguments.length) {\n"
+                                  "      // or we should throw this as an exception ?\n"
+                                  "      // Who knows how many node modules would break..\n"
+                                  "      console.error('You are on iOS. This platform does not support setting cwd');\n"
+                                  "    }\n"
+                                  "    return '%s';\n"
+                                  "  };\n"
+                                  "  node_module.addGlobalPath(process.cwd());\n"
+                                  "  node_module.addGlobalPath(process.userPath);\n"
+                                  "};\n%s";
+        
+        int script_size = ((int)frm_str.size() + (int)mainContents.size() + (int)mJxCoreFolderpath.size() + (int)mUserFolderpath.size() ) * 2;
+        char itializationScript[script_size];
+        sprintf(itializationScript, frm_str.c_str(), mUserFolderpath.c_str(), mJxCoreFolderpath.c_str(), mainContents.c_str());
+        
+        JX_Initialize(mJxCoreFolderpath.c_str(), callback);
+        JX_InitializeNewEngine();
+        JX_DefineExtension("callJXcoreNative", callJXcoreNative);
+        //JX_DefineExtension("defineEventCB", defineEventCB);
+        JX_DefineExtension("js_entry_point", call_js_entry_point);
+        JX_DefineExtension("httpServerStarted", callServerStarted);
+        
+        
+        //do_test_extension();
+        
+        
+        JX_DefineMainFile(itializationScript);
+        JX_StartEngine();
+        
+        jxcoreLoop(0);
+        
+        
+    }
+private:
+    rho::String mMainFilepath;
+    rho::String mJxCoreFolderpath;
+    rho::String mUserFolderpath;
+};
+
+class CjxCoreQueue_Command_startApp: public rho::common::CThreadQueue::IQueueCommand
+{
+public:
+    CjxCoreQueue_Command_startApp( const rho::String& app_filename) : mAppFilepath(app_filename){}
+    virtual ~CjxCoreQueue_Command_startApp(){};
+    virtual bool equals(const IQueueCommand& cmd)
+    {
+        return false;
+    }
+    virtual rho::String toString()
+    {
+        return "CjxCoreQueue_Command_startApp";
+    }
+    virtual void cancel(){}
+    
+    virtual void execute()
+    {
+        //callEventCallback_with_JSON("StartApplication", mAppFilepath.c_str());
+        rho::String js_code = "Mobile.loadMainFile('"+mAppFilepath+"');";
+        
+        JXValue eval_res;
+        
+        LOG(INFO) + "jxCore.executeJS for loadMainFile with " + js_code;
+        
+        bool is_ok = JX_Evaluate(js_code.c_str(), NULL, &eval_res);
+        
+    }
+private:
+    rho::String mAppFilepath;
+};
+
+class CjxCoreQueue_Command_executeJS: public rho::common::CThreadQueue::IQueueCommand
+{
+public:
+    CjxCoreQueue_Command_executeJS( const rho::String& js_code) : mJSCode(js_code){}
+    virtual ~CjxCoreQueue_Command_executeJS(){};
+    virtual bool equals(const IQueueCommand& cmd)
+    {
+        return false;
+    }
+    virtual rho::String toString()
+    {
+        return "CjxCoreQueue_Command_executeJS";
+    }
+    virtual void cancel(){}
+    
+    virtual void execute()
+    {
+        JXValue eval_res;
+        
+        LOG(INFO) + "jxCore.executeJS with " + mJSCode;
+
+        bool is_ok = JX_Evaluate(mJSCode.c_str(), NULL, &eval_res);
+        
+        
+    }
+private:
+    rho::String mJSCode;
+};
+
+
+
+
+static CjxCoreQueue* ourJxCoreQueue = NULL;
+
+
+
+
+extern "C" void jxcore_jvm_callback_provider(const char* js_code) {
+    
+    
+    ourJxCoreQueue->addQueueCommand(new CjxCoreQueue_Command_executeJS(js_code));
+    
+}
+
+
+
+
+
+
+extern "C" void jxcoretau_init() {
+    setCustomJVMCallbackProvider("jxcore", jxcore_jvm_callback_provider);
+    
+    const char* user_path = rho_rhodesapp_getuserrootpath();
+    rho::String root_path = rho_rhodesapp_getapprootpath();
+    rho::String main_filename = root_path + "/nodejs/main.js";
+    rho::String jxcore_path = root_path + "/nodejs/server/";
+    
+    jxcoretau_start(main_filename.c_str(), jxcore_path.c_str(), user_path);
+    jxcoretau_start_app("app.js");
+    
+    while (!jxcoretau_is_http_server_started()) {
+        usleep(100000);
+        LOG(INFO) + "wait Node.js server ...";
+    }
+    
+    
+    
+}
+
+
+extern "C" void jxcoretau_start(const char* main_filename, const char* xjcore_folderpath, const char* user_folderpath) {
+    ourJxCoreQueue = new CjxCoreQueue();
+    ourJxCoreQueue->start(rho::common::CThreadQueue::epNormal);
+    ourJxCoreQueue->addQueueCommand(new CjxCoreQueue_Command_startJXCore(main_filename, xjcore_folderpath, user_folderpath));
+}
+
+extern "C" void jxcoretau_start_app(const char* filename) {
+    ourJxCoreQueue->addQueueCommand(new CjxCoreQueue_Command_startApp(filename));
+}
+
+extern "C" bool jxcoretau_is_http_server_started() {
+    return our_is_http_server_started;
+}
+
+extern "C" void jxcoretau_execute_javascript(const char* javascript) {
+    ourJxCoreQueue->addQueueCommand(new CjxCoreQueue_Command_executeJS(javascript));
+}