443 lines
15 KiB
Rust
443 lines
15 KiB
Rust
use ely_browser_core::SyncEngine;
|
|
use ely_domain::{
|
|
ArchivePolicy, DEFAULT_TRANSLUCENCY_PCT, DownloadPolicy, FavoriteLimit, HistoryRecordingPolicy,
|
|
NewTabDestination, ProfileId, ProfileSyncPolicy, SearchEngine, SyncObjectKind,
|
|
SyncObjectPolicy, ThemeMode, WallpaperTheme,
|
|
};
|
|
use gpui::Context;
|
|
use gpui_component::slider::SliderValue;
|
|
|
|
use crate::services::servo_profile_data::{default_profile_data_root, sync_profile_data_dir};
|
|
|
|
use super::sync_inbox::SyncStateSender;
|
|
use super::sync_state::{
|
|
PendingMergeUpload, SyncStateUpdate, sync_failure_update, sync_platform_label,
|
|
};
|
|
use super::{ElyShell, ShellState};
|
|
|
|
impl ElyShell {
|
|
pub(super) fn set_active_space_archive_policy(
|
|
&mut self,
|
|
archive_policy: ArchivePolicy,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.set_active_space_archive_policy(archive_policy).is_ok()
|
|
{
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_search_engine(
|
|
&mut self,
|
|
search_engine: SearchEngine,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_search_engine(search_engine);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_search_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_search_settings();
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_new_tab_destination(
|
|
&mut self,
|
|
destination: NewTabDestination,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_new_tab_destination(destination);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_wallpaper_theme(
|
|
&mut self,
|
|
wallpaper: WallpaperTheme,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_wallpaper_theme(wallpaper);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_theme_mode(&mut self, theme_mode: ThemeMode, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_theme_mode(theme_mode);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
/// Cycle the theme mode for the topbar's quick-toggle button:
|
|
/// System → Light → Dark → System. Mirrors the segmented control
|
|
/// in the appearance settings page so the topbar toggle reaches
|
|
/// every state without spawning a settings page.
|
|
pub(super) fn cycle_theme_mode(&mut self, cx: &mut Context<Self>) {
|
|
let ShellState::Ready(core) = &mut self.state else {
|
|
return;
|
|
};
|
|
let next = match core.appearance().theme_mode() {
|
|
ThemeMode::System => ThemeMode::Light,
|
|
ThemeMode::Light => ThemeMode::Dark,
|
|
ThemeMode::Dark => ThemeMode::System,
|
|
};
|
|
core.set_theme_mode(next);
|
|
cx.notify();
|
|
}
|
|
|
|
pub(super) fn toggle_reduce_motion(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
let next = !core.appearance().reduce_motion();
|
|
core.set_reduce_motion(next);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_translucency_pct(&mut self, value: u8, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_translucency_pct(value);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_translucency_pct_from_preset(
|
|
&mut self,
|
|
value: u8,
|
|
window: &mut gpui::Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.set_translucency_pct(value, cx);
|
|
let slider = self.translucency_slider.clone();
|
|
slider.update(cx, |state, cx| {
|
|
state.set_value(SliderValue::Single(f32::from(value)), window, cx);
|
|
});
|
|
}
|
|
|
|
pub(super) fn reset_appearance(&mut self, window: &mut gpui::Window, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_appearance();
|
|
cx.notify();
|
|
}
|
|
let slider = self.translucency_slider.clone();
|
|
slider.update(cx, |state, cx| {
|
|
state.set_value(SliderValue::Single(f32::from(DEFAULT_TRANSLUCENCY_PCT)), window, cx);
|
|
});
|
|
}
|
|
|
|
pub(super) fn reset_general_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_general_settings();
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_history_recording_policy(
|
|
&mut self,
|
|
policy: HistoryRecordingPolicy,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_history_recording_policy(policy);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_privacy_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_privacy_settings();
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_active_profile_download_policy(
|
|
&mut self,
|
|
policy: DownloadPolicy,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.set_active_profile_download_policy(policy).is_ok()
|
|
{
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_active_profile_download_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.reset_active_profile_download_settings().is_ok()
|
|
{
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_profile_sync_policy(
|
|
&mut self,
|
|
profile_id: &ProfileId,
|
|
sync_policy: ProfileSyncPolicy,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.set_profile_sync_policy(profile_id, sync_policy).is_ok()
|
|
{
|
|
self.schedule_cloud_sync_upload(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_profile_sync_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_profile_sync_settings();
|
|
self.schedule_cloud_sync_upload(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_favorite_limit(
|
|
&mut self,
|
|
favorite_limit: FavoriteLimit,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_favorite_limit(favorite_limit);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_sidebar_tabs_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.reset_sidebar_tabs_settings().is_ok()
|
|
{
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn set_sync_object_policy(
|
|
&mut self,
|
|
kind: SyncObjectKind,
|
|
policy: SyncObjectPolicy,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.set_sync_object_policy(kind, policy);
|
|
self.schedule_cloud_sync_upload(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_sync_settings(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state {
|
|
core.reset_sync_settings();
|
|
self.schedule_cloud_sync_upload(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn trigger_cloud_sync_upload(&mut self) {
|
|
self.trigger_cloud_sync_upload_with_merge(None);
|
|
}
|
|
|
|
pub(super) fn trigger_cloud_sync_upload_after_remote(&mut self, merge: PendingMergeUpload) {
|
|
self.trigger_cloud_sync_upload_with_merge(Some(merge));
|
|
}
|
|
|
|
fn trigger_cloud_sync_upload_with_merge(&mut self, mut merge: Option<PendingMergeUpload>) {
|
|
let cloud_sync_enabled = match &self.state {
|
|
ShellState::Ready(core) => core.cloud_sync_upload_enabled(),
|
|
ShellState::StartupError(_) => false,
|
|
};
|
|
if !cloud_sync_enabled {
|
|
self.sync_upload_scheduled = false;
|
|
self.clear_pending_cloud_sync_upload();
|
|
return;
|
|
}
|
|
if self.sync_upload_in_flight {
|
|
self.sync_upload_scheduled = false;
|
|
self.queue_cloud_sync_upload(merge);
|
|
return;
|
|
}
|
|
self.sync_upload_scheduled = false;
|
|
|
|
let ShellState::Ready(core) = &self.state else {
|
|
return;
|
|
};
|
|
let Some(snapshot) = core.snapshot().ok() else {
|
|
return;
|
|
};
|
|
let active_profile_id = snapshot.active_profile_id.clone();
|
|
if merge.as_ref().is_some_and(|merge| merge.profile_id != active_profile_id) {
|
|
merge = None;
|
|
}
|
|
let device_name = format!("ELY · {}", snapshot.active_profile_name);
|
|
let Some(profile_root) = default_profile_data_root() else {
|
|
tracing::warn!(target: "ely::sync", "profile data root is unavailable");
|
|
return;
|
|
};
|
|
let profile_dir = sync_profile_data_dir(&profile_root, &active_profile_id);
|
|
let bytes = match core.build_sync_snapshot_bytes() {
|
|
Ok(bytes) => bytes,
|
|
Err(error) => {
|
|
tracing::warn!(
|
|
target: "ely::sync",
|
|
error = %error,
|
|
"snapshot serialisation failed; aborting upload",
|
|
);
|
|
return;
|
|
}
|
|
};
|
|
let tx = self.sync_state_sender();
|
|
let worker_profile_id = active_profile_id.clone();
|
|
let thread_name = if merge.is_some() { "ely-sync-merge-upload" } else { "ely-sync-upload" };
|
|
let Some(operation_lease) = self.begin_authenticated_operation() else {
|
|
return;
|
|
};
|
|
self.sync_upload_in_flight = true;
|
|
if let Err(error) =
|
|
std::thread::Builder::new().name(thread_name.to_string()).spawn(move || {
|
|
let _operation_lease = operation_lease;
|
|
run_sync_upload(worker_profile_id, profile_dir, device_name, bytes, merge, tx)
|
|
})
|
|
{
|
|
self.sync_upload_in_flight = false;
|
|
tracing::warn!(
|
|
target: "ely::sync",
|
|
error = %error,
|
|
"failed to spawn ely-sync-upload thread",
|
|
);
|
|
}
|
|
}
|
|
|
|
pub(super) fn archive_idle_tabs_now(&mut self, cx: &mut Context<Self>) {
|
|
if let ShellState::Ready(core) = &mut self.state
|
|
&& core.archive_idle_tabs(std::time::SystemTime::now()).is_ok()
|
|
{
|
|
cx.notify();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn run_sync_upload(
|
|
profile_id: ProfileId,
|
|
profile_dir: std::path::PathBuf,
|
|
device_name: String,
|
|
bytes: Vec<u8>,
|
|
merge: Option<PendingMergeUpload>,
|
|
inbox: SyncStateSender,
|
|
) {
|
|
let mut engine = match SyncEngine::for_profile_dir(
|
|
&profile_id,
|
|
&profile_dir,
|
|
device_name,
|
|
sync_platform_label(),
|
|
) {
|
|
Ok(engine) => engine,
|
|
Err(error) => {
|
|
let message = error.to_string();
|
|
tracing::warn!(target: "ely::sync", error = %message, "could not initialise sync engine");
|
|
let _ = inbox.send(sync_failure_update(profile_id, error));
|
|
return;
|
|
}
|
|
};
|
|
let prior_conflict_count = merge.as_ref().map_or(0, |merge| merge.conflict_count);
|
|
let outcome = match merge {
|
|
Some(merge) => engine.upload_merged_bytes(bytes, merge.base),
|
|
None => engine.sync_bytes(bytes),
|
|
};
|
|
match outcome {
|
|
Ok(ely_browser_core::SyncOutcome::SignedOut) => {
|
|
tracing::info!(target: "ely::sync", "no bearer token on disk; sync skipped");
|
|
let _ = inbox.send(SyncStateUpdate::AuthenticationExpired { profile_id });
|
|
}
|
|
Ok(ely_browser_core::SyncOutcome::AwaitingDeviceApproval { device_id }) => {
|
|
tracing::info!(
|
|
target: "ely::sync",
|
|
device_id = %device_id,
|
|
"sync device is awaiting approval",
|
|
);
|
|
let _ = inbox.send(SyncStateUpdate::AwaitingDeviceApproval {
|
|
profile_id,
|
|
finishes_upload: true,
|
|
});
|
|
}
|
|
Ok(ely_browser_core::SyncOutcome::RemoteSnapshot {
|
|
snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id,
|
|
bytes,
|
|
merge_base,
|
|
cas_conflict,
|
|
}) => {
|
|
tracing::info!(
|
|
target: "ely::sync",
|
|
snapshot_id = %snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id = %device_id,
|
|
"remote snapshot downloaded",
|
|
);
|
|
let conflict_count =
|
|
if cas_conflict { prior_conflict_count.saturating_add(1) } else { 0 };
|
|
let _ = inbox.send(SyncStateUpdate::RemoteSnapshot {
|
|
profile_id: profile_id.clone(),
|
|
bytes,
|
|
merge: PendingMergeUpload { profile_id, base: merge_base, conflict_count },
|
|
});
|
|
}
|
|
Ok(ely_browser_core::SyncOutcome::AlreadyCurrent {
|
|
snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id,
|
|
}) => {
|
|
tracing::info!(
|
|
target: "ely::sync",
|
|
snapshot_id = %snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id = %device_id,
|
|
"snapshot already current",
|
|
);
|
|
let last_synced_at_secs = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_secs())
|
|
.unwrap_or(0);
|
|
let _ = inbox.send(SyncStateUpdate::SyncReady { profile_id, last_synced_at_secs });
|
|
}
|
|
Ok(ely_browser_core::SyncOutcome::Uploaded {
|
|
snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id,
|
|
}) => {
|
|
tracing::info!(
|
|
target: "ely::sync",
|
|
snapshot_id = %snapshot_id,
|
|
logical_clock,
|
|
payload_bytes,
|
|
device_id = %device_id,
|
|
"snapshot upload complete",
|
|
);
|
|
let last_synced_at_secs = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_secs())
|
|
.unwrap_or(0);
|
|
let _ = inbox.send(SyncStateUpdate::SyncReady { profile_id, last_synced_at_secs });
|
|
}
|
|
Err(ely_sync_client::SyncClientError::SnapshotBusy) => {
|
|
tracing::info!(target: "ely::sync", "snapshot head is busy; retry scheduled");
|
|
let _ = inbox.send(SyncStateUpdate::SyncBusy { profile_id });
|
|
}
|
|
Err(error) => {
|
|
let message = error.to_string();
|
|
tracing::warn!(target: "ely::sync", error = %message, "snapshot upload failed");
|
|
let _ = inbox.send(sync_failure_update(profile_id, error));
|
|
}
|
|
}
|
|
}
|