use camera::{BackendId, CameraErrorKind, OperationStage, RecoveryHint};
use serde_json::json;
use thiserror::Error;
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum CameraError {
#[error(transparent)]
Camera(#[from] camera::CameraError),
#[error("JNI: {0}")]
Jni(#[from] jni::errors::Error),
#[error("Android adapter: {message}")]
Adapter {
kind: CameraErrorKind,
recovery_hint: RecoveryHint,
message: String,
},
#[error("Android I/O: {0}")]
Io(#[from] std::io::Error),
}
impl CameraError {
pub fn adapter(kind: CameraErrorKind, message: impl Into<String>) -> Self {
Self::Adapter {
kind,
recovery_hint: RecoveryHint::None,
message: message.into(),
}
}
pub fn kind(&self) -> CameraErrorKind {
match self {
Self::Camera(error) => error.kind(),
Self::Jni(_) => CameraErrorKind::BackendFailure,
Self::Adapter { kind, .. } => *kind,
Self::Io(_) => CameraErrorKind::Io,
}
}
pub fn code(&self) -> &'static str {
self.kind().as_str()
}
pub fn recovery_hint(&self) -> RecoveryHint {
match self {
Self::Camera(error) => error.recovery_hint(),
Self::Jni(_) | Self::Adapter { .. } => RecoveryHint::None,
Self::Io(_) => RecoveryHint::Retry,
}
}
pub fn is_retryable(&self) -> bool {
self.recovery_hint().is_retryable()
}
pub fn backend(&self) -> Option<&BackendId> {
match self {
Self::Camera(error) => error.backend(),
_ => None,
}
}
pub fn stage(&self) -> Option<OperationStage> {
match self {
Self::Camera(error) => error.stage(),
Self::Jni(_) | Self::Adapter { .. } => Some(OperationStage::BackendCommand),
Self::Io(_) => Some(OperationStage::Open),
}
}
pub fn native_code(&self) -> Option<i64> {
match self {
Self::Camera(error) => error.native_code(),
Self::Io(error) => error.raw_os_error().map(i64::from),
_ => None,
}
}
pub fn boundary_payload(&self) -> String {
json!({
"schemaVersion": 1,
"code": self.code(),
"recovery": self.recovery_hint().as_str(),
"backend": self.backend().map(BackendId::as_str),
"stage": self.stage().map(OperationStage::as_str),
"nativeCode": self.native_code(),
"message": self.to_string(),
})
.to_string()
}
}
pub type Result<T> = std::result::Result<T, CameraError>;