@dittolive/ditto 4.7.4-rc.2 → 4.7.4

package/react-native/cpp/include/TypedArray.hpp

@@ -0,0 +1,167 @@
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+enum class TypedArrayKind {
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+};
+
+template <TypedArrayKind T>
+class TypedArray;
+
+template <TypedArrayKind T>
+struct typedArrayTypeMap;
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int8Array> {
+  typedef int8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int16Array> {
+  typedef int16_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int32Array> {
+  typedef int32_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint8Array> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint8ClampedArray> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint16Array> {
+  typedef uint16_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint32Array> {
+  typedef uint32_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Float32Array> {
+  typedef float type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
+  typedef double type;
+};
+
+// Instance of this class will invalidate PropNameIDCache when destructor is called.
+// Attach this object to global in specific jsi::Runtime to make sure lifecycle of
+// the cache object is connected to the lifecycle of the js runtime
+class InvalidateCacheOnDestroy : public jsi::HostObject {
+public:
+  InvalidateCacheOnDestroy(jsi::Runtime &runtime);
+  virtual ~InvalidateCacheOnDestroy();
+  virtual jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) {
+    return jsi::Value::null();
+  }
+  virtual void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) {}
+  virtual std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) {
+    return {};
+  }
+
+private:
+  uintptr_t key;
+};
+
+class TypedArrayBase : public jsi::Object {
+public:
+  template <TypedArrayKind T>
+  using ContentType = typename typedArrayTypeMap<T>::type;
+
+  TypedArrayBase(jsi::Runtime &, size_t, TypedArrayKind);
+  TypedArrayBase(jsi::Runtime &, const jsi::Object &);
+  TypedArrayBase(TypedArrayBase &&) = default;
+  TypedArrayBase &operator=(TypedArrayBase &&) = default;
+
+  TypedArrayKind getKind(jsi::Runtime &runtime) const;
+
+  template <TypedArrayKind T>
+  TypedArray<T> get(jsi::Runtime &runtime) const &;
+  template <TypedArrayKind T>
+  TypedArray<T> get(jsi::Runtime &runtime) &&;
+  template <TypedArrayKind T>
+  TypedArray<T> as(jsi::Runtime &runtime) const &;
+  template <TypedArrayKind T>
+  TypedArray<T> as(jsi::Runtime &runtime) &&;
+
+  size_t size(jsi::Runtime &runtime) const;
+  size_t length(jsi::Runtime &runtime) const;
+  size_t byteLength(jsi::Runtime &runtime) const;
+  size_t byteOffset(jsi::Runtime &runtime) const;
+  bool hasBuffer(jsi::Runtime &runtime) const;
+
+  std::vector<uint8_t> toVector(jsi::Runtime &runtime);
+  jsi::ArrayBuffer getBuffer(jsi::Runtime &runtime) const;
+
+private:
+  template <TypedArrayKind>
+  friend class TypedArray;
+};
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+TypedArrayBase getTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+
+std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime, jsi::Object &jsObj);
+void arrayBufferUpdate(
+                       jsi::Runtime &runtime,
+                       jsi::ArrayBuffer &buffer,
+                       std::vector<uint8_t> data,
+                       size_t offset);
+
+template <TypedArrayKind T>
+class TypedArray : public TypedArrayBase {
+public:
+  TypedArray(jsi::Runtime &runtime, size_t size);
+  TypedArray(jsi::Runtime &runtime, std::vector<ContentType<T>> data);
+  TypedArray(TypedArrayBase &&base);
+  TypedArray(TypedArray &&) = default;
+  TypedArray &operator=(TypedArray &&) = default;
+
+  std::vector<ContentType<T>> toVector(jsi::Runtime &runtime);
+  void update(jsi::Runtime &runtime, const std::vector<ContentType<T>> &data);
+};
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::get(jsi::Runtime &runtime) const & {
+  assert(getKind(runtime) == T);
+  (void)runtime; // when assert is disabled we need to mark this as used
+  return TypedArray<T>(jsi::Value(runtime, jsi::Value(runtime, *this).asObject(runtime)));
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::get(jsi::Runtime &runtime) && {
+  assert(getKind(runtime) == T);
+  (void)runtime; // when assert is disabled we need to mark this as used
+  return TypedArray<T>(std::move(*this));
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::as(jsi::Runtime &runtime) const & {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a TypedArray");
+  }
+  return get<T>(runtime);
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::as(jsi::Runtime &runtime) && {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a TypedArray");
+  }
+  return std::move(*this).get<T>(runtime);
+}

package/react-native/cpp/include/Utils.h

@@ -0,0 +1,70 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <vector>
+#include <jsi/jsi.h>
+#include "TypedArray.hpp"
+#include <dittoffi.h>
+
+#define STRINGIFY(it) #it
+
+#define STRINGIFIED_FUNC_NAME() STRINGIFY(__function)
+#define STRINGIFY_TYPE(T) #T
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+
+std::string pointerToHexString(void const *ptr);
+
+template <typename T>
+Value cPointerToJSPointerObject(Runtime &runtime, const T *pointer) {
+  if (pointer == nullptr) {
+    return Value::null();
+  }
+
+  Object obj(runtime);
+  obj.setProperty(runtime, "type", STRINGIFY_TYPE(T));
+  obj.setProperty(runtime, "addr", pointerToHexString(pointer));
+  return obj;
+}
+
+template<typename T>
+T *jsPointerObjectToCPointer(Runtime &runtime, const Value &arg)
+{
+  if (arg.isNull() || arg.isUndefined()) {
+    return nullptr;
+  }
+  Object obj = arg.getObject(runtime);
+  std::string str = obj.getProperty(runtime, "addr").toString(runtime).utf8(runtime);
+  T *ptr;
+  sscanf(str.c_str(), "%p", &ptr);
+  return ptr;
+}
+
+template<typename T>
+Object cSlicedBoxToJSSlicedBox(Runtime &runtime, T 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;
+}
+
+std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg);
+std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg);
+
+slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const& v);
+slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const& v);
+
+Value int64ToBigIntOrNumber(Runtime &runtime, int64_t value);
+Value uint64ToBigIntOrNumber(Runtime &runtime, uint64_t value);
+int64_t bigIntOrNumberToInt64(Runtime &runtime, Value const& value);
+uint64_t bigIntOrNumberToUint64(Runtime &runtime, Value const& value);
+
+void ditto_tick(Runtime* jsi);
+void ditto_enqueue_call(std::function<void(Runtime *)> && task);
+}
+
+#endif /* UTILS_H */

package/react-native/cpp/include/main.h

@@ -0,0 +1,10 @@
+#ifndef EXAMPLE_H
+#define EXAMPLE_H
+
+namespace sharedjsi 
+{
+void install(facebook::jsi::Runtime &jsiRuntime);
+}
+
+
+#endif /* EXAMPLE_H */

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

@@ -0,0 +1,272 @@
+#include "Utils.h"
+
+#include <Attachment.h>
+#include <Arc.hpp>
+
+namespace sharedjsi
+{
+
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+
+class AttachmentResolver {
+public:
+  Function onCompleteCb;
+  Function onProgressCb;
+  Function onDeletedCb;
+
+  AttachmentResolver(Function onComplete, Function onProgress, Function onDeleted)
+  : onCompleteCb(std::move(onComplete)), onDeletedCb(std::move(onDeleted)), onProgressCb(std::move(onProgress)) {}
+};
+
+extern "C" {
+void v_on_complete(void *ctx, AttachmentHandle_t *handle)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onCompleteCb.call(runtime, cPointerToJSPointerObject<AttachmentHandle>(runtime, handle));
+  });
+}
+
+void v_on_progress(void *ctx, uint64_t downloaded, uint64_t to_download)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onProgressCb.call(runtime, uint64ToBigIntOrNumber(runtime, downloaded), uint64ToBigIntOrNumber(runtime, to_download));
+  });
+}
+
+void v_on_deleted(void *ctx)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onDeletedCb.call(runtime);
+  });
+}
+}
+
+Function ditto_cancel_resolve_attachment(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::vector<uint8_t> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t id = borrowVecAsOptRefSlice(id_vec);
+    uint64_t cancelToken = bigIntOrNumberToUint64(runtime, arguments[2]);
+
+    return static_cast<double>(::ditto_cancel_resolve_attachment(ditto, id, cancelToken));
+  });
+}
+
+Function ditto_free_attachment_handle(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
+                                          {
+    ::ditto_free_attachment_handle(jsPointerObjectToCPointer<AttachmentHandle_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_get_attachment_status(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::vector<uint8_t> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t id = borrowVecAsRefSlice(id_vec);
+
+    AttachmentHandleResult_t res = ::ditto_get_attachment_status(ditto, id);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "handle", cPointerToJSPointerObject<AttachmentHandle_t>(runtime, res.handle));
+    return obj;
+  });
+}
+
+Function ditto_get_complete_attachment_data(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    AttachmentHandle_t* handle = jsPointerObjectToCPointer<AttachmentHandle_t>(runtime, arguments[1]);
+    AttachmentDataResult_t res = ::ditto_get_complete_attachment_data(ditto, handle);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status));
+    obj.setProperty(runtime, "data", cSlicedBoxToJSSlicedBox(runtime, res.data));
+    return obj;
+  });
+}
+
+Function ditto_get_complete_attachment_path(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    AttachmentHandle_t *attachmentHandler = jsPointerObjectToCPointer<AttachmentHandle_t>(runtime, arguments[1]);
+
+    char *res = ::ditto_get_complete_attachment_path(ditto, attachmentHandler);
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+
+Function ditto_new_attachment_from_bytes(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::vector<uint8_t> bytes_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t bytes = borrowVecAsRefSlice(bytes_vec);
+
+    CAttachment_t c_attachment;
+    uint32_t res = ::ditto_new_attachment_from_bytes(ditto, bytes, &c_attachment);
+
+    if (res != 0) {
+      // It failed, bubble up the error.
+      return static_cast<double>(res);
+    }
+
+    Object attachment = arguments[2].getObject(runtime);
+
+    attachment.setProperty(runtime, "len", uint64ToBigIntOrNumber(runtime , c_attachment.len));
+    // Factor this out as: cSliceToUInt8Array()
+    std::vector<uint8_t> id(c_attachment.id.ptr, c_attachment.id.ptr + c_attachment.id.len);
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, id);
+    attachment.setProperty(runtime, "id", typedArray);
+    attachment.setProperty(runtime, "handle", cPointerToJSPointerObject(runtime, c_attachment.handle));
+
+    return 0;
+  });
+}
+
+Function ditto_new_attachment_from_file(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::string source_path_str = jsTypedArrayToCString(runtime, arguments[1]);
+    std::string file_operation_str = arguments[2].toString(runtime).utf8(runtime);
+
+    AttachmentFileOperation_t file_operation;
+    if (file_operation_str == "Copy") {
+      file_operation = ATTACHMENT_FILE_OPERATION_COPY;
+    } else if (file_operation_str == "Move") {
+      file_operation = ATTACHMENT_FILE_OPERATION_MOVE;
+    } else {
+      throw "Invalid attachment file operation.";
+    }
+
+    CAttachment_t c_attachment;
+    uint32_t res = ::ditto_new_attachment_from_file(ditto, source_path_str.c_str(), file_operation, &c_attachment);
+
+    if (res != 0) {
+      // It failed, bubble up the error.
+      return static_cast<double>(res);
+    }
+
+    Object attachment = arguments[3].getObject(runtime);
+
+    attachment.setProperty(runtime, "len", uint64ToBigIntOrNumber(runtime, c_attachment.len));
+    // Factor this out as: cSliceToUInt8Array()
+    std::vector<uint8_t> id(c_attachment.id.ptr, c_attachment.id.ptr + c_attachment.id.len);
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, id);
+    attachment.setProperty(runtime, "id", typedArray);
+    attachment.setProperty(runtime, "handle", cPointerToJSPointerObject(runtime, c_attachment.handle));
+
+    return 0;
+  });
+}
+
+Function ditto_resolve_attachment(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+
+    std::vector<uint8_t> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t id = borrowVecAsRefSlice(id_vec);
+
+    Function onCompleteCallback = arguments[2].getObject(runtime).getFunction(runtime);
+    Function onProgressCallback = arguments[3].getObject(runtime).getFunction(runtime);
+    Function onDeleteCallback = arguments[4].getObject(runtime).getFunction(runtime);
+
+    AttachmentResolver resolver(std::move(onCompleteCallback),
+                                std::move(onProgressCallback),
+                                std::move(onDeleteCallback));
+    Arc<AttachmentResolver> wrappedStateFfiWrapper(std::move(resolver));
+
+    CancelTokenResult_t res = ::ditto_resolve_attachment(ditto,
+                                                         id,
+                                                         Arc<AttachmentResolver>::into_raw(std::move(wrappedStateFfiWrapper)),
+                                                         nullptr,
+                                                         nullptr,
+                                                         v_on_complete,
+                                                         v_on_progress,
+                                                         v_on_deleted);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "cancel_token", int64ToBigIntOrNumber(runtime, res.cancel_token));
+    return obj;
+  });
+}
+}