@dittolive/ditto 4.8.2 → 4.9.0-alpha.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.8.2",
-  "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
+  "version": "4.9.0-alpha.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",
 
@@ -48,6 +48,6 @@
   },
 
   "devDependencies": {
-    "serve": "^14.2.1"
+    "serve": "^14.2.3"
   }
 }

package/react-native/android/CMakeLists.txt

@@ -1,35 +1,33 @@
 cmake_minimum_required(VERSION 3.9.0)
 
-set (PACKAGE_NAME "cpp")
+set(PACKAGE_NAME "dittorn")
 project(PACKAGE_NAME)
-set (BUILD_DIR ../../../)
+set(BUILD_DIR ../../../)
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 17)
 
 include_directories(
-            ../cpp/include
-            ../dittoffi
+        ../cpp/include
+        dittoffi/src
 )
 
-file(GLOB SOURCES "../cpp/src/*.cpp")
+file(GLOB SOURCES "../cpp/src/*.cpp" "dittoffi/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")
+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}
-        ditto
+        dittoffi
         ${log-lib}
         ReactAndroid::jsi
         android

package/react-native/android/build.gradle

@@ -118,11 +118,11 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-def aarFile = file('libs/ditto.aar')
+def aarFile = file('dittoffi/aar/ditto.aar')
 def aarExists = aarFile.exists()
 
   if (aarExists) {
-      implementation files('libs/ditto.aar')  
+      implementation files('dittoffi/aar/ditto.aar')  
   } else {
       implementation "live.ditto:ditto:${project.version}"
   }
@@ -133,10 +133,10 @@ task downloadBinaries {
         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"
+            def fileUrl = "https://software.ditto.live/react-native/ditto/${project.version}/android/${arch}/libdittoffi.so"
 
-            new File("${project.projectDir}/../dittoffi/android/${arch}").mkdirs()
-            def localFilePath = "${project.projectDir}/../dittoffi/android/${arch}/libdittoffi.a"
+            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"

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

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

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

@@ -0,0 +1,75 @@
+extern "C" {
+#include "dittoffi.h"
+}
+
+#include "retainable.h"
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) AttachmentObserverRust;
+%apply(char *STRING, size_t LENGTH) { (const unsigned char *id_ptr, uintptr_t id_len) };
+#endif
+class AttachmentObserverRust: public Retainable {
+public:
+  virtual ~AttachmentObserverRust() {}
+  virtual void completedEventHandler(
+    const struct AttachmentHandle *ah
+  ) = 0;
+
+  virtual void progressEventHandler(
+    uint64_t downloadedBytes,
+    uint64_t totalBytes
+  ) = 0;
+
+  virtual void deletedEventHandler(
+  ) = 0;
+
+  static void invokeCompletedEventHandler(
+    void *ctx,
+    struct AttachmentHandle *ah
+  ) {
+    auto inst = static_cast<AttachmentObserverRust*>(ctx);
+    return inst->completedEventHandler(
+      ah
+    );
+  }
+
+  static void invokeProgressEventHandler(
+    void *ctx,
+    uint64_t downloadedBytes,
+    uint64_t totalBytes
+  ) {
+    auto inst = static_cast<AttachmentObserverRust*>(ctx);
+    return inst->progressEventHandler(
+      downloadedBytes,
+      totalBytes
+    );
+  }
+
+  static void invokeDeletedEventHandler(
+    void *ctx
+  ) {
+    auto inst = static_cast<AttachmentObserverRust*>(ctx);
+    return inst->deletedEventHandler(
+    );
+  }
+
+  virtual CancelTokenResult_t resolve_attachment(
+    struct CDitto *ditto_raw,
+    const unsigned char *id_ptr,
+    uintptr_t id_len
+  ) {
+     return ditto_resolve_attachment(
+       ditto_raw,
+       (slice_ref_uint8_t) {
+           .ptr = id_ptr,
+           .len = id_len,
+       },
+       this,
+       AttachmentObserverRust::invokeRetain,
+       AttachmentObserverRust::invokeRelease,
+       AttachmentObserverRust::invokeCompletedEventHandler,
+       AttachmentObserverRust::invokeProgressEventHandler,
+       AttachmentObserverRust::invokeDeletedEventHandler
+     );
+  }
+};

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

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

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

@@ -0,0 +1,56 @@
+extern "C" {
+#include "dittoffi.h"
+}
+
+#include "retainable.h"
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) ConnectionRequestHandlerRust;
+#endif
+
+/** \brief
+ *  Context object for Kotlin DittoConnectionRequestHandler which handles wiring up callbacks from
+ *  Rust across the FFI boundary.
+ */
+class ConnectionRequestHandlerRust: public Retainable {
+public:
+  virtual ~ConnectionRequestHandlerRust() {}
+
+  static void invokeEventHandler(
+    Erased_t const *ctx,
+    dittoffi_connection_request_t *connection_request
+  ) {
+    auto inst = (ConnectionRequestHandlerRust *)ctx;
+    return inst->eventHandler(connection_request);
+  }
+
+  virtual void eventHandler(
+    dittoffi_connection_request_t *connection_request
+  ) = 0;
+
+  virtual void registerConnectionRequestHandler(
+    struct CDitto *ditto_raw,
+    ConnectionRequestHandlerRust *handler
+  ) {
+    Erased_t* handler_pointer;
+    if (handler != nullptr) {
+      Retainable::invokeRetain(handler);
+      handler_pointer = (Erased_t *)handler;
+    } else {
+      handler_pointer = NULL; // Pass null to clear the handler
+    }
+
+    FfiConnectionRequestHandlerVTable_t const v_table = {
+      .release_vptr = (void (*)(Erased_t *)) ConnectionRequestHandlerRust::invokeRelease,
+      .retain_vptr = ConnectionRequestHandlerRust::invokeVirtualPtrRetain,
+      .on_connecting = ConnectionRequestHandlerRust::invokeEventHandler
+    };
+
+    VirtualPtr__Erased_ptr_FfiConnectionRequestHandlerVTable_t const ffi_handler = {
+      .ptr = handler_pointer,
+      .vtable = v_table
+    };
+
+    dittoffi_presence_set_connection_request_handler(ditto_raw, ffi_handler);
+  }
+};

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

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

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

@@ -0,0 +1,40 @@
+extern "C" {
+#include "dittoffi.h"
+}
+
+#include "retainable.h"
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) CrashReporterFfi;
+#endif
+
+class CrashReporterFfi: public Retainable {
+public:
+  virtual ~CrashReporterFfi() {}
+
+  static void ffiInvokeReportCrashKotlinImplementation(
+    void *ctx,
+    dittoffi_panic_t *panic
+  ) {
+    auto inst = (CrashReporterFfi *)ctx;
+    return inst->reportCrashKotlinImplementation(panic);
+  }
+
+  virtual void reportCrashKotlinImplementation(
+    dittoffi_panic_t *panic
+  ) = 0;
+
+  virtual void overrideCrashReporter(
+    struct CDitto *ditto_raw
+  ) {
+    CrashReporterFfi * handler = this;
+
+    BoxDynFnMut1_void_dittoffi_panic_ptr_t ffiPanicHandler;
+    handler->retain();
+    ffiPanicHandler.env_ptr = handler;
+    ffiPanicHandler.call = CrashReporterFfi::ffiInvokeReportCrashKotlinImplementation;
+    ffiPanicHandler.free = CrashReporterFfi::invokeRelease;
+
+    dittoffi_override_crash_reporter(ffiPanicHandler);
+  }
+};

package/react-native/android/dittoffi/src/dittoffi_java.i

@@ -0,0 +1,42 @@
+/* File: dittoffi_java.i */
+%module(directors="1") dittoffi
+
+%{
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+%}
+
+// `%include`s mean that SWIG processes the files and generates wrapper and
+// proxy classes as appropriate for the types it encounters.
+%{
+#include "logger_cb.h"
+#include "logger_export.h"
+%}
+// 🐉🐉
+// Make sure to have this `%include` before that of dependent classes.
+// SWIG won't directly error if you don't, but things will nonetheless
+// break at runtime, which gets very hard to debug and diagnose. Fun™
+// 🐉🐉
+%include "retainable.h"
+%include "logger_cb.h"
+%include "logger_export.h"
+%include "dittomesh_java.i"
+%include "dittostore_java.i"
+extern "C" {
+  %include "dittoffi.h"
+}
+
+// imports
+// http://www.swig.org/Doc4.0/Java.html#Java_imclass_pragmas
+%pragma(java) jniclassimports=%{
+import live.ditto.internal.NativeLibraryLoader;
+%}
+
+// class dittoffiJNI {
+%pragma(java) jniclasscode=%{
+  static {
+    NativeLibraryLoader loader = new NativeLibraryLoader();
+    loader.loadDitto();
+  }
+%}

package/react-native/android/dittoffi/src/dittomesh_java.i

@@ -0,0 +1,16 @@
+%{
+#include "mesh_java_interfaces.h"
+%}
+typedef int int32_t;
+
+%include "mesh_java_interfaces.h"
+
+%include "cpointer.i"
+%include <stdint.i>
+
+%typemap(newfree) char * {
+  if ($1 != NULL) {
+    ditto_c_string_free($1);
+  }
+}
+%newobject ditto_auth_client_user_id;