@dittolive/ditto 4.10.2 → 4.11.0-preview.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.10.2",
+  "version": "4.11.0-preview.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",

package/react-native/android/build.gradle

@@ -1,8 +1,9 @@
 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"]
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["rnsdk_" + name]
+  }
 
   repositories {
     google()
@@ -10,9 +11,9 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
-       // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
@@ -21,20 +22,9 @@ def 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"
-}
-
-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()
@@ -74,10 +64,18 @@ android {
 
     externalNativeBuild {
       cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
-        // ESSENTIAL for adding JSI
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
         arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
+      
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }
@@ -111,23 +109,8 @@ repositories {
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
-def getVersionFromPackageJson() {
-  def packageJsonPath = file('../../package.json')
-  if (packageJsonPath.exists()) {
-      def packageJson = new JsonSlurper().parse(packageJsonPath)
-      return packageJson.version
-  } else {
-      throw new FileNotFoundException("package.json not found at: ${packageJsonPath}")
-  }
-}
-
-project.version = getVersionFromPackageJson()
-
 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 "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
   def aarFile = file('dittoffi/aar/ditto.aar')
@@ -141,6 +124,18 @@ dependencies {
   }
 }
 
+def getVersionFromPackageJson() {
+  def packageJsonPath = file('../../package.json')
+  if (packageJsonPath.exists()) {
+      def packageJson = new JsonSlurper().parse(packageJsonPath)
+      return packageJson.version
+  } else {
+      throw new FileNotFoundException("package.json not found at: ${packageJsonPath}")
+  }
+}
+
+project.version = getVersionFromPackageJson()
+
 tasks.register('downloadBinaries') {
   doLast {
     def defaultArchitectures = ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']

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

@@ -129,12 +129,11 @@ void install(Runtime &jsiRuntime) {
                                     std::move(ditto_sdk_transports_android_missing_permissions));
 }
 
-
-extern "C" 
+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)
-{
+Java_com_dittolive_rnsdk_DittoRNSDKModule_nativeInstall(JNIEnv *env, jobject thiz, jobject context,
+                                                        jobject call_invoker, 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);
@@ -147,13 +146,13 @@ Java_com_dittolive_rnsdk_DittoRNSDKModule_nativeInstall(JNIEnv *env, jobject thi
     // 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 
+    //
+    // 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 callInvokerHolderObjRef = reinterpret_cast<react::CallInvokerHolder::javaobject>(call_invoker);
     auto jsCallInvokerHolder = jni::alias_ref<react::CallInvokerHolder::javaobject>(callInvokerHolderObjRef)->cthis();
     auto jsCallInvoker = jsCallInvokerHolder->getCallInvoker();
 

package/react-native/android/dittoffi/src/ditto_transaction.cpp

@@ -0,0 +1 @@
+#include "ditto_transaction.h"

package/react-native/android/dittoffi/src/ditto_transaction.h

@@ -0,0 +1,91 @@
+extern "C" {
+#include "dittoffi.h"
+}
+#include "retainable.h"
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) TransactionCompletionContinuation;
+%feature("director", assumeoverride=1) TransactionExecuteContinuation;
+%feature("director", assumeoverride=1) BeginTransactionContinuation;
+#endif
+
+/** \brief
+ *  Context object for Kotlin DittoTransaction.InternalTransactionCompletionContinuation which handles wiring up the
+ *  callback from Rust across the FFI boundary.
+ */
+class TransactionCompletionContinuation : public Retainable {
+public:
+    virtual ~TransactionCompletionContinuation() {}
+
+    // To be overridden by Kotlin/Java
+    virtual void invoke(dittoffi_result_dittoffi_transaction_completion_action_t result) = 0;
+
+    static void invokeContinuationCompletion(void *const context,
+                                             dittoffi_result_dittoffi_transaction_completion_action_t result) {
+        auto instance = static_cast<TransactionCompletionContinuation *>(context);
+        instance->invoke(result);
+    }
+
+    BoxDynFnMut1_void_dittoffi_result_dittoffi_transaction_completion_action_t intoFfi() {
+        this->java_retain();
+        BoxDynFnMut1_void_dittoffi_result_dittoffi_transaction_completion_action_t ffiCompletion = {};
+        ffiCompletion.env_ptr = this;
+        ffiCompletion.call = TransactionCompletionContinuation::invokeContinuationCompletion;
+        ffiCompletion.free = TransactionCompletionContinuation::invokeRelease;
+        return ffiCompletion;
+    }
+};
+
+/** \brief
+ *  Context object for Kotlin DittoTransaction.InternalTransactionExecuteContinuation which handles wiring up the
+ *  callback from Rust across the FFI boundary.
+ */
+class TransactionExecuteContinuation : public Retainable {
+public:
+    virtual ~TransactionExecuteContinuation() {}
+
+    // To be overridden by Kotlin/Java
+    virtual void invoke(dittoffi_result_dittoffi_query_result_ptr_t result) = 0;
+
+    static void invokeContinuationExecute(void *const context,
+                                          dittoffi_result_dittoffi_query_result_ptr_t result) {
+        auto instance = static_cast<TransactionExecuteContinuation *>(context);
+        instance->invoke(result);
+    }
+
+    BoxDynFnMut1_void_dittoffi_result_dittoffi_query_result_ptr_t intoFfi() {
+        this->java_retain();
+        BoxDynFnMut1_void_dittoffi_result_dittoffi_query_result_ptr_t ffiExecute = {};
+        ffiExecute.env_ptr = this;
+        ffiExecute.call = TransactionExecuteContinuation::invokeContinuationExecute;
+        ffiExecute.free = TransactionExecuteContinuation::invokeRelease;
+        return ffiExecute;
+    }
+};
+
+/** \brief
+ *  Context object for Kotlin DittoStore.InternalDittoBeginTransactionContinuation which handles wiring up the
+ *  callback from Rust across the FFI boundary.
+ */
+class BeginTransactionContinuation : public Retainable {
+public:
+    virtual ~BeginTransactionContinuation() {}
+
+    // To be overridden by Kotlin
+    virtual void invoke(dittoffi_result_dittoffi_transaction_ptr_t result) = 0;
+
+    static void invokeContinuation(void *const context,
+                                   dittoffi_result_dittoffi_transaction_ptr_t result) {
+        auto instance = static_cast<BeginTransactionContinuation *>(context);
+        instance->invoke(result);
+    }
+
+    BoxDynFnMut1_void_dittoffi_result_dittoffi_transaction_ptr_t intoFfi() {
+        this->java_retain();
+        BoxDynFnMut1_void_dittoffi_result_dittoffi_transaction_ptr_t ffiBeginTransaction = {};
+        ffiBeginTransaction.env_ptr = this;
+        ffiBeginTransaction.call = BeginTransactionContinuation::invokeContinuation;
+        ffiBeginTransaction.free = BeginTransactionContinuation::invokeRelease;
+        return ffiBeginTransaction;
+    }
+};