CameraDevice

namespace VideoKit {
    /// <summary>
    /// Camera device for streaming pixel buffers.
    /// </summary>
    class CameraDevice { ... }
}

/// <summary>
/// Check the current camera permission status.
/// </summary>
/// <param name="request">Request permissions if the user has not yet been asked.</param>
/// <returns>Camera permission status.</returns>
static Task<PermissionStatus> CheckPermissions (bool request = true);

/// <summary>
/// Device permissions status.
/// </summary>
enum PermissionStatus : int {
    /// <summary>
    /// User has not authorized or denied access to media device.
    /// </summary>
    Unknown = 0,
    /// <summary>
    /// User has denied access to media device.
    /// </summary>
    Denied = 2,
    /// <summary>
    /// User has authorized access to media device.
    /// </summary>
    Authorized = 3
}

/// <summary>
/// Discover available camera devices.
/// </summary>
static Task<CameraDevice[]> Discover ();

/// <summary>
/// Camera unique ID.
/// </summary>
string uniqueId { get; }

/// <summary>
/// Display friendly camera name.
/// </summary>
string name { get; }

/// <summary>
/// Device location.
/// </summary>
Location location { get; }

/// <summary>
/// Whether this camera is the default camera device.
/// </summary>
bool defaultForMediaType { get; }

/// <summary>
/// Whether the camera is front facing.
/// </summary>
bool frontFacing { get; }

/// <summary>
/// Whether flash is supported for photo capture.
/// </summary>
bool flashSupported { get; }

/// <summary>
/// Whether torch is supported.
/// </summary>
bool torchSupported { get; }

/// <summary>
/// Whether setting the exposure point is supported.
/// </summary>
bool exposurePointSupported { get; }

/// <summary>
/// Whether setting the focus point is supported.
/// </summary>
bool focusPointSupported { get; }

/// <summary>
/// Whether depth streaming is supported.
/// </summary>
bool depthStreamingSupported { get; }

/// <summary>
/// Field of view in degrees.
/// </summary>
(float width, float height) fieldOfView { get; }

/// <summary>
/// Exposure bias range in EV.
/// </summary>
(float min, float max) exposureBiasRange { get; }

/// <summary>
/// Exposure duration range in seconds.
/// </summary>
(float min, float max) exposureDurationRange { get; }

/// <summary>
/// Sensor sensitivity range.
/// </summary>
(float min, float max) ISORange { get; }

/// <summary>
/// Zoom ratio range.
/// </summary>
(float min, float max) zoomRange { get; }

/// <summary>
/// Get or set the preview resolution.
/// </summary>
(int width, int height) previewResolution { get; set; }

/// <summary>
/// Get or set the preview framerate.
/// </summary>
float frameRate { get; set; }

/// <summary>
/// Whether the device is running.
/// </summary>
bool running { get; }

/// <summary>
/// Start the camera preview.
/// </summary>
/// <param name="handler">Delegate to receive preview image frames.</param>
void StartRunning (Action<PixelBuffer> handler);

/// <summary>
/// Stop running.
/// </summary>
void StopRunning ();

/// <summary>
/// Get or set the exposure mode.
/// If the requested exposure mode is not supported, the camera device will ignore.
/// </summary>
ExposureMode exposureMode { get; set; } = ExposureMode.Continuous;

/// <summary>
/// Check if a given exposure mode is supported by the camera device.
/// </summary>
/// <param name="mode">Exposure mode.</param>
bool IsExposureModeSupported (ExposureMode mode);

/// <summary>
/// Exposure mode.
/// </summary>
enum ExposureMode : int {
    /// <summary>
    /// Continuous auto exposure.
    /// </summary>
    Continuous  = 0,
    /// <summary>
    /// Locked auto exposure.
    /// </summary>
    Locked      = 1,
    /// <summary>
    /// Manual exposure.
    /// </summary>
    Manual      = 2
}

/// <summary>
/// Set the exposure point of interest.
/// The point is specified in normalized coordinates in range [0.0, 1.0].
/// </summary>
/// <param name="x">Normalized x coordinate.</param>
/// <param name="y">Normalized y coordinate.</param>
void SetExposurePoint (float x, float y);

/// <summary>
/// Get or set the exposure bias.
/// This value must be in the range returned by `exposureRange`.
/// </summary>
float exposureBias { get; set; }

/// <summary>
/// Get or set the current exposure duration in seconds.
/// </summary>
float exposureDuration { get; }

/// <summary>
/// Get or set the current exposure sensitivity.
/// </summary>
float ISO { get; }

/// <summary>
/// Set manual exposure.
/// </summary>
/// <param name="duration">Exposure duration in seconds. MUST be in `exposureDurationRange`.</param>
/// <param name="ISO">Sensor sensitivity ISO value. MUST be in `ISORange`.</param>
void SetExposureDuration (float duration, float ISO);

/// <summary>
/// Get or set the photo flash mode.
/// </summary>
FlashMode flashMode { get; set; }

/// <summary>
/// Photo flash mode.
/// </summary>
enum FlashMode : int {
    /// <summary>
    /// Never use flash.
    /// </summary>
    Off     = 0,
    /// <summary>
    /// Always use flash.
    /// </summary>
    On      = 1,
    /// <summary>
    /// Let the sensor detect if it needs flash.
    /// </summary>
    Auto    = 2
}

/// <summary>
/// Get or set the focus mode.
/// </summary>
FocusMode focusMode { get; set; }

/// <summary>
/// Check if a given focus mode is supported by the camera device.
/// </summary>
/// <param name="mode">Focus mode.</param>
bool IsFocusModeSupported (FocusMode mode);

/// <summary>
/// Focus mode.
/// </summary>
enum FocusMode : int {
    /// <summary>
    /// Continuous autofocus.
    /// </summary>
    Continuous  = 0,
    /// <summary>
    /// Locked focus.
    /// </summary>
    Locked      = 1,
}

/// <summary>
/// Set the focus point of interest.
/// The point is specified in normalized coordinates in range [0.0, 1.0].
/// </summary>
/// <param name="x">Normalized x coordinate.</param>
/// <param name="y">Normalized y coordinate.</param>
void SetFocusPoint (float x, float y);

/// <summary>
/// Get or set the torch mode.
/// </summary>
TorchMode torchMode { get; set; }

/// <summary>
/// Torch mode.
/// </summary>
enum TorchMode : int {
    /// <summary>
    /// Disabled torch.
    /// </summary>
    Off     = 0,
    /// <summary>
    /// Maximum supported torch level.
    /// </summary>
    Maximum = 100
}

/// <summary>
/// Get or set the white balance mode.
/// </summary>
WhiteBalanceMode whiteBalanceMode { get; set; }

/// <summary>
/// Check if a given white balance mode is supported by the camera device.
/// </summary>
/// <param name="mode">White balance mode.</param>
bool IsWhiteBalanceModeSupported (WhiteBalanceMode mode);

/// <summary>
/// White balance mode.
/// </summary>
enum WhiteBalanceMode : int {
    /// <summary>
    /// Continuous auto white balance.
    /// </summary>
    Continuous  = 0,
    /// <summary>
    /// Locked auto white balance.
    /// </summary>
    Locked      = 1,
}

/// <summary>
/// Get or set the video stabilization mode.
/// </summary>
VideoStabilizationMode videoStabilizationMode { get; set; }

/// <summary>
/// Check if a given video stabilization mode is supported by the camera device.
/// </summary>
/// <param name="mode">Video stabilization mode.</param>
bool IsVideoStabilizationModeSupported (VideoStabilizationMode mode);

/// <summary>
/// Video stabilization mode.
/// </summary>
enum VideoStabilizationMode : int {
    /// <summary>
    /// Disabled video stabilization.
    /// </summary>
    Off         = 0,
    /// <summary>
    /// Standard video stabilization.
    /// </summary>
    Standard    = 1
}

/// <summary>
/// Get or set the zoom ratio.
/// This value must be in the range returned by `zoomRange`.
/// </summary>
float zoomRatio { get; set; }

/// <summary>
/// Get or set the photo resolution.
/// </summary>
(int width, int height) photoResolution { get; set; }

/// <summary>
/// Capture a photo.
/// </summary>
/// <param name="handler">Delegate to receive high-resolution photo.</param>
void CapturePhoto (Action<PixelBuffer> handler);