tauri-plugin-screen-wake-lock 0.1.0

use serde::de::DeserializeOwned;
use std::sync::Mutex;
use tauri::{plugin::PluginApi, AppHandle, Runtime};

use crate::error::Error;
use crate::models::*;

pub fn init<R: Runtime, C: DeserializeOwned>(
  app: &AppHandle<R>,
  _api: PluginApi<R, C>,
) -> crate::Result<ScreenWakeLock<R>> {
  Ok(ScreenWakeLock {
    app: app.clone(),
    state: Mutex::new(WakeLockState { lock: None }),
  })
}

struct WakeLockState {
  lock: Option<screen_wake_lock::ScreenWakeLock>,
}

/// Access to the screen-wake-lock APIs.
pub struct ScreenWakeLock<R: Runtime> {
  app: AppHandle<R>,
  state: Mutex<WakeLockState>,
}

impl<R: Runtime> ScreenWakeLock<R> {
  pub fn set_enabled(&self, payload: SetEnabledRequest) -> crate::Result<SetEnabledResponse> {
    let SetEnabledRequest {
      enabled,
      reason,
      linux_options,
    } = payload;
    let mut state = self.state.lock().map_err(|_| Error::StateUnavailable)?;

    if enabled {
      if state.lock.is_some() {
        return Ok(SetEnabledResponse { enabled: true });
      }

      let reason = reason.unwrap_or_else(|| self.app.package_info().name.clone());
      let linux_options = self.to_linux_options(linux_options);
      let lock = screen_wake_lock::ScreenWakeLock::acquire_with_linux_options(reason, linux_options)?;
      state.lock = Some(lock);
      Ok(SetEnabledResponse { enabled: true })
    } else {
      state.lock = None;
      Ok(SetEnabledResponse { enabled: false })
    }
  }

  pub fn is_enabled(&self) -> crate::Result<IsEnabledResponse> {
    let state = self.state.lock().map_err(|_| Error::StateUnavailable)?;
    Ok(IsEnabledResponse {
      enabled: state.lock.is_some(),
    })
  }

  pub fn is_supported(&self) -> IsSupportedResponse {
    IsSupportedResponse {
      supported: screen_wake_lock::ScreenWakeLock::is_supported(),
    }
  }

  fn to_linux_options(&self, linux_options: Option<LinuxOptions>) -> screen_wake_lock::LinuxOptions {
    let mut linux_options = linux_options.unwrap_or_default();
    if linux_options.application_id.is_none() {
      linux_options.application_id = Some(self.app.config().identifier.clone());
    }

    screen_wake_lock::LinuxOptions {
      application_id: linux_options.application_id,
      reason: linux_options.reason,
    }
  }
}