react-native-nitro-modules 0.0.2 → 0.0.4

package/NitroModules.podspec

@@ -0,0 +1,49 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::UI.puts "[NitroModules] Your app is boosted by nitro modules! 🔥"
+
+Pod::Spec.new do |s|
+  s.name         = "NitroModules"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/mrousavy/react-native-nitro.git", :tag => "#{s.version}" }
+
+  # VisionCamera Core C++ bindings
+  s.source_files = [
+    # Shared C++ codebase
+    "cpp/**/*.{h,hpp}",
+    "cpp/**/*.{c,cpp}",
+    # iOS codebase
+    "ios/**/*.{h,hpp}",
+    "ios/**/*.{c,cpp}",
+    "ios/**/*.{m,mm}",
+    "ios/**/*.swift",
+  ]
+  s.public_header_files = [
+    # Public C++ headers will be exposed in modulemap (for Swift)
+    "cpp/core/HybridObject.hpp",
+    "cpp/core/HybridContext.hpp",
+    "cpp/registry/HybridObjectRegistry.hpp",
+    "cpp/jsi/JSIConverter.hpp",
+    "cpp/jsi/ArrayBuffer.hpp",
+    "cpp/threading/Dispatcher.hpp",
+    "cpp/utils/NitroHash.hpp",
+    "cpp/utils/NitroDefines.hpp",
+  ]
+
+  s.pod_target_xcconfig = {
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+  }
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -1,15 +1,52 @@
-cmake_minimum_required(VERSION 3.4.1)
-project(Nitro)
+project(NitroModules)
+cmake_minimum_required(VERSION 3.9.0)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 20)
 
-add_library(react-native-nitro            SHARED
-            ../cpp/react-native-nitro.cpp
-            cpp-adapter.cpp
+# Find all C++ files (shared and platform specifics)
+file(GLOB shared_files
+     "../cpp/**/*.cpp"
+)
+file(GLOB android_files
+     "src/main/cpp/**/*.cpp"
+)
+
+# Create library "NitroModules" and add all C++ files to it
+add_library(NitroModules SHARED
+            ${shared_files}
+            ${android_files}
 )
 
 # Specifies a path to native header files.
 include_directories(
-            ../cpp
+  # Shared C++ includes
+  ../cpp/core
+  ../cpp/jsi
+  ../cpp/platform
+  ../cpp/registry
+  ../cpp/test-object
+  ../cpp/threading
+  ../cpp/turbomodule
+  ../cpp/utils
+  # Android-specific C++ includes
+  src/main/cpp/core
+  src/main/cpp/registry
+  src/main/cpp/platform
+  src/main/cpp/utils
+)
+
+# Find required libraries
+find_library(LOG_LIB log)
+find_package(fbjni REQUIRED NitroConfig)
+find_package(ReactAndroid REQUIRED NitroConfig)
+
+# Link all libraries together
+target_link_libraries(
+        NitroModules
+        ${LOG_LIB}                                # <-- Logcat logger
+        android                                   # <-- Android JNI core
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
 )

package/android/build.gradle

@@ -19,6 +19,7 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
@@ -32,25 +33,8 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Nitro_" + name]).toInteger()
 }
 
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
-
 android {
-  if (supportsNamespace()) {
-    namespace "com.nitro"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
+  namespace "com.margelo.nitro"
 
   ndkVersion getExtOrDefault("ndkVersion")
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -63,6 +47,7 @@ android {
     externalNativeBuild {
       cmake {
         cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
       }
     }
@@ -76,6 +61,14 @@ android {
 
   buildFeatures {
     buildConfig true
+    prefab true
+    prefabPublishing true
+  }
+
+  prefab {
+    NitroModules {
+      headers "${project.buildDir}/headers/nitromodules/"
+    }
   }
 
   buildTypes {
@@ -96,10 +89,10 @@ android {
   sourceSets {
     main {
       if (isNewArchitectureEnabled()) {
-          java.srcDirs += [
-            // This is needed to build Kotlin project with NewArch enabled
-            "${project.buildDir}/generated/source/codegen/java"
-          ]
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
       }
     }
   }
@@ -121,7 +114,18 @@ dependencies {
 if (isNewArchitectureEnabled()) {
   react {
     jsRootDir = file("../src/")
-    libraryName = "Nitro"
-    codegenJavaPackageName = "com.nitro"
+    libraryName = "NitroModules"
+    codegenJavaPackageName = "com.margelo.nitro"
   }
 }
+
+
+task prepareHeaders(type: Copy) {
+  from fileTree('./src/main/cpp').filter { it.isFile() }
+  from fileTree('../cpp/').filter { it.isFile() }
+  include "*.hpp"
+  into "${project.buildDir}/headers/nitromodules/NitroModules/"
+  includeEmptyDirs = false
+}
+
+preBuild.dependsOn(prepareHeaders)

package/cpp/core/AnyMap.cpp

@@ -0,0 +1,181 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#include "AnyMap.hpp"
+
+namespace margelo::nitro {
+
+// Contains
+bool AnyMap::contains(const std::string& key) const {
+  return _map.contains(key);
+}
+void AnyMap::remove(const std::string& key) {
+  _map.erase(key);
+}
+void AnyMap::clear() noexcept {
+  _map.clear();
+}
+
+// Is
+bool AnyMap::isNull(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<std::monostate>(found->second);
+}
+bool AnyMap::isDouble(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<double>(found->second);
+}
+bool AnyMap::isBoolean(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<bool>(found->second);
+}
+bool AnyMap::isBigInt(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<int64_t>(found->second);
+}
+bool AnyMap::isString(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<std::string>(found->second);
+}
+bool AnyMap::isArray(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<AnyArray>(found->second);
+}
+bool AnyMap::isObject(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<AnyObject>(found->second);
+}
+
+// Get
+std::monostate AnyMap::getNull(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<std::monostate>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a null!");
+  }
+}
+double AnyMap::getDouble(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<double>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a double!");
+  }
+}
+bool AnyMap::getBoolean(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<bool>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a bool!");
+  }
+}
+int64_t AnyMap::getBigInt(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<int64_t>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a bigint!");
+  }
+}
+std::string AnyMap::getString(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<std::string>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a string!");
+  }
+}
+AnyArray AnyMap::getArray(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<AnyArray>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not an array!");
+  }
+}
+AnyObject AnyMap::getObject(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<AnyObject>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not an object!");
+  }
+}
+
+// Set
+void AnyMap::setNull(const std::string& key) {
+  _map.emplace(key, std::monostate());
+}
+void AnyMap::setDouble(const std::string& key, double value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setBoolean(const std::string& key, bool value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setBigInt(const std::string& key, int64_t value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setString(const std::string& key, const std::string& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setArray(const std::string& key, const AnyArray& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setObject(const std::string& key, const AnyObject& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setAny(const std::string& key, const AnyValue& value) {
+  _map.emplace(key, value);
+}
+
+// C++ getter
+const std::unordered_map<std::string, AnyValue>& AnyMap::getMap() const {
+  return _map;
+}
+
+} // namespace margelo::nitro

package/cpp/core/AnyMap.hpp

@@ -0,0 +1,191 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+namespace margelo::nitro {
+
+struct AnyValue;
+using AnyArray = std::vector<AnyValue>;
+using AnyObject = std::unordered_map<std::string, AnyValue>;
+
+using VariantType = std::variant<std::monostate, bool, double, int64_t, std::string, AnyArray, AnyObject>;
+struct AnyValue : VariantType {
+  using VariantType::variant;
+
+  AnyValue(const VariantType& variant) : VariantType(variant) {}
+  AnyValue(VariantType&& variant) : VariantType(std::move(variant)) {}
+};
+
+/**
+ * Represents a JS map-like object (`Record<K, V>`).
+ * This is essentially a wrapper around `std::unordered_map<string, variant<...>>`.
+ *
+ * Supported values are:
+ * 1. Primitives
+ * 2. Arrays of primitives
+ * 3. Objects of primitives
+ */
+class AnyMap {
+public:
+  /**
+   * Create a new instance of AnyMap.
+   */
+  explicit AnyMap() {}
+
+public:
+  /**
+   * Create a new shared_ptr instance of AnyMap.
+   */
+  static std::shared_ptr<AnyMap> make() {
+    return std::make_shared<AnyMap>();
+  }
+
+public:
+  /**
+   * Returns whether the map contains the given key, or not.
+   */
+  bool contains(const std::string& key) const;
+  /**
+   * Removes the given key from the map, leaving no value.
+   */
+  void remove(const std::string& key);
+  /**
+   * Deletes all keys and values inside the map.
+   */
+  void clear() noexcept;
+
+public:
+  /**
+   * Returns whether the value under the given key is a `null`.
+   * If the value is not a `null` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isNull(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `double`.
+   * If the value is not a `double` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isDouble(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `boolean`.
+   * If the value is not a `boolean` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isBoolean(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `bigint`.
+   * If the value is not a `bigint` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isBigInt(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `string`.
+   * If the value is not a `string` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isString(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is an array.
+   * If the value is not an array (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isArray(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is an object.
+   * If the value is not an object (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isObject(const std::string& key) const;
+
+public:
+  /**
+   * Returns the null value at the given `key`.
+   * If no `null` value exists at the given `key`, this method will throw.
+   */
+  std::monostate getNull(const std::string& key) const;
+  /**
+   * Returns the double value at the given `key`.
+   * If no `double` value exists at the given `key`, this method will throw.
+   */
+  double getDouble(const std::string& key) const;
+  /**
+   * Returns the boolean value at the given `key`.
+   * If no `boolean` value exists at the given `key`, this method will throw.
+   */
+  bool getBoolean(const std::string& key) const;
+  /**
+   * Returns the bigint value at the given `key`.
+   * If no `bigint` value exists at the given `key`, this method will throw.
+   */
+  int64_t getBigInt(const std::string& key) const;
+  /**
+   * Returns the string value at the given `key`.
+   * If no `string` value exists at the given `key`, this method will throw.
+   */
+  std::string getString(const std::string& key) const;
+  /**
+   * Returns the array value at the given `key`.
+   * If no array value exists at the given `key`, this method will throw.
+   */
+  AnyArray getArray(const std::string& key) const;
+  /**
+   * Returns the object value at the given `key`.
+   * If no object value exists at the given `key`, this method will throw.
+   */
+  AnyObject getObject(const std::string& key) const;
+
+public:
+  /**
+   * Set the value at the given key to `null`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setNull(const std::string& key);
+  /**
+   * Set the value at the given key to the given `double`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setDouble(const std::string& key, double value);
+  /**
+   * Set the value at the given key to the given `boolean`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setBoolean(const std::string& key, bool value);
+  /**
+   * Set the value at the given key to the given `bigint`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setBigInt(const std::string& key, int64_t value);
+  /**
+   * Set the value at the given key to the given `string`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setString(const std::string& key, const std::string& value);
+  /**
+   * Set the value at the given key to the given array.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setArray(const std::string& key, const AnyArray& value);
+  /**
+   * Set the value at the given key to the given object.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setObject(const std::string& key, const AnyObject& value);
+  /**
+   * Set the value at the given key to the given `AnyValue`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setAny(const std::string& key, const AnyValue& value);
+
+public:
+  /**
+   * Get the actual C++ map that holds all keys and variant values.
+   */
+  const std::unordered_map<std::string, AnyValue>& getMap() const;
+
+private:
+  std::unordered_map<std::string, AnyValue> _map;
+};
+
+} // namespace margelo::nitro

package/cpp/core/HybridContext.hpp

@@ -0,0 +1,51 @@
+//
+//  HybridContext.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 17.07.24.
+//
+
+#pragma once
+
+#include "NitroLogger.hpp"
+#include "TypeInfo.hpp"
+#include <memory>
+
+namespace margelo::nitro {
+
+class HybridObject;
+
+/**
+ * Represents contextual state for a `HybridObject`.
+ *
+ * This can be used in remote implementations, e.g. in a Swift implementation
+ * to properly (weak-)reference the `HybridObject` instead of re-creating it each time.
+ */
+struct HybridContext final {
+public:
+  std::weak_ptr<HybridObject> cppPart;
+
+public:
+  template <typename THybridObject, typename TSwiftPart>
+  static inline std::shared_ptr<THybridObject> getOrCreate(TSwiftPart swiftPart) noexcept {
+    auto hybridContext = swiftPart.getHybridContext();
+    auto hybridObject = std::static_pointer_cast<THybridObject>(hybridContext.cppPart.lock());
+    if (hybridObject != nullptr) [[likely]] {
+      // Fast path - an existing HybridObject is still in cache! (HybridContext)
+      return hybridObject;
+    }
+
+    // Slow path - we need to create a new HybridObject that wraps our Swift implementation.
+    Logger::log(TAG, "Creating new HybridObject<%s> for %s...", TypeInfo::getFriendlyTypename<THybridObject>(),
+                TypeInfo::getFriendlyTypename<TSwiftPart>());
+    hybridObject = std::make_shared<THybridObject>(std::forward<decltype(swiftPart)>(swiftPart));
+    hybridContext.cppPart = hybridObject;
+    swiftPart.setHybridContext(hybridContext);
+    return hybridObject;
+  }
+
+private:
+  static constexpr auto TAG = "HybridContext";
+};
+
+} // namespace margelo::nitro