react-native-vision-camera/ios/CameraError.swift
Marc Rousavy eeb765f018
fix: Move Audio Input initialization shortly before startRecording (#159)
* rename

* Update AVAudioSession+updateCategory.swift

* fix bootstrap script

* Update CameraView+AVAudioSession.swift

* move audio input adding lower

* Activate AudioSession only when starting recording

* format

* Deactivate Audio Session

* remove audio input before deactivating audio session

* Update CameraView+AVAudioSession.swift

* log time

* Update CameraView+AVAudioSession.swift

* measure time with `measureElapsedTime`

* Update project.pbxproj

* only log in debug builds

* bootstrap with bridge (RNN new API)

* Mark two funcs as `@inlinable`

* format

* Update ReactLogger.swift

* Make audioWriter optional (allow videos without sound)

* only log frame drop reason in DEBUG

* Make audio writing entirely optional

* format

* Use function name as label for measureElapsedTime

* Update MeasureElapsedTime.swift

* Update MeasureElapsedTime.swift

* Mark AudioWriter as finished

* set `automaticallyConfiguresApplicationAudioSession` once

* Add JS console logging

* log to JS console for a few logs

* Update AVAudioSession+updateCategory.swift

* format

* Update JSConsoleHelper.mm

* catch log errors

* Update ReactLogger.swift

* fix docs

* Update RecordingSession.swift

* Immediatelly add audio input

* Update CameraView+AVCaptureSession.swift

* Update CameraView+AVCaptureSession.swift

* Update ReactLogger.swift

* immediatelly set audio session

* extract

* format

* Update TROUBLESHOOTING.mdx

* hmm

* Update AVAudioSession+updateCategory.swift

* Create secondary `AVCaptureSession` for audio

* Configure once, start stop on demand

* format

* fix audio notification interruptions

* docs
2021-06-03 14:16:02 +02:00

305 lines
9.0 KiB
Swift

//
// CameraError.swift
// Cuvent
//
// Created by Marc Rousavy on 14.01.21.
// Copyright © 2021 mrousavy. All rights reserved.
//
import Foundation
// MARK: - PermissionError
enum PermissionError: String {
case microphone = "microphone-permission-denied"
case camera = "camera-permission-denied"
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)
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"
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)
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 audioSessionFailedToActivate
case audioInUseByOtherApp
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"
case .audioSessionFailedToActivate:
return "audio-session-failed-to-activate"
}
}
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!"
case .audioSessionFailedToActivate:
return "Failed to activate Audio Session!"
}
}
}
// MARK: - CaptureError
enum CaptureError {
case invalidPhotoFormat
case recordingInProgress
case noRecordingInProgress
case fileError
case createTempFileError
case createRecorderError(message: String? = nil)
case invalidPhotoCodec
case unknown(message: String? = nil)
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 .createRecorderError:
return "create-recorder-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 .createRecorderError(message: message):
return "Failed to create the AVAssetWriter (Recorder)! \(message ?? "(no additional message)")"
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"
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)
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."
}
}
}