@dittolive/ditto 4.4.4 → 4.5.0

package/package.json

@@ -1,17 +1,29 @@
 {
-  "name": "@dittolive/ditto",
-  "version": "4.4.4",
-  "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
-  "homepage": "https://ditto.live",
-  "license": "SEE LICENSE IN LICENSE.md",
-
-  "author": {
-    "name": "DittoLive Incorporated.",
-    "email": "contact@ditto.live",
-    "url": "https://ditto.live"
+  "author" : {
+    "email" : "contact@ditto.live",
+    "name" : "DittoLive Incorporated.",
+    "url" : "https://ditto.live"
   },
-
-  "keywords": [
+  "browser" : "web/ditto.es6.js",
+  "browser/umd" : "web/ditto.umd.js",
+  "browserslist" : [
+    "defaults"
+  ],
+  "dependencies" : {
+    "@ungap/weakrefs" : "^0.2.0",
+    "cbor-js" : "^0.1.0",
+    "cbor-redux" : "^1.0.0",
+    "fastestsmallesttextencoderdecoder" : "^1.0.22"
+  },
+  "description" : "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
+  "devDependencies" : {
+    "serve" : "^14.2.0"
+  },
+  "engines" : {
+    "node" : ">=14"
+  },
+  "homepage" : "https://ditto.live",
+  "keywords" : [
     "ditto",
     "dittolive",
     "webassembly",
@@ -21,30 +33,14 @@
     "sync",
     "p2p"
   ],
-
-  "engines": {
-    "node": ">=14"
-  },
-
-  "browserslist": [
-    "defaults"
-  ],
-
-  "main": "node/ditto.cjs.js",
-  "browser": "web/ditto.es6.js",
-  "browser/umd": "web/ditto.umd.js",
-  "types": "types/ditto.d.ts",
-
-  "scripts": {
-    "play:web": "npx serve --listen 5285",
-    "play:node": "node --experimental-repl-await --unhandled-rejections=strict playground.cjs"
-  },
-
-  "dependencies": {
-    "cbor-redux": "^1.0.0"
+  "license" : "SEE LICENSE IN LICENSE.md",
+  "main" : "node/ditto.cjs.js",
+  "name" : "@dittolive/ditto",
+  "react-native" : "react-native/src/index.ts",
+  "scripts" : {
+    "play:node" : "node --experimental-repl-await --unhandled-rejections=strict playground.cjs",
+    "play:web" : "npx serve --listen 5285"
   },
-
-  "devDependencies": {
-    "serve": "^14.2.0"
-  }
-}
+  "types" : "types/ditto.d.ts",
+  "version" : "4.5.0"
+}

package/react-native/android/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME "cpp")
+project(PACKAGE_NAME)
+set (BUILD_DIR ../../../)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 17)
+
+include_directories(
+            ../cpp/include
+            ../dittoffi
+            ../boost
+)
+
+file(GLOB SOURCES "../cpp/src/*.cpp")
+add_library(
+        ${PACKAGE_NAME}
+        SHARED
+        ${SOURCES}
+        ../dittoffi/ifaddrs.cpp
+        ./cpp-adapter.cpp
+
+)
+
+find_package(ReactAndroid REQUIRED CONFIG)
+find_library(log-lib log)
+
+add_library(ditto STATIC IMPORTED)
+set_target_properties(ditto PROPERTIES IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/../dittoffi/android/${ANDROID_ABI}/libdittoffi.a")
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ditto
+        ${log-lib}
+        ReactAndroid::jsi
+        android
+)

package/react-native/android/build.gradle

@@ -0,0 +1,203 @@
+import java.nio.file.Paths
+
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.2.1'
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["rnsdk_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["rnsdk_" + name]).toInteger()
+}
+
+def found = false
+def basePath = projectDir.toPath().normalize()
+
+// Find node_modules inside the example project
+def nodeModulesDir = Paths.get(basePath.getParent().toString(), "example/node_modules")
+def reactNativeDir = Paths.get(nodeModulesDir.toString(), "react-native/android")
+if (nodeModulesDir.toFile().exists() && reactNativeDir.toFile().exists()) {
+  found = true
+}
+
+if(!found){
+  // Node's module resolution algorithm searches up to the root directory,
+  // after which the base path will be null
+  while (basePath) {
+    nodeModulesDir = Paths.get(basePath.toString(), "node_modules")
+    reactNativeDir = Paths.get(nodeModulesDir.toString(), "react-native/android")
+    if (nodeModulesDir.toFile().exists() && reactNativeDir.toFile().exists()) {
+      found = true
+      break;
+    }
+    basePath = basePath.getParent()
+  }
+}
+
+if(!found) {
+    throw new GradleException(
+            "${project.name}: unable to locate React Native android sources. " +
+                    "Ensure you have you installed React Native as a dependency in your project and try again.")
+}
+
+def nodeModulesPath = nodeModulesDir.toString().replace("\\", "/")
+def reactNativePath = reactNativeDir.toString().replace("\\", "/")
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  if (major == 7 && minor >= 3) {
+    return true
+  }
+
+  return major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.dittolive.rnsdk"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  // ESSENTIAL for adding JSI
+  buildFeatures {
+    prefab true
+  }
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        // ESSENTIAL for adding JSI
+        arguments "-DANDROID_STL=c++_shared"
+        abiFilters "x86", "x86_64", "armeabi-v7a", "arm64-v8a"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+          java.srcDirs += [
+            // This is needed to build Kotlin project with NewArch enabled
+            "${project.buildDir}/generated/source/codegen/java"
+          ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation files('libs/ditto.aar')
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "DittoRNSDK"
+    codegenJavaPackageName = "com.dittolive.rnsdk"
+  }
+}
+
+task downloadBinaries {
+    doLast {
+        def defaultArchitectures = ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']
+
+        defaultArchitectures.each { arch ->
+            def fileUrl = "https://software.ditto.live/react-native/ditto/4.5.0/android/${arch}/libdittoffi.a"
+
+            new File("${project.projectDir}/../dittoffi/android/${arch}").mkdirs()
+            def localFilePath = "${project.projectDir}/../dittoffi/android/${arch}/libdittoffi.a"
+
+            if (!new File(localFilePath).exists()) {
+                println "Downloading file for $arch: $fileUrl"
+                ant.get(src: fileUrl, dest: localFilePath, verbose: true)
+            } else {
+                println "File for $arch already exists, skipping download: $localFilePath"
+            }
+        }
+    }
+}
+preBuild.dependsOn downloadBinaries
+
+task downloadAar {
+    def fileUrl = "https://software.ditto.live/react-native/ditto/4.5.0/android/ditto.aar"
+
+    doLast {
+        new File("${project.projectDir}/libs").mkdirs()
+
+        def localFilePath = "${project.projectDir}/libs/ditto.aar"
+        if (!new File(localFilePath).exists()) {
+            println "Downloading file: $fileUrl"
+            ant.get(src: fileUrl, dest: localFilePath, verbose: true)
+        } else {
+            println "File already exists, skipping download: $localFilePath"
+        }
+    }
+}
+preBuild.dependsOn downloadAar

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>