@dittolive/ditto 4.4.5 → 4.5.0

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

@@ -0,0 +1,270 @@
+#include "Utils.h"
+
+#include <Transports.h>
+#include <dittoffi.h>
+
+namespace sharedjsi
+{
+
+Function ditto_sdk_transports_error_new(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
+                                          {
+    DittoSdkTransportsError_t *outError = ::ditto_sdk_transports_error_new();
+    return cPointerToJSPointerObject<DittoSdkTransportsError_t>(runtime, outError);
+  });
+}
+
+Function ditto_sdk_transports_init(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
+                                          {
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[0]);
+    return ::ditto_sdk_transports_init(outError);
+  });
+}
+
+Function ditto_sdk_transports_error_value(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
+                                          {
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[0]);
+    DittoSdkTransportsError_t error = ::ditto_sdk_transports_error_value(outError);
+
+    switch (error)
+    {
+      case DITTO_SDK_TRANSPORTS_ERROR_NONE:
+        return String::createFromUtf8(runtime, "None");
+      case DITTO_SDK_TRANSPORTS_ERROR_GENERIC:
+        return String::createFromUtf8(runtime, "Generic");
+      case DITTO_SDK_TRANSPORTS_ERROR_UNAVAILABLE:
+        return String::createFromUtf8(runtime, "Unavailable");
+      default:
+        throw "Unimplemented error value";
+    }
+  });
+}
+
+Function ditto_sdk_transports_error_free(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_sdk_transports_error_free(jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_sdk_transports_ble_is_available(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
+                                          {
+    return ::ditto_sdk_transports_ble_is_available(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_sdk_transports_ble_create(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]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    void *res = ::ditto_sdk_transports_ble_create(ditto, outError);
+    void *transports = static_cast<void *>(res);
+    return cPointerToJSPointerObject<void>(runtime, transports);
+  });
+}
+
+Function ditto_sdk_transports_ble_destroy(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
+                                          {
+    void *ble = jsPointerObjectToCPointer<void>(runtime, arguments[0]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    return ::ditto_sdk_transports_ble_destroy(ble, outError);
+  });
+}
+
+Function ditto_sdk_transports_lan_is_available(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
+                                          {
+    return ::ditto_sdk_transports_lan_is_available(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_sdk_transports_lan_create(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]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    void *res = ::ditto_sdk_transports_lan_create(ditto, outError);
+    void *transports = static_cast<void *>(res);
+    return cPointerToJSPointerObject<void>(runtime, transports);
+  });
+}
+
+Function ditto_sdk_transports_lan_destroy(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
+                                          {
+    void *lan = jsPointerObjectToCPointer<void>(runtime, arguments[0]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    return ::ditto_sdk_transports_lan_destroy(lan, outError);
+  });
+}
+
+Function ditto_sdk_transports_awdl_is_available(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
+                                          {
+    return ::ditto_sdk_transports_awdl_is_available(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_sdk_transports_awdl_create(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]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    void *res = ::ditto_sdk_transports_awdl_create(ditto, outError);
+    void *transports = static_cast<void *>(res);
+    return cPointerToJSPointerObject<void>(runtime, transports);
+  });
+}
+
+Function ditto_sdk_transports_awdl_destroy(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
+                                          {
+    void *awdl = jsPointerObjectToCPointer<void>(runtime, arguments[0]);
+    DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[1]);
+    return ::ditto_sdk_transports_awdl_destroy(awdl, outError);
+  });
+}
+
+Function ditto_add_multicast_transport(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_add_multicast_transport(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_remove_multicast_transport(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_remove_multicast_transport(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+}

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

@@ -0,0 +1,303 @@
+#include "TypedArray.hpp"
+
+#include <unordered_map>
+#include <stdexcept>
+
+template <TypedArrayKind T>
+using ContentType = typename typedArrayTypeMap<T>::type;
+
+enum class Prop {
+  Buffer, // "buffer"
+  Constructor, // "constructor"
+  Name, // "name"
+  Proto, // "__proto__"
+  Length, // "length"
+  ByteLength, // "byteLength"
+  ByteOffset, // "offset"
+  IsView, // "isView"
+  ArrayBuffer, // "ArrayBuffer"
+  Int8Array, // "Int8Array"
+  Int16Array, // "Int16Array"
+  Int32Array, // "Int32Array"
+  Uint8Array, // "Uint8Array"
+  Uint8ClampedArray, // "Uint8ClampedArray"
+  Uint16Array, // "Uint16Array"
+  Uint32Array, // "Uint32Array"
+  Float32Array, // "Float32Array"
+  Float64Array, // "Float64Array"
+};
+
+class PropNameIDCache {
+public:
+  const jsi::PropNameID &get(jsi::Runtime &runtime, Prop prop) {
+    auto key = reinterpret_cast<uintptr_t>(&runtime);
+    if (this->props.find(key) == this->props.end()) {
+      this->props[key] = std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>>();
+    }
+    if (!this->props[key][prop]) {
+      this->props[key][prop] = std::make_unique<jsi::PropNameID>(createProp(runtime, prop));
+    }
+    return *(this->props[key][prop]);
+  }
+
+  const jsi::PropNameID &getConstructorNameProp(jsi::Runtime &runtime, TypedArrayKind kind);
+
+  void invalidate(uintptr_t key) {
+    if (props.find(key) != props.end()) {
+      props[key].clear();
+    }
+  }
+
+private:
+  std::unordered_map<uintptr_t, std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>>> props;
+
+  jsi::PropNameID createProp(jsi::Runtime &runtime, Prop prop);
+};
+
+PropNameIDCache propNameIDCache;
+
+InvalidateCacheOnDestroy::InvalidateCacheOnDestroy(jsi::Runtime &runtime) {
+  key = reinterpret_cast<uintptr_t>(&runtime);
+}
+InvalidateCacheOnDestroy::~InvalidateCacheOnDestroy() {
+  propNameIDCache.invalidate(key);
+}
+
+TypedArrayKind getTypedArrayKindForName(const std::string &name);
+
+TypedArrayBase::TypedArrayBase(jsi::Runtime &runtime, size_t size, TypedArrayKind kind)
+: TypedArrayBase(
+                 runtime,
+                 runtime.global()
+                 .getProperty(runtime, propNameIDCache.getConstructorNameProp(runtime, kind))
+                 .asObject(runtime)
+                 .asFunction(runtime)
+                 .callAsConstructor(runtime, {static_cast<double>(size)})
+                 .asObject(runtime)) {}
+
+TypedArrayBase::TypedArrayBase(jsi::Runtime &runtime, const jsi::Object &obj)
+: jsi::Object(jsi::Value(runtime, obj).asObject(runtime)) {}
+
+TypedArrayKind TypedArrayBase::getKind(jsi::Runtime &runtime) const {
+  auto constructorName = this->getProperty(runtime, propNameIDCache.get(runtime, Prop::Constructor))
+    .asObject(runtime)
+    .getProperty(runtime, propNameIDCache.get(runtime, Prop::Name))
+    .asString(runtime)
+    .utf8(runtime);
+  return getTypedArrayKindForName(constructorName);
+};
+
+size_t TypedArrayBase::size(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length)).asNumber();
+}
+
+size_t TypedArrayBase::length(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length)).asNumber();
+}
+
+size_t TypedArrayBase::byteLength(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength)).asNumber();
+}
+
+size_t TypedArrayBase::byteOffset(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteOffset)).asNumber();
+}
+
+bool TypedArrayBase::hasBuffer(jsi::Runtime &runtime) const {
+  auto buffer = getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
+  return buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime);
+}
+
+std::vector<uint8_t> TypedArrayBase::toVector(jsi::Runtime &runtime) {
+  auto start = reinterpret_cast<uint8_t *>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
+  auto end = start + byteLength(runtime);
+  return std::vector<uint8_t>(start, end);
+}
+
+jsi::ArrayBuffer TypedArrayBase::getBuffer(jsi::Runtime &runtime) const {
+  auto buffer = getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
+  if (buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime)) {
+    return buffer.asObject(runtime).getArrayBuffer(runtime);
+  } else {
+    throw std::runtime_error("No ArrayBuffer attached");
+  }
+}
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+  auto jsVal = runtime.global()
+    .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
+    .asObject(runtime)
+    .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
+    .asObject(runtime)
+    .asFunction(runtime)
+    .callWithThis(runtime, runtime.global(), {jsi::Value(runtime, jsObj)});
+  if (jsVal.isBool()) {
+    return jsVal.getBool();
+  } else {
+    throw std::runtime_error("value is not a boolean");
+  }
+}
+
+TypedArrayBase getTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+  auto jsVal = runtime.global()
+    .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
+    .asObject(runtime)
+    .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
+    .asObject(runtime)
+    .asFunction(runtime)
+    .callWithThis(runtime, runtime.global(), {jsi::Value(runtime, jsObj)});
+  if (jsVal.isBool()) {
+    return TypedArrayBase(runtime, jsObj);
+  } else {
+    throw std::runtime_error("value is not a boolean");
+  }
+}
+
+std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime, jsi::Object &jsObj) {
+  if (!jsObj.isArrayBuffer(runtime)) {
+    throw std::runtime_error("Object is not an ArrayBuffer");
+  }
+  auto jsArrayBuffer = jsObj.getArrayBuffer(runtime);
+
+  uint8_t *dataBlock = jsArrayBuffer.data(runtime);
+  size_t blockSize =
+  jsArrayBuffer.getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength)).asNumber();
+  return std::vector<uint8_t>(dataBlock, dataBlock + blockSize);
+}
+
+void arrayBufferUpdate(
+                       jsi::Runtime &runtime,
+                       jsi::ArrayBuffer &buffer,
+                       std::vector<uint8_t> data,
+                       size_t offset) {
+  uint8_t *dataBlock = buffer.data(runtime);
+  size_t blockSize = buffer.size(runtime);
+  if (data.size() > blockSize) {
+    throw jsi::JSError(runtime, "ArrayBuffer is to small to fit data");
+  }
+  std::copy(data.begin(), data.end(), dataBlock + offset);
+}
+
+template <TypedArrayKind T>
+TypedArray<T>::TypedArray(jsi::Runtime &runtime, size_t size) : TypedArrayBase(runtime, size, T){};
+
+template <TypedArrayKind T>
+TypedArray<T>::TypedArray(jsi::Runtime &runtime, std::vector<ContentType<T>> data)
+: TypedArrayBase(runtime, data.size(), T) {
+  update(runtime, data);
+};
+
+template <TypedArrayKind T>
+TypedArray<T>::TypedArray(TypedArrayBase &&base) : TypedArrayBase(std::move(base)) {}
+
+template <TypedArrayKind T>
+std::vector<ContentType<T>> TypedArray<T>::toVector(jsi::Runtime &runtime) {
+  auto start =
+  reinterpret_cast<ContentType<T> *>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
+  auto end = start + size(runtime);
+  return std::vector<ContentType<T>>(start, end);
+}
+
+template <TypedArrayKind T>
+void TypedArray<T>::update(jsi::Runtime &runtime, const std::vector<ContentType<T>> &data) {
+  if (data.size() != size(runtime)) {
+    throw jsi::JSError(runtime, "TypedArray can only be updated with a vector of the same size");
+  }
+  uint8_t *rawData = getBuffer(runtime).data(runtime) + byteOffset(runtime);
+  std::copy(data.begin(), data.end(), reinterpret_cast<ContentType<T> *>(rawData));
+}
+
+const jsi::PropNameID &PropNameIDCache::getConstructorNameProp(
+                                                               jsi::Runtime &runtime,
+                                                               TypedArrayKind kind) {
+  switch (kind) {
+    case TypedArrayKind::Int8Array:
+      return get(runtime, Prop::Int8Array);
+    case TypedArrayKind::Int16Array:
+      return get(runtime, Prop::Int16Array);
+    case TypedArrayKind::Int32Array:
+      return get(runtime, Prop::Int32Array);
+    case TypedArrayKind::Uint8Array:
+      return get(runtime, Prop::Uint8Array);
+    case TypedArrayKind::Uint8ClampedArray:
+      return get(runtime, Prop::Uint8ClampedArray);
+    case TypedArrayKind::Uint16Array:
+      return get(runtime, Prop::Uint16Array);
+    case TypedArrayKind::Uint32Array:
+      return get(runtime, Prop::Uint32Array);
+    case TypedArrayKind::Float32Array:
+      return get(runtime, Prop::Float32Array);
+    case TypedArrayKind::Float64Array:
+      return get(runtime, Prop::Float64Array);
+  }
+}
+
+jsi::PropNameID PropNameIDCache::createProp(jsi::Runtime &runtime, Prop prop) {
+  auto create = [&](const std::string &propName) {
+    return jsi::PropNameID::forUtf8(runtime, propName);
+  };
+  switch (prop) {
+    case Prop::Buffer:
+      return create("buffer");
+    case Prop::Constructor:
+      return create("constructor");
+    case Prop::Name:
+      return create("name");
+    case Prop::Proto:
+      return create("__proto__");
+    case Prop::Length:
+      return create("length");
+    case Prop::ByteLength:
+      return create("byteLength");
+    case Prop::ByteOffset:
+      return create("byteOffset");
+    case Prop::IsView:
+      return create("isView");
+    case Prop::ArrayBuffer:
+      return create("ArrayBuffer");
+    case Prop::Int8Array:
+      return create("Int8Array");
+    case Prop::Int16Array:
+      return create("Int16Array");
+    case Prop::Int32Array:
+      return create("Int32Array");
+    case Prop::Uint8Array:
+      return create("Uint8Array");
+    case Prop::Uint8ClampedArray:
+      return create("Uint8ClampedArray");
+    case Prop::Uint16Array:
+      return create("Uint16Array");
+    case Prop::Uint32Array:
+      return create("Uint32Array");
+    case Prop::Float32Array:
+      return create("Float32Array");
+    case Prop::Float64Array:
+      return create("Float64Array");
+  }
+}
+
+std::unordered_map<std::string, TypedArrayKind> nameToKindMap = {
+  {"Int8Array", TypedArrayKind::Int8Array},
+  {"Int16Array", TypedArrayKind::Int16Array},
+  {"Int32Array", TypedArrayKind::Int32Array},
+  {"Uint8Array", TypedArrayKind::Uint8Array},
+  {"Uint8ClampedArray", TypedArrayKind::Uint8ClampedArray},
+  {"Uint16Array", TypedArrayKind::Uint16Array},
+  {"Uint32Array", TypedArrayKind::Uint32Array},
+  {"Float32Array", TypedArrayKind::Float32Array},
+  {"Float64Array", TypedArrayKind::Float64Array},
+};
+
+TypedArrayKind getTypedArrayKindForName(const std::string &name) {
+  return nameToKindMap.at(name);
+}
+
+template class TypedArray<TypedArrayKind::Int8Array>;
+template class TypedArray<TypedArrayKind::Int16Array>;
+template class TypedArray<TypedArrayKind::Int32Array>;
+template class TypedArray<TypedArrayKind::Uint8Array>;
+template class TypedArray<TypedArrayKind::Uint8ClampedArray>;
+template class TypedArray<TypedArrayKind::Uint16Array>;
+template class TypedArray<TypedArrayKind::Uint32Array>;
+template class TypedArray<TypedArrayKind::Float32Array>;
+template class TypedArray<TypedArrayKind::Float64Array>;