@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

package/react-native/cpp/src/Utils.cpp

@@ -0,0 +1,138 @@
+#include "Utils.h"
+
+#include <functional>
+#include <mutex>
+#include <thread>
+// #include <condition_variable>
+
+namespace sharedjsi {
+
+std::string pointerToHexString(void const *ptr) {
+  char buffer[20]; // Assuming a 64-bit pointer, 16 characters for address + 2 for "0x" + 1 for null-terminator.
+  snprintf(buffer, sizeof(buffer), "%p", ptr);
+  return std::string(buffer);
+}
+
+// To be used with `Option<slice_ref_uint8_t> (check Rust Core API)
+slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const& v) {
+  slice_ref_uint8_t it {};
+  it.ptr = v.empty() ? nullptr : v.data();
+  it.len = v.size();
+  return it;
+}
+
+// To be used with non-optional `slice_ref_uint8_t` (check Rust Core API)
+slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const& v) {
+  slice_ref_uint8_t it {};
+  it.ptr = v.empty() ? (uint8_t *) 0xbad000 : v.data();
+  it.len = v.size();
+  return it;
+}
+
+Function sliceBoxedToUInt8Array(Runtime &runtime) {
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto fatPtrJs = arguments[0].asObject(runtime);
+    auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
+    auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
+    slice_boxed_uint8 slice = { .ptr = ptr, .len = len };
+    if (!slice.ptr) {
+      return Value::null();
+    }
+
+    auto typedArray = TypedArray<TypedArrayKind::Uint8Array>(runtime, slice.len);
+    auto arrayBuffer = typedArray.getBuffer(runtime);
+    std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
+
+    ::ditto_c_bytes_free(slice);
+
+    return typedArray;
+  });
+}
+
+std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg) {
+  if (arg.isUndefined() || arg.isNull()) {
+    return {};
+  }
+  TypedArrayBase typedArrayBase(runtime, arg.asObject(runtime));
+  return typedArrayBase.toVector(runtime);
+}
+
+std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg) {
+  std::vector<uint8_t> vec = jsTypedArrayToCVector(runtime, arg);
+  return std::string(vec.begin(), vec.end());
+}
+
+Value cSlicedBoxToJSSlicedBox(Runtime &runtime, slice_boxed_uint8 box_c_bytes) {
+  Object obj(runtime);
+  obj.setProperty(runtime, "ptr", cPointerToJSPointerObject<uint8_t>(runtime, box_c_bytes.ptr));
+  obj.setProperty(runtime, "len", static_cast<double>(box_c_bytes.len));
+  return obj;
+}
+
+Function withOutBoxCBytes(Runtime &runtime) {
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto callback = arguments[0].asObject(runtime).asFunction(runtime);
+    slice_boxed_uint8 box_c_bytes = { 0 };
+    auto out_box_cbytes = &box_c_bytes;
+    auto out_box_cbytes_js = cPointerToJSPointerObject<slice_boxed_uint8>(runtime, out_box_cbytes);
+    
+    callback.call(runtime, out_box_cbytes_js);
+
+    return cSlicedBoxToJSSlicedBox(runtime, box_c_bytes);
+  });
+}
+
+
+
+using Task = std::function<void(Runtime *)>;
+
+struct {
+  std::mutex mutex;
+  std::vector<Task> tasks;
+  // std::condition_variable condition;
+} TASKS;
+
+void ditto_enqueue_call(Task &&task) {
+  std::unique_lock<std::mutex> lock{TASKS.mutex};
+  TASKS.tasks.emplace_back(task);
+  // TASKS.condition.notify_one();
+}
+
+Task try_recv_task() {
+  std::unique_lock<std::mutex> lock(TASKS.mutex);
+  // TASKS.condition.wait(lock, [] { return !TASKS.tasks.empty(); });
+  if (TASKS.tasks.empty()) {
+    return nullptr;
+  }
+  Task task{std::move(TASKS.tasks.back())};
+  TASKS.tasks.pop_back();
+  return task;
+}
+
+void ditto_tick(Runtime *jsi) {
+  while (1) {
+    Task task = try_recv_task();
+    if (task == nullptr) {
+      return;
+    } else {
+      task(jsi);
+    }
+  }
+}
+}

package/react-native/cpp/src/main.cpp

@@ -0,0 +1,152 @@
+#include <jsi/jsi.h>
+#include <dittoffi.h>
+
+#include "main.h"
+#include "Utils.h"
+#include "DQL.h"
+#include "Document.h"
+#include "Authentication.h"
+#include "Lifecycle.h"
+#include "Misc.h"
+#include "Identity.h"
+#include "Presence.h"
+#include "Attachment.h"
+#include "LiveQuery.h"
+#include "Collection.h"
+#include "Logger.h"
+#include "SmallPeerInfo.h"
+#include "Transports.h"
+
+// Note: `runtime` variable must exist in scope.
+#define REGISTER_JS_FUNCTION(fname) runtime.global().setProperty(runtime, STRINGIFY(fname), fname(runtime));
+
+using namespace facebook::jsi;
+using namespace std;
+
+namespace sharedjsi
+{
+
+  void install(Runtime &runtime)
+  {
+    // Identity
+    REGISTER_JS_FUNCTION(ditto_identity_config_make_online_playground);
+    REGISTER_JS_FUNCTION(ditto_identity_config_make_offline_playground);
+    REGISTER_JS_FUNCTION(ditto_identity_config_make_manual_v0);
+    REGISTER_JS_FUNCTION(ditto_identity_config_make_shared_key);
+    REGISTER_JS_FUNCTION(ditto_identity_config_make_online_with_authentication);
+
+    // Lifecycle
+    REGISTER_JS_FUNCTION(ditto_init_sdk_version);
+    REGISTER_JS_FUNCTION(ditto_uninitialized_ditto_make);
+    REGISTER_JS_FUNCTION(ditto_make);
+    REGISTER_JS_FUNCTION(ditto_shutdown);
+    REGISTER_JS_FUNCTION(ditto_free);
+
+    // Authentication
+    REGISTER_JS_FUNCTION(ditto_auth_client_get_app_id);
+    REGISTER_JS_FUNCTION(ditto_auth_client_is_x509_valid);
+    REGISTER_JS_FUNCTION(ditto_auth_client_is_web_valid);
+    REGISTER_JS_FUNCTION(ditto_auth_client_get_site_id);
+    REGISTER_JS_FUNCTION(ditto_auth_client_set_validity_listener);
+    REGISTER_JS_FUNCTION(ditto_auth_client_make_login_provider);
+    REGISTER_JS_FUNCTION(ditto_auth_set_login_provider);
+    REGISTER_JS_FUNCTION(ditto_auth_client_login_with_token);
+    REGISTER_JS_FUNCTION(ditto_auth_client_login_with_credentials);
+    REGISTER_JS_FUNCTION(ditto_auth_client_logout);
+    REGISTER_JS_FUNCTION(ditto_auth_client_user_id);
+
+    // DQL
+    REGISTER_JS_FUNCTION(dittoffi_try_experimental_register_change_observer_str_detached);
+    REGISTER_JS_FUNCTION(dittoffi_try_experimental_add_dql_subscription);
+    REGISTER_JS_FUNCTION(dittoffi_try_experimental_remove_dql_subscription);
+    REGISTER_JS_FUNCTION(dittoffi_try_experimental_exec_statement_str);
+    REGISTER_JS_FUNCTION(ditto_dql_response_result_count);
+    REGISTER_JS_FUNCTION(ditto_dql_response_result_at);
+    REGISTER_JS_FUNCTION(ditto_dql_response_affected_document_id_count);
+    REGISTER_JS_FUNCTION(ditto_dql_response_affected_document_id_at);
+    REGISTER_JS_FUNCTION(ditto_result_cbor);
+    REGISTER_JS_FUNCTION(ditto_result_json);
+
+    // Documents
+    REGISTER_JS_FUNCTION(ditto_document_id_query_compatible);
+    REGISTER_JS_FUNCTION(ditto_document_id);
+    REGISTER_JS_FUNCTION(ditto_document_free);
+    REGISTER_JS_FUNCTION(ditto_document_get_cbor_with_path_type);
+    REGISTER_JS_FUNCTION(ditto_validate_document_id);
+
+    // Presence
+    REGISTER_JS_FUNCTION(ditto_presence_v3);
+    REGISTER_JS_FUNCTION(ditto_register_presence_v3_callback);
+    REGISTER_JS_FUNCTION(ditto_clear_presence_v3_callback);
+
+    // Attachment
+    REGISTER_JS_FUNCTION(ditto_cancel_resolve_attachment);
+    REGISTER_JS_FUNCTION(ditto_free_attachment_handle);
+    REGISTER_JS_FUNCTION(ditto_get_complete_attachment_path);
+    REGISTER_JS_FUNCTION(ditto_new_attachment_from_bytes);
+
+    // LiveQuery
+    REGISTER_JS_FUNCTION(ditto_live_query_start);
+    REGISTER_JS_FUNCTION(ditto_live_query_stop);
+    REGISTER_JS_FUNCTION(ditto_live_query_signal_available_next);
+
+    // Collection
+    REGISTER_JS_FUNCTION(ditto_collection_insert_value);
+
+    // Logger
+    REGISTER_JS_FUNCTION(ditto_log);
+    REGISTER_JS_FUNCTION(ditto_logger_set_log_file);
+    REGISTER_JS_FUNCTION(ditto_logger_minimum_log_level_get);
+    REGISTER_JS_FUNCTION(ditto_logger_minimum_log_level);
+    REGISTER_JS_FUNCTION(ditto_logger_emoji_headings_enabled_get);
+    REGISTER_JS_FUNCTION(ditto_logger_emoji_headings_enabled);
+    REGISTER_JS_FUNCTION(ditto_logger_enabled_get);
+    REGISTER_JS_FUNCTION(ditto_logger_enabled);
+
+    // Small Peer Info
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_set_transport_config_data);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_get_is_enabled);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_set_enabled);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_get_sync_scope);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_set_sync_scope);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_get_metadata);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_set_metadata);
+
+    // FFI functions
+    REGISTER_JS_FUNCTION(withOutBoxCBytes);
+    REGISTER_JS_FUNCTION(sliceBoxedToUInt8Array);
+
+    // Transports
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_init);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_error_new);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_error_value);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_error_free);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_ble_is_available);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_ble_create);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_ble_destroy);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_lan_is_available);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_lan_create);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_lan_destroy);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_awdl_is_available);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_awdl_create);
+    REGISTER_JS_FUNCTION(ditto_sdk_transports_awdl_destroy);
+    REGISTER_JS_FUNCTION(ditto_add_multicast_transport);
+    REGISTER_JS_FUNCTION(ditto_remove_multicast_transport);
+
+    // Misc
+    REGISTER_JS_FUNCTION(ditto_tick);
+    REGISTER_JS_FUNCTION(ditto_set_connect_retry_interval);
+    REGISTER_JS_FUNCTION(ditto_set_device_name);
+    REGISTER_JS_FUNCTION(ditto_get_sdk_version);
+    REGISTER_JS_FUNCTION(dittoffi_get_sdk_semver);
+    REGISTER_JS_FUNCTION(ditto_error_message);
+    REGISTER_JS_FUNCTION(dittoffi_error_code);
+    REGISTER_JS_FUNCTION(dittoffi_error_description);
+    REGISTER_JS_FUNCTION(dittoffi_error_free);
+    REGISTER_JS_FUNCTION(ditto_verify_license);
+    REGISTER_JS_FUNCTION(ditto_run_garbage_collection);
+    REGISTER_JS_FUNCTION(ditto_set_static_websocket_clients);
+    REGISTER_JS_FUNCTION(ditto_set_sync_group);
+    REGISTER_JS_FUNCTION(refCStringToString);
+  }
+}