react-native-vision-camera/ios/CameraError.swift

311 lines
8.6 KiB
Swift
Raw Normal View History

2021-02-19 08:28:05 -07:00
//
// CameraError.swift
// Cuvent
//
// Created by Marc Rousavy on 14.01.21.
// Copyright © 2021 Facebook. All rights reserved.
//
import Foundation
2021-03-09 02:53:29 -07:00
// MARK: - PermissionError
2021-02-19 08:28:05 -07:00
enum PermissionError: String {
case microphone = "microphone-permission-denied"
case camera = "camera-permission-denied"
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
return rawValue
}
var message: String {
switch self {
case .microphone:
return "The Microphone permission was denied!"
case .camera:
return "The Camera permission was denied!"
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - ParameterError
2021-02-19 08:28:05 -07:00
enum ParameterError {
case invalid(unionName: String, receivedValue: String)
case unsupportedOS(unionName: String, receivedValue: String, supportedOnOs: String)
case unsupportedOutput(outputDescriptor: String)
case unsupportedInput(inputDescriptor: String)
case invalidCombination(provided: String, missing: String)
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
switch self {
case .invalid:
return "invalid-parameter"
case .unsupportedOS:
return "unsupported-os"
case .unsupportedOutput:
return "unsupported-output"
case .unsupportedInput:
return "unsupported-input"
case .invalidCombination:
return "invalid-combination"
}
}
var message: String {
switch self {
case let .invalid(unionName: unionName, receivedValue: receivedValue):
return "The value \"\(receivedValue)\" could not be parsed to type \(unionName)!"
case let .unsupportedOS(unionName: unionName, receivedValue: receivedValue, supportedOnOs: os):
return "The value \"\(receivedValue)\" for type \(unionName) is not supported on the current iOS version! Required OS: \(os) or higher"
case let .unsupportedOutput(outputDescriptor: output):
return "The output \"\(output)\" is not supported!"
case let .unsupportedInput(inputDescriptor: input):
return "The input \"\(input)\" is not supported!"
case let .invalidCombination(provided: provided, missing: missing):
return "Invalid combination! If \"\(provided)\" is provided, \"\(missing)\" also has to be set!"
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - DeviceError
2021-02-19 08:28:05 -07:00
enum DeviceError: String {
case configureError = "configuration-error"
case noDevice = "no-device"
case invalid = "invalid-device"
case torchUnavailable = "torch-unavailable"
case microphoneUnavailable = "microphone-unavailable"
case lowLightBoostNotSupported = "low-light-boost-not-supported"
case focusNotSupported = "focus-not-supported"
case notAvailableOnSimulator = "camera-not-available-on-simulator"
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
return rawValue
}
var message: String {
switch self {
case .configureError:
return "Failed to lock the device for configuration."
case .noDevice:
return "No device was set! Use `getAvailableCameraDevices()` to select a suitable Camera device."
case .invalid:
return "The given Camera device was invalid. Use `getAvailableCameraDevices()` to select a suitable Camera device."
case .torchUnavailable:
return "The current camera device does not have a torch."
case .lowLightBoostNotSupported:
return "The currently selected camera device does not support low-light boost! Make sure you select a device where `supportsLowLightBoost` is true!"
case .focusNotSupported:
return "The currently selected camera device does not support focussing!"
case .microphoneUnavailable:
return "The microphone was unavailable."
case .notAvailableOnSimulator:
return "The Camera is not available on the iOS Simulator!"
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - FormatError
2021-02-19 08:28:05 -07:00
enum FormatError {
case invalidFps(fps: Int)
case invalidHdr
case invalidFormat
case invalidPreset(preset: String)
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
switch self {
case .invalidFormat:
return "invalid-format"
case .invalidFps:
return "invalid-fps"
case .invalidHdr:
return "invalid-hdr"
case .invalidPreset:
return "invalid-preset"
}
}
var message: String {
switch self {
case .invalidFormat:
return "The given format was invalid. Did you check if the current device supports the given format by using `getAvailableCameraDevices(...)`?"
case let .invalidFps(fps):
return "The given FPS were not valid for the currently selected format. Make sure you select a format which `frameRateRanges` includes \(fps) FPS!"
case .invalidHdr:
return "The currently selected format does not support HDR capture! Make sure you select a format which `frameRateRanges` includes `supportsPhotoHDR`!"
case let .invalidPreset(preset):
return "The preset \"\(preset)\" is not available for the current camera device."
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - SessionError
enum SessionError {
case cameraNotReady
case audioSessionSetupFailed(reason: String)
case audioInUseByOtherApp
2021-02-19 08:28:05 -07:00
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
switch self {
case .cameraNotReady:
return "camera-not-ready"
case .audioSessionSetupFailed:
return "audio-session-setup-failed"
case .audioInUseByOtherApp:
return "audio-in-use-by-other-app"
}
2021-02-19 08:28:05 -07:00
}
var message: String {
switch self {
case .cameraNotReady:
return "The Camera is not ready yet! Wait for the onInitialized() callback!"
case let .audioSessionSetupFailed(reason):
return "The audio session failed to setup! \(reason)"
case .audioInUseByOtherApp:
return "The audio session is already in use by another app with higher priority!"
2021-02-19 08:28:05 -07:00
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - CaptureError
2021-02-19 08:28:05 -07:00
enum CaptureError {
case invalidPhotoFormat
case recordingInProgress
case noRecordingInProgress
case fileError
case createTempFileError
case invalidPhotoCodec
case unknown(message: String? = nil)
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
switch self {
case .invalidPhotoFormat:
return "invalid-photo-format"
case .recordingInProgress:
return "recording-in-progress"
case .noRecordingInProgress:
return "no-recording-in-progress"
case .fileError:
return "file-io-error"
case .createTempFileError:
return "create-temp-file-error"
case .invalidPhotoCodec:
return "invalid-photo-codec"
case .unknown:
return "unknown"
}
}
var message: String {
switch self {
case .invalidPhotoFormat:
return "The given photo format was invalid!"
case .invalidPhotoCodec:
return "The given photo codec was invalid!"
case .recordingInProgress:
return "There is already an active video recording in progress! Did you call startRecording() twice?"
case .noRecordingInProgress:
return "There was no active video recording in progress! Did you call stopRecording() twice?"
case .fileError:
return "An unexpected File IO error occured!"
case .createTempFileError:
return "Failed to create a temporary file!"
case let .unknown(message: message):
return message ?? "An unknown error occured while capturing a video/photo."
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - SystemError
2021-02-19 08:28:05 -07:00
enum SystemError: String {
case noManager = "no-camera-manager"
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
return rawValue
}
var message: String {
switch self {
case .noManager:
return "No Camera Manager was found."
}
}
}
2021-03-09 02:53:29 -07:00
// MARK: - CameraError
2021-02-19 08:28:05 -07:00
enum CameraError: Error {
case permission(_ id: PermissionError)
case parameter(_ id: ParameterError)
case device(_ id: DeviceError)
case format(_ id: FormatError)
case session(_ id: SessionError)
case capture(_ id: CaptureError)
case system(_ id: SystemError)
case unknown(message: String? = nil)
2021-03-09 02:53:29 -07:00
// MARK: Internal
2021-02-19 08:28:05 -07:00
var code: String {
switch self {
case let .permission(id: id):
return "permission/\(id.code)"
case let .parameter(id: id):
return "parameter/\(id.code)"
case let .device(id: id):
return "device/\(id.code)"
case let .format(id: id):
return "format/\(id.code)"
case let .session(id: id):
return "session/\(id.code)"
case let .capture(id: id):
return "capture/\(id.code)"
case let .system(id: id):
return "system/\(id.code)"
case .unknown:
return "unknown/unknown"
}
}
var message: String {
switch self {
case let .permission(id: id):
return id.message
case let .parameter(id: id):
return id.message
case let .device(id: id):
return id.message
case let .format(id: id):
return id.message
case let .session(id: id):
return id.message
case let .capture(id: id):
return id.message
case let .system(id: id):
return id.message
case let .unknown(message: message):
return message ?? "An unexpected error occured."
}
}
}