@dittolive/ditto 4.9.0-rc.3 → 4.9.1-rc.1

package/DittoReactNative.podspec

@@ -36,21 +36,21 @@ Pod::Spec.new do |s|
   if respond_to?(:install_modules_dependencies, true)
     install_modules_dependencies(s)
   else
-  s.dependency "React-Core"
+    s.dependency "React-Core"
 
-  # Don't install the dependencies when we run `pod install` in the old architecture.
-  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    s.pod_target_xcconfig    = {
-        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-    }
-    s.dependency "React-Codegen"
-    s.dependency "RCT-Folly"
-    s.dependency "RCTRequired"
-    s.dependency "RCTTypeSafety"
-    s.dependency "ReactCommon/turbomodule/core"
-   end
-  end    
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end 
 end

package/LICENSE.md

@@ -32,3 +32,20 @@ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
+
+### Third-Party Notices
+
+This project includes code from the "MockFinalizationRegistry.js" gist by `cray0000`, available at:
+https://gist.github.com/cray0000/abecb1ca71fd28a1d8efff2be9e0f6c5
+
+This code is used under the MIT License:
+
+MIT License
+
+Copyright (c) 2024 cray0000
+
+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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.

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.9.0-rc.3**
+Version: **4.9.1-rc.1**
 
 For more information please visit [ditto.live](https://ditto.live), as well as the
-[API Reference](https://software.ditto.live/js/Ditto/4.9.0-rc.3/api-reference/) for this particular version.
+[API Reference](https://software.ditto.live/js/Ditto/4.9.1-rc.1/api-reference/) for this particular version.
 
 ---
 

package/node/ditto.cjs.js

@@ -2310,7 +2310,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.9.0-rc.3';
+const fullBuildVersionString = '4.9.1-rc.1';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.9.0-rc.3",
+  "version": "4.9.1-rc.1",
   "description": "Ditto is a cross-platform SDK that allows apps to sync with and even without internet connectivity.",
   "homepage": "https://ditto.live",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -42,9 +42,7 @@
   },
 
   "dependencies": {
-    "cbor-redux": "^1.0.0",
-    "@ungap/weakrefs": "^0.2.0",
-    "fastestsmallesttextencoderdecoder": "^1.0.22"
+    "cbor-redux": "^1.0.0"
   },
 
   "devDependencies": {

package/react-native/android/CMakeLists.txt

@@ -2,7 +2,6 @@ cmake_minimum_required(VERSION 3.9.0)
 
 set(PACKAGE_NAME "dittorn")
 project(PACKAGE_NAME)
-set(BUILD_DIR ../../../)
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 17)
 
@@ -20,15 +19,25 @@ add_library(
 )
 
 find_package(ReactAndroid REQUIRED CONFIG)
-find_library(log-lib log)
+find_library(LOG_LIB log)
+find_package(fbjni REQUIRED CONFIG)
 
 add_library(dittoffi SHARED IMPORTED)
 set_target_properties(dittoffi PROPERTIES IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/dittoffi/libs/${ANDROID_ABI}/libdittoffi.so")
 
-target_link_libraries(
-        ${PACKAGE_NAME}
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+        target_link_libraries(${PACKAGE_NAME} ReactAndroid::reactnative)
+else()
+        target_link_libraries(${PACKAGE_NAME}
+                ReactAndroid::turbomodulejsijni
+                ReactAndroid::react_nativemodule_core
+                android
+        )
+endif()
+
+target_link_libraries(${PACKAGE_NAME}
         dittoffi
-        ${log-lib}
+        ${LOG_LIB}
         ReactAndroid::jsi
-        android
+        fbjni::fbjni
 )

package/react-native/android/build.gradle

@@ -1,7 +1,9 @@
-import java.nio.file.Paths
 import groovy.json.JsonSlurper
 
 buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["rnsdk_kotlinVersion"]
+
   repositories {
     google()
     mavenCentral()
@@ -9,15 +11,22 @@ buildscript {
 
   dependencies {
     classpath "com.android.tools.build:gradle:7.2.1"
+       // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
 apply plugin: "com.android.library"
-
+apply plugin: "kotlin-android"
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
@@ -68,7 +77,7 @@ android {
         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"
+        abiFilters (*reactNativeArchitectures())
       }
     }
   }
@@ -100,6 +109,8 @@ repositories {
   google()
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
 def getVersionFromPackageJson() {
   def packageJsonPath = file('../../package.json')
   if (packageJsonPath.exists()) {
@@ -117,34 +128,36 @@ dependencies {
   // 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 "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-def aarFile = file('dittoffi/aar/ditto.aar')
-def aarExists = aarFile.exists()
+  def aarFile = file('dittoffi/aar/ditto.aar')
+  def aarExists = aarFile.exists()
 
   if (aarExists) {
-      implementation files('dittoffi/aar/ditto.aar')  
+      println "Using local `ditto.aar`."
+      implementation files('dittoffi/aar/ditto.aar')
   } else {
       implementation "live.ditto:ditto:${project.version}"
   }
 }
 
-task downloadBinaries {
-    doLast {
-        def defaultArchitectures = ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']
+tasks.register('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.so"
+    defaultArchitectures.each { arch ->
+      def fileUrl = "https://software.ditto.live/react-native/ditto/${project.version}/android/${arch}/libdittoffi.so"
 
-            new File("${project.projectDir}/dittoffi/libs/${arch}").mkdirs()
-            def localFilePath = "${project.projectDir}/dittoffi/libs/${arch}/libdittoffi.so"
+      new File("${project.projectDir}/dittoffi/libs/${arch}").mkdirs()
+      def localFilePath = "${project.projectDir}/dittoffi/libs/${arch}/libdittoffi.so"
 
-            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"
-            }
-        }
+      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

@@ -1,145 +1,103 @@
 #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>
+#include <ReactCommon/CallInvokerHolder.h>
+
+#include "dittoffi.h"
+#include "main.h"
+
 
-using namespace facebook::jsi;
+using namespace facebook;
 
 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
+ * A callback function that detaches the current JNI Environment when the thread exits.
+ * See https://stackoverflow.com/a/30026231 for detailed explanation.
  */
-
-void DeferThreadDetach(JNIEnv *env)
-{
+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)
-                                            {
+    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.
+            }
+        });
+        if (err) {
+            // Failed to create TSD key. Handle error if necessary.
         }
         return 0;
-    }();
+    };
+
+    run_once();
 
-    // 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.
+    if (!ts_env) {
+        if (pthread_setspecific(thread_key, env)) {
+            // Failed to set thread-specific value for key. Handle error if necessary.
         }
     }
 }
 
 /**
- * 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
+ * Gets a JNIEnv* valid for the current thread, attaching to the JVM if necessary.
+ * See https://stackoverflow.com/a/30026231 for detailed explanation.
  */
-JNIEnv *GetJniEnv()
-{
+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)
-        {
+    if (get_env_result == JNI_EDETACHED) {
+        if (java_vm->AttachCurrentThread(&env, NULL) == JNI_OK) {
             DeferThreadDetach(env);
+        } else {
+            // Failed to attach thread. Handle error if necessary.
         }
-        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.
+    } else if (get_env_result == JNI_EVERSION) {
+        // Unsupported JNI version. Handle error if necessary.
     }
     return env;
 }
 
-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));
-                                                          });
+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();
+
+                jclass local_java_class = jniEnv->GetObjectClass(java_object);
+                jmethodID defaultDeviceNameMethod = jniEnv->GetMethodID(
+                        local_java_class, "defaultDeviceName", "()Ljava/lang/String;");
+                jobject result = jniEnv->CallObjectMethod(java_object, defaultDeviceNameMethod);
+
+                const char *str = jniEnv->GetStringUTFChars((jstring)result, NULL);
+                Value returnValue = Value(runtime, String::createFromUtf8(runtime, str));
+
+                jniEnv->ReleaseStringUTFChars((jstring)result, str);
+                jniEnv->DeleteLocalRef(result);
+                jniEnv->DeleteLocalRef(local_java_class);
+
+                return returnValue;
+            });
 
     jsiRuntime.global().setProperty(jsiRuntime, "defaultDeviceName", std::move(defaultDeviceName));
 
-    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);
-                                                                                     });
+    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 {
+                int result = ::ditto_sdk_transports_set_android_context(GetJniEnv(), java_context);
+                return Value(result);
+            });
 
     jsiRuntime.global().setProperty(jsiRuntime, "ditto_sdk_transports_set_android_context",
                                     std::move(ditto_sdk_transports_set_android_context));
@@ -148,11 +106,8 @@ void install(Runtime &jsiRuntime)
             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();
+            [](Runtime &runtime, const Value &thisArg, const Value *args, size_t count) -> Value {
+                const char *result = ::ditto_sdk_transports_android_missing_permissions();
                 std::vector<std::string> lines;
                 std::stringstream ss(result);
                 std::string line;
@@ -165,6 +120,8 @@ void install(Runtime &jsiRuntime)
                     jsiArray.setValueAtIndex(runtime, i, String::createFromUtf8(runtime, lines[i]));
                 }
 
+                free(const_cast<char*>(result));
+
                 return jsiArray;
             });
 
@@ -172,21 +129,40 @@ void install(Runtime &jsiRuntime)
                                     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, jstring defaultDir) {
+
+extern "C" 
+JNIEXPORT void JNICALL
+Java_com_dittolive_rnsdk_DittoRNSDKModule_nativeInstall(JNIEnv *env, jobject thiz, jobject context, jobject callInvokerHolderObj,
+                                                        jlong jsi_ptr, jstring default_dir)
+{
     // 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);
 
-    Runtime &runtime = *(reinterpret_cast<Runtime *>(jsiPtr));
+    Runtime &runtime = *(reinterpret_cast<Runtime *>(jsi_ptr));
+
+    // We knew we need to pass the callInvoker from Java to JNI and eventually
+    // access the cthis() method to get the actual CallInvoker object, just like
+    // in the video: https://youtu.be/oLmGInjKU2U?feature=shared&t=1220
+    // The details on how to do this were not documented, though.
+    // We have to figure a way to get the actual CallInvoker object using the fbjni library.
+    // 
+    // jni::alias_ref<> is a wrapper provided by the React Native JNI layer. 
+    // It creates an “alias” reference type which helps in managing the 
+    // lifecycle of JNI references more safely. The alias_ref ensures that the 
+    // reference is valid within the current scope and automatically deletes 
+    // the local reference when going out of scope to prevent memory leaks.
+    auto callInvokerHolderObjRef = reinterpret_cast<react::CallInvokerHolder::javaobject>(callInvokerHolderObj);
+    auto jsCallInvokerHolder = jni::alias_ref<react::CallInvokerHolder::javaobject>(callInvokerHolderObjRef)->cthis();
+    auto jsCallInvoker = jsCallInvokerHolder->getCallInvoker();
 
     Object parameters(runtime);
-    const char *str = env->GetStringUTFChars(defaultDir, NULL);
+    const char *str = env->GetStringUTFChars(default_dir, NULL);
     String defaultDirStr = String::createFromUtf8(runtime, str);
     parameters.setProperty(runtime, "defaultDirectory", defaultDirStr);
+    env->ReleaseStringUTFChars(default_dir, str);
 
-    sharedjsi::install(runtime, parameters);
+    sharedjsi::install(runtime, jsCallInvoker, parameters);
     install(runtime);
 }

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

@@ -0,0 +1,59 @@
+package com.dittolive.rnsdk
+
+import android.os.Build
+import android.util.Log
+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 com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+
+@ReactModule(name = DittoRNSDKModule.NAME)
+class DittoRNSDKModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+  companion object {
+    const val NAME = "DittoRNSDK"
+  }
+
+  private external fun nativeInstall(
+    context: ReactApplicationContext,
+    callInvoker: CallInvokerHolder,
+    jsiPtr: Long,
+    defaultDir: String
+  )
+
+  override fun getName(): String = NAME
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun install(): Boolean {
+    return try {
+      System.loadLibrary("dittorn")
+
+      val jsContextHolder = reactContext.javaScriptContextHolder
+      val jsCallInvokerHolder = reactContext.catalystInstance.jsCallInvokerHolder
+
+      if (jsContextHolder != null && jsCallInvokerHolder != null) {
+          nativeInstall(
+            reactContext,
+            jsCallInvokerHolder,
+            jsContextHolder.get(),
+            reactContext.filesDir.absolutePath
+          )
+          true
+      } else {
+        Log.e("ReactNative", "JavaScript context or call invoker holder is null.")
+        false
+      }
+    } catch (exception: Exception) {
+      Log.e("ReactNative", "Failed to load library or initialize: ${exception.message}", exception)
+      false
+    }
+  }
+
+  fun defaultDeviceName(): String {
+    val manufacturer = Build.MANUFACTURER
+    val model = Build.MODEL
+    return if (model.startsWith(manufacturer)) model else "$manufacturer $model"
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.dittolive.rnsdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class DittoRNSDKPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(DittoRNSDKModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/react-native/cpp/include/DQL.h

@@ -16,6 +16,7 @@ Function dittoffi_query_result_mutated_document_id_count(Runtime &runtime);
 Function dittoffi_query_result_mutated_document_id_at(Runtime &runtime);
 Function dittoffi_query_result_item_cbor(Runtime &runtime);
 Function dittoffi_query_result_item_json(Runtime &runtime);
+Function dittoffi_query_result_free(Runtime &runtime);
 }
 
 #endif /* DQL_H */

package/react-native/cpp/include/GlobalCallInvoker.h

@@ -0,0 +1,8 @@
+#ifndef GlobalCallInvoker_H
+#define GlobalCallInvoker_H
+
+#include "ReactCommon/CallInvoker.h"
+
+extern std::shared_ptr<facebook::react::CallInvoker> globalCallInvoker;
+
+#endif // GlobalCallInvoker_H

package/react-native/cpp/include/Lifecycle.h

@@ -13,4 +13,4 @@ Function ditto_free(Runtime &runtime);
 Function ditto_make(Runtime &runtime);
 }
 
-#endif /* Document_H */
+#endif /* Lifecycle_H */

package/react-native/cpp/include/LiveQuery.h

@@ -10,8 +10,6 @@ namespace sharedjsi
 Function ditto_live_query_signal_available_next(Runtime &runtime);
 Function ditto_live_query_start(Runtime &runtime);
 Function ditto_live_query_stop(Runtime &runtime);
-Function ditto_live_query_register_str_detached(Runtime &runtime);
-void v_live_query_update(void *ctx, c_cb_params_t params);
 }
 
 #endif /* LiveQuery_H */