@dittolive/ditto 4.7.4-rc.2 → 4.7.4

package/DittoReactNative.podspec

@@ -0,0 +1,27 @@
+# Podspec *must* be located at package root level or it will not be find for React
+# Native's autolinking.
+#
+# It would be great to move this to the RN folder and still have the
+# relative paths work in production somehow. Maybe when RN will stop forcing
+# the podspec to exist at root level or allow us to modify it via some property.
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "DittoReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "14.0" }
+  s.source       = { :http => 'https://ditto.live' }
+
+  s.source_files = "react-native/ios/**/*.{h,m,mm}", "react-native/cpp/**/*.{h,cpp,hpp}",
+  s.public_header_files = 'react-native/dittoffi/dittoffi.h', 'react-native/dittoffi/ifaddrs.h'
+
+  s.dependency "React-Core"
+  s.dependency 'DittoReactNativeIOS', "~> #{package["version"]}"
+end

package/README.md

@@ -3,10 +3,10 @@
 _Ditto is a cross-platform SDK that allows mobile, web, and IoT apps to sync
 with and even without connectivity._
 
-Version: **4.7.4-rc.2**
+Version: **4.7.4**
 
 For more information please visit [ditto.live](https://ditto.live), as well as the
-[API Reference](https://software.ditto.live/js/Ditto/4.7.4-rc.2/api-reference/) for this particular version.
+[API Reference](https://software.ditto.live/js/Ditto/4.7.4/api-reference/) for this particular version.
 
 ---
 

package/node/ditto.cjs.js

@@ -2222,7 +2222,7 @@ class AttachmentToken {
 
 // NOTE: this is patched up with the actual build version by Jake task
 // build:package and has to be a valid semantic version as defined here: https://semver.org.
-const fullBuildVersionString = '4.7.4-rc.2';
+const fullBuildVersionString = '4.7.4';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.7.4-rc.2",
+  "version": "4.7.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",
@@ -34,6 +34,7 @@
   "browser": "web/ditto.es6.js",
   "browser/umd": "web/ditto.umd.js",
   "types": "types/ditto.d.ts",
+  "react-native": "react-native/src/index.ts",
 
   "scripts": {
     "play:web": "npx serve --listen 5285",
@@ -41,7 +42,9 @@
   },
 
   "dependencies": {
-    "cbor-redux": "^1.0.0"
+    "cbor-redux": "^1.0.0",
+    "@ungap/weakrefs": "^0.2.0",
+    "fastestsmallesttextencoderdecoder": "^1.0.22"
   },
 
   "devDependencies": {

package/react-native/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Thu Aug 01 08:49:33 MDT 2024
+gradle.version=8.9

package/react-native/android/CMakeLists.txt

@@ -0,0 +1,36 @@
+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
+)
+
+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,190 @@
+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 "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+      }
+    }
+  }
+
+  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()
+}
+
+// This can be moved to gradle.properties (minus the quotes) with no code changes
+// here since `version` is a default project property.
+version = "4.7.4"
+
+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 "live.ditto:ditto:${project.version}"
+}
+
+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/${project.version}/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

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

@@ -0,0 +1,259 @@
+#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;
+
+void DeferThreadDetach(JNIEnv *env)
+{
+    static pthread_key_t thread_key;
+
+    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;
+    }();
+
+    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.
+        }
+    }
+}
+
+JNIEnv *GetJniEnv()
+{
+    JNIEnv *env = nullptr;
+
+    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 defaultDeviceName = Function::createFromHostFunction(jsiRuntime,
+                                                          PropNameID::forAscii(jsiRuntime,
+                                                                               "defaultDeviceName"),
+                                                          0,
+                                                          [](Runtime &runtime,
+                                                             const Value &thisValue,
+                                                             const Value *arguments,
+                                                             size_t count) -> Value
+                                                          {
+                                                              JNIEnv *jniEnv = GetJniEnv();
+
+                                                              java_class = jniEnv->GetObjectClass(
+                                                                  java_object);
+                                                              jmethodID defaultDeviceName = jniEnv->GetMethodID(
+                                                                  java_class, "defaultDeviceName",
+                                                                  "()Ljava/lang/String;");
+                                                              jobject result = jniEnv->CallObjectMethod(
+                                                                  java_object, defaultDeviceName);
+                                                              const char *str = jniEnv->GetStringUTFChars(
+                                                                  (jstring)result, NULL);
+
+                                                              return Value(runtime,
+                                                                           String::createFromUtf8(
+                                                                               runtime, str));
+                                                          });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "defaultDeviceName", std::move(defaultDeviceName));
+
+    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 copyFile = Function::createFromHostFunction(jsiRuntime,
+                                                     PropNameID::forAscii(jsiRuntime, "copyFile"),
+                                                     3,
+                                                     [](Runtime &runtime,
+                                                        const Value &thisValue,
+                                                        const Value *arguments,
+                                                        size_t count) -> Value {
+                                                         std::string sourcePath = arguments[0].getString(runtime).utf8(runtime);
+                                                         std::string destinationPath = arguments[1].getString(runtime).utf8(runtime);
+                                                         std::string defaultFolder = arguments[2].getString(runtime).utf8(runtime);
+
+                                                         JNIEnv *jniEnv = GetJniEnv();
+
+                                                         jclass fileManagerClass = jniEnv->GetObjectClass(java_object);
+                                                         jmethodID copyFileMethod = jniEnv->GetMethodID(fileManagerClass, "copyFile", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+
+                                                         jstring jSourcePath = jniEnv->NewStringUTF(sourcePath.c_str());
+                                                         jstring jDestinationPath = jniEnv->NewStringUTF(destinationPath.c_str());
+                                                         jstring jDefaultFolder = jniEnv->NewStringUTF(defaultFolder.c_str());
+
+                                                         jniEnv->CallVoidMethod(java_object, copyFileMethod, jSourcePath, jDestinationPath, jDefaultFolder);
+
+                                                         jniEnv->DeleteLocalRef(jSourcePath);
+                                                         jniEnv->DeleteLocalRef(jDestinationPath);
+                                                         jniEnv->DeleteLocalRef(jDefaultFolder);
+                                                         jniEnv->DeleteLocalRef(fileManagerClass);
+
+                                                         return Value();
+                                                     });
+
+    jsiRuntime.global().setProperty(jsiRuntime, "copyFile", std::move(copyFile));
+
+    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>