@dittolive/ditto 4.4.5 → 4.5.1

package/react-native/android/cpp-adapter.cpp

@@ -0,0 +1,254 @@
+#include <jni.h>
+#include <sys/types.h>
+#include <jsi/jsi.h>
+#include <pthread.h>
+
+#include "main.h"
+#include "TypedArray.hpp"
+#include "dittoffi.h"
+#include <sstream>
+#include <string>
+#include <vector>
+#include <android/log.h>
+
+using namespace facebook::jsi;
+
+JavaVM *java_vm;
+jclass java_class;
+jobject java_object;
+jobject java_context;
+
+/**
+ * A simple callback function that allows us to detach current JNI Environment
+ * when the thread
+ * See https://stackoverflow.com/a/30026231 for detailed explanation
+ */
+
+void DeferThreadDetach(JNIEnv *env)
+{
+    static pthread_key_t thread_key;
+
+    // Set up a Thread Specific Data key, and a callback that
+    // will be executed when a thread is destroyed.
+    // This is only done once, across all threads, and the value
+    // associated with the key for any given thread will initially
+    // be NULL.
+    static auto run_once = []
+    {
+        const auto err = pthread_key_create(&thread_key, [](void *ts_env)
+                                            {
+            if (ts_env) {
+                java_vm->DetachCurrentThread();
+            } });
+        if (err)
+        {
+            // Failed to create TSD key. Throw an exception if you want to.
+        }
+        return 0;
+    }();
+
+    // For the callback to actually be executed when a thread exits
+    // we need to associate a non-NULL value with the key on that thread.
+    // We can use the JNIEnv* as that value.
+    const auto ts_env = pthread_getspecific(thread_key);
+    if (!ts_env)
+    {
+        if (pthread_setspecific(thread_key, env))
+        {
+            // Failed to set thread-specific value for key. Throw an exception if you want to.
+        }
+    }
+}
+
+/**
+ * Get a JNIEnv* valid for this thread, regardless of whether
+ * we're on a native thread or a Java thread.
+ * If the calling thread is not currently attached to the JVM
+ * it will be attached, and then automatically detached when the
+ * thread is destroyed.
+ *
+ * See https://stackoverflow.com/a/30026231 for detailed explanation
+ */
+JNIEnv *GetJniEnv()
+{
+    JNIEnv *env = nullptr;
+    // We still call GetEnv first to detect if the thread already
+    // is attached. This is done to avoid setting up a DetachCurrentThread
+    // call on a Java thread.
+
+    // g_vm is a global.
+    auto get_env_result = java_vm->GetEnv((void **)&env, JNI_VERSION_1_6);
+    if (get_env_result == JNI_EDETACHED)
+    {
+        if (java_vm->AttachCurrentThread(&env, NULL) == JNI_OK)
+        {
+            DeferThreadDetach(env);
+        }
+        else
+        {
+            // Failed to attach thread. Throw an exception if you want to.
+        }
+    }
+    else if (get_env_result == JNI_EVERSION)
+    {
+        // Unsupported JNI version. Throw an exception if you want to.
+    }
+    return env;
+}
+
+static jstring string2jstring(JNIEnv *env, const std::string &str)
+{
+    return (*env).NewStringUTF(str.c_str());
+}
+
+void install(Runtime &jsiRuntime)
+{
+    auto getDeviceName = Function::createFromHostFunction(jsiRuntime,
+                                                          PropNameID::forAscii(jsiRuntime,
+                                                                               "getDeviceName"),
+                                                          0,
+                                                          [](Runtime &runtime,
+                                                             const Value &thisValue,
+                                                             const Value *arguments,
+                                                             size_t count) -> Value
+                                                          {
+                                                              JNIEnv *jniEnv = GetJniEnv();
+
+                                                              java_class = jniEnv->GetObjectClass(
+                                                                  java_object);
+                                                              jmethodID getDeviceName = jniEnv->GetMethodID(
+                                                                  java_class, "getDeviceName",
+                                                                  "()Ljava/lang/String;");
+                                                              jobject result = jniEnv->CallObjectMethod(
+                                                                  java_object, getDeviceName);
+                                                              const char *str = jniEnv->GetStringUTFChars(
+                                                                  (jstring)result, NULL);
+
+                                                              return Value(runtime,
+                                                                           String::createFromUtf8(
+                                                                               runtime, str));
+                                                          });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "getDeviceName", std::move(getDeviceName));
+
+    auto createDirectory = Function::createFromHostFunction(jsiRuntime,
+                                                            PropNameID::forAscii(jsiRuntime,
+                                                                                 "createDirectory"),
+                                                            0,
+                                                            [](Runtime &runtime,
+                                                               const Value &thisValue,
+                                                               const Value *arguments,
+                                                               size_t count) -> Value
+                                                            {
+                                                                std::string path = arguments[0].getString(runtime).utf8(runtime);
+                                                                JNIEnv *jniEnv = GetJniEnv();
+
+                                                                jclass localJavaClass = jniEnv->GetObjectClass(java_object);
+                                                                jmethodID createDirectory = jniEnv->GetMethodID(localJavaClass, "createDirectory", "(Ljava/lang/String;)Ljava/lang/String;");
+                                                                jstring jPath = string2jstring(jniEnv, path);
+                                                                jobject result = jniEnv->CallObjectMethod(java_object, createDirectory, jPath);
+
+                                                                const char *str = jniEnv->GetStringUTFChars((jstring)result, NULL);
+
+                                                                jniEnv->ReleaseStringUTFChars((jstring)result, str);
+                                                                jniEnv->DeleteLocalRef(jPath);
+                                                                jniEnv->DeleteLocalRef(localJavaClass);
+                                                                jniEnv->DeleteLocalRef(result);
+
+                                                                return Value(runtime, String::createFromUtf8(runtime, str));
+                                                            });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "createDirectory", std::move(createDirectory));
+
+    auto getRandomValues = Function::createFromHostFunction(jsiRuntime,
+                                                            PropNameID::forUtf8(jsiRuntime, "getRandomValues"),
+                                                            1,
+                                                            [](Runtime &runtime,
+                                                               const Value &thisArg,
+                                                               const Value *args,
+                                                               size_t count) -> Value
+                                                            {
+                                                                TypedArrayBase typedArrayBase(runtime, args[0].asObject(runtime));
+                                                                auto byteLength = typedArrayBase.byteLength(runtime);
+
+                                                                JNIEnv *jniEnv = GetJniEnv();
+                                                                jclass clazz = jniEnv->GetObjectClass(java_object);
+                                                                jmethodID getRandomValues = jniEnv->GetMethodID(clazz, "getRandomValues", "(I)[B");
+                                                                auto b = (jbyteArray)jniEnv->CallObjectMethod(java_object,
+                                                                                                              getRandomValues,
+                                                                                                              byteLength);
+                                                                jboolean isCopy = true;
+                                                                jbyte *values = jniEnv->GetByteArrayElements(b, &isCopy);
+                                                                jniEnv->DeleteLocalRef(b);
+
+                                                                auto randomValues = reinterpret_cast<std::byte *>(values);
+
+                                                                auto typedArray = TypedArray<TypedArrayKind::Uint8Array>(runtime, byteLength);
+                                                                auto arrayBuffer = typedArray.getBuffer(runtime);
+                                                                memcpy(arrayBuffer.data(runtime), reinterpret_cast<std::byte *>(randomValues), byteLength);
+                                                                return typedArray;
+                                                            });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "getRandomValues", std::move(getRandomValues));
+
+    auto ditto_sdk_transports_set_android_context = Function::createFromHostFunction(jsiRuntime,
+                                                                                     PropNameID::forUtf8(
+                                                                                             jsiRuntime,
+                                                                                             "ditto_sdk_transports_set_android_context"),
+                                                                                     1,
+                                                                                     [](Runtime &runtime,
+                                                                                        const Value &thisArg,
+                                                                                        const Value *args,
+                                                                                        size_t count) -> Value {
+
+                                                                                         return ::ditto_sdk_transports_set_android_context(
+                                                                                                 GetJniEnv(),
+                                                                                                 java_context);
+                                                                                     });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "ditto_sdk_transports_set_android_context",
+                                    std::move(ditto_sdk_transports_set_android_context));
+
+    auto ditto_sdk_transports_android_missing_permissions = Function::createFromHostFunction(
+            jsiRuntime,
+            PropNameID::forUtf8(jsiRuntime, "ditto_sdk_transports_android_missing_permissions"),
+            1,
+            [](Runtime &runtime,
+               const Value &thisArg,
+               const Value *args,
+               size_t count) -> Value {
+                char *result = ::ditto_sdk_transports_android_missing_permissions();
+                std::vector<std::string> lines;
+                std::stringstream ss(result);
+                std::string line;
+                while (std::getline(ss, line, '\n')) {
+                    lines.push_back(line);
+                }
+
+                Array jsiArray(runtime, lines.size());
+                for (size_t i = 0; i < lines.size(); ++i) {
+                    jsiArray.setValueAtIndex(runtime, i, String::createFromUtf8(runtime, lines[i]));
+                }
+
+                return jsiArray;
+            });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "ditto_sdk_transports_android_missing_permissions",
+                                    std::move(ditto_sdk_transports_android_missing_permissions));
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_dittolive_rnsdk_DittoRNSDKModule_nativeInstall(JNIEnv *env, jobject thiz, jobject context,
+                                                        jlong jsiPtr) {
+    // Save context, module, java_vm objects globally (thread-safe, as opposed to JNIEnv)
+    java_context = env->NewGlobalRef(context);
+    java_object = env->NewGlobalRef(thiz);
+    env->GetJavaVM(&java_vm);
+
+    // Install JSI
+    Runtime *runtime = reinterpret_cast<Runtime *>(jsiPtr);
+    if (runtime) {
+        sharedjsi::install(*runtime);
+        install(*runtime);
+    }
+}

package/react-native/android/gradle.properties

@@ -0,0 +1,5 @@
+rnsdk_kotlinVersion=1.7.0
+rnsdk_minSdkVersion=24
+rnsdk_targetSdkVersion=31
+rnsdk_compileSdkVersion=31
+rnsdk_ndkversion=21.4.7075529

package/react-native/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.dittolive.rnsdk">
+
+</manifest>

package/react-native/android/src/main/java/com/dittolive/rnsdk/DittoRNSDKModule.java

@@ -0,0 +1,85 @@
+package com.dittolive.rnsdk;
+
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.io.File;
+
+import java.security.SecureRandom;
+
+@ReactModule(name = DittoRNSDKModule.NAME)
+public class DittoRNSDKModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "DittoRNSDK";
+  private native void nativeInstall(ReactApplicationContext context, long jsiPtr);
+
+  public DittoRNSDKModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install() {
+    try {
+      System.loadLibrary("cpp");
+
+      ReactApplicationContext context = getReactApplicationContext();
+      nativeInstall(
+        context,
+        context.getJavaScriptContextHolder().get()
+      );
+      return true;
+    } catch (Exception exception) {
+      return false;
+    }
+  }
+
+  public String getDeviceName() {
+    String manufacturer = Build.MANUFACTURER;
+    String model = Build.MODEL;
+    if (model.startsWith(manufacturer)) {
+      return model;
+    } else {
+      return manufacturer + " " + model;
+    }
+  }
+
+  public String createDirectory(String path) {
+    File dir;
+
+    // If the path doesn't start with '/', treat it as a relative path.
+    if (!path.startsWith("/")) {
+        ReactApplicationContext context = getReactApplicationContext();
+        File appDir = context.getFilesDir();  // Get app's data directory
+        dir = new File(appDir, path);
+    } else {
+        dir = new File(path);
+    }
+
+    if (!dir.exists() && !dir.mkdirs()) {
+        Log.e("AppLog", "Error creating directory: " + dir.getAbsolutePath());
+    }
+
+    return dir.getAbsolutePath();
+  }
+
+
+public byte[] getRandomValues(int byteLength) {
+    byte[] data = new byte[byteLength];
+    SecureRandom random = new SecureRandom();
+
+    random.nextBytes(data);
+
+    return data;
+  }
+}

package/react-native/android/src/main/java/com/dittolive/rnsdk/DittoRNSDKPackage.java

@@ -0,0 +1,28 @@
+package com.dittolive.rnsdk;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class DittoRNSDKPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new DittoRNSDKModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/react-native/boost/boost/assert.hpp

@@ -0,0 +1,85 @@
+//
+//  boost/assert.hpp - BOOST_ASSERT(expr)
+//                     BOOST_ASSERT_MSG(expr, msg)
+//                     BOOST_VERIFY(expr)
+//                     BOOST_VERIFY_MSG(expr, msg)
+//                     BOOST_ASSERT_IS_VOID
+//
+//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007, 2014 Peter Dimov
+//  Copyright (c) Beman Dawes 2011
+//  Copyright (c) 2015 Ion Gaztanaga
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+//  Note: There are no include guards. This is intentional.
+//
+//  See http://www.boost.org/libs/assert/assert.html for documentation.
+//
+
+//
+// Stop inspect complaining about use of 'assert':
+//
+// boostinspect:naassert_macro
+//
+
+//
+// BOOST_ASSERT, BOOST_ASSERT_MSG, BOOST_ASSERT_IS_VOID
+//
+
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
+
+# define BOOST_ASSERT(expr) ((void)0)
+# define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+# define BOOST_ASSERT_IS_VOID
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
+
+#include <boost/config.hpp> // for BOOST_LIKELY
+#include <boost/current_function.hpp>
+
+namespace boost
+{
+    void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+    void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined
+} // namespace boost
+
+#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+
+# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
+
+# define BOOST_ASSERT(expr) assert(expr)
+# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
+#if defined(NDEBUG)
+# define BOOST_ASSERT_IS_VOID
+#endif
+
+#endif
+
+//
+// BOOST_VERIFY, BOOST_VERIFY_MSG
+//
+
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
+
+# define BOOST_VERIFY(expr) ((void)(expr))
+# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr))
+
+#else
+
+# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg)
+
+#endif

package/react-native/boost/boost/config/abi/borland_prefix.hpp

@@ -0,0 +1,27 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  for C++ Builder the following options effect the ABI:
+//
+//  -b (on or off - effect emum sizes)
+//  -Vx  (on or off - empty members)
+//  -Ve (on or off - empty base classes)
+//  -aX (alignment - 5 options).
+//  -pX (Calling convention - 4 options)
+//  -VmX (member pointer size and layout - 5 options)
+//  -VC (on or off, changes name mangling)
+//  -Vl (on or off, changes struct layout).
+
+//  In addition the following warnings are sufficiently annoying (and
+//  unfixable) to have them turned off by default:
+//
+//  8027 - functions containing [for|while] loops are not expanded inline
+//  8026 - functions taking class by value arguments are not expanded inline
+
+#pragma nopushoptwarn
+#  pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026
+
+
+

package/react-native/boost/boost/config/abi/borland_suffix.hpp

@@ -0,0 +1,12 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#  pragma option pop
+#pragma nopushoptwarn
+
+
+
+
+

package/react-native/boost/boost/config/abi/msvc_prefix.hpp

@@ -0,0 +1,22 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//
+// Boost binaries are built with the compiler's default ABI settings,
+// if the user changes their default alignment in the VS IDE then their
+// code will no longer be binary compatible with the bjam built binaries
+// unless this header is included to force Boost code into a consistent ABI.
+//
+// Note that inclusion of this header is only necessary for libraries with 
+// separate source, header only libraries DO NOT need this as long as all
+// translation units are built with the same options.
+//
+#if defined(_M_X64)
+#  pragma pack(push,16)
+#else
+#  pragma pack(push,8)
+#endif
+
+

package/react-native/boost/boost/config/abi/msvc_suffix.hpp

@@ -0,0 +1,8 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma pack(pop)
+
+

package/react-native/boost/boost/config/abi_prefix.hpp

@@ -0,0 +1,25 @@
+//  abi_prefix header  -------------------------------------------------------//
+
+// (c) Copyright John Maddock 2003
+   
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
+# define BOOST_CONFIG_ABI_PREFIX_HPP
+#else
+# error double inclusion of header boost/config/abi_prefix.hpp is an error
+#endif
+
+#include <boost/config.hpp>
+
+// this must occur after all other includes and before any code appears:
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+#if defined( BOOST_BORLANDC )
+#pragma nopushoptwarn
+#endif
+

package/react-native/boost/boost/config/abi_suffix.hpp

@@ -0,0 +1,25 @@
+//  abi_sufffix header  -------------------------------------------------------//
+
+// (c) Copyright John Maddock 2003
+   
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+// This header should be #included AFTER code that was preceded by a #include
+// <boost/config/abi_prefix.hpp>.
+
+#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
+# error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp
+#else
+# undef BOOST_CONFIG_ABI_PREFIX_HPP
+#endif
+
+// the suffix header occurs after all of our code:
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#if defined( BOOST_BORLANDC )
+#pragma nopushoptwarn
+#endif