mirror of
https://github.com/MindWorkAI/AI-Studio.git
synced 2026-07-21 17:46:27 +00:00
4cc9d1f9a8
Some checks are pending
Build and Release / Determine run mode (push) Waiting to run
Build and Release / Read metadata (push) Blocked by required conditions
Build and Release / Sync Flatpak repo (push) Blocked by required conditions
Build and Release / Collect Flatpak artifacts (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-aarch64-apple-darwin, osx-arm64, macos-latest, aarch64-apple-darwin, dmg,app,updater, dmg) (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-aarch64-pc-windows-msvc.exe, win-arm64, windows-latest, aarch64-pc-windows-msvc, nsis,updater, nsis) (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-aarch64-unknown-linux-gnu, linux-arm64, ubuntu-22.04-arm, aarch64-unknown-linux-gnu, appimage,updater, appimage) (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-x86_64-apple-darwin, osx-x64, macos-latest, x86_64-apple-darwin, dmg,app,updater, dmg) (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-x86_64-pc-windows-msvc.exe, win-x64, windows-latest, x86_64-pc-windows-msvc, nsis,updater, nsis) (push) Blocked by required conditions
Build and Release / Build app (${{ matrix.dotnet_runtime }}) (-x86_64-unknown-linux-gnu, linux-x64, ubuntu-22.04, x86_64-unknown-linux-gnu, appimage,updater, appimage) (push) Blocked by required conditions
Build and Release / Prepare & create release (push) Blocked by required conditions
Build and Release / Publish release (push) Blocked by required conditions
966 lines
37 KiB
Rust
966 lines
37 KiB
Rust
#![cfg_attr(not(any(target_os = "linux", test)), allow(dead_code))]
|
|
|
|
use std::collections::HashMap;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
use std::sync::atomic::AtomicU64;
|
|
|
|
use log::{error, info, warn};
|
|
use once_cell::sync::Lazy;
|
|
use serde::{Deserialize, Serialize};
|
|
use strum_macros::Display;
|
|
use tauri_plugin_global_shortcut::GlobalShortcutExt;
|
|
use tokio::sync::{Mutex, broadcast};
|
|
|
|
use crate::app_window::{Event, TauriEventType};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
use ashpd::desktop::{CreateSessionOptions, ResponseError};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
use ashpd::desktop::global_shortcuts::{
|
|
BindShortcutsOptions, GlobalShortcuts, ListShortcutsOptions, NewShortcut, Shortcut as AshpdShortcut,
|
|
};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
use futures::StreamExt;
|
|
|
|
/// Serializes access to the active shortcut bindings across API requests.
|
|
static SHORTCUT_MANAGER: Lazy<Mutex<ShortcutManager>> = Lazy::new(|| Mutex::new(ShortcutManager::default()));
|
|
|
|
/// Indicates whether shortcut activations must currently be ignored.
|
|
static PROCESSING_SUSPENDED: AtomicBool = AtomicBool::new(false);
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Supplies unique generations for portal sessions so stale signal tasks can be ignored.
|
|
static NEXT_PORTAL_GENERATION: AtomicU64 = AtomicU64::new(1);
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Maps each shortcut to the generation of its currently active portal session.
|
|
static ACTIVE_PORTAL_GENERATIONS: Lazy<std::sync::Mutex<HashMap<Shortcut, u64>>> = Lazy::new(|| std::sync::Mutex::new(HashMap::new()));
|
|
|
|
/// Enum identifying global keyboard shortcuts.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Display)]
|
|
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
|
|
pub enum Shortcut {
|
|
/// Null value used when no supported shortcut was specified.
|
|
None = 0,
|
|
|
|
/// Toggles voice recording and transcription.
|
|
VoiceRecordingToggle,
|
|
}
|
|
|
|
impl Shortcut {
|
|
/// Resolves an application-provided portal shortcut ID to its internal identifier.
|
|
#[cfg(target_os = "linux")]
|
|
fn from_portal_id(id: &str) -> Option<Self> {
|
|
match id {
|
|
"VOICE_RECORDING_TOGGLE" => Some(Self::VoiceRecordingToggle),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Request payload for registering or disabling a global shortcut.
|
|
#[derive(Clone, Deserialize)]
|
|
pub struct RegisterShortcutRequest {
|
|
/// Identifies the action controlled by the shortcut.
|
|
pub id: Shortcut,
|
|
|
|
/// Contains the preferred key combination in Tauri shortcut syntax.
|
|
pub shortcut: String,
|
|
|
|
/// Contains the localized action description shown by the desktop portal.
|
|
pub description: String,
|
|
|
|
/// Indicates that the user deliberately requested a different key combination.
|
|
pub reconfigure: bool,
|
|
}
|
|
|
|
/// Backend used for a shortcut registration.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum ShortcutBackend {
|
|
/// No native shortcut backend is active.
|
|
None,
|
|
|
|
/// The XDG Desktop Portal manages the shortcut.
|
|
Portal,
|
|
|
|
/// The Tauri global-shortcut plugin manages the shortcut.
|
|
Tauri,
|
|
}
|
|
|
|
/// Response for shortcut registration and processing state changes.
|
|
#[derive(Serialize)]
|
|
pub struct ShortcutResponse {
|
|
/// Indicates whether the requested operation completed successfully.
|
|
pub success: bool,
|
|
|
|
/// Contains a technical error description when the operation failed.
|
|
pub error_message: String,
|
|
|
|
/// Identifies the backend involved in the operation.
|
|
pub backend: ShortcutBackend,
|
|
|
|
/// Indicates whether the user cancelled the portal request.
|
|
pub cancelled: bool,
|
|
|
|
/// Contains the effective, user-facing shortcut label selected by the backend.
|
|
pub effective_display_name: String,
|
|
}
|
|
|
|
impl ShortcutResponse {
|
|
/// Creates a successful shortcut response for the selected backend.
|
|
fn success(backend: ShortcutBackend, effective_display_name: String) -> Self {
|
|
Self {
|
|
success: true,
|
|
error_message: String::new(),
|
|
backend,
|
|
cancelled: false,
|
|
effective_display_name,
|
|
}
|
|
}
|
|
|
|
/// Creates a failed shortcut response with its backend and cancellation state.
|
|
fn error(error_message: impl Into<String>, backend: ShortcutBackend, cancelled: bool) -> Self {
|
|
Self {
|
|
success: false,
|
|
error_message: error_message.into(),
|
|
backend,
|
|
cancelled,
|
|
effective_display_name: String::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
/// Owns all currently active shortcut bindings.
|
|
struct ShortcutManager {
|
|
/// Maps each logical shortcut to its active backend binding.
|
|
bindings: HashMap<Shortcut, ActiveBinding>,
|
|
}
|
|
|
|
/// Stores the backend-specific resources required by an active shortcut.
|
|
enum ActiveBinding {
|
|
/// Stores a shortcut registered through the Tauri plugin.
|
|
Tauri {
|
|
/// Contains the registered shortcut in Tauri syntax.
|
|
shortcut: String,
|
|
},
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Stores a shortcut and its live XDG portal session.
|
|
Portal {
|
|
/// Contains the preferred shortcut in Tauri syntax.
|
|
shortcut: String,
|
|
/// Contains the effective human-readable trigger selected by the portal.
|
|
effective_display_name: String,
|
|
/// Distinguishes this session from superseded portal signal tasks.
|
|
generation: u64,
|
|
/// Keeps the portal registration active for the binding's lifetime.
|
|
session: ashpd::desktop::Session<GlobalShortcuts>,
|
|
},
|
|
}
|
|
|
|
impl ActiveBinding {
|
|
/// Returns the preferred Tauri-format shortcut associated with the binding.
|
|
fn shortcut(&self) -> &str {
|
|
match self {
|
|
Self::Tauri { shortcut } => shortcut,
|
|
#[cfg(target_os = "linux")]
|
|
Self::Portal { shortcut, .. } => shortcut,
|
|
}
|
|
}
|
|
|
|
/// Returns the native backend used by the binding.
|
|
fn backend(&self) -> ShortcutBackend {
|
|
match self {
|
|
Self::Tauri { .. } => ShortcutBackend::Tauri,
|
|
#[cfg(target_os = "linux")]
|
|
Self::Portal { .. } => ShortcutBackend::Portal,
|
|
}
|
|
}
|
|
|
|
/// Returns the shortcut label that should be displayed in the UI.
|
|
fn effective_display_name(&self) -> String {
|
|
match self {
|
|
Self::Tauri { shortcut } => shortcut.clone(),
|
|
#[cfg(target_os = "linux")]
|
|
Self::Portal { effective_display_name, .. } => effective_display_name.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns a snapshot of all registered shortcut IDs and their preferred combinations.
|
|
pub async fn registered_shortcuts() -> Vec<(Shortcut, String)> {
|
|
SHORTCUT_MANAGER
|
|
.lock()
|
|
.await
|
|
.bindings
|
|
.iter()
|
|
.map(|(id, binding)| (*id, binding.shortcut().to_string()))
|
|
.collect()
|
|
}
|
|
|
|
/// Registers, reconfigures, or disables a global shortcut through the appropriate backend.
|
|
pub async fn register(
|
|
app_handle: Option<tauri::AppHandle>,
|
|
event_sender: Option<broadcast::Sender<Event>>,
|
|
request: RegisterShortcutRequest,
|
|
) -> ShortcutResponse {
|
|
if request.id == Shortcut::None {
|
|
return ShortcutResponse::error("Cannot register NONE shortcut", ShortcutBackend::None, false);
|
|
}
|
|
|
|
let Some(app_handle) = app_handle else {
|
|
return ShortcutResponse::error("Main window not available", ShortcutBackend::None, false);
|
|
};
|
|
let Some(event_sender) = event_sender else {
|
|
return ShortcutResponse::error("Event broadcast not initialized", ShortcutBackend::None, false);
|
|
};
|
|
|
|
let mut manager = SHORTCUT_MANAGER.lock().await;
|
|
if request.shortcut.is_empty() {
|
|
return disable_binding(&app_handle, &mut manager, request.id).await;
|
|
}
|
|
|
|
if registration_is_unchanged(manager.bindings.get(&request.id).map(ActiveBinding::shortcut), &request.shortcut, request.reconfigure) {
|
|
info!(Source = "Global shortcuts"; "Ignoring unchanged registration for '{}'.", request.id);
|
|
let binding = manager.bindings.get(&request.id).unwrap();
|
|
return ShortcutResponse::success(binding.backend(), binding.effective_display_name());
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
match prepare_portal_binding(&request, event_sender.clone()).await {
|
|
Ok(new_binding) => {
|
|
let effective_display_name = new_binding.effective_display_name();
|
|
replace_portal_binding(&app_handle, &mut manager, request.id, new_binding).await;
|
|
info!(Source = "XDG portal"; "Global shortcut '{}' is active through the desktop portal.", request.id);
|
|
return ShortcutResponse::success(ShortcutBackend::Portal, effective_display_name);
|
|
},
|
|
|
|
Err(error) if may_fallback_to_tauri(
|
|
error.kind,
|
|
manager.bindings.get(&request.id).map(ActiveBinding::backend),
|
|
) => {
|
|
warn!(Source = "XDG portal"; "Global shortcuts portal is unavailable; using the Tauri X11 backend: {}", error.message);
|
|
},
|
|
|
|
Err(error) => {
|
|
let cancelled = error.kind == PortalFailureKind::Cancelled;
|
|
if cancelled {
|
|
warn!(Source = "XDG portal"; "Global shortcut configuration was cancelled by the user.");
|
|
} else if error.kind == PortalFailureKind::Denied {
|
|
warn!(Source = "XDG portal"; "Global shortcut permission was denied: {}", error.message);
|
|
} else {
|
|
error!(Source = "XDG portal"; "Global shortcut registration failed: {}", error.message);
|
|
}
|
|
|
|
return ShortcutResponse::error(error.message, ShortcutBackend::Portal, cancelled);
|
|
},
|
|
}
|
|
}
|
|
|
|
match register_tauri_binding(&app_handle, &request.shortcut, request.id, event_sender) {
|
|
Ok(()) => {
|
|
if let Some(old_binding) = manager.bindings.remove(&request.id) {
|
|
close_binding(&app_handle, request.id, old_binding).await;
|
|
}
|
|
|
|
manager.bindings.insert(request.id, ActiveBinding::Tauri { shortcut: request.shortcut.clone() });
|
|
ShortcutResponse::success(ShortcutBackend::Tauri, request.shortcut)
|
|
},
|
|
|
|
Err(error) => ShortcutResponse::error(
|
|
format!("Failed to register shortcut: {error}"),
|
|
ShortcutBackend::Tauri,
|
|
false,
|
|
),
|
|
}
|
|
}
|
|
|
|
/// Determines whether an existing registration already satisfies the request.
|
|
fn registration_is_unchanged(current: Option<&str>, requested: &str, reconfigure: bool) -> bool {
|
|
current.is_some_and(|current| current.eq_ignore_ascii_case(requested)) && !reconfigure
|
|
}
|
|
|
|
/// Removes an active binding and returns a successful disabled response.
|
|
async fn disable_binding(
|
|
app_handle: &tauri::AppHandle,
|
|
manager: &mut ShortcutManager,
|
|
id: Shortcut,
|
|
) -> ShortcutResponse {
|
|
if let Some(binding) = manager.bindings.remove(&id) {
|
|
close_binding(app_handle, id, binding).await;
|
|
}
|
|
|
|
info!(Source = "Global shortcuts"; "Shortcut '{}' has been disabled.", id);
|
|
ShortcutResponse::success(ShortcutBackend::None, String::new())
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Activates a prepared portal binding before closing the superseded binding.
|
|
async fn replace_portal_binding(
|
|
app_handle: &tauri::AppHandle,
|
|
manager: &mut ShortcutManager,
|
|
id: Shortcut,
|
|
new_binding: ActiveBinding,
|
|
) {
|
|
#[cfg(target_os = "linux")]
|
|
if let ActiveBinding::Portal { generation, .. } = &new_binding {
|
|
ACTIVE_PORTAL_GENERATIONS.lock().unwrap().insert(id, *generation);
|
|
}
|
|
|
|
let old_binding = manager.bindings.insert(id, new_binding);
|
|
if let Some(old_binding) = old_binding {
|
|
close_binding(app_handle, id, old_binding).await;
|
|
}
|
|
}
|
|
|
|
/// Releases the native resources owned by an active shortcut binding.
|
|
async fn close_binding(app_handle: &tauri::AppHandle, id: Shortcut, binding: ActiveBinding) {
|
|
match binding {
|
|
ActiveBinding::Tauri { shortcut } => {
|
|
if let Err(error) = app_handle.global_shortcut().unregister(shortcut.as_str()) {
|
|
warn!(Source = "Tauri"; "Failed to unregister shortcut '{shortcut}' for '{}': {error}", id);
|
|
}
|
|
},
|
|
|
|
#[cfg(target_os = "linux")]
|
|
ActiveBinding::Portal { generation, session, .. } => {
|
|
let is_still_active = ACTIVE_PORTAL_GENERATIONS.lock().unwrap().get(&id) == Some(&generation);
|
|
if is_still_active {
|
|
ACTIVE_PORTAL_GENERATIONS.lock().unwrap().remove(&id);
|
|
}
|
|
if let Err(error) = session.close().await {
|
|
warn!(Source = "XDG portal"; "Failed to close portal session for '{}': {error}", id);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Registers a shortcut callback through the Tauri global-shortcut plugin.
|
|
fn register_tauri_binding(
|
|
app_handle: &tauri::AppHandle,
|
|
shortcut: &str,
|
|
shortcut_id: Shortcut,
|
|
event_sender: broadcast::Sender<Event>,
|
|
) -> Result<(), tauri_plugin_global_shortcut::Error> {
|
|
app_handle.global_shortcut().on_shortcut(shortcut, move |_app, _shortcut, _event| {
|
|
if PROCESSING_SUSPENDED.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
|
|
send_shortcut_pressed(&event_sender, shortcut_id, "Tauri");
|
|
})
|
|
}
|
|
|
|
/// Publishes a shortcut activation using the existing runtime event format.
|
|
fn send_shortcut_pressed(event_sender: &broadcast::Sender<Event>, shortcut_id: Shortcut, source: &str) {
|
|
info!(Source = "Global shortcuts"; "Global shortcut triggered through {source} for '{}'.", shortcut_id);
|
|
if let Err(error) = event_sender.send(Event::new(
|
|
TauriEventType::GlobalShortcutPressed,
|
|
vec![shortcut_id.to_string()],
|
|
)) {
|
|
error!(Source = "Global shortcuts"; "Failed to send global shortcut event: {error}");
|
|
}
|
|
}
|
|
|
|
/// Suspends shortcut processing while preserving portal sessions for later use.
|
|
pub async fn suspend(app_handle: Option<tauri::AppHandle>) -> ShortcutResponse {
|
|
PROCESSING_SUSPENDED.store(true, Ordering::Relaxed);
|
|
let Some(app_handle) = app_handle else {
|
|
PROCESSING_SUSPENDED.store(false, Ordering::Relaxed);
|
|
return ShortcutResponse::error("Main window not available", ShortcutBackend::None, false);
|
|
};
|
|
|
|
let manager = SHORTCUT_MANAGER.lock().await;
|
|
for (id, binding) in &manager.bindings {
|
|
if unregister_backend_during_suspend(binding.backend())
|
|
&& let ActiveBinding::Tauri { shortcut } = binding
|
|
&& let Err(error) = app_handle.global_shortcut().unregister(shortcut.as_str())
|
|
{
|
|
warn!(Source = "Tauri"; "Failed to suspend shortcut '{shortcut}' for '{}': {error}", id);
|
|
}
|
|
}
|
|
|
|
ShortcutResponse::success(ShortcutBackend::None, String::new())
|
|
}
|
|
|
|
/// Resumes shortcut processing and restores shortcuts owned by the Tauri backend.
|
|
pub async fn resume(
|
|
app_handle: Option<tauri::AppHandle>,
|
|
event_sender: Option<broadcast::Sender<Event>>,
|
|
) -> ShortcutResponse {
|
|
let Some(app_handle) = app_handle else {
|
|
return ShortcutResponse::error("Main window not available", ShortcutBackend::None, false);
|
|
};
|
|
|
|
let Some(event_sender) = event_sender else {
|
|
return ShortcutResponse::error("Event broadcast not initialized", ShortcutBackend::None, false);
|
|
};
|
|
|
|
let manager = SHORTCUT_MANAGER.lock().await;
|
|
for (id, binding) in &manager.bindings {
|
|
if let ActiveBinding::Tauri { shortcut } = binding
|
|
&& let Err(error) = register_tauri_binding(&app_handle, shortcut, *id, event_sender.clone())
|
|
{
|
|
PROCESSING_SUSPENDED.store(false, Ordering::Relaxed);
|
|
return ShortcutResponse::error(
|
|
format!("Failed to resume shortcut: {error}"),
|
|
ShortcutBackend::Tauri,
|
|
false,
|
|
);
|
|
}
|
|
}
|
|
|
|
PROCESSING_SUSPENDED.store(false, Ordering::Relaxed);
|
|
ShortcutResponse::success(ShortcutBackend::None, String::new())
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
|
|
/// Classifies portal failures so fallback and user feedback remain intentional.
|
|
enum PortalFailureKind {
|
|
/// The portal service or GlobalShortcuts interface is not available.
|
|
Unavailable,
|
|
|
|
/// The user cancelled the portal interaction.
|
|
Cancelled,
|
|
|
|
/// The portal explicitly denied the shortcut request.
|
|
Denied,
|
|
|
|
/// The portal failed for another technical reason.
|
|
Technical,
|
|
}
|
|
|
|
/// Determines whether an unavailable portal may safely fall back to Tauri.
|
|
fn may_fallback_to_tauri(failure: PortalFailureKind, current_backend: Option<ShortcutBackend>) -> bool {
|
|
failure == PortalFailureKind::Unavailable && current_backend.is_none_or(|backend| backend == ShortcutBackend::Tauri)
|
|
}
|
|
|
|
/// Determines whether a backend must unregister its shortcut during suspension.
|
|
fn unregister_backend_during_suspend(backend: ShortcutBackend) -> bool {
|
|
backend == ShortcutBackend::Tauri
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
/// Describes how a newly created portal session should obtain its shortcut.
|
|
enum PortalBindingAction {
|
|
/// Reuse a shortcut that the portal restored from an earlier session.
|
|
Restore,
|
|
|
|
/// Ask the portal to bind or deliberately reconfigure the shortcut.
|
|
Bind,
|
|
}
|
|
|
|
/// Selects restore or bind based on portal state and explicit user intent.
|
|
fn portal_binding_action(was_restored: bool, reconfigure: bool) -> PortalBindingAction {
|
|
if was_restored && !reconfigure {
|
|
PortalBindingAction::Restore
|
|
} else {
|
|
PortalBindingAction::Bind
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
|
|
/// Carries a classified portal failure and its technical description.
|
|
struct PortalFailure {
|
|
/// Identifies the semantic failure category.
|
|
kind: PortalFailureKind,
|
|
|
|
/// Contains the technical error text used for logging and API responses.
|
|
message: String,
|
|
}
|
|
|
|
impl PortalFailure {
|
|
#[cfg(target_os = "linux")]
|
|
/// Converts an `ashpd` error into the application's portal failure categories.
|
|
fn from_error(error: ashpd::Error) -> Self {
|
|
let kind = match &error {
|
|
ashpd::Error::Response(ResponseError::Cancelled) => PortalFailureKind::Cancelled,
|
|
ashpd::Error::Portal(ashpd::PortalError::Cancelled(_)) => PortalFailureKind::Cancelled,
|
|
ashpd::Error::Portal(ashpd::PortalError::NotAllowed(_)) => PortalFailureKind::Denied,
|
|
ashpd::Error::PortalNotFound(_) | ashpd::Error::RequiresVersion(_, _) => PortalFailureKind::Unavailable,
|
|
_ if portal_error_is_unavailable(&error.to_string()) => PortalFailureKind::Unavailable,
|
|
_ => PortalFailureKind::Technical,
|
|
};
|
|
|
|
Self { kind, message: error.to_string() }
|
|
}
|
|
|
|
/// Creates an explicit portal-permission denial.
|
|
fn denied(message: impl Into<String>) -> Self {
|
|
Self { kind: PortalFailureKind::Denied, message: message.into() }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
/// Contains the portal-facing ID and effective label of a registered shortcut.
|
|
struct PortalShortcutInfo {
|
|
/// Contains the stable application-provided shortcut ID.
|
|
id: String,
|
|
|
|
/// Contains the human-readable trigger returned by the portal.
|
|
effective_display_name: String,
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Normalizes shortcuts returned by `ashpd` for backend-independent processing.
|
|
fn normalize_portal_shortcuts(shortcuts: &[AshpdShortcut]) -> Vec<PortalShortcutInfo> {
|
|
shortcuts
|
|
.iter()
|
|
.map(|shortcut| PortalShortcutInfo {
|
|
id: shortcut.id().to_string(),
|
|
effective_display_name: shortcut.trigger_description().to_string(),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Abstracts portal listing and binding operations for deterministic lifecycle tests.
|
|
trait PortalAdapter {
|
|
/// Lists shortcuts restored into the current portal session.
|
|
async fn list_shortcuts(&mut self) -> Result<Vec<PortalShortcutInfo>, PortalFailure>;
|
|
|
|
/// Binds a shortcut with a localized description and preferred XDG trigger.
|
|
async fn bind_shortcut(
|
|
&mut self,
|
|
id: &str,
|
|
description: &str,
|
|
preferred_trigger: &str,
|
|
) -> Result<Vec<PortalShortcutInfo>, PortalFailure>;
|
|
}
|
|
|
|
/// Restores an approved portal shortcut or binds it when required.
|
|
async fn resolve_portal_shortcut<A: PortalAdapter>(
|
|
adapter: &mut A,
|
|
request: &RegisterShortcutRequest,
|
|
) -> Result<String, PortalFailure> {
|
|
let listed = adapter.list_shortcuts().await?;
|
|
let restored = listed.iter().find(|shortcut| shortcut.id == request.id.to_string());
|
|
if portal_binding_action(restored.is_some(), request.reconfigure) == PortalBindingAction::Restore {
|
|
return Ok(restored.unwrap().effective_display_name.clone());
|
|
}
|
|
|
|
let preferred_trigger = tauri_shortcut_to_xdg(&request.shortcut).map_err(|message| PortalFailure {
|
|
kind: PortalFailureKind::Technical,
|
|
message,
|
|
})?;
|
|
|
|
let bound = adapter
|
|
.bind_shortcut(
|
|
&request.id.to_string(),
|
|
&request.description,
|
|
&preferred_trigger,
|
|
)
|
|
.await?;
|
|
|
|
bound
|
|
.into_iter()
|
|
.find(|shortcut| shortcut.id == request.id.to_string())
|
|
.map(|shortcut| shortcut.effective_display_name)
|
|
.ok_or_else(|| PortalFailure::denied("The desktop portal did not approve the requested shortcut."))
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Implements portal operations through `ashpd` for one live session.
|
|
struct AshpdPortalAdapter<'a> {
|
|
/// Provides access to the GlobalShortcuts portal interface.
|
|
portal: &'a GlobalShortcuts,
|
|
|
|
/// Identifies the session whose shortcuts are listed or bound.
|
|
session: &'a ashpd::desktop::Session<GlobalShortcuts>,
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
impl PortalAdapter for AshpdPortalAdapter<'_> {
|
|
/// Lists and normalizes shortcuts restored by the XDG portal.
|
|
async fn list_shortcuts(&mut self) -> Result<Vec<PortalShortcutInfo>, PortalFailure> {
|
|
let response = self
|
|
.portal
|
|
.list_shortcuts(self.session, ListShortcutsOptions::default())
|
|
.await
|
|
.and_then(|request| request.response())
|
|
.map_err(PortalFailure::from_error)?;
|
|
|
|
Ok(normalize_portal_shortcuts(response.shortcuts()))
|
|
}
|
|
|
|
/// Binds one shortcut through the XDG portal and normalizes its response.
|
|
async fn bind_shortcut(
|
|
&mut self,
|
|
id: &str,
|
|
description: &str,
|
|
preferred_trigger: &str,
|
|
) -> Result<Vec<PortalShortcutInfo>, PortalFailure> {
|
|
let shortcut = NewShortcut::new(id, description).preferred_trigger(preferred_trigger);
|
|
let response = self
|
|
.portal
|
|
.bind_shortcuts(self.session, &[shortcut], None, BindShortcutsOptions::default())
|
|
.await
|
|
.and_then(|request| request.response())
|
|
.map_err(PortalFailure::from_error)?;
|
|
|
|
Ok(normalize_portal_shortcuts(response.shortcuts()))
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Detects D-Bus error strings that specifically indicate an unavailable portal.
|
|
fn portal_error_is_unavailable(message: &str) -> bool {
|
|
let normalized = message.to_ascii_lowercase();
|
|
normalized.contains("unknownmethod")
|
|
|| normalized.contains("unknown method")
|
|
|| normalized.contains("serviceunknown")
|
|
|| normalized.contains("globalshortcuts portal was not found")
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
/// Prepares a complete portal session and its signal listeners without replacing the active binding.
|
|
async fn prepare_portal_binding(
|
|
request: &RegisterShortcutRequest,
|
|
event_sender: broadcast::Sender<Event>,
|
|
) -> Result<ActiveBinding, PortalFailure> {
|
|
let portal = GlobalShortcuts::new().await.map_err(PortalFailure::from_error)?;
|
|
if portal.version() < 1 {
|
|
return Err(PortalFailure {
|
|
kind: PortalFailureKind::Unavailable,
|
|
message: "The GlobalShortcuts portal is not supported by this desktop.".to_string(),
|
|
});
|
|
}
|
|
|
|
let mut activated = portal.receive_activated().await.map_err(PortalFailure::from_error)?;
|
|
let mut changed = portal.receive_shortcuts_changed().await.map_err(PortalFailure::from_error)?;
|
|
|
|
let session = portal
|
|
.create_session(CreateSessionOptions::default())
|
|
.await
|
|
.map_err(PortalFailure::from_error)?;
|
|
|
|
let mut adapter = AshpdPortalAdapter { portal: &portal, session: &session };
|
|
let effective_display_name = match resolve_portal_shortcut(&mut adapter, request).await {
|
|
Ok(effective_display_name) => effective_display_name,
|
|
Err(error) => {
|
|
let _ = session.close().await;
|
|
return Err(error);
|
|
},
|
|
};
|
|
|
|
let generation = NEXT_PORTAL_GENERATION.fetch_add(1, Ordering::Relaxed);
|
|
let activation_sender = event_sender.clone();
|
|
|
|
tauri::async_runtime::spawn(async move {
|
|
while let Some(signal) = activated.next().await {
|
|
let Some(id) = Shortcut::from_portal_id(signal.shortcut_id()) else {
|
|
continue;
|
|
};
|
|
|
|
let is_active = ACTIVE_PORTAL_GENERATIONS.lock().unwrap().get(&id) == Some(&generation);
|
|
if is_active && !PROCESSING_SUSPENDED.load(Ordering::Relaxed) {
|
|
send_shortcut_pressed(&activation_sender, id, "XDG portal");
|
|
}
|
|
}
|
|
});
|
|
|
|
tauri::async_runtime::spawn(async move {
|
|
while let Some(signal) = changed.next().await {
|
|
for shortcut in signal.shortcuts() {
|
|
let Some(id) = Shortcut::from_portal_id(shortcut.id()) else {
|
|
continue;
|
|
};
|
|
|
|
let is_active = ACTIVE_PORTAL_GENERATIONS.lock().unwrap().get(&id) == Some(&generation);
|
|
if is_active {
|
|
let _ = event_sender.send(Event::new(
|
|
TauriEventType::GlobalShortcutChanged,
|
|
vec![id.to_string(), shortcut.trigger_description().to_string()],
|
|
));
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok(ActiveBinding::Portal {
|
|
shortcut: request.shortcut.clone(),
|
|
effective_display_name,
|
|
generation,
|
|
session,
|
|
})
|
|
}
|
|
|
|
/// Converts a Tauri-format shortcut into the XDG shortcuts specification format.
|
|
fn tauri_shortcut_to_xdg(shortcut: &str) -> Result<String, String> {
|
|
let mut converted = Vec::new();
|
|
let parts: Vec<&str> = shortcut.split('+').collect();
|
|
if parts.len() < 2 {
|
|
return Err(format!("Invalid global shortcut '{shortcut}'."));
|
|
}
|
|
|
|
for (index, part) in parts.iter().enumerate() {
|
|
let normalized = part.to_ascii_lowercase();
|
|
let is_last = index == parts.len() - 1;
|
|
let value = if !is_last {
|
|
match normalized.as_str() {
|
|
"cmdorcontrol" | "commandorcontrol" | "ctrl" | "control" => "CTRL",
|
|
"shift" => "SHIFT",
|
|
"alt" | "option" => "ALT",
|
|
"cmd" | "command" | "meta" | "super" => "LOGO",
|
|
|
|
_ => return Err(format!("Unsupported shortcut modifier '{part}'.")),
|
|
}.to_string()
|
|
|
|
} else {
|
|
|
|
match normalized.as_str() {
|
|
"enter" => "Return".to_string(),
|
|
"backspace" => "BackSpace".to_string(),
|
|
"pageup" => "Prior".to_string(),
|
|
"pagedown" => "Next".to_string(),
|
|
"arrowup" => "Up".to_string(),
|
|
"arrowdown" => "Down".to_string(),
|
|
"arrowleft" => "Left".to_string(),
|
|
"arrowright" => "Right".to_string(),
|
|
"escape" => "Escape".to_string(),
|
|
"delete" => "Delete".to_string(),
|
|
"insert" => "Insert".to_string(),
|
|
"home" => "Home".to_string(),
|
|
"end" => "End".to_string(),
|
|
"space" => "space".to_string(),
|
|
"tab" => "Tab".to_string(),
|
|
"up" => "Up".to_string(),
|
|
"down" => "Down".to_string(),
|
|
"left" => "Left".to_string(),
|
|
"right" => "Right".to_string(),
|
|
"minus" => "minus".to_string(),
|
|
"equal" => "equal".to_string(),
|
|
"bracketleft" => "bracketleft".to_string(),
|
|
"bracketright" => "bracketright".to_string(),
|
|
"backslash" => "backslash".to_string(),
|
|
"semicolon" => "semicolon".to_string(),
|
|
"quote" => "apostrophe".to_string(),
|
|
"backquote" => "grave".to_string(),
|
|
"comma" => "comma".to_string(),
|
|
"period" => "period".to_string(),
|
|
"slash" => "slash".to_string(),
|
|
|
|
_ if normalized.starts_with("num") => numpad_key_to_xdg(&normalized).ok_or_else(|| format!("Unsupported shortcut key '{part}'."))?,
|
|
_ if part.len() == 1 && part.as_bytes()[0].is_ascii_alphabetic() => normalized,
|
|
_ if part.chars().all(|character| character.is_ascii_alphanumeric() || character == '_') => part.to_string(),
|
|
|
|
_ => return Err(format!("Unsupported shortcut key '{part}'.")),
|
|
}
|
|
};
|
|
|
|
converted.push(value);
|
|
}
|
|
|
|
Ok(converted.join("+"))
|
|
}
|
|
|
|
/// Converts Tauri numpad key names into XKB keypad key symbols.
|
|
fn numpad_key_to_xdg(key: &str) -> Option<String> {
|
|
let suffix = match key {
|
|
"num0" => "0",
|
|
"num1" => "1",
|
|
"num2" => "2",
|
|
"num3" => "3",
|
|
"num4" => "4",
|
|
"num5" => "5",
|
|
"num6" => "6",
|
|
"num7" => "7",
|
|
"num8" => "8",
|
|
"num9" => "9",
|
|
|
|
"numadd" => "Add",
|
|
"numsubtract" => "Subtract",
|
|
"nummultiply" => "Multiply",
|
|
"numdivide" => "Divide",
|
|
"numdecimal" => "Decimal",
|
|
"numenter" => "Enter",
|
|
|
|
_ => return None,
|
|
};
|
|
|
|
Some(format!("KP_{suffix}"))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[derive(Default)]
|
|
/// Simulates portal listing and binding outcomes for lifecycle tests.
|
|
struct FakePortalAdapter {
|
|
/// Shortcuts returned by the simulated list operation.
|
|
listed: Vec<PortalShortcutInfo>,
|
|
/// Shortcuts returned by the simulated bind operation.
|
|
bound: Vec<PortalShortcutInfo>,
|
|
/// Optional failure returned instead of a successful bind result.
|
|
bind_failure: Option<PortalFailure>,
|
|
/// Counts bind calls so tests can detect unnecessary portal dialogs.
|
|
bind_calls: usize,
|
|
/// Records the preferred trigger supplied to the simulated portal.
|
|
last_preferred_trigger: String,
|
|
}
|
|
|
|
impl PortalAdapter for FakePortalAdapter {
|
|
/// Returns the shortcuts configured as restored by the fake portal.
|
|
async fn list_shortcuts(&mut self) -> Result<Vec<PortalShortcutInfo>, PortalFailure> {
|
|
Ok(self.listed.clone())
|
|
}
|
|
|
|
/// Records the bind request and returns the configured result or failure.
|
|
async fn bind_shortcut(
|
|
&mut self,
|
|
_id: &str,
|
|
_description: &str,
|
|
preferred_trigger: &str,
|
|
) -> Result<Vec<PortalShortcutInfo>, PortalFailure> {
|
|
self.bind_calls += 1;
|
|
self.last_preferred_trigger = preferred_trigger.to_string();
|
|
if let Some(error) = &self.bind_failure {
|
|
return Err(error.clone());
|
|
}
|
|
Ok(self.bound.clone())
|
|
}
|
|
}
|
|
|
|
/// Creates a voice-recording shortcut request for portal lifecycle tests.
|
|
fn portal_request(shortcut: &str, reconfigure: bool) -> RegisterShortcutRequest {
|
|
RegisterShortcutRequest {
|
|
id: Shortcut::VoiceRecordingToggle,
|
|
shortcut: shortcut.to_string(),
|
|
description: "Toggle voice recording".to_string(),
|
|
reconfigure,
|
|
}
|
|
}
|
|
|
|
/// Creates normalized portal shortcut data for test responses.
|
|
fn portal_shortcut(display_name: &str) -> PortalShortcutInfo {
|
|
PortalShortcutInfo {
|
|
id: Shortcut::VoiceRecordingToggle.to_string(),
|
|
effective_display_name: display_name.to_string(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Verifies conversion from representative Tauri combinations to XDG triggers.
|
|
fn converts_tauri_shortcut_to_xdg_trigger() {
|
|
assert_eq!(tauri_shortcut_to_xdg("CmdOrControl+Shift+1").unwrap(), "CTRL+SHIFT+1");
|
|
assert_eq!(tauri_shortcut_to_xdg("Control+Alt+Enter").unwrap(), "CTRL+ALT+Return");
|
|
assert_eq!(tauri_shortcut_to_xdg("Super+Space").unwrap(), "LOGO+space");
|
|
assert_eq!(tauri_shortcut_to_xdg("Ctrl+A").unwrap(), "CTRL+a");
|
|
assert_eq!(tauri_shortcut_to_xdg("Ctrl+Num1").unwrap(), "CTRL+KP_1");
|
|
assert_eq!(tauri_shortcut_to_xdg("Ctrl+Quote").unwrap(), "CTRL+apostrophe");
|
|
}
|
|
|
|
#[test]
|
|
/// Verifies that unsupported modifiers and keys are rejected during conversion.
|
|
fn rejects_unsupported_xdg_trigger_parts() {
|
|
assert!(tauri_shortcut_to_xdg("Hyper+1").is_err());
|
|
assert!(tauri_shortcut_to_xdg("Ctrl++").is_err());
|
|
}
|
|
|
|
#[test]
|
|
/// Verifies that unchanged settings do not cause duplicate native registrations.
|
|
fn identical_configuration_is_not_registered_twice() {
|
|
assert!(registration_is_unchanged(Some("CmdOrControl+Shift+1"), "cmdorcontrol+shift+1", false));
|
|
assert!(!registration_is_unchanged(Some("CmdOrControl+Shift+1"), "CmdOrControl+Shift+2", false));
|
|
assert!(!registration_is_unchanged(Some("CmdOrControl+Shift+1"), "CmdOrControl+Shift+1", true));
|
|
}
|
|
|
|
#[tokio::test]
|
|
/// Verifies that an approved shortcut is restored without another bind request.
|
|
async fn portal_adapter_restores_without_binding() {
|
|
let mut adapter = FakePortalAdapter {
|
|
listed: vec![portal_shortcut("Ctrl+Shift+1")],
|
|
..Default::default()
|
|
};
|
|
|
|
let display_name = resolve_portal_shortcut(&mut adapter, &portal_request("CmdOrControl+Shift+1", false)).await.unwrap();
|
|
|
|
assert_eq!(display_name, "Ctrl+Shift+1");
|
|
assert_eq!(adapter.bind_calls, 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
/// Verifies that a missing shortcut is bound with its converted preferred trigger.
|
|
async fn portal_adapter_binds_missing_shortcut_with_preferred_trigger() {
|
|
let mut adapter = FakePortalAdapter {
|
|
bound: vec![portal_shortcut("Ctrl+Shift+1")],
|
|
..Default::default()
|
|
};
|
|
|
|
let display_name = resolve_portal_shortcut(&mut adapter, &portal_request("CmdOrControl+Shift+1", false)).await.unwrap();
|
|
|
|
assert_eq!(display_name, "Ctrl+Shift+1");
|
|
assert_eq!(adapter.bind_calls, 1);
|
|
assert_eq!(adapter.last_preferred_trigger, "CTRL+SHIFT+1");
|
|
}
|
|
|
|
#[tokio::test]
|
|
/// Verifies that deliberate changes bind again instead of restoring the old trigger.
|
|
async fn portal_adapter_rebinds_after_deliberate_change() {
|
|
let mut adapter = FakePortalAdapter {
|
|
listed: vec![portal_shortcut("Ctrl+Shift+1")],
|
|
bound: vec![portal_shortcut("Ctrl+Shift+2")],
|
|
..Default::default()
|
|
};
|
|
|
|
let display_name = resolve_portal_shortcut(&mut adapter, &portal_request("CmdOrControl+Shift+2", true)).await.unwrap();
|
|
|
|
assert_eq!(display_name, "Ctrl+Shift+2");
|
|
assert_eq!(adapter.bind_calls, 1);
|
|
assert_eq!(adapter.last_preferred_trigger, "CTRL+SHIFT+2");
|
|
}
|
|
|
|
#[tokio::test]
|
|
/// Verifies that portal cancellation remains distinguishable from technical errors.
|
|
async fn portal_adapter_preserves_cancellation() {
|
|
let mut adapter = FakePortalAdapter {
|
|
bind_failure: Some(PortalFailure {
|
|
kind: PortalFailureKind::Cancelled,
|
|
message: "cancelled".to_string(),
|
|
}),
|
|
..Default::default()
|
|
};
|
|
|
|
let error = resolve_portal_shortcut(&mut adapter, &portal_request("CmdOrControl+Shift+1", false)).await.unwrap_err();
|
|
|
|
assert_eq!(error.kind, PortalFailureKind::Cancelled);
|
|
assert_eq!(adapter.bind_calls, 1);
|
|
}
|
|
|
|
#[test]
|
|
/// Verifies that fallback is restricted to unavailable portals and safe active states.
|
|
fn fallback_is_limited_to_an_unavailable_portal() {
|
|
assert!(may_fallback_to_tauri(PortalFailureKind::Unavailable, None));
|
|
assert!(may_fallback_to_tauri(PortalFailureKind::Unavailable, Some(ShortcutBackend::Tauri)));
|
|
assert!(!may_fallback_to_tauri(PortalFailureKind::Unavailable, Some(ShortcutBackend::Portal)));
|
|
assert!(!may_fallback_to_tauri(PortalFailureKind::Cancelled, None));
|
|
assert!(!may_fallback_to_tauri(PortalFailureKind::Denied, None));
|
|
assert!(!may_fallback_to_tauri(PortalFailureKind::Technical, None));
|
|
}
|
|
|
|
#[test]
|
|
/// Verifies that suspend keeps portal sessions while unregistering Tauri bindings.
|
|
fn suspend_keeps_portal_session_registered() {
|
|
assert!(!unregister_backend_during_suspend(ShortcutBackend::Portal));
|
|
assert!(unregister_backend_during_suspend(ShortcutBackend::Tauri));
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
/// Verifies recognition of unavailable-portal D-Bus errors without misclassifying rejection.
|
|
fn only_unavailable_portal_errors_allow_fallback() {
|
|
assert!(portal_error_is_unavailable("org.freedesktop.DBus.Error.UnknownMethod"));
|
|
assert!(portal_error_is_unavailable("ServiceUnknown"));
|
|
assert!(!portal_error_is_unavailable("Portal request was cancelled"));
|
|
assert!(!portal_error_is_unavailable("NotAllowed"));
|
|
}
|
|
} |