react-native-webrtc-nitro 1.0.0 → 1.2.0

package/lib/typescript/src/specs/MediaRecorder.nitro.d.ts

@@ -0,0 +1,17 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+import { MediaStream } from './MediaStream.nitro';
+interface MediaRecorder extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    stream: MediaStream;
+    takePhoto(file: string): Promise<void>;
+    startRecording(file: string): void;
+    stopRecording(): void;
+}
+declare const MediaRecorderExport: {
+    new (stream: MediaStream): MediaRecorder;
+};
+type MediaRecorderExport = MediaRecorder;
+export { MediaRecorderExport as MediaRecorder };
+//# sourceMappingURL=MediaRecorder.nitro.d.ts.map

package/lib/typescript/src/specs/MediaRecorder.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaRecorder.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/MediaRecorder.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEjD,UAAU,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC;IAC1E,MAAM,EAAE,WAAW,CAAA;IACnB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,aAAa,IAAI,IAAI,CAAA;CACtB;AAKD,QAAA,MAAM,mBAAmB,EAMnB;IAAE,KAAK,MAAM,EAAE,WAAW,GAAG,aAAa,CAAA;CAAE,CAAA;AAElD,KAAK,mBAAmB,GAAG,aAAa,CAAA;AACxC,OAAO,EAAE,mBAAmB,IAAI,aAAa,EAAE,CAAA"}

package/lib/typescript/src/specs/Permissions.nitro.d.ts

@@ -0,0 +1,17 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export type PermissionState = 'denied' | 'granted' | 'prompt';
+type PermissionName = 'camera' | 'microphone';
+export interface PermissionDescriptor {
+    name: PermissionName;
+}
+interface Permissions extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    query(permissionDesc: PermissionDescriptor): Promise<PermissionState>;
+    request(permissionDesc: PermissionDescriptor): Promise<PermissionState>;
+}
+declare const PermissionsExport: Permissions;
+type PermissionsExport = Permissions;
+export { PermissionsExport as Permissions };
+//# sourceMappingURL=Permissions.nitro.d.ts.map

package/lib/typescript/src/specs/Permissions.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Permissions.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/Permissions.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAG9D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAA;AAC7D,KAAK,cAAc,GAAG,QAAQ,GAAG,YAAY,CAAA;AAE7C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,cAAc,CAAA;CACrB;AAED,UAAU,WAAY,SAAQ,YAAY,CAAC;IACzC,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,KAAK,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IACrE,OAAO,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;CACxE;AAED,QAAA,MAAM,iBAAiB,aACsC,CAAA;AAC7D,KAAK,iBAAiB,GAAG,WAAW,CAAA;AACpC,OAAO,EAAE,iBAAiB,IAAI,WAAW,EAAE,CAAA"}

package/nitro.json

@@ -13,6 +13,10 @@
     "androidCxxLibName": "Webrtc"
   },
   "autolinking": {
+    "Permissions": {
+      "swift": "HybridPermissions",
+      "kotlin": "HybridPermissions"
+    },
     "Microphone": {
       "swift": "HybridMicrophone",
       "kotlin": "HybridMicrophone"
@@ -34,6 +38,9 @@
     "MediaDevices": {
       "cpp": "HybridMediaDevices"
     },
+    "MediaRecorder": {
+      "cpp": "HybridMediaRecorder"
+    },
     "RTCRtpSender": {
       "cpp": "HybridRTCRtpSender"
     },

package/nitrogen/generated/android/Webrtc+autolinking.cmake

@@ -35,9 +35,11 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridCameraSpec.cpp
   ../nitrogen/generated/shared/c++/HybridMediaDevicesSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMediaRecorderSpec.cpp
   ../nitrogen/generated/shared/c++/HybridMediaStreamSpec.cpp
   ../nitrogen/generated/shared/c++/HybridMediaStreamTrackSpec.cpp
   ../nitrogen/generated/shared/c++/HybridMicrophoneSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPermissionsSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRTCPeerConnectionSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRTCRtpReceiverSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRTCRtpSenderSpec.cpp
@@ -47,6 +49,7 @@ target_sources(
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridCameraSpec.cpp
   ../nitrogen/generated/android/c++/JHybridMicrophoneSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridPermissionsSpec.cpp
   ../nitrogen/generated/android/c++/JHybridWebrtcViewSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridWebrtcViewStateUpdater.cpp
 )

package/nitrogen/generated/android/WebrtcOnLoad.cpp

@@ -17,12 +17,14 @@
 
 #include "JHybridCameraSpec.hpp"
 #include "JHybridMicrophoneSpec.hpp"
+#include "JHybridPermissionsSpec.hpp"
 #include "JHybridWebrtcViewSpec.hpp"
 #include "views/JHybridWebrtcViewStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 #include "HybridMediaStreamTrack.hpp"
 #include "HybridMediaStream.hpp"
 #include "HybridMediaDevices.hpp"
+#include "HybridMediaRecorder.hpp"
 #include "HybridRTCRtpSender.hpp"
 #include "HybridRTCRtpReceiver.hpp"
 #include "HybridRTCRtpTransceiver.hpp"
@@ -39,10 +41,19 @@ int initialize(JavaVM* vm) {
     // Register native JNI methods
     margelo::nitro::webrtc::JHybridCameraSpec::registerNatives();
     margelo::nitro::webrtc::JHybridMicrophoneSpec::registerNatives();
+    margelo::nitro::webrtc::JHybridPermissionsSpec::registerNatives();
     margelo::nitro::webrtc::JHybridWebrtcViewSpec::registerNatives();
     margelo::nitro::webrtc::views::JHybridWebrtcViewStateUpdater::registerNatives();
 
     // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Permissions",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridPermissionsSpec::javaobject> object("com/webrtc/HybridPermissions");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Microphone",
       []() -> std::shared_ptr<HybridObject> {
@@ -94,6 +105,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridMediaDevices>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "MediaRecorder",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridMediaRecorder>,
+                      "The HybridObject \"HybridMediaRecorder\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridMediaRecorder>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "RTCRtpSender",
       []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/android/c++/JHybridPermissionsSpec.cpp

@@ -0,0 +1,91 @@
+///
+/// JHybridPermissionsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridPermissionsSpec.hpp"
+
+// Forward declaration of `PermissionState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionState; }
+// Forward declaration of `PermissionDescriptor` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct PermissionDescriptor; }
+// Forward declaration of `PermissionName` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionName; }
+
+#include "PermissionState.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPermissionState.hpp"
+#include "PermissionDescriptor.hpp"
+#include "JPermissionDescriptor.hpp"
+#include "PermissionName.hpp"
+#include "JPermissionName.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  jni::local_ref<JHybridPermissionsSpec::jhybriddata> JHybridPermissionsSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridPermissionsSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridPermissionsSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridPermissionsSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridPermissionsSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridPermissionsSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<PermissionState>> JHybridPermissionsSpec::query(const PermissionDescriptor& permissionDesc) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPermissionDescriptor> /* permissionDesc */)>("query");
+    auto __result = method(_javaPart, JPermissionDescriptor::fromCpp(permissionDesc));
+    return [&]() {
+      auto __promise = Promise<PermissionState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionState>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<PermissionState>> JHybridPermissionsSpec::request(const PermissionDescriptor& permissionDesc) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPermissionDescriptor> /* permissionDesc */)>("request");
+    auto __result = method(_javaPart, JPermissionDescriptor::fromCpp(permissionDesc));
+    return [&]() {
+      auto __promise = Promise<PermissionState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionState>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/android/c++/JHybridPermissionsSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridPermissionsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridPermissionsSpec.hpp"
+
+
+
+
+namespace margelo::nitro::webrtc {
+
+  using namespace facebook;
+
+  class JHybridPermissionsSpec: public jni::HybridClass<JHybridPermissionsSpec, JHybridObject>,
+                                public virtual HybridPermissionsSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/webrtc/HybridPermissionsSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridPermissionsSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridPermissionsSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridPermissionsSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridPermissionsSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<PermissionState>> query(const PermissionDescriptor& permissionDesc) override;
+    std::shared_ptr<Promise<PermissionState>> request(const PermissionDescriptor& permissionDesc) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridPermissionsSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/android/c++/JPermissionDescriptor.hpp

@@ -0,0 +1,58 @@
+///
+/// JPermissionDescriptor.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PermissionDescriptor.hpp"
+
+#include "JPermissionName.hpp"
+#include "PermissionName.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PermissionDescriptor" and the the Kotlin data class "PermissionDescriptor".
+   */
+  struct JPermissionDescriptor final: public jni::JavaClass<JPermissionDescriptor> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/webrtc/PermissionDescriptor;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PermissionDescriptor by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionDescriptor toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<JPermissionName>("name");
+      jni::local_ref<JPermissionName> name = this->getFieldValue(fieldName);
+      return PermissionDescriptor(
+        name->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPermissionDescriptor::javaobject> fromCpp(const PermissionDescriptor& value) {
+      using JSignature = JPermissionDescriptor(jni::alias_ref<JPermissionName>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JPermissionName::fromCpp(value.name)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/android/c++/JPermissionName.hpp

@@ -0,0 +1,59 @@
+///
+/// JPermissionName.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PermissionName.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PermissionName" and the the Kotlin enum "PermissionName".
+   */
+  struct JPermissionName final: public jni::JavaClass<JPermissionName> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/webrtc/PermissionName;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PermissionName.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionName toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PermissionName>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPermissionName> fromCpp(PermissionName value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCAMERA = clazz->getStaticField<JPermissionName>("CAMERA");
+      static const auto fieldMICROPHONE = clazz->getStaticField<JPermissionName>("MICROPHONE");
+      
+      switch (value) {
+        case PermissionName::CAMERA:
+          return clazz->getStaticFieldValue(fieldCAMERA);
+        case PermissionName::MICROPHONE:
+          return clazz->getStaticFieldValue(fieldMICROPHONE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/android/c++/JPermissionState.hpp

@@ -0,0 +1,62 @@
+///
+/// JPermissionState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PermissionState.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PermissionState" and the the Kotlin enum "PermissionState".
+   */
+  struct JPermissionState final: public jni::JavaClass<JPermissionState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/webrtc/PermissionState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PermissionState.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PermissionState>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPermissionState> fromCpp(PermissionState value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDENIED = clazz->getStaticField<JPermissionState>("DENIED");
+      static const auto fieldGRANTED = clazz->getStaticField<JPermissionState>("GRANTED");
+      static const auto fieldPROMPT = clazz->getStaticField<JPermissionState>("PROMPT");
+      
+      switch (value) {
+        case PermissionState::DENIED:
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case PermissionState::GRANTED:
+          return clazz->getStaticFieldValue(fieldGRANTED);
+        case PermissionState::PROMPT:
+          return clazz->getStaticFieldValue(fieldPROMPT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/HybridPermissionsSpec.kt

@@ -0,0 +1,62 @@
+///
+/// HybridPermissionsSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the Permissions HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of Permissions.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridPermissionsSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject Permissions]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun query(permissionDesc: PermissionDescriptor): Promise<PermissionState>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun request(permissionDesc: PermissionDescriptor): Promise<PermissionState>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridPermissionsSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionDescriptor.kt

@@ -0,0 +1,38 @@
+///
+/// PermissionDescriptor.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "PermissionDescriptor".
+ */
+@DoNotStrip
+@Keep
+data class PermissionDescriptor(
+  @DoNotStrip
+  @Keep
+  val name: PermissionName
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(name: PermissionName): PermissionDescriptor {
+      return PermissionDescriptor(name)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionName.kt

@@ -0,0 +1,21 @@
+///
+/// PermissionName.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "PermissionName".
+ */
+@DoNotStrip
+@Keep
+enum class PermissionName(@DoNotStrip @Keep val value: Int) {
+  CAMERA(0),
+  MICROPHONE(1);
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionState.kt

@@ -0,0 +1,22 @@
+///
+/// PermissionState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "PermissionState".
+ */
+@DoNotStrip
+@Keep
+enum class PermissionState(@DoNotStrip @Keep val value: Int) {
+  DENIED(0),
+  GRANTED(1),
+  PROMPT(2);
+}

package/nitrogen/generated/ios/Webrtc-Swift-Cxx-Bridge.cpp

@@ -10,6 +10,7 @@
 // Include C++ implementation defined types
 #include "HybridCameraSpecSwift.hpp"
 #include "HybridMicrophoneSpecSwift.hpp"
+#include "HybridPermissionsSpecSwift.hpp"
 #include "HybridWebrtcViewSpecSwift.hpp"
 #include "Webrtc-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
@@ -64,6 +65,30 @@ namespace margelo::nitro::webrtc::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::function<void(PermissionState /* result */)>
+  Func_void_PermissionState create_Func_void_PermissionState(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = Webrtc::Func_void_PermissionState::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](PermissionState result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPermissionsSpec>
+  std::shared_ptr<HybridPermissionsSpec> create_std__shared_ptr_HybridPermissionsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    Webrtc::HybridPermissionsSpec_cxx swiftPart = Webrtc::HybridPermissionsSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::webrtc::HybridPermissionsSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridPermissionsSpec_(std__shared_ptr_HybridPermissionsSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::webrtc::HybridPermissionsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::webrtc::HybridPermissionsSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridPermissionsSpec\" is not implemented in Swift!");
+    }
+    #endif
+    Webrtc::HybridPermissionsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridWebrtcViewSpec>
   std::shared_ptr<HybridWebrtcViewSpec> create_std__shared_ptr_HybridWebrtcViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     Webrtc::HybridWebrtcViewSpec_cxx swiftPart = Webrtc::HybridWebrtcViewSpec_cxx::fromUnsafe(swiftUnsafePointer);