1558dd2f15
* Remove Audio Device if it failed to configure * Add `audio-in-use-by-other-app` error * Try removing on interruption * Format code * Make error more clear
311 lines
8.6 KiB
Swift
311 lines
8.6 KiB
Swift
//
|
|
// CameraError.swift
|
|
// Cuvent
|
|
//
|
|
// Created by Marc Rousavy on 14.01.21.
|
|
// Copyright © 2021 Facebook. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
// MARK: - PermissionError
|
|
|
|
enum PermissionError: String {
|
|
case microphone = "microphone-permission-denied"
|
|
case camera = "camera-permission-denied"
|
|
|
|
// MARK: Internal
|
|
|
|
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!"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - ParameterError
|
|
|
|
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)
|
|
|
|
// MARK: Internal
|
|
|
|
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!"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - DeviceError
|
|
|
|
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"
|
|
|
|
// MARK: Internal
|
|
|
|
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!"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - FormatError
|
|
|
|
enum FormatError {
|
|
case invalidFps(fps: Int)
|
|
case invalidHdr
|
|
case invalidFormat
|
|
case invalidPreset(preset: String)
|
|
|
|
// MARK: Internal
|
|
|
|
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."
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SessionError
|
|
|
|
enum SessionError {
|
|
case cameraNotReady
|
|
case audioSessionSetupFailed(reason: String)
|
|
case audioInUseByOtherApp
|
|
|
|
// MARK: Internal
|
|
|
|
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"
|
|
}
|
|
}
|
|
|
|
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!"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - CaptureError
|
|
|
|
enum CaptureError {
|
|
case invalidPhotoFormat
|
|
case recordingInProgress
|
|
case noRecordingInProgress
|
|
case fileError
|
|
case createTempFileError
|
|
case invalidPhotoCodec
|
|
case unknown(message: String? = nil)
|
|
|
|
// MARK: Internal
|
|
|
|
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."
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SystemError
|
|
|
|
enum SystemError: String {
|
|
case noManager = "no-camera-manager"
|
|
|
|
// MARK: Internal
|
|
|
|
var code: String {
|
|
return rawValue
|
|
}
|
|
|
|
var message: String {
|
|
switch self {
|
|
case .noManager:
|
|
return "No Camera Manager was found."
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - CameraError
|
|
|
|
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)
|
|
|
|
// MARK: Internal
|
|
|
|
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."
|
|
}
|
|
}
|
|
}
|