@dittolive/ditto 4.8.2 → 4.9.0-alpha.1

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

@@ -0,0 +1,664 @@
+extern "C" {
+#include "dittoffi.h"
+}
+#include "retainable.h"
+#include <atomic>
+#include <cassert>
+#include <memory>
+#include <string>
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) WifiAwareRust;
+%apply(char *STRING, size_t LENGTH) { (const char data[], size_t len) }; // byte[] instead of String
+#endif
+class WifiAwareRust : public Retainable {
+public:
+  virtual ~WifiAwareRust() {}
+
+  virtual void clientStartSearching(const char *hashed_app_name,
+                                    const char *local_announce) = 0;
+  virtual void clientStopSearching() = 0;
+  virtual void clientCreateNetwork(const char *announce) = 0;
+  virtual void clientUpdatePeer(const char *announce, ConnectState_t state) = 0;
+
+  virtual void serverStartAdvertising(const char *announce,
+                                      const char *hashed_app_name,
+                                      uint16_t service_port) = 0;
+  virtual void serverStopAdvertising() = 0;
+  virtual void serverUpdatePeer(const char *announce, ConnectState_t state) = 0;
+  virtual void
+  updateParameterU64(dittoffi_wifi_aware_system_parameter_u64 parameter,
+                     uint64_t value) = 0;
+
+  static void invokeClientStartSearching(void *ctx, const char *hashed_app_name,
+                                         const char *local_announce) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->clientStartSearching(hashed_app_name, local_announce);
+  }
+
+  static void invokeClientStopSearching(void *ctx) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->clientStopSearching();
+  }
+
+  static void invokeClientCreateNetwork(void *ctx, const char *announce) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->clientCreateNetwork(announce);
+  }
+
+  static void invokeClientUpdatePeer(void *ctx, const char *announce,
+                                     ConnectState_t state) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->clientUpdatePeer(announce, state);
+  }
+
+  static void invokeServerStartAdvertising(void *ctx, const char *announce,
+                                           const char *hashed_app_name,
+                                           uint16_t service_port) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->serverStartAdvertising(announce, hashed_app_name,
+                                        service_port);
+  }
+  static void invokeServerStopAdvertising(void *ctx) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->serverStopAdvertising();
+  }
+
+  static void invokeServerUpdatePeer(void *ctx, const char *announce,
+                                     ConnectState_t state) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->serverUpdatePeer(announce, state);
+  }
+
+  static void
+  invokeUpdateParameterU64(void *ctx,
+                           dittoffi_wifi_aware_system_parameter_u64 parameter,
+                           uint64_t value) {
+    auto inst = static_cast<WifiAwareRust *>(ctx);
+    return inst->updateParameterU64(parameter, value);
+  }
+
+  virtual void addWifiAwareClientTransport(struct CDitto *ditto) {
+    WifiAwareClientCallbacks_t 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);
+    atomic_store(
+        &clientHandle,
+        std::shared_ptr<TransportHandle_WifiAwareClientPlatformEvent_t>(
+            handle, [](TransportHandle_WifiAwareClientPlatformEvent_t *h) {
+              ditto_wifi_aware_client_free_handle(h);
+            }));
+  }
+
+  virtual void removeWifiAwareClientTransport() {
+    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>());
+  }
+
+  virtual void clientPeerAppeared(const char *announce) {
+    auto handle = atomic_load(&clientHandle);
+    if (handle) {
+      ditto_wifi_aware_client_peer_appeared(handle.get(), announce);
+    }
+  }
+  virtual void clientPeerDisappeared(const char *announce) {
+    auto handle = atomic_load(&clientHandle);
+    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);
+    if (handle) {
+      ditto_wifi_aware_client_scanning_state_changed(handle.get(), state,
+                                                     result);
+    }
+  }
+  virtual void clientNetworkDidCreate(const char *announce,
+                                      const char *hostname, uint16_t port) {
+    auto handle = atomic_load(&clientHandle);
+    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);
+    if (handle) {
+      ditto_wifi_aware_client_peer_did_not_connect(handle.get(), announce);
+    }
+  }
+
+  virtual void serverAdvertisingStateChanged(OnlineState_t state,
+                                             TransportCondition_t result) {
+    auto handle = atomic_load(&serverHandle);
+    if (handle) {
+      ditto_wifi_aware_server_advertising_state_changed(handle.get(), state,
+                                                        result);
+    }
+  }
+
+  std::shared_ptr<TransportHandle_WifiAwareClientPlatformEvent_t> clientHandle;
+  std::shared_ptr<TransportHandle_WifiAwareServerPlatformEvent_t> serverHandle;
+};
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) BluetoothLeRadioRust;
+%apply(char *STRING, size_t LENGTH) { (const char peripheralUuid[], size_t uuidLen) }; // byte[] instead of String
+%apply(char *STRING, size_t LENGTH) { (const char centralUuid[], size_t uuidLen) }; // need one per param name for SWIG
+%apply(char *STRING, size_t LENGTH) { (const char uuid[], size_t uuidLen) };
+%apply(char *STRING, size_t LENGTH) { (const char serviceUuid[], size_t uuidLen) };
+%apply(char *STRING, size_t LENGTH) { (const char characteristicUuid[], size_t uuidLen) };
+%apply(char *STRING, size_t LENGTH) { (const char manufacturerData[], size_t manufacturerDataLen) };
+// It is implied that UUID buffers are 16 bytes in length - insert an extra size_t for this Java array conversion
+%apply(char *STRING, size_t LENGTH) { (const char data[], size_t len) }; // byte[] instead of String
+#endif
+class BluetoothLeRadioRust : public Retainable {
+public:
+  virtual ~BluetoothLeRadioRust() {}
+  virtual void connectPeripheral(const char peripheralUuid[],
+                                 size_t uuidLen) = 0;
+  virtual void disconnectPeripheral(const char peripheralUuid[],
+                                    size_t uuidLen) = 0;
+  virtual OnlineState_t getAdvertisingState() { return ONLINE_STATE_OFFLINE; }
+  virtual OnlineState_t getScanningState() { return ONLINE_STATE_OFFLINE; }
+  virtual SendResult_t notifyToCentral(BleDataType_t sendType,
+                                       const char centralUuid[], size_t uuidLen,
+                                       const char data[], size_t len) = 0;
+  virtual void startAdvertising(const char serviceUuid[], size_t uuidLen,
+                                char *localName) = 0;
+  virtual void startScanning(const char serviceUuid[], size_t uuidLen,
+                             char *announce) = 0;
+  virtual void stopAdvertising() = 0;
+  virtual void stopScanning() = 0;
+  virtual SendResult_t writeToPeripheral(BleDataType_t sendType,
+                                         const char peripheralUuid[],
+                                         size_t uuidLen, const char data[],
+                                         size_t len) = 0;
+  virtual bool appIsInForeground() = 0;
+  virtual int readL2capFromPeripheral(const char peripheralUuid[],
+                                      size_t uuidLen,
+                                      slice_mut_uint8_t data) = 0;
+  virtual int sendL2capToPeripheral(const char peripheralUuid[], size_t uuidLen,
+                                    const char data[], size_t len) = 0;
+  virtual int readL2capFromCentral(const char centralUuid[], size_t uuidLen,
+                                   slice_mut_uint8_t data) = 0;
+  virtual int sendL2capToCentral(const char centralUuid[], size_t uuidLen,
+                                 const char data[], size_t len) = 0;
+
+  static void invokeConnectPeripheral(void *ctx,
+                                      uint8_16_array_t const *peripheral_uuid) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->connectPeripheral((const char *)peripheral_uuid, (size_t)16);
+  }
+  static void
+  invokeDisconnectPeripheral(void *ctx,
+                             uint8_16_array_t const *peripheral_uuid) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->disconnectPeripheral((const char *)peripheral_uuid,
+                                      (size_t)16);
+  }
+  static OnlineState_t invokeGetAdvertisingState(void *ctx) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->getAdvertisingState();
+  }
+  static OnlineState_t invokeGetScanningState(void *ctx) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->getScanningState();
+  }
+  static SendResult_t
+  invokeNotifyToCentral(void *ctx, BleDataType_t sendType,
+                        uint8_16_array_t const *central_uuid,
+                        slice_ref_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->notifyToCentral(sendType, (char const *)central_uuid, 16,
+                                 (char const *)data.ptr, data.len);
+  }
+  static void invokeStartAdvertising(void *ctx,
+                                     uint8_16_array_t const *service_uuid,
+                                     slice_ref_uint8_t local_name) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    char *local_name_str =
+        strndup((char const *)local_name.ptr, local_name.len);
+    inst->startAdvertising((const char *)service_uuid, 16, local_name_str);
+    free(local_name_str);
+  }
+  static void invokeStartScanning(void *ctx,
+                                  uint8_16_array_t const *service_uuid,
+                                  slice_ref_uint8_t announce) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    char *announce_str = strndup((char const *)announce.ptr, announce.len);
+    inst->startScanning((const char *)service_uuid, 16, announce_str);
+    free(announce_str);
+  }
+  static void invokeStopAdvertising(void *ctx) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    inst->stopAdvertising();
+  }
+  static void invokeStopScanning(void *ctx) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    inst->stopScanning();
+  }
+  static SendResult_t
+  invokeWriteToPeripheral(void *ctx, BleDataType_t sendType,
+                          uint8_16_array_t const *peripheral_uuid,
+                          slice_ref_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->writeToPeripheral(sendType, (const char *)peripheral_uuid, 16,
+                                   (const char *)data.ptr, data.len);
+  }
+  static bool invokeAppIsInForeground(void *ctx) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->appIsInForeground();
+  }
+  static int
+  invokeReadL2capFromPeripheral(void *ctx,
+                                uint8_16_array_t const *peripheral_uuid,
+                                slice_mut_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->readL2capFromPeripheral((const char *)peripheral_uuid, 16,
+                                         data);
+  }
+  static int
+  invokeSendL2capToPeripheral(void *ctx,
+                              uint8_16_array_t const *peripheral_uuid,
+                              slice_ref_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->sendL2capToPeripheral((const char *)peripheral_uuid, 16,
+                                       (char const *)data.ptr, data.len);
+  }
+  static int invokeReadL2capFromCentral(void *ctx,
+                                        uint8_16_array_t const *central_uuid,
+                                        slice_mut_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->readL2capFromCentral((const char *)central_uuid, 16, data);
+  }
+  static int invokeSendL2capToCentral(void *ctx,
+                                      uint8_16_array_t const *central_uuid,
+                                      slice_ref_uint8_t data) {
+    auto inst = static_cast<BluetoothLeRadioRust *>(ctx);
+    return inst->sendL2capToCentral((const char *)central_uuid, 16,
+                                    (char const *)data.ptr, data.len);
+  }
+  virtual void addBleClientTransport(struct CDitto *ditto) {
+    BleClientCallbacks_t cb = {
+        .start_scanning = BluetoothLeRadioRust::invokeStartScanning,
+        .stop_scanning = BluetoothLeRadioRust::invokeStopScanning,
+        .scanning_state = BluetoothLeRadioRust::invokeGetScanningState,
+        .connect_peripheral = BluetoothLeRadioRust::invokeConnectPeripheral,
+        .disconnect_peripheral =
+            BluetoothLeRadioRust::invokeDisconnectPeripheral,
+        .write_to_peripheral = BluetoothLeRadioRust::invokeWriteToPeripheral,
+        .app_is_in_foreground = BluetoothLeRadioRust::invokeAppIsInForeground,
+        .read_l2cap_from_peripheral =
+            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 = {
+        .start_advertising = BluetoothLeRadioRust::invokeStartAdvertising,
+        .stop_advertising = BluetoothLeRadioRust::invokeStopAdvertising,
+        .advertising_state = BluetoothLeRadioRust::invokeGetAdvertisingState,
+        .notify_to_central = BluetoothLeRadioRust::invokeNotifyToCentral,
+        .app_is_in_foreground = BluetoothLeRadioRust::invokeAppIsInForeground,
+        .read_l2cap_from_central =
+            BluetoothLeRadioRust::invokeReadL2capFromCentral,
+        .send_l2cap_to_central =
+            BluetoothLeRadioRust::invokeSendL2capToCentral};
+    auto handle = ditto_add_ble_server_transport(
+        ditto, 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);
+                     }));
+  }
+  virtual void dropBleClientTransport() {
+    // 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>());
+  }
+  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);
+    if (handle) {
+      ditto_transports_ble_advertisement_heard(
+          handle.get(), (uint8_16_array_t const *)peripheralUuid,
+          slice_ref_uint8_t{
+              .ptr = (uint8_t const *)manufacturerData,
+              .len = manufacturerDataLen,
+          },
+          manufacturerDataIncludesId,
+          slice_ref_uint8_t{
+              .ptr = (uint8_t const *)name,
+              .len = name ? strlen(name) : 0,
+          },
+          rssi);
+    }
+    (void)uuidLen;
+  }
+  virtual void connectionStateChanged(const char peripheralUuid[],
+                                      size_t uuidLen, ConnectState_t state,
+                                      bool l2cap_available, int mtu) {
+    auto handle = atomic_load(&clientHandle);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_connection_state_changed(handle.get(),
+                                   (uint8_16_array_t const *)peripheralUuid,
+                                   state, l2cap_available ? 1 : 0, mtu);
+    }
+    (void)uuidLen;
+  }
+  virtual void peripheralMtuUpdated(const char uuid[], size_t uuidLen,
+                                    int mtu) {
+    auto handle = atomic_load(&clientHandle);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_peripheral_mtu_updated(handle.get(), (uint8_16_array_t const *)uuid,
+                                 mtu);
+    }
+    (void)uuidLen;
+  }
+  virtual void receivedFromPeripheral(const char peripheralUuid[],
+                                      size_t uuidLen, BleDataType_t dataType,
+                                      const char data[], size_t len) {
+    auto handle = atomic_load(&clientHandle);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_received_from_peripheral(
+          handle.get(), (uint8_16_array_t const *)peripheralUuid, dataType,
+          (slice_ref_uint8_t){
+              .ptr = (uint8_t const *)data,
+              .len = len,
+          });
+    }
+    (void)uuidLen;
+  }
+  virtual void scanningStateChanged(OnlineState_t state,
+                                    TransportCondition_t result) {
+    auto handle = atomic_load(&clientHandle);
+    if (handle) {
+      ble_scanning_state_changed(handle.get(), state, result);
+    }
+  }
+  virtual void peripheralReadyToSend(const char uuid[], size_t uuidLen) {
+    auto handle = atomic_load(&clientHandle);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_peripheral_ready_to_send(handle.get(),
+                                   (uint8_16_array_t const *)uuid);
+    }
+    (void)uuidLen;
+  }
+  virtual void peripheralL2capReadyToSend(const char uuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&clientHandle);
+    if (handle) {
+      ble_peripheral_l2cap_ready_to_send(handle.get(),
+                                         (uint8_16_array_t const *)uuid);
+    }
+    (void)uuidLen;
+  }
+  virtual void peripheralL2capDataAvailable(const char uuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&clientHandle);
+    if (handle) {
+      ble_peripheral_l2cap_data_available(handle.get(),
+                                          (uint8_16_array_t const *)uuid);
+    }
+    (void)uuidLen;
+  }
+  virtual void advertisingStateChanged(OnlineState_t state,
+                                       TransportCondition_t result) {
+    auto handle = atomic_load(&serverHandle);
+    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);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_central_mtu_updated(handle.get(), (uint8_16_array_t const *)uuid,
+                              mtu);
+    }
+    (void)uuidLen;
+  }
+  virtual void receivedFromCentral(const char centralUuid[], size_t uuidLen,
+                                   BleDataType_t dataType, const char data[],
+                                   size_t len) {
+    auto handle = atomic_load(&serverHandle);
+    assert(uuidLen == 16);
+    if (handle) {
+      ble_received_from_central(handle.get(),
+                                (uint8_16_array_t const *)centralUuid, dataType,
+                                (slice_ref_uint8_t){
+                                    .ptr = (uint8_t const *)data,
+                                    .len = len,
+                                });
+    }
+    (void)uuidLen;
+  }
+  virtual void centralFinishedConnecting(const char centralUuid[],
+                                         size_t uuidLen, const char data[],
+                                         size_t len, bool l2capAvailable,
+                                         int mtu) {
+    auto handle = atomic_load(&serverHandle);
+    if (handle) {
+      ble_central_finished_connecting(handle.get(),
+                                      (uint8_16_array_t const *)centralUuid,
+                                      (slice_ref_uint8_t){
+                                          .ptr = (uint8_t const *)data,
+                                          .len = len,
+                                      },
+                                      l2capAvailable ? 1 : 0, mtu);
+    }
+  }
+  virtual void centralUnsubscribed(const char centralUuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&serverHandle);
+    if (handle) {
+      ble_central_unsubscribed(handle.get(),
+                               (uint8_16_array_t const *)centralUuid);
+    }
+  }
+  virtual void centralReadyToSend(const char uuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&serverHandle);
+    if (handle) {
+      ble_central_ready_to_send(handle.get(), (uint8_16_array_t const *)uuid);
+    }
+    (void)uuidLen;
+  }
+  virtual void centralL2capReadyToSend(const char uuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&serverHandle);
+    if (handle) {
+      ble_central_l2cap_ready_to_send(handle.get(),
+                                      (uint8_16_array_t const *)uuid);
+    }
+    (void)uuidLen;
+  }
+  virtual void centralL2capDataAvailable(const char uuid[], size_t uuidLen) {
+    assert(uuidLen == 16);
+    auto handle = atomic_load(&serverHandle);
+    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;
+};
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) StatusRust;
+#endif
+class StatusRust : public Retainable {
+public:
+  virtual ~StatusRust() {}
+  virtual void transportConditionDidChange(ConditionSource source,
+                                           TransportCondition_t condition) = 0;
+
+  static void
+  invokeTransportConditionDidChange(void *ctx, ConditionSource source,
+                                    TransportCondition_t condition) {
+    auto inst = static_cast<StatusRust *>(ctx);
+    return inst->transportConditionDidChange(source, condition);
+  }
+
+  virtual void submit(struct CDitto *ditto) {
+    ditto_register_transport_condition_changed_callback(
+        ditto, this, StatusRust::invokeRetain, StatusRust::invokeRelease,
+        StatusRust::invokeTransportConditionDidChange);
+  }
+
+  virtual void shutdown(struct CDitto *ditto) {
+    ditto_register_transport_condition_changed_callback(ditto, nullptr, nullptr,
+                                                        nullptr, nullptr);
+  }
+};
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) LoginProviderRust;
+#endif
+class LoginProviderRust : public Retainable {
+public:
+  virtual ~LoginProviderRust() {}
+  virtual void authenticationExpiring(unsigned int time_remaining) = 0;
+
+  static void invokeAuthenticationExpiring(void *ctx,
+                                           unsigned int time_remaining) {
+    auto inst = static_cast<LoginProviderRust *>(ctx);
+    return inst->authenticationExpiring(time_remaining);
+  }
+
+  virtual void submit() {
+    this->loginProviderPtr = ditto_auth_client_make_login_provider(
+        this, LoginProviderRust::invokeRetain, LoginProviderRust::invokeRelease,
+        LoginProviderRust::invokeAuthenticationExpiring);
+  }
+
+  CLoginProvider *loginProviderPtr;
+};
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) ValidityListenerRust;
+#endif
+class ValidityListenerRust : public Retainable {
+public:
+  virtual ~ValidityListenerRust() {}
+  virtual void validityUpdated(bool web_valid, bool x509_valid) = 0;
+
+  static void invokeValidityUpdated(void *ctx, int web_valid, int x509_valid) {
+    auto inst = static_cast<ValidityListenerRust *>(ctx);
+    return inst->validityUpdated((web_valid != 0), (x509_valid != 0));
+  }
+
+  virtual void submit(struct CDitto *ditto) {
+    ditto_auth_client_set_validity_listener(
+        ditto, this, ValidityListenerRust::invokeRetain,
+        ValidityListenerRust::invokeRelease,
+        ValidityListenerRust::invokeValidityUpdated);
+  }
+};
+
+#ifdef SWIG
+%feature("director", assumeoverride=1) DiskUsageObserverRust;
+#endif
+class DiskUsageObserverRust : public Retainable {
+private:
+  DiskUsageObserver *observerHandle;
+
+public:
+  virtual ~DiskUsageObserverRust() {}
+  virtual void diskUsageUpdated(slice_ref_uint8_t diskUsageBytes) = 0;
+
+  static void invokeDiskUsageUpdated(void *ctx,
+                                     slice_ref_uint8_t diskUsageBytes) {
+    auto inst = static_cast<DiskUsageObserverRust *>(ctx);
+    return inst->diskUsageUpdated(diskUsageBytes);
+  }
+
+  virtual void subscribe(struct CDitto *ditto) {
+    observerHandle = 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); }
+};
+
+#ifdef SWIG
+%apply(char *STRING, size_t LENGTH) { (const char value[], size_t valueLen) };
+%extend slice_mut_uint8 {
+	// The maximum number of bytes that can be written to this slice. Any larger values will be truncated.
+	size_t getCapacity() {
+		return $self->len;
+	}
+
+	// Write a byte array to the mutable memory represented by this slice. Returns the actual number of bytes written.
+	size_t setValue(const char value[], size_t valueLen) {
+		size_t len = (valueLen < $self->len ? valueLen : $self->len);
+		memcpy($self->ptr, value, len);
+		return len;
+	}
+}
+#endif

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

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