///
/// JHybridCameraFactorySpec.cpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#include "JHybridCameraFactorySpec.hpp"

// Forward declaration of `PermissionStatus` to properly resolve imports.
namespace margelo::nitro::camera { enum class PermissionStatus; }
// Forward declaration of `HybridCameraSessionSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraSessionSpec; }
// Forward declaration of `HybridCameraSessionConfigSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraSessionConfigSpec; }
// Forward declaration of `HybridCameraDeviceFactorySpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraDeviceFactorySpec; }
// Forward declaration of `HybridCameraPhotoOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraPhotoOutputSpec; }
// Forward declaration of `HybridCameraVideoOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraVideoOutputSpec; }
// Forward declaration of `HybridCameraFrameOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraFrameOutputSpec; }
// Forward declaration of `HybridCameraDepthFrameOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraDepthFrameOutputSpec; }
// Forward declaration of `HybridCameraPreviewOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraPreviewOutputSpec; }
// Forward declaration of `HybridCameraObjectOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraObjectOutputSpec; }
// Forward declaration of `HybridCameraOutputSynchronizerSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraOutputSynchronizerSpec; }
// Forward declaration of `HybridZoomGestureControllerSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridZoomGestureControllerSpec; }
// Forward declaration of `HybridTapToFocusGestureControllerSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridTapToFocusGestureControllerSpec; }
// Forward declaration of `HybridOrientationManagerSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridOrientationManagerSpec; }
// Forward declaration of `HybridFrameRendererSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridFrameRendererSpec; }
// Forward declaration of `HybridMeteringPointSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridMeteringPointSpec; }
// Forward declaration of `HybridCameraDeviceSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraDeviceSpec; }
// Forward declaration of `CameraOutputConfiguration` to properly resolve imports.
namespace margelo::nitro::camera { struct CameraOutputConfiguration; }
// Forward declaration of `MirrorMode` to properly resolve imports.
namespace margelo::nitro::camera { enum class MirrorMode; }
// Forward declaration of `HybridCameraOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraOutputSpec; }
// Forward declaration of `FPSConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct FPSConstraint; }
// Forward declaration of `VideoStabilizationModeConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct VideoStabilizationModeConstraint; }
// Forward declaration of `PreviewStabilizationModeConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct PreviewStabilizationModeConstraint; }
// Forward declaration of `ResolutionBiasConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct ResolutionBiasConstraint; }
// Forward declaration of `VideoDynamicRangeConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct VideoDynamicRangeConstraint; }
// Forward declaration of `PhotoHDRConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct PhotoHDRConstraint; }
// Forward declaration of `PixelFormatConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct PixelFormatConstraint; }
// Forward declaration of `BinnedConstraint` to properly resolve imports.
namespace margelo::nitro::camera { struct BinnedConstraint; }
// Forward declaration of `TargetStabilizationMode` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetStabilizationMode; }
// Forward declaration of `TargetDynamicRange` to properly resolve imports.
namespace margelo::nitro::camera { struct TargetDynamicRange; }
// Forward declaration of `TargetDynamicRangeBitDepth` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetDynamicRangeBitDepth; }
// Forward declaration of `TargetColorSpace` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetColorSpace; }
// Forward declaration of `TargetColorRange` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetColorRange; }
// Forward declaration of `PixelFormat` to properly resolve imports.
namespace margelo::nitro::camera { enum class PixelFormat; }
// Forward declaration of `PhotoOutputOptions` to properly resolve imports.
namespace margelo::nitro::camera { struct PhotoOutputOptions; }
// Forward declaration of `Size` to properly resolve imports.
namespace margelo::nitro::camera { struct Size; }
// Forward declaration of `TargetPhotoContainerFormat` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetPhotoContainerFormat; }
// Forward declaration of `QualityPrioritization` to properly resolve imports.
namespace margelo::nitro::camera { enum class QualityPrioritization; }
// Forward declaration of `VideoOutputOptions` to properly resolve imports.
namespace margelo::nitro::camera { struct VideoOutputOptions; }
// Forward declaration of `RecorderFileType` to properly resolve imports.
namespace margelo::nitro::camera { enum class RecorderFileType; }
// Forward declaration of `FrameOutputOptions` to properly resolve imports.
namespace margelo::nitro::camera { struct FrameOutputOptions; }
// Forward declaration of `TargetVideoPixelFormat` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetVideoPixelFormat; }
// Forward declaration of `DepthFrameOutputOptions` to properly resolve imports.
namespace margelo::nitro::camera { struct DepthFrameOutputOptions; }
// Forward declaration of `ObjectOutputOptions` to properly resolve imports.
namespace margelo::nitro::camera { struct ObjectOutputOptions; }
// Forward declaration of `ScannedObjectType` to properly resolve imports.
namespace margelo::nitro::camera { enum class ScannedObjectType; }
// Forward declaration of `OrientationSource` to properly resolve imports.
namespace margelo::nitro::camera { enum class OrientationSource; }

#include "PermissionStatus.hpp"
#include "JPermissionStatus.hpp"
#include <NitroModules/Promise.hpp>
#include <NitroModules/JPromise.hpp>
#include <memory>
#include "HybridCameraSessionSpec.hpp"
#include "JHybridCameraSessionSpec.hpp"
#include "HybridCameraSessionConfigSpec.hpp"
#include "JHybridCameraSessionConfigSpec.hpp"
#include "HybridCameraDeviceFactorySpec.hpp"
#include "JHybridCameraDeviceFactorySpec.hpp"
#include "HybridCameraPhotoOutputSpec.hpp"
#include "JHybridCameraPhotoOutputSpec.hpp"
#include "HybridCameraVideoOutputSpec.hpp"
#include "JHybridCameraVideoOutputSpec.hpp"
#include "HybridCameraFrameOutputSpec.hpp"
#include "JHybridCameraFrameOutputSpec.hpp"
#include "HybridCameraDepthFrameOutputSpec.hpp"
#include "JHybridCameraDepthFrameOutputSpec.hpp"
#include "HybridCameraPreviewOutputSpec.hpp"
#include "JHybridCameraPreviewOutputSpec.hpp"
#include "HybridCameraObjectOutputSpec.hpp"
#include "JHybridCameraObjectOutputSpec.hpp"
#include "HybridCameraOutputSynchronizerSpec.hpp"
#include "JHybridCameraOutputSynchronizerSpec.hpp"
#include "HybridZoomGestureControllerSpec.hpp"
#include "JHybridZoomGestureControllerSpec.hpp"
#include "HybridTapToFocusGestureControllerSpec.hpp"
#include "JHybridTapToFocusGestureControllerSpec.hpp"
#include "HybridOrientationManagerSpec.hpp"
#include "JHybridOrientationManagerSpec.hpp"
#include "HybridFrameRendererSpec.hpp"
#include "JHybridFrameRendererSpec.hpp"
#include "HybridMeteringPointSpec.hpp"
#include "JHybridMeteringPointSpec.hpp"
#include "HybridCameraDeviceSpec.hpp"
#include "JHybridCameraDeviceSpec.hpp"
#include "CameraOutputConfiguration.hpp"
#include <vector>
#include "JCameraOutputConfiguration.hpp"
#include "MirrorMode.hpp"
#include "JMirrorMode.hpp"
#include "HybridCameraOutputSpec.hpp"
#include "JHybridCameraOutputSpec.hpp"
#include "FPSConstraint.hpp"
#include "VideoStabilizationModeConstraint.hpp"
#include "PreviewStabilizationModeConstraint.hpp"
#include "ResolutionBiasConstraint.hpp"
#include "VideoDynamicRangeConstraint.hpp"
#include "PhotoHDRConstraint.hpp"
#include "PixelFormatConstraint.hpp"
#include "BinnedConstraint.hpp"
#include <variant>
#include "JConstraint.hpp"
#include "JFPSConstraint.hpp"
#include "JVideoStabilizationModeConstraint.hpp"
#include "TargetStabilizationMode.hpp"
#include "JTargetStabilizationMode.hpp"
#include "JPreviewStabilizationModeConstraint.hpp"
#include "JResolutionBiasConstraint.hpp"
#include "JVideoDynamicRangeConstraint.hpp"
#include "TargetDynamicRange.hpp"
#include "JTargetDynamicRange.hpp"
#include "TargetDynamicRangeBitDepth.hpp"
#include "JTargetDynamicRangeBitDepth.hpp"
#include "TargetColorSpace.hpp"
#include "JTargetColorSpace.hpp"
#include "TargetColorRange.hpp"
#include "JTargetColorRange.hpp"
#include "JPhotoHDRConstraint.hpp"
#include "JPixelFormatConstraint.hpp"
#include "PixelFormat.hpp"
#include "JPixelFormat.hpp"
#include "JBinnedConstraint.hpp"
#include <optional>
#include "PhotoOutputOptions.hpp"
#include "JPhotoOutputOptions.hpp"
#include "Size.hpp"
#include "JSize.hpp"
#include "TargetPhotoContainerFormat.hpp"
#include "JTargetPhotoContainerFormat.hpp"
#include "QualityPrioritization.hpp"
#include "JQualityPrioritization.hpp"
#include "VideoOutputOptions.hpp"
#include "JVideoOutputOptions.hpp"
#include "RecorderFileType.hpp"
#include "JRecorderFileType.hpp"
#include "FrameOutputOptions.hpp"
#include "JFrameOutputOptions.hpp"
#include "TargetVideoPixelFormat.hpp"
#include "JTargetVideoPixelFormat.hpp"
#include "DepthFrameOutputOptions.hpp"
#include "JDepthFrameOutputOptions.hpp"
#include "ObjectOutputOptions.hpp"
#include "JObjectOutputOptions.hpp"
#include "ScannedObjectType.hpp"
#include "JScannedObjectType.hpp"
#include "OrientationSource.hpp"
#include "JOrientationSource.hpp"

namespace margelo::nitro::camera {

  std::shared_ptr<JHybridCameraFactorySpec> JHybridCameraFactorySpec::JavaPart::getJHybridCameraFactorySpec() {
    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
    auto castHybridObject = std::dynamic_pointer_cast<JHybridCameraFactorySpec>(hybridObject);
    if (castHybridObject == nullptr) [[unlikely]] {
      throw std::runtime_error("Failed to downcast JHybridObject to JHybridCameraFactorySpec!");
    }
    return castHybridObject;
  }

  jni::local_ref<JHybridCameraFactorySpec::CxxPart::jhybriddata> JHybridCameraFactorySpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
    return makeCxxInstance(jThis);
  }

  std::shared_ptr<JHybridObject> JHybridCameraFactorySpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
    auto castJavaPart = jni::dynamic_ref_cast<JHybridCameraFactorySpec::JavaPart>(javaPart);
    if (castJavaPart == nullptr) [[unlikely]] {
      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridCameraFactorySpec::JavaPart!");
    }
    return std::make_shared<JHybridCameraFactorySpec>(castJavaPart);
  }

  void JHybridCameraFactorySpec::CxxPart::registerNatives() {
    registerHybrid({
      makeNativeMethod("initHybrid", JHybridCameraFactorySpec::CxxPart::initHybrid),
    });
  }

  // Properties
  PermissionStatus JHybridCameraFactorySpec::getCameraPermissionStatus() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getCameraPermissionStatus");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  PermissionStatus JHybridCameraFactorySpec::getMicrophonePermissionStatus() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getMicrophonePermissionStatus");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  bool JHybridCameraFactorySpec::getSupportsMultiCamSessions() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsMultiCamSessions");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }

  // Methods
  std::shared_ptr<Promise<bool>> JHybridCameraFactorySpec::requestCameraPermission() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestCameraPermission");
    auto __result = method(_javaPart);
    return [&]() {
      auto __promise = Promise<bool>::create();
      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
        __promise->resolve(static_cast<bool>(__result->value()));
      });
      __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<bool>> JHybridCameraFactorySpec::requestMicrophonePermission() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestMicrophonePermission");
    auto __result = method(_javaPart);
    return [&]() {
      auto __promise = Promise<bool>::create();
      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
        __promise->resolve(static_cast<bool>(__result->value()));
      });
      __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<std::shared_ptr<HybridCameraSessionSpec>>> JHybridCameraFactorySpec::createCameraSession(bool enableMultiCam) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jboolean /* enableMultiCam */)>("createCameraSession");
    auto __result = method(_javaPart, enableMultiCam);
    return [&]() {
      auto __promise = Promise<std::shared_ptr<HybridCameraSessionSpec>>::create();
      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
        auto __result = jni::static_ref_cast<JHybridCameraSessionSpec::JavaPart>(__boxedResult);
        __promise->resolve(__result->getJHybridCameraSessionSpec());
      });
      __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<std::shared_ptr<HybridCameraSessionConfigSpec>>> JHybridCameraFactorySpec::resolveConstraints(const std::shared_ptr<HybridCameraDeviceSpec>& device, const std::vector<CameraOutputConfiguration>& outputConfigurations, const std::vector<std::variant<FPSConstraint, VideoStabilizationModeConstraint, PreviewStabilizationModeConstraint, ResolutionBiasConstraint, VideoDynamicRangeConstraint, PhotoHDRConstraint, PixelFormatConstraint, BinnedConstraint>>& constraints, std::optional<bool> requiresMultiCam) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JHybridCameraDeviceSpec::JavaPart> /* device */, jni::alias_ref<jni::JArrayClass<JCameraOutputConfiguration>> /* outputConfigurations */, jni::alias_ref<jni::JArrayClass<JConstraint>> /* constraints */, jni::alias_ref<jni::JBoolean> /* requiresMultiCam */)>("resolveConstraints");
    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridCameraDeviceSpec>(device)->getJavaPart(), [&](auto&& __input) {
      size_t __size = __input.size();
      jni::local_ref<jni::JArrayClass<JCameraOutputConfiguration>> __array = jni::JArrayClass<JCameraOutputConfiguration>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = __input[__i];
        auto __elementJni = JCameraOutputConfiguration::fromCpp(__element);
        __array->setElement(__i, *__elementJni);
      }
      return __array;
    }(outputConfigurations), [&](auto&& __input) {
      size_t __size = __input.size();
      jni::local_ref<jni::JArrayClass<JConstraint>> __array = jni::JArrayClass<JConstraint>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = __input[__i];
        auto __elementJni = JConstraint::fromCpp(__element);
        __array->setElement(__i, *__elementJni);
      }
      return __array;
    }(constraints), requiresMultiCam.has_value() ? jni::JBoolean::valueOf(requiresMultiCam.value()) : nullptr);
    return [&]() {
      auto __promise = Promise<std::shared_ptr<HybridCameraSessionConfigSpec>>::create();
      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
        auto __result = jni::static_ref_cast<JHybridCameraSessionConfigSpec::JavaPart>(__boxedResult);
        __promise->resolve(__result->getJHybridCameraSessionConfigSpec());
      });
      __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<std::shared_ptr<HybridCameraDeviceFactorySpec>>> JHybridCameraFactorySpec::createDeviceFactory() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("createDeviceFactory");
    auto __result = method(_javaPart);
    return [&]() {
      auto __promise = Promise<std::shared_ptr<HybridCameraDeviceFactorySpec>>::create();
      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
        auto __result = jni::static_ref_cast<JHybridCameraDeviceFactorySpec::JavaPart>(__boxedResult);
        __promise->resolve(__result->getJHybridCameraDeviceFactorySpec());
      });
      __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<HybridCameraPhotoOutputSpec> JHybridCameraFactorySpec::createPhotoOutput(const PhotoOutputOptions& options) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraPhotoOutputSpec::JavaPart>(jni::alias_ref<JPhotoOutputOptions> /* options */)>("createPhotoOutput");
    auto __result = method(_javaPart, JPhotoOutputOptions::fromCpp(options));
    return __result->getJHybridCameraPhotoOutputSpec();
  }
  std::shared_ptr<HybridCameraVideoOutputSpec> JHybridCameraFactorySpec::createVideoOutput(const VideoOutputOptions& options) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraVideoOutputSpec::JavaPart>(jni::alias_ref<JVideoOutputOptions> /* options */)>("createVideoOutput");
    auto __result = method(_javaPart, JVideoOutputOptions::fromCpp(options));
    return __result->getJHybridCameraVideoOutputSpec();
  }
  std::shared_ptr<HybridCameraFrameOutputSpec> JHybridCameraFactorySpec::createFrameOutput(const FrameOutputOptions& options) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraFrameOutputSpec::JavaPart>(jni::alias_ref<JFrameOutputOptions> /* options */)>("createFrameOutput");
    auto __result = method(_javaPart, JFrameOutputOptions::fromCpp(options));
    return __result->getJHybridCameraFrameOutputSpec();
  }
  std::shared_ptr<HybridCameraDepthFrameOutputSpec> JHybridCameraFactorySpec::createDepthFrameOutput(const DepthFrameOutputOptions& options) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraDepthFrameOutputSpec::JavaPart>(jni::alias_ref<JDepthFrameOutputOptions> /* options */)>("createDepthFrameOutput");
    auto __result = method(_javaPart, JDepthFrameOutputOptions::fromCpp(options));
    return __result->getJHybridCameraDepthFrameOutputSpec();
  }
  std::shared_ptr<HybridCameraPreviewOutputSpec> JHybridCameraFactorySpec::createPreviewOutput() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraPreviewOutputSpec::JavaPart>()>("createPreviewOutput");
    auto __result = method(_javaPart);
    return __result->getJHybridCameraPreviewOutputSpec();
  }
  std::shared_ptr<HybridCameraObjectOutputSpec> JHybridCameraFactorySpec::createObjectOutput(const ObjectOutputOptions& options) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraObjectOutputSpec::JavaPart>(jni::alias_ref<JObjectOutputOptions> /* options */)>("createObjectOutput");
    auto __result = method(_javaPart, JObjectOutputOptions::fromCpp(options));
    return __result->getJHybridCameraObjectOutputSpec();
  }
  std::shared_ptr<HybridCameraOutputSynchronizerSpec> JHybridCameraFactorySpec::createOutputSynchronizer(const std::vector<std::shared_ptr<HybridCameraOutputSpec>>& outputs) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraOutputSynchronizerSpec::JavaPart>(jni::alias_ref<jni::JArrayClass<JHybridCameraOutputSpec::JavaPart>> /* outputs */)>("createOutputSynchronizer");
    auto __result = method(_javaPart, [&](auto&& __input) {
      size_t __size = __input.size();
      jni::local_ref<jni::JArrayClass<JHybridCameraOutputSpec::JavaPart>> __array = jni::JArrayClass<JHybridCameraOutputSpec::JavaPart>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = __input[__i];
        auto __elementJni = std::dynamic_pointer_cast<JHybridCameraOutputSpec>(__element)->getJavaPart();
        __array->setElement(__i, *__elementJni);
      }
      return __array;
    }(outputs));
    return __result->getJHybridCameraOutputSynchronizerSpec();
  }
  std::shared_ptr<HybridZoomGestureControllerSpec> JHybridCameraFactorySpec::createZoomGestureController() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridZoomGestureControllerSpec::JavaPart>()>("createZoomGestureController");
    auto __result = method(_javaPart);
    return __result->getJHybridZoomGestureControllerSpec();
  }
  std::shared_ptr<HybridTapToFocusGestureControllerSpec> JHybridCameraFactorySpec::createTapToFocusGestureController() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridTapToFocusGestureControllerSpec::JavaPart>()>("createTapToFocusGestureController");
    auto __result = method(_javaPart);
    return __result->getJHybridTapToFocusGestureControllerSpec();
  }
  std::shared_ptr<HybridOrientationManagerSpec> JHybridCameraFactorySpec::createOrientationManager(OrientationSource orientationSource) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridOrientationManagerSpec::JavaPart>(jni::alias_ref<JOrientationSource> /* orientationSource */)>("createOrientationManager");
    auto __result = method(_javaPart, JOrientationSource::fromCpp(orientationSource));
    return __result->getJHybridOrientationManagerSpec();
  }
  std::shared_ptr<HybridFrameRendererSpec> JHybridCameraFactorySpec::createFrameRenderer() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridFrameRendererSpec::JavaPart>()>("createFrameRenderer");
    auto __result = method(_javaPart);
    return __result->getJHybridFrameRendererSpec();
  }
  std::shared_ptr<HybridMeteringPointSpec> JHybridCameraFactorySpec::createNormalizedMeteringPoint(double x, double y, std::optional<double> size) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridMeteringPointSpec::JavaPart>(double /* x */, double /* y */, jni::alias_ref<jni::JDouble> /* size */)>("createNormalizedMeteringPoint");
    auto __result = method(_javaPart, x, y, size.has_value() ? jni::JDouble::valueOf(size.value()) : nullptr);
    return __result->getJHybridMeteringPointSpec();
  }

} // namespace margelo::nitro::camera