@dittolive/ditto 4.10.2 → 4.11.0-preview.1

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

@@ -57,6 +57,57 @@ protected:
     Swig::BoolArray<3> swig_override;
 };
 
+class SwigDirector_TransactionCompletionContinuation : public TransactionCompletionContinuation, public Swig::Director {
+
+public:
+    void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);
+    SwigDirector_TransactionCompletionContinuation(JNIEnv *jenv);
+    virtual ~SwigDirector_TransactionCompletionContinuation();
+    virtual void java_retain();
+    virtual void java_release();
+    virtual void invoke(dittoffi_result_dittoffi_transaction_completion_action_t result);
+public:
+    bool swig_overrides(int n) {
+      return (n < 3 ? swig_override[n] : false);
+    }
+protected:
+    Swig::BoolArray<3> swig_override;
+};
+
+class SwigDirector_TransactionExecuteContinuation : public TransactionExecuteContinuation, public Swig::Director {
+
+public:
+    void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);
+    SwigDirector_TransactionExecuteContinuation(JNIEnv *jenv);
+    virtual ~SwigDirector_TransactionExecuteContinuation();
+    virtual void java_retain();
+    virtual void java_release();
+    virtual void invoke(dittoffi_result_dittoffi_query_result_ptr_t result);
+public:
+    bool swig_overrides(int n) {
+      return (n < 3 ? swig_override[n] : false);
+    }
+protected:
+    Swig::BoolArray<3> swig_override;
+};
+
+class SwigDirector_BeginTransactionContinuation : public BeginTransactionContinuation, public Swig::Director {
+
+public:
+    void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);
+    SwigDirector_BeginTransactionContinuation(JNIEnv *jenv);
+    virtual ~SwigDirector_BeginTransactionContinuation();
+    virtual void java_retain();
+    virtual void java_release();
+    virtual void invoke(dittoffi_result_dittoffi_transaction_ptr_t result);
+public:
+    bool swig_overrides(int n) {
+      return (n < 3 ? swig_override[n] : false);
+    }
+protected:
+    Swig::BoolArray<3> swig_override;
+};
+
 class SwigDirector_WifiAwareRust : public WifiAwareRust, public Swig::Director {
 
 public:
@@ -73,16 +124,16 @@ public:
     virtual void serverStopAdvertising();
     virtual void serverUpdatePeer(char const *announce,ConnectState_t state);
     virtual void updateParameterU64(dittoffi_wifi_aware_system_parameter_u64 parameter,uint64_t value);
-    virtual void addWifiAwareClientTransport(CDitto *ditto);
-    virtual void removeWifiAwareClientTransport();
-    virtual void addWifiAwareServerAdvertiser(CDitto *ditto);
-    virtual void removeWifiAwareServerAdvertiser();
+    virtual void addWifiAwareTransport(CDitto *ditto);
+    virtual void removeWifiAwareTransport();
     virtual void clientPeerAppeared(char const *announce);
     virtual void clientPeerDisappeared(char const *announce);
     virtual void clientScanningStateChanged(OnlineState_t state,TransportCondition_t result);
     virtual void clientNetworkDidCreate(char const *announce,char const *hostname,uint16_t port);
     virtual void clientNetworkDidNotCreate(char const *announce);
     virtual void serverAdvertisingStateChanged(OnlineState_t state,TransportCondition_t result);
+    virtual void serverNetworkScopeIdAdded(uint32_t scope_id);
+    virtual void serverNetworkScopeIdRemoved(uint32_t scope_id);
     virtual void goOnlineRequest();
     virtual void goOfflineRequest();
 public:
@@ -116,10 +167,8 @@ public:
     virtual int sendL2capToPeripheral(char const peripheralUuid[],size_t uuidLen,char const data[],size_t len);
     virtual int readL2capFromCentral(char const centralUuid[],size_t uuidLen,slice_mut_uint8_t data);
     virtual int sendL2capToCentral(char const centralUuid[],size_t uuidLen,char const data[],size_t len);
-    virtual void addBleClientTransport(CDitto *ditto);
-    virtual void addBleServerTransport(CDitto *ditto);
-    virtual void dropBleClientTransport();
-    virtual void dropBleServerTransport();
+    virtual void addBleTransport(CDitto *ditto);
+    virtual void dropBleTransport();
     virtual void advertisementHeard(char const peripheralUuid[],size_t uuidLen,char const manufacturerData[],size_t manufacturerDataLen,bool manufacturerDataIncludesId,char *name,float rssi);
     virtual void connectionStateChanged(char const peripheralUuid[],size_t uuidLen,ConnectState_t state,bool l2cap_available,int mtu);
     virtual void peripheralMtuUpdated(char const uuid[],size_t uuidLen,int mtu);
@@ -138,10 +187,10 @@ public:
     virtual void centralL2capDataAvailable(char const uuid[],size_t uuidLen);
 public:
     bool swig_overrides(int n) {
-      return (n < 37 ? swig_override[n] : false);
+      return (n < 35 ? swig_override[n] : false);
     }
 protected:
-    Swig::BoolArray<37> swig_override;
+    Swig::BoolArray<35> swig_override;
 };
 
 class SwigDirector_StatusRust : public StatusRust, public Swig::Director {

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

@@ -12,6 +12,7 @@
 %{
 #include "logger_cb.h"
 #include "logger_export.h"
+#include "ditto_transaction.h"
 %}
 // 🐉🐉
 // Make sure to have this `%include` before that of dependent classes.
@@ -21,6 +22,7 @@
 %include "retainable.h"
 %include "logger_cb.h"
 %include "logger_export.h"
+%include "ditto_transaction.h"
 %include "dittomesh_java.i"
 %include "dittostore_java.i"
 extern "C" {

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

@@ -285,6 +285,54 @@
   }
 }
 
+/* Ditto for `SWIGTYPE_p_dittoffi_query_result_item[] -> slice_ref_dittoffi_query_result_item_ptr_t`: */
+// High-level Java type (corresponding to Kotlin's `Array<SWIGTYPE_p_dittoffi_query_result_item>`):
+%typemap(jstype) slice_ref_dittoffi_query_result_item_ptr_t "SWIGTYPE_p_dittoffi_query_result_item[]"
+// JNI-compatible Java type
+%typemap(jtype) slice_ref_dittoffi_query_result_item_ptr_t "SWIGTYPE_p_dittoffi_query_result_item[]"
+// Conversion from the former to the latter (inwards)
+%typemap(javain) slice_ref_dittoffi_query_result_item_ptr_t "$javainput"
+// C JNI-equivalent to the `jtype`:
+%typemap(jni) slice_ref_dittoffi_query_result_item_ptr_t "jobjectArray"
+// Conversion from it to the C FFI type
+%typemap(in) slice_ref_dittoffi_query_result_item_ptr_t {
+  size_t arr_len = (size_t) JCALL1(GetArrayLength, jenv, $input);
+  if (arr_len == 0) {
+    $1 = (slice_ref_dittoffi_query_result_item_ptr_t) { .ptr = (dittoffi_query_result_item * const *)0xbad000, .len = 0 };
+  } else {
+    $1 = (slice_ref_dittoffi_query_result_item_ptr_t) {
+      .len = arr_len,
+    };
+    $1.ptr = (typeof($1.ptr)) calloc(sizeof(*$1.ptr), $1.len);
+    // Prepare to call `SWIGTYPE_p_dittoffi_query_result_item.getCPtr()` as done above
+    jclass jcls_SWIGTYPE_p_dittoffi_query_result_item = JCALL1(FindClass, jenv
+      , "live/ditto/internal/swig/ffi/SWIGTYPE_p_dittoffi_query_result_item"
+    );
+    ASSERT_AND_THROW_RETURN_NULL(jcls_SWIGTYPE_p_dittoffi_query_result_item != NULL, jenv, "jcls_SWIGTYPE_p_dittoffi_query_result_item is NULL");
+    jmethodID getCPtr = JCALL3(GetStaticMethodID, jenv
+      , jcls_SWIGTYPE_p_dittoffi_query_result_item
+      , "getCPtr"
+      , "(Llive/ditto/internal/swig/ffi/SWIGTYPE_p_dittoffi_query_result_item;)J"
+    );
+    ASSERT_AND_THROW_RETURN_NULL(getCPtr != 0, jenv, "Failed to get method ID for getCPtr");
+    for (size_t i = 0; i < $1.len; ++i) {
+      jobject jobj = JCALL2(GetObjectArrayElement, jenv, $input, i);
+      ((dittoffi_query_result_item const * *) $1.ptr)[i] = (dittoffi_query_result_item *)JCALL3(CallStaticLongMethod, jenv
+        , jcls_SWIGTYPE_p_dittoffi_query_result_item
+        , getCPtr
+        , jobj
+      );
+      JCALL1(DeleteLocalRef, jenv, jobj);
+    }
+    // Freeing $1.ptr is to be done within the `freearg` typemap
+  }
+}
+%typemap(freearg) slice_ref_dittoffi_query_result_item_ptr_t {
+  if ($1.len > 0) {
+    free((void *) $1.ptr); // frees calloc
+  }
+}
+
 /* These SWIG typemaps means that a Java `byte[]` is returned in place of a
  * `slice_boxed_uint8_t` ("outwards")
  */

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

@@ -78,70 +78,52 @@ public:
     return inst->updateParameterU64(parameter, value);
   }
 
-  virtual void addWifiAwareClientTransport(struct CDitto *ditto) {
-    WifiAwareClientCallbacks_t cb = {
+  virtual void addWifiAwareTransport(struct CDitto *ditto) {
+    WifiAwareClientCallbacks_t client_cb = {
         .start_searching = WifiAwareRust::invokeClientStartSearching,
         .stop_searching = WifiAwareRust::invokeClientStopSearching,
         .create_network = WifiAwareRust::invokeClientCreateNetwork,
         .update_peer = WifiAwareRust::invokeClientUpdatePeer,
     };
-    auto handle = ditto_add_wifi_aware_client_transport(
-        ditto, cb, this, WifiAwareRust::invokeRetain,
-        WifiAwareRust::invokeRelease);
+    WifiAwareServerCallbacks_t server_cb = {
+      .start_advertising = WifiAwareRust::invokeServerStartAdvertising,
+      .stop_advertising = WifiAwareRust::invokeServerStopAdvertising,
+      .update_peer = WifiAwareRust::invokeServerUpdatePeer,
+      .update_parameter_u64 = WifiAwareRust::invokeUpdateParameterU64,
+  };
+
+  auto handle = ditto_add_wifi_aware_transport(
+      ditto, client_cb, server_cb, this, WifiAwareRust::invokeRetain,
+      WifiAwareRust::invokeRelease);
     atomic_store(
-        &clientHandle,
-        std::shared_ptr<TransportHandle_WifiAwareClientPlatformEvent_t>(
-            handle, [](TransportHandle_WifiAwareClientPlatformEvent_t *h) {
-              ditto_wifi_aware_client_free_handle(h);
+        &transportHandle,
+        std::shared_ptr<TransportHandle_WifiAwarePlatformEvent_t>(
+            handle, [](TransportHandle_WifiAwarePlatformEvent_t *h) {
+              ditto_wifi_aware_transport_free_handle(h);
             }));
   }
 
-  virtual void removeWifiAwareClientTransport() {
+  virtual void removeWifiAwareTransport() {
     atomic_store(
-        &clientHandle,
-        std::shared_ptr<TransportHandle_WifiAwareClientPlatformEvent_t>());
-  }
-
-  virtual void addWifiAwareServerAdvertiser(struct CDitto *ditto) {
-    WifiAwareServerCallbacks_t cb = {
-        .start_advertising = WifiAwareRust::invokeServerStartAdvertising,
-        .stop_advertising = WifiAwareRust::invokeServerStopAdvertising,
-        .update_peer = WifiAwareRust::invokeServerUpdatePeer,
-        .update_parameter_u64 = WifiAwareRust::invokeUpdateParameterU64,
-    };
-
-    auto handle = ditto_add_wifi_aware_server_advertiser(
-        ditto, cb, this, WifiAwareRust::invokeRetain,
-        WifiAwareRust::invokeRelease);
-    atomic_store(
-        &serverHandle,
-        std::shared_ptr<TransportHandle_WifiAwareServerPlatformEvent_t>(
-            handle, [](TransportHandle_WifiAwareServerPlatformEvent_t *h) {
-              ditto_wifi_aware_server_free_handle(h);
-            }));
-  }
-
-  virtual void removeWifiAwareServerAdvertiser() {
-    atomic_store(
-        &serverHandle,
-        std::shared_ptr<TransportHandle_WifiAwareServerPlatformEvent_t>());
+        &transportHandle,
+        std::shared_ptr<TransportHandle_WifiAwarePlatformEvent_t>());
   }
 
   virtual void clientPeerAppeared(const char *announce) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_client_peer_appeared(handle.get(), announce);
     }
   }
   virtual void clientPeerDisappeared(const char *announce) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_client_peer_disappeared(handle.get(), announce);
     }
   }
   virtual void clientScanningStateChanged(OnlineState_t state,
                                           TransportCondition_t result) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_client_scanning_state_changed(handle.get(), state,
                                                      result);
@@ -149,14 +131,14 @@ public:
   }
   virtual void clientNetworkDidCreate(const char *announce,
                                       const char *hostname, uint16_t port) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_client_network_did_create(handle.get(), announce,
                                                  hostname, port);
     }
   }
   virtual void clientNetworkDidNotCreate(const char *announce) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_client_peer_did_not_connect(handle.get(), announce);
     }
@@ -164,37 +146,44 @@ public:
 
   virtual void serverAdvertisingStateChanged(OnlineState_t state,
                                              TransportCondition_t result) {
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_wifi_aware_server_advertising_state_changed(handle.get(), state,
                                                         result);
     }
   }
 
-  virtual void goOnlineRequest() {
-    auto server_handle = atomic_load(&serverHandle);
-    if (server_handle) {
-      ditto_wifi_aware_server_go_online_request(server_handle.get());
+  virtual void serverNetworkScopeIdAdded(uint32_t scope_id) {
+    auto handle = atomic_load(&transportHandle);
+    if (handle) {
+      ditto_wifi_aware_server_network_scope_id_added(handle.get(), scope_id);
+    }
+  }
+
+  virtual void serverNetworkScopeIdRemoved(uint32_t scope_id) {
+    auto handle = atomic_load(&transportHandle);
+    if (handle) {
+      ditto_wifi_aware_server_network_scope_id_removed(handle.get(), scope_id);
     }
-    auto client_handle = atomic_load(&clientHandle);
-    if (client_handle) {
-      ditto_wifi_aware_client_go_online_request(client_handle.get());
+  }
+
+  virtual void goOnlineRequest() {
+    auto handle = atomic_load(&transportHandle);
+    if (handle) {
+      ditto_wifi_aware_server_go_online_request(handle.get());
+      ditto_wifi_aware_client_go_online_request(handle.get());
     }
   }
 
   virtual void goOfflineRequest() {
-    auto server_handle = atomic_load(&serverHandle);
-    if (server_handle) {
-      ditto_wifi_aware_server_go_offline_request(server_handle.get());
-    }
-    auto client_handle = atomic_load(&clientHandle);
-    if (client_handle) {
-      ditto_wifi_aware_client_go_offline_request(client_handle.get());
+    auto handle = atomic_load(&transportHandle);
+    if (handle) {
+      ditto_wifi_aware_server_go_offline_request(handle.get());
+      ditto_wifi_aware_client_go_offline_request(handle.get());
     }
   }
 
-  std::shared_ptr<TransportHandle_WifiAwareClientPlatformEvent_t> clientHandle;
-  std::shared_ptr<TransportHandle_WifiAwareServerPlatformEvent_t> serverHandle;
+  std::shared_ptr<TransportHandle_WifiAwarePlatformEvent_t> transportHandle;
 };
 
 #ifdef SWIG
@@ -335,8 +324,8 @@ public:
     return inst->sendL2capToCentral((const char *)central_uuid, 16,
                                     (char const *)data.ptr, data.len);
   }
-  virtual void addBleClientTransport(struct CDitto *ditto) {
-    BleClientCallbacks_t cb = {
+  virtual void addBleTransport(struct CDitto *ditto) {
+    BleClientCallbacks_t client_cb = {
         .start_scanning = BluetoothLeRadioRust::invokeStartScanning,
         .stop_scanning = BluetoothLeRadioRust::invokeStopScanning,
         .scanning_state = BluetoothLeRadioRust::invokeGetScanningState,
@@ -348,20 +337,7 @@ public:
             BluetoothLeRadioRust::invokeReadL2capFromPeripheral,
         .send_l2cap_to_peripheral =
             BluetoothLeRadioRust::invokeSendL2capToPeripheral};
-    auto handle = ditto_add_ble_client_transport(
-        ditto, cb, this, BluetoothLeRadioRust::invokeRetain,
-        BluetoothLeRadioRust::invokeRelease);
-    atomic_store(&clientHandle,
-                 std::shared_ptr<TransportHandle_BleClientPlatformEvent_t>(
-                     handle, [](TransportHandle_BleClientPlatformEvent_t *h) {
-                       // We own this pointer
-                       // When nobody is using it any more we will free it via
-                       // Rust
-                       ble_client_free_handle(h);
-                     }));
-  }
-  virtual void addBleServerTransport(struct CDitto *ditto) {
-    BleServerCallbacks_t cb = {
+    BleServerCallbacks_t server_cb = {
         .start_advertising = BluetoothLeRadioRust::invokeStartAdvertising,
         .stop_advertising = BluetoothLeRadioRust::invokeStopAdvertising,
         .advertising_state = BluetoothLeRadioRust::invokeGetAdvertisingState,
@@ -370,31 +346,28 @@ public:
             BluetoothLeRadioRust::invokeReadL2capFromCentral,
         .send_l2cap_to_central =
             BluetoothLeRadioRust::invokeSendL2capToCentral};
-    auto handle = ditto_add_ble_server_transport(
-        ditto, cb, this, BluetoothLeRadioRust::invokeRetain,
+    auto handle = ditto_add_ble_transport(
+        ditto, client_cb, this, server_cb, this, BluetoothLeRadioRust::invokeRetain,
         BluetoothLeRadioRust::invokeRelease);
-    atomic_store(&serverHandle,
-                 std::shared_ptr<TransportHandle_BleServerPlatformEvent_t>(
-                     handle, [](TransportHandle_BleServerPlatformEvent_t *h) {
-                       ble_server_free_handle(h);
+    atomic_store(&transportHandle,
+                 std::shared_ptr<TransportHandle_BlePlatformEvent_t>(
+                     handle, [](TransportHandle_BlePlatformEvent_t *h) {
+                       ditto_ble_transport_free_handle(h);
                      }));
   }
-  virtual void dropBleClientTransport() {
+
+  virtual void dropBleTransport() {
     // This is how we break the circular ownership when it is time to shut down
     // the transport
-    atomic_store(&clientHandle,
-                 std::shared_ptr<TransportHandle_BleClientPlatformEvent_t>());
-  }
-  virtual void dropBleServerTransport() {
-    atomic_store(&serverHandle,
-                 std::shared_ptr<TransportHandle_BleServerPlatformEvent_t>());
+    atomic_store(&transportHandle,
+                 std::shared_ptr<TransportHandle_BlePlatformEvent_t>());
   }
   virtual void advertisementHeard(const char peripheralUuid[], size_t uuidLen,
                                   const char manufacturerData[],
                                   size_t manufacturerDataLen,
                                   bool manufacturerDataIncludesId, char *name,
                                   float rssi) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ditto_transports_ble_advertisement_heard(
           handle.get(), (uint8_16_array_t const *)peripheralUuid,
@@ -414,7 +387,7 @@ public:
   virtual void connectionStateChanged(const char peripheralUuid[],
                                       size_t uuidLen, ConnectState_t state,
                                       bool l2cap_available, int mtu) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_connection_state_changed(handle.get(),
@@ -425,7 +398,7 @@ public:
   }
   virtual void peripheralMtuUpdated(const char uuid[], size_t uuidLen,
                                     int mtu) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_peripheral_mtu_updated(handle.get(), (uint8_16_array_t const *)uuid,
@@ -436,7 +409,7 @@ public:
   virtual void receivedFromPeripheral(const char peripheralUuid[],
                                       size_t uuidLen, BleDataType_t dataType,
                                       const char data[], size_t len) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_received_from_peripheral(
@@ -450,13 +423,13 @@ public:
   }
   virtual void scanningStateChanged(OnlineState_t state,
                                     TransportCondition_t result) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_scanning_state_changed(handle.get(), state, result);
     }
   }
   virtual void peripheralReadyToSend(const char uuid[], size_t uuidLen) {
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_peripheral_ready_to_send(handle.get(),
@@ -466,7 +439,7 @@ public:
   }
   virtual void peripheralL2capReadyToSend(const char uuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_peripheral_l2cap_ready_to_send(handle.get(),
                                          (uint8_16_array_t const *)uuid);
@@ -475,7 +448,7 @@ public:
   }
   virtual void peripheralL2capDataAvailable(const char uuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&clientHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_peripheral_l2cap_data_available(handle.get(),
                                           (uint8_16_array_t const *)uuid);
@@ -484,13 +457,13 @@ public:
   }
   virtual void advertisingStateChanged(OnlineState_t state,
                                        TransportCondition_t result) {
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_advertising_state_changed(handle.get(), state, result);
     }
   }
   virtual void centralMtuUpdated(const char uuid[], size_t uuidLen, int mtu) {
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_central_mtu_updated(handle.get(), (uint8_16_array_t const *)uuid,
@@ -501,7 +474,7 @@ public:
   virtual void receivedFromCentral(const char centralUuid[], size_t uuidLen,
                                    BleDataType_t dataType, const char data[],
                                    size_t len) {
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     assert(uuidLen == 16);
     if (handle) {
       ble_received_from_central(handle.get(),
@@ -517,7 +490,7 @@ public:
                                          size_t uuidLen, const char data[],
                                          size_t len, bool l2capAvailable,
                                          int mtu) {
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_central_finished_connecting(handle.get(),
                                       (uint8_16_array_t const *)centralUuid,
@@ -530,7 +503,7 @@ public:
   }
   virtual void centralUnsubscribed(const char centralUuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_central_unsubscribed(handle.get(),
                                (uint8_16_array_t const *)centralUuid);
@@ -538,7 +511,7 @@ public:
   }
   virtual void centralReadyToSend(const char uuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_central_ready_to_send(handle.get(), (uint8_16_array_t const *)uuid);
     }
@@ -546,7 +519,7 @@ public:
   }
   virtual void centralL2capReadyToSend(const char uuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_central_l2cap_ready_to_send(handle.get(),
                                       (uint8_16_array_t const *)uuid);
@@ -555,15 +528,14 @@ public:
   }
   virtual void centralL2capDataAvailable(const char uuid[], size_t uuidLen) {
     assert(uuidLen == 16);
-    auto handle = atomic_load(&serverHandle);
+    auto handle = atomic_load(&transportHandle);
     if (handle) {
       ble_central_l2cap_data_available(handle.get(),
                                        (uint8_16_array_t const *)uuid);
     }
     (void)uuidLen;
   }
-  std::shared_ptr<TransportHandle_BleClientPlatformEvent_t> clientHandle;
-  std::shared_ptr<TransportHandle_BleServerPlatformEvent_t> serverHandle;
+  std::shared_ptr<TransportHandle_BlePlatformEvent_t> transportHandle;
 };
 
 #ifdef SWIG
@@ -649,7 +621,7 @@ public:
 #endif
 class DiskUsageObserverRust : public Retainable {
 private:
-  DiskUsageObserver *observerHandle;
+  DiskUsageObserver *obplatformHandle;
 
 public:
   virtual ~DiskUsageObserverRust() {}
@@ -662,14 +634,14 @@ public:
   }
 
   virtual void subscribe(struct CDitto *ditto) {
-    observerHandle = ditto_register_disk_usage_callback(
+    obplatformHandle = ditto_register_disk_usage_callback(
         ditto, FsComponent::FS_COMPONENT_ROOT, this,
         DiskUsageObserverRust::invokeRetain,
         DiskUsageObserverRust::invokeRelease,
         DiskUsageObserverRust::invokeDiskUsageUpdated);
   }
 
-  virtual void stop() { ditto_release_disk_usage_callback(observerHandle); }
+  virtual void stop() { ditto_release_disk_usage_callback(obplatformHandle); }
 };
 
 #ifdef SWIG

package/react-native/android/gradle.properties

@@ -1,5 +1,6 @@
-rnsdk_kotlinVersion=1.7.0
-rnsdk_minSdkVersion=24
-rnsdk_targetSdkVersion=31
-rnsdk_compileSdkVersion=31
-rnsdk_ndkversion=21.4.7075529
+rnsdk__kotlinVersion=2.0.21
+rnsdk__minSdkVersion=24
+rnsdk__targetSdkVersion=34
+rnsdk__compileSdkVersion=35
+rnsdk__ndkVersion=27.1.12297006
+

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

@@ -4,16 +4,15 @@ 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
+import com.facebook.soloader.SoLoader
 
-
-@ReactModule(name = DittoRNSDKModule.NAME)
 class DittoRNSDKModule(private val reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
-  companion object {
-    const val NAME = "DittoRNSDK"
+
+  override fun getName(): String {
+    return NAME
   }
 
   private external fun nativeInstall(
@@ -23,24 +22,27 @@ class DittoRNSDKModule(private val reactContext: ReactApplicationContext) :
     defaultDir: String
   )
 
-  override fun getName(): String = NAME
-
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
     return try {
-      System.loadLibrary("dittorn")
+      SoLoader.init(reactContext, false)
+      SoLoader.loadLibrary("dittorn")
+
 
       val jsContextHolder = reactContext.javaScriptContextHolder
+      // Although catalystInstance.jsCallInvokerHolder, it used to be the only
+      // way to make it work with older RN project (0.73, I believe), so be sure
+      // to check there if modifying.
       val jsCallInvokerHolder = reactContext.catalystInstance.jsCallInvokerHolder
 
       if (jsContextHolder != null && jsCallInvokerHolder != null) {
-          nativeInstall(
-            reactContext,
-            jsCallInvokerHolder,
-            jsContextHolder.get(),
-            reactContext.filesDir.absolutePath
-          )
-          true
+        nativeInstall(
+          reactContext,
+          jsCallInvokerHolder,
+          jsContextHolder.get(),
+          reactContext.filesDir.absolutePath
+        )
+        true
       } else {
         Log.e("ReactNative", "JavaScript context or call invoker holder is null.")
         false
@@ -51,9 +53,15 @@ class DittoRNSDKModule(private val reactContext: ReactApplicationContext) :
     }
   }
 
+  // This is actually called by the JS SDK.
+  @Suppress("unused")
   fun defaultDeviceName(): String {
     val manufacturer = Build.MANUFACTURER
     val model = Build.MODEL
     return if (model.startsWith(manufacturer)) model else "$manufacturer $model"
   }
+
+  companion object {
+    const val NAME = "DittoRNSDK"
+  }
 }