mirror of
https://github.com/narrrl/proton-stream.git
synced 2026-11-03 16:41:26 +01:00
feat(core,stream,meta,app,android,cli): sign in to Proton and sync watch history
A Proton account is now optional alongside public links. Signing in (password, then a second-factor code and a mailbox password where the account has them; a CAPTCHA gate is solved in the Android app) stores one session blob in the OS credential store under `proton-account`, writing back every refreshed token since refresh tokens are single-use. With an account, folders of the viewer's own Drive — My Files, other devices, shared with me — can be added as shares through the same `ShareClient` surface as a public link. Watch history syncs through a `proton-stream` device in that Drive: one `watch-history/<installation>.json` per installation, so no two devices ever write the same file. Each sync reads the others and merges per episode, newer `updated_at` wins, with a deterministic tie-break. It runs at launch, after sign-in, whenever the player closes and every five minutes. A session that can no longer refresh signs the app out instead of failing on every launch. The CLI gains `login`, `logout`, `account`, `browse` and `sync`. Also in this change: - Android offline downloads no longer look stuck (B64): two transfer at once, through a copy stream with no read-ahead, with a smoothed transfer rate. - Choosing a metadata match by hand now enriches the title too, instead of keeping the old match's episodes and artwork. The catalog schema is unchanged.
This commit is contained in:
nvrl committed
1 parent
6cdab2fde1
commit
0b2813cd42
37 files changed
+4111
-159
No files matched your search
@@ -15,7 +15,8 @@ use pstr_core::library::Library;
|
||||
use pstr_core::metadata::{EpisodeGuide, MetadataConfig, MetadataRecord, TitleNames};
|
||||
|
||||
use crate::engine::{
|
||||
DownloadItem, DownloadKey, Engine, Event, ImageCache, describe_failures, watch_state,
|
||||
AccountStatus, DownloadItem, DownloadKey, Engine, Event, ImageCache, describe_failures,
|
||||
watch_state,
|
||||
};
|
||||
use crate::pacing::Pacer;
|
||||
use crate::playback::{Playback, PlaybackTarget};
|
||||
@@ -126,6 +127,25 @@ pub enum Action {
|
||||
url: String,
|
||||
password: Option<String>,
|
||||
},
|
||||
/// Add a folder of the signed-in account as a share.
|
||||
AddAccountFolder {
|
||||
name: String,
|
||||
uid: pstr_core::proton_sdk::ids::NodeUid,
|
||||
},
|
||||
SignIn {
|
||||
username: String,
|
||||
password: String,
|
||||
},
|
||||
SubmitSecondFactor(String),
|
||||
SubmitMailboxPassword(String),
|
||||
CancelSignIn,
|
||||
SignOut,
|
||||
/// Sync watch history with the account's Drive now.
|
||||
SyncNow,
|
||||
/// List the account's top-level places in the Drive browser.
|
||||
BrowsePlaces,
|
||||
/// List one folder in the Drive browser.
|
||||
BrowseFolder(pstr_core::proton_sdk::ids::NodeUid),
|
||||
/// Ask whether to forget a share. [`Action::ForgetShare`] does it.
|
||||
RemoveShare(String),
|
||||
ForgetShare(String),
|
||||
@@ -535,6 +555,8 @@ pub struct App {
|
||||
/// library means "not loaded", not "nothing in it".
|
||||
pub loaded: bool,
|
||||
pub form: ShareForm,
|
||||
/// The Proton account section of the shares page.
|
||||
pub account: ui::account::AccountPanel,
|
||||
pub playback: Option<Playback>,
|
||||
/// Whether the player page's controls are showing, and why.
|
||||
pub overlay: ui::player::Overlay,
|
||||
@@ -630,6 +652,7 @@ impl App {
|
||||
view: LibraryView::default(),
|
||||
loaded: false,
|
||||
form: ShareForm::default(),
|
||||
account: ui::account::AccountPanel::default(),
|
||||
playback: None,
|
||||
overlay: ui::player::Overlay::default(),
|
||||
up_next: UpNext::default(),
|
||||
@@ -882,6 +905,9 @@ impl App {
|
||||
None => Page::Library,
|
||||
};
|
||||
}
|
||||
// Where it stopped is the position another device
|
||||
// wants next, so it goes now rather than on the timer.
|
||||
self.engine.sync_watch_history();
|
||||
}
|
||||
}
|
||||
Event::Watched {
|
||||
@@ -905,6 +931,23 @@ impl App {
|
||||
}
|
||||
}
|
||||
Event::OfflineFiles(files) => self.offline_files = files,
|
||||
Event::Account(status) => {
|
||||
if let AccountStatus::SignedIn(username) = &status
|
||||
&& self.account.busy
|
||||
{
|
||||
self.note(ctx, format!("signed in as {username}"), false);
|
||||
}
|
||||
self.account.set_status(status);
|
||||
}
|
||||
Event::SignInFailed(error) => self.account.refused(error),
|
||||
Event::Synced(report) => {
|
||||
self.account.sync_error = None;
|
||||
self.account.synced = Some((ui::account::unix_now(), report));
|
||||
}
|
||||
Event::SyncFailed(error) => self.account.sync_error = Some(error),
|
||||
Event::Places(places) => self.account.browser.places_arrived(places),
|
||||
Event::Folder { uid, entries } => self.account.browser.folder_arrived(uid, entries),
|
||||
Event::BrowseFailed(error) => self.account.browser.failed(error),
|
||||
}
|
||||
}
|
||||
// Pictures become textures a few per frame; the rest wait for the next.
|
||||
@@ -1369,6 +1412,20 @@ impl App {
|
||||
self.form.error = None;
|
||||
self.engine.add_share(name, url, password);
|
||||
}
|
||||
Action::AddAccountFolder { name, uid } => {
|
||||
self.crawling = true;
|
||||
self.engine.add_account_folder(name, uid);
|
||||
}
|
||||
Action::SignIn { username, password } => self.engine.sign_in(username, password),
|
||||
Action::SubmitSecondFactor(code) => self.engine.submit_second_factor(code),
|
||||
Action::SubmitMailboxPassword(password) => {
|
||||
self.engine.submit_mailbox_password(password)
|
||||
}
|
||||
Action::CancelSignIn => self.engine.cancel_sign_in(),
|
||||
Action::SignOut => self.engine.sign_out(),
|
||||
Action::SyncNow => self.engine.sync_watch_history(),
|
||||
Action::BrowsePlaces => self.engine.browse_places(),
|
||||
Action::BrowseFolder(uid) => self.engine.browse_folder(uid),
|
||||
Action::RemoveShare(id) => self.confirm_remove_share = Some(id),
|
||||
Action::ForgetShare(id) => {
|
||||
self.confirm_remove_share = None;
|
||||
@@ -1868,6 +1925,7 @@ impl eframe::App for App {
|
||||
view,
|
||||
loaded,
|
||||
form,
|
||||
account,
|
||||
matcher,
|
||||
playback,
|
||||
opening,
|
||||
@@ -1964,7 +2022,9 @@ impl eframe::App for App {
|
||||
},
|
||||
&mut actions,
|
||||
),
|
||||
Page::Shares => ui::shares::show(ui, shares, library, form, &mut actions),
|
||||
Page::Shares => {
|
||||
ui::shares::show(ui, shares, library, form, account, &mut actions)
|
||||
}
|
||||
Page::Settings => {
|
||||
ui::settings::show(ui, settings, prefs, api_key, &mut actions)
|
||||
}
|
||||
|
||||
+314
-54
@@ -25,6 +25,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{Receiver, Sender, channel};
|
||||
|
||||
use parking_lot::Mutex;
|
||||
use pstr_core::account::{DriveEntry, DrivePlace, PendingSignIn, SignIn};
|
||||
use pstr_core::appearance::Appearance;
|
||||
use pstr_core::catalog::{
|
||||
Catalog, CatalogNode, OfflineFile, TitleTrackPrefs, WatchState, build_rows,
|
||||
@@ -35,13 +36,15 @@ use pstr_core::metadata::{EpisodeGuide, MetadataConfig, MetadataRecord, Provider
|
||||
use pstr_core::prefs::PlaybackPrefs;
|
||||
use pstr_core::proton_drive_rs::ThumbnailType;
|
||||
use pstr_core::proton_sdk::ids::{LinkId, NodeUid, VolumeId};
|
||||
use pstr_core::{Share, ShareStore, SharedLibrary};
|
||||
use pstr_core::shares::AccountFolder;
|
||||
use pstr_core::sync::{SyncReport, WatchSync};
|
||||
use pstr_core::{Account, AccountStore, KeyringSecretStore, Share, ShareStore, SharedLibrary};
|
||||
use pstr_meta::MetadataService;
|
||||
|
||||
use crate::desktop_prefs::{DesktopPrefs, DesktopPrefsFile};
|
||||
use pstr_stream::{
|
||||
BlockSource, DiskCacheConfig, FileBlocks, LibraryOpener, StreamConfig, StreamSource,
|
||||
VideoStream,
|
||||
BlockSource, COPY_BLOCKS_IN_FLIGHT, DiskCacheConfig, FileBlocks, LibraryOpener, StreamConfig,
|
||||
StreamSource, VideoStream,
|
||||
};
|
||||
use tokio::runtime::Runtime;
|
||||
|
||||
@@ -269,6 +272,38 @@ pub enum Event {
|
||||
DownloadProgress(Box<DownloadItem>),
|
||||
/// Completed local copies, for badges and online-only actions.
|
||||
OfflineFiles(HashSet<DownloadKey>),
|
||||
/// The Proton account signed in or out, or a sign-in wants more.
|
||||
Account(AccountStatus),
|
||||
/// A sign-in step was refused, with why.
|
||||
SignInFailed(String),
|
||||
/// Watch history synced with the account's Drive.
|
||||
Synced(SyncReport),
|
||||
/// Watch history did not sync, with why. Not a toast: it is retried on a
|
||||
/// timer, and an offline evening would be a stack of them.
|
||||
SyncFailed(String),
|
||||
/// The account's top-level places, for the Drive browser.
|
||||
Places(Vec<DrivePlace>),
|
||||
/// One folder of the account, for the Drive browser.
|
||||
Folder {
|
||||
uid: NodeUid,
|
||||
entries: Vec<DriveEntry>,
|
||||
},
|
||||
/// The Drive browser's last request failed.
|
||||
BrowseFailed(String),
|
||||
}
|
||||
|
||||
/// Where the Proton account stands.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
||||
pub enum AccountStatus {
|
||||
/// The stored session has not been read yet.
|
||||
#[default]
|
||||
Unknown,
|
||||
SignedOut,
|
||||
SignedIn(String),
|
||||
/// A sign-in is waiting for a second-factor code.
|
||||
SecondFactor,
|
||||
/// A sign-in is waiting for the mailbox password.
|
||||
MailboxPassword,
|
||||
}
|
||||
|
||||
/// The share clients and the block layer, once they exist.
|
||||
@@ -335,6 +370,17 @@ pub struct Engine {
|
||||
desktop_file: Arc<DesktopPrefsFile>,
|
||||
/// Bumped to stop the crawls in flight; each watches it from its start.
|
||||
crawl_cancel: Arc<tokio::sync::watch::Sender<u64>>,
|
||||
accounts: AccountStore,
|
||||
/// The signed-in Proton account, if any.
|
||||
account: Arc<Mutex<Option<Account>>>,
|
||||
/// False until the stored session has been read. Opening the shares waits
|
||||
/// on it, or a launch would open the account's folders before the account
|
||||
/// and report every one of them as failing to.
|
||||
account_settled: Arc<tokio::sync::watch::Sender<bool>>,
|
||||
/// A sign-in waiting for a code or the mailbox password.
|
||||
pending_sign_in: Arc<Mutex<Option<PendingSignIn>>>,
|
||||
/// `None` when this installation's sync identity could not be written.
|
||||
watch_sync: Option<Arc<WatchSync>>,
|
||||
events: Sender<Event>,
|
||||
ctx: egui::Context,
|
||||
}
|
||||
@@ -345,10 +391,10 @@ const THUMBNAIL_CONCURRENCY: usize = 6;
|
||||
/// How many provider lookups may be in flight at once. See [`Engine::lookups`].
|
||||
const LOOKUP_CONCURRENCY: usize = 2;
|
||||
const DOWNLOAD_CONCURRENCY: usize = 3;
|
||||
/// How many blocks of one download are fetched at once. Four is what the
|
||||
/// stream layer itself allows a single read, for the same reason: enough to
|
||||
/// hide a round trip, few enough that three downloads do not swamp a player.
|
||||
const DOWNLOAD_BLOCKS_IN_FLIGHT: usize = 4;
|
||||
|
||||
/// How often watch history is synced while the app is open, on top of at
|
||||
/// launch and whenever a player stops.
|
||||
const SYNC_INTERVAL: std::time::Duration = std::time::Duration::from_secs(5 * 60);
|
||||
|
||||
/// Enrichment as currently configured.
|
||||
struct Enrichment {
|
||||
@@ -427,6 +473,11 @@ impl Engine {
|
||||
Enrichment::build(config.clone())
|
||||
};
|
||||
|
||||
let watch_sync = WatchSync::open(&dirs)
|
||||
.inspect_err(|error| tracing::warn!("watch-history sync unavailable: {error}"))
|
||||
.ok()
|
||||
.map(Arc::new);
|
||||
|
||||
let track_prefs = catalog.all_title_track_prefs().unwrap_or_else(|error| {
|
||||
tracing::warn!("read show track preferences: {error}");
|
||||
HashMap::new()
|
||||
@@ -449,6 +500,11 @@ impl Engine {
|
||||
download_permits: Arc::new(tokio::sync::Semaphore::new(DOWNLOAD_CONCURRENCY)),
|
||||
picture_shown: Arc::new(AtomicBool::new(false)),
|
||||
crawl_cancel: Arc::new(tokio::sync::watch::channel(0).0),
|
||||
accounts: AccountStore::new(Arc::new(KeyringSecretStore)),
|
||||
account: Arc::new(Mutex::new(None)),
|
||||
account_settled: Arc::new(tokio::sync::watch::channel(false).0),
|
||||
pending_sign_in: Arc::new(Mutex::new(None)),
|
||||
watch_sync,
|
||||
desktop: Arc::new(Mutex::new(desktop)),
|
||||
desktop_file: Arc::new(desktop_file),
|
||||
events,
|
||||
@@ -460,6 +516,8 @@ impl Engine {
|
||||
deferred.install_enrichment(Enrichment::build(config), true);
|
||||
});
|
||||
}
|
||||
engine.load_account();
|
||||
engine.sync_periodically();
|
||||
Ok((engine, receiver))
|
||||
}
|
||||
|
||||
@@ -591,10 +649,239 @@ impl Engine {
|
||||
};
|
||||
engine.emit(Event::ShareAdded(share.name.clone()));
|
||||
engine.load_shares();
|
||||
// The open connection predates the share, and crawling it through
|
||||
// that would find it "not open".
|
||||
engine.connection.lock().take();
|
||||
engine.connect_and_crawl(Some(share.id)).await;
|
||||
});
|
||||
}
|
||||
|
||||
/// Add a folder of the signed-in account as a share, then crawl it.
|
||||
pub fn add_account_folder(&self, name: String, folder: NodeUid) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
let folder = AccountFolder {
|
||||
volume_id: folder.volume_id.as_str().to_owned(),
|
||||
link_id: folder.link_id.as_str().to_owned(),
|
||||
};
|
||||
let share = match engine.store.add_folder(&name, folder) {
|
||||
Ok(share) => share,
|
||||
Err(error) => return engine.emit(Event::ShareRejected(error.to_string())),
|
||||
};
|
||||
engine.emit(Event::ShareAdded(share.name.clone()));
|
||||
engine.load_shares();
|
||||
engine.connection.lock().take();
|
||||
engine.connect_and_crawl(Some(share.id)).await;
|
||||
});
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------- account
|
||||
|
||||
/// Read the stored session, off the UI thread — a keyring read can be a
|
||||
/// D-Bus round trip to a keyring that has to unlock first.
|
||||
fn load_account(&self) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn_blocking(move || {
|
||||
match engine.accounts.resume() {
|
||||
Ok(Some(account)) => {
|
||||
let username = account.username().to_owned();
|
||||
*engine.account.lock() = Some(account);
|
||||
engine.emit(Event::Account(AccountStatus::SignedIn(username)));
|
||||
engine.sync_watch_history();
|
||||
}
|
||||
Ok(None) => engine.emit(Event::Account(AccountStatus::SignedOut)),
|
||||
Err(error) => {
|
||||
engine.emit(Event::Account(AccountStatus::SignedOut));
|
||||
engine.fail("read the Proton session", error);
|
||||
}
|
||||
}
|
||||
engine.account_settled.send_replace(true);
|
||||
});
|
||||
}
|
||||
|
||||
/// Start signing in. What happens next arrives as [`Event::Account`] or
|
||||
/// [`Event::SignInFailed`].
|
||||
pub fn sign_in(&self, username: String, password: String) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
match engine.accounts.sign_in(&username, &password, None).await {
|
||||
Ok(step) => engine.sign_in_step(step),
|
||||
Err(pstr_core::Error::HumanVerification(_)) => {
|
||||
engine.emit(Event::SignInFailed(
|
||||
"Proton wants a CAPTCHA before it accepts this sign-in, and this app \
|
||||
cannot show one. Try again later, or sign in once from the Android app."
|
||||
.to_owned(),
|
||||
));
|
||||
}
|
||||
Err(error) => engine.emit(Event::SignInFailed(error.to_string())),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
pub fn submit_second_factor(&self, code: String) {
|
||||
let Some(pending) = self.pending_sign_in.lock().take() else {
|
||||
return self.emit(Event::Account(AccountStatus::SignedOut));
|
||||
};
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
match pending.second_factor(&code).await {
|
||||
Ok(step) => engine.sign_in_step(step),
|
||||
Err(error) => {
|
||||
// The half-made session is spent; the viewer starts over.
|
||||
engine.emit(Event::Account(AccountStatus::SignedOut));
|
||||
engine.emit(Event::SignInFailed(error.to_string()));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
pub fn submit_mailbox_password(&self, password: String) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
let Some(pending) = engine.pending_sign_in.lock().take() else {
|
||||
return engine.emit(Event::Account(AccountStatus::SignedOut));
|
||||
};
|
||||
match pending.mailbox_password(&password).await {
|
||||
Ok(account) => engine.signed_in(account),
|
||||
Err(error) => {
|
||||
// Kept: a mistyped mailbox password can be typed again.
|
||||
*engine.pending_sign_in.lock() = Some(pending);
|
||||
engine.emit(Event::SignInFailed(error.to_string()));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
pub fn cancel_sign_in(&self) {
|
||||
self.pending_sign_in.lock().take();
|
||||
self.emit(Event::Account(AccountStatus::SignedOut));
|
||||
}
|
||||
|
||||
fn sign_in_step(&self, step: SignIn) {
|
||||
match step {
|
||||
SignIn::Done(account) => self.signed_in(account),
|
||||
SignIn::SecondFactor(pending) => {
|
||||
*self.pending_sign_in.lock() = Some(pending);
|
||||
self.emit(Event::Account(AccountStatus::SecondFactor));
|
||||
}
|
||||
SignIn::MailboxPassword(pending) => {
|
||||
*self.pending_sign_in.lock() = Some(pending);
|
||||
self.emit(Event::Account(AccountStatus::MailboxPassword));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn signed_in(&self, account: Account) {
|
||||
let username = account.username().to_owned();
|
||||
*self.account.lock() = Some(account);
|
||||
if let Some(sync) = &self.watch_sync {
|
||||
sync.reset();
|
||||
}
|
||||
// Folders of the account that failed to open before are openable now.
|
||||
self.connection.lock().take();
|
||||
self.emit(Event::Account(AccountStatus::SignedIn(username)));
|
||||
self.connect();
|
||||
self.sync_watch_history();
|
||||
}
|
||||
|
||||
/// Sign out and forget the stored session. The library keeps everything
|
||||
/// it has; the account's folders stop opening until the next sign-in.
|
||||
pub fn sign_out(&self) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
let account = engine.account.lock().take();
|
||||
if let Err(error) = engine.accounts.sign_out(account.as_ref()).await {
|
||||
engine.fail("forget the Proton session", error);
|
||||
}
|
||||
engine.signed_out();
|
||||
});
|
||||
}
|
||||
|
||||
fn signed_out(&self) {
|
||||
self.account.lock().take();
|
||||
if let Some(sync) = &self.watch_sync {
|
||||
sync.reset();
|
||||
}
|
||||
self.connection.lock().take();
|
||||
self.emit(Event::Account(AccountStatus::SignedOut));
|
||||
}
|
||||
|
||||
/// Sync watch history now, if an account is signed in.
|
||||
pub fn sync_watch_history(&self) {
|
||||
let (Some(account), Some(sync)) = (self.account.lock().clone(), self.watch_sync.clone())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
match sync.sync(&account, &engine.catalog).await {
|
||||
Ok(report) => {
|
||||
if report.applied > 0 {
|
||||
engine.load_library();
|
||||
}
|
||||
engine.emit(Event::Synced(report));
|
||||
}
|
||||
Err(error) if error.is_signed_out() => {
|
||||
// The refresh token died — revoked from another device, or
|
||||
// unused for too long. Signing in again is the only fix,
|
||||
// and a stored session that can never resume only makes
|
||||
// every later launch fail the same way.
|
||||
let _ = engine.accounts.sign_out(None).await;
|
||||
engine.signed_out();
|
||||
engine.emit(Event::Error(
|
||||
"Your Proton session ended. Sign in again to keep syncing watch history."
|
||||
.to_owned(),
|
||||
));
|
||||
}
|
||||
Err(error) => {
|
||||
tracing::warn!("sync watch history: {error}");
|
||||
engine.emit(Event::SyncFailed(error.to_string()));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn sync_periodically(&self) {
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
let mut ticks = tokio::time::interval(SYNC_INTERVAL);
|
||||
// The first tick is immediate, and launch already syncs.
|
||||
ticks.tick().await;
|
||||
loop {
|
||||
ticks.tick().await;
|
||||
engine.sync_watch_history();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// List the account's top-level places, for the Drive browser.
|
||||
pub fn browse_places(&self) {
|
||||
let Some(account) = self.account.lock().clone() else {
|
||||
return self.emit(Event::BrowseFailed("not signed in".to_owned()));
|
||||
};
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
match account.places().await {
|
||||
Ok(places) => engine.emit(Event::Places(places)),
|
||||
Err(error) => engine.emit(Event::BrowseFailed(error.to_string())),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// List one folder of the account, for the Drive browser.
|
||||
pub fn browse_folder(&self, uid: NodeUid) {
|
||||
let Some(account) = self.account.lock().clone() else {
|
||||
return self.emit(Event::BrowseFailed("not signed in".to_owned()));
|
||||
};
|
||||
let engine = self.clone();
|
||||
self.runtime.spawn(async move {
|
||||
match account.folder_children(&uid).await {
|
||||
Ok(entries) => engine.emit(Event::Folder { uid, entries }),
|
||||
Err(error) => engine.emit(Event::BrowseFailed(error.to_string())),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Forget a share and its stored secrets.
|
||||
pub fn remove_share(&self, id: String) {
|
||||
let engine = self.clone();
|
||||
@@ -696,7 +983,11 @@ impl Engine {
|
||||
return Some(opened);
|
||||
}
|
||||
|
||||
let (library, failures) = match SharedLibrary::open_all(&self.store).await {
|
||||
let mut settled = self.account_settled.subscribe();
|
||||
let _ = settled.wait_for(|settled| *settled).await;
|
||||
let account = self.account.lock().clone();
|
||||
let (library, failures) = match SharedLibrary::open_all(&self.store, account.as_ref()).await
|
||||
{
|
||||
Ok(opened) => opened,
|
||||
Err(error) => {
|
||||
self.emit(Event::ConnectFailed(error.to_string()));
|
||||
@@ -1555,8 +1846,8 @@ impl Engine {
|
||||
return Ok(DownloadEnd::Cancelled);
|
||||
}
|
||||
let size = block_sizes[block_index];
|
||||
let pending =
|
||||
fetches.get_or_insert_with(|| fetch_in_order(&stream, &block_sizes, block_index));
|
||||
let pending = fetches
|
||||
.get_or_insert_with(|| stream.blocks_in_order(block_index, COPY_BLOCKS_IN_FLIGHT));
|
||||
let Some(bytes) = pending.try_next().await? else {
|
||||
anyhow::bail!("block {block_index} never arrived");
|
||||
};
|
||||
@@ -2043,26 +2334,24 @@ impl Engine {
|
||||
return engine.emit(Event::Error(engine.no_service_reason()));
|
||||
};
|
||||
let name = found.name.clone();
|
||||
let record = service.chosen(title.key.clone(), found.clone());
|
||||
if let Err(error) = engine.catalog.lock().set_metadata(&record) {
|
||||
let outcome = service.choose(&title, found).await;
|
||||
if let Some(record) = &outcome.record
|
||||
&& let Err(error) = engine.catalog.lock().set_metadata(record)
|
||||
{
|
||||
return engine.fail("store the match", error);
|
||||
}
|
||||
|
||||
// A failure leaves the title un-enriched, and the next match run
|
||||
// asks again.
|
||||
match service.enrich(&title, &found).await {
|
||||
Ok(enrichment) => {
|
||||
let stored = engine.catalog.lock().set_enrichment(
|
||||
&title.key,
|
||||
service.provider(),
|
||||
now(),
|
||||
&enrichment,
|
||||
);
|
||||
if let Err(error) = stored {
|
||||
tracing::warn!("store enrichment for {}: {error}", title.key);
|
||||
}
|
||||
if let Some(enrichment) = &outcome.enrichment {
|
||||
let stored = engine.catalog.lock().set_enrichment(
|
||||
&title.key,
|
||||
service.provider(),
|
||||
now(),
|
||||
enrichment,
|
||||
);
|
||||
if let Err(error) = stored {
|
||||
tracing::warn!("store enrichment for {}: {error}", title.key);
|
||||
}
|
||||
Err(error) => tracing::warn!("enrich {}: {error}", title.key),
|
||||
}
|
||||
|
||||
engine.emit(Event::Status(format!("{} is now {name}", title.name)));
|
||||
@@ -2223,35 +2512,6 @@ fn resume_position(existing: u64, block_sizes: &[u64]) -> (usize, u64) {
|
||||
(block_sizes.len(), offset)
|
||||
}
|
||||
|
||||
/// A file's blocks from `first` on, fetched several at a time and yielded in
|
||||
/// file order — which is what the resume marker's "the length is the
|
||||
/// boundary" rule needs. One at a time, a download runs at one block per round
|
||||
/// trip whatever the link can carry.
|
||||
fn fetch_in_order(
|
||||
stream: &VideoStream,
|
||||
block_sizes: &[u64],
|
||||
first: usize,
|
||||
) -> futures::stream::BoxStream<'static, pstr_stream::Result<Vec<u8>>> {
|
||||
use futures::StreamExt as _;
|
||||
let start: u64 = block_sizes[..first].iter().sum();
|
||||
let ranges: Vec<(u64, u64)> = block_sizes[first..]
|
||||
.iter()
|
||||
.scan(start, |offset, size| {
|
||||
let range = (*offset, *size);
|
||||
*offset += size;
|
||||
Some(range)
|
||||
})
|
||||
.collect();
|
||||
let stream = stream.clone();
|
||||
futures::stream::iter(ranges)
|
||||
.map(move |(offset, size)| {
|
||||
let stream = stream.clone();
|
||||
async move { stream.read_range(offset, size).await }
|
||||
})
|
||||
.buffered(DOWNLOAD_BLOCKS_IN_FLIGHT)
|
||||
.boxed()
|
||||
}
|
||||
|
||||
async fn wait_until_runnable(command: &mut tokio::sync::watch::Receiver<DownloadCommand>) -> bool {
|
||||
loop {
|
||||
let current = *command.borrow_and_update();
|
||||
|
||||
@@ -0,0 +1,596 @@
|
||||
//! The Proton account, on the shares page: signing in, watch-history sync, and
|
||||
//! picking folders of the viewer's own Drive as library shares.
|
||||
//!
|
||||
//! Optional and said so: public links need no account, and the page reads the
|
||||
//! same without one. What signing in adds is spelled out next to the form,
|
||||
//! because "sign in" alone does not say why an app that streams public links
|
||||
//! would want a password.
|
||||
|
||||
use pstr_core::account::{DriveEntry, DrivePlace, PlaceKind};
|
||||
use pstr_core::proton_sdk::ids::NodeUid;
|
||||
use pstr_core::sync::SyncReport;
|
||||
|
||||
use crate::app::Action;
|
||||
use crate::engine::AccountStatus;
|
||||
use crate::theme;
|
||||
use crate::ui;
|
||||
|
||||
/// What the account section holds between frames.
|
||||
#[derive(Default)]
|
||||
pub struct AccountPanel {
|
||||
pub status: AccountStatus,
|
||||
pub username: String,
|
||||
pub password: String,
|
||||
pub code: String,
|
||||
pub mailbox: String,
|
||||
/// A request is out and not answered yet.
|
||||
pub busy: bool,
|
||||
/// Why the last sign-in step was refused.
|
||||
pub error: Option<String>,
|
||||
/// When watch history last synced, in Unix seconds, and what it did.
|
||||
pub synced: Option<(i64, SyncReport)>,
|
||||
/// Why the last sync failed, until one succeeds.
|
||||
pub sync_error: Option<String>,
|
||||
pub browser: DriveBrowser,
|
||||
}
|
||||
|
||||
impl AccountPanel {
|
||||
/// Apply where the account now stands. The typed secrets go as soon as
|
||||
/// they are not needed: a password has no business sitting in a struct for
|
||||
/// the rest of the session.
|
||||
pub fn set_status(&mut self, status: AccountStatus) {
|
||||
self.busy = false;
|
||||
match &status {
|
||||
AccountStatus::SignedIn(_) | AccountStatus::SignedOut => {
|
||||
self.password.clear();
|
||||
self.code.clear();
|
||||
self.mailbox.clear();
|
||||
if matches!(status, AccountStatus::SignedIn(_)) {
|
||||
self.error = None;
|
||||
} else {
|
||||
self.browser = DriveBrowser::default();
|
||||
self.synced = None;
|
||||
self.sync_error = None;
|
||||
}
|
||||
}
|
||||
AccountStatus::SecondFactor => self.error = None,
|
||||
AccountStatus::MailboxPassword => {
|
||||
self.code.clear();
|
||||
self.error = None;
|
||||
}
|
||||
AccountStatus::Unknown => {}
|
||||
}
|
||||
self.status = status;
|
||||
}
|
||||
|
||||
pub fn refused(&mut self, error: String) {
|
||||
self.busy = false;
|
||||
self.error = Some(error);
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the Drive browser is.
|
||||
#[derive(Default)]
|
||||
pub struct DriveBrowser {
|
||||
pub open: bool,
|
||||
/// The folders descended through, each by name. Empty means the places.
|
||||
pub trail: Vec<(String, NodeUid)>,
|
||||
pub places: Option<Vec<DrivePlace>>,
|
||||
/// The listing of the folder at the end of the trail, once it arrives.
|
||||
pub entries: Option<(NodeUid, Vec<DriveEntry>)>,
|
||||
pub loading: bool,
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
impl DriveBrowser {
|
||||
pub fn places_arrived(&mut self, places: Vec<DrivePlace>) {
|
||||
self.loading = false;
|
||||
self.error = None;
|
||||
self.places = Some(places);
|
||||
}
|
||||
|
||||
/// Take a listing, unless the viewer has already moved on from it.
|
||||
pub fn folder_arrived(&mut self, uid: NodeUid, entries: Vec<DriveEntry>) {
|
||||
if self
|
||||
.trail
|
||||
.last()
|
||||
.is_some_and(|(_, current)| *current == uid)
|
||||
{
|
||||
self.loading = false;
|
||||
self.error = None;
|
||||
self.entries = Some((uid, entries));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn failed(&mut self, error: String) {
|
||||
self.loading = false;
|
||||
self.error = Some(error);
|
||||
}
|
||||
|
||||
fn enter(&mut self, name: String, uid: NodeUid, actions: &mut Vec<Action>) {
|
||||
self.trail.push((name, uid.clone()));
|
||||
self.entries = None;
|
||||
self.loading = true;
|
||||
self.error = None;
|
||||
actions.push(Action::BrowseFolder(uid));
|
||||
}
|
||||
|
||||
fn up(&mut self, actions: &mut Vec<Action>) {
|
||||
self.trail.pop();
|
||||
self.entries = None;
|
||||
self.error = None;
|
||||
match self.trail.last() {
|
||||
Some((_, uid)) => {
|
||||
self.loading = true;
|
||||
actions.push(Action::BrowseFolder(uid.clone()));
|
||||
}
|
||||
None => self.loading = self.places.is_none(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The account card: a sign-in form, or who is signed in and how sync is doing.
|
||||
pub fn section(ui: &mut egui::Ui, panel: &mut AccountPanel, actions: &mut Vec<Action>) {
|
||||
ui::section(ui, "Proton account");
|
||||
ui.label(ui::muted(
|
||||
"Optional. Signed in, your watch history is kept in your own Drive and every device \
|
||||
resumes where another left off, and folders of your Drive — your files, other \
|
||||
devices, what was shared with you — can be added to the library.",
|
||||
));
|
||||
ui.add_space(theme::space::L);
|
||||
|
||||
card(ui, |ui| match panel.status.clone() {
|
||||
AccountStatus::Unknown => {
|
||||
ui.horizontal(|ui| {
|
||||
ui.add(egui::Spinner::new().size(14.0));
|
||||
ui.label(ui::muted("reading the stored session…"));
|
||||
});
|
||||
}
|
||||
AccountStatus::SignedOut => sign_in_form(ui, panel, actions),
|
||||
AccountStatus::SecondFactor => code_form(ui, panel, actions),
|
||||
AccountStatus::MailboxPassword => mailbox_form(ui, panel, actions),
|
||||
AccountStatus::SignedIn(username) => signed_in(ui, panel, &username, actions),
|
||||
});
|
||||
}
|
||||
|
||||
fn card(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui)) {
|
||||
egui::Frame::new()
|
||||
.fill(theme::card())
|
||||
.corner_radius(egui::CornerRadius::same(theme::radius::MD))
|
||||
.inner_margin(egui::Margin::same(14))
|
||||
.show(ui, |ui| {
|
||||
ui.set_width(ui.available_width().min(640.0));
|
||||
add(ui);
|
||||
});
|
||||
}
|
||||
|
||||
fn sign_in_form(ui: &mut egui::Ui, panel: &mut AccountPanel, actions: &mut Vec<Action>) {
|
||||
ui.label(ui::muted("Address"));
|
||||
ui.add(
|
||||
egui::TextEdit::singleline(&mut panel.username)
|
||||
.hint_text("you@proton.me")
|
||||
.desired_width(f32::INFINITY),
|
||||
);
|
||||
ui.add_space(theme::space::M);
|
||||
ui.label(ui::muted("Password"));
|
||||
let field = ui.add(
|
||||
egui::TextEdit::singleline(&mut panel.password)
|
||||
.password(true)
|
||||
.desired_width(f32::INFINITY),
|
||||
);
|
||||
ui.add_space(theme::space::L);
|
||||
error_line(ui, panel);
|
||||
let ready = !panel.username.trim().is_empty() && !panel.password.is_empty() && !panel.busy;
|
||||
let submitted = field.lost_focus() && ui.input(|input| input.key_pressed(egui::Key::Enter));
|
||||
ui.horizontal(|ui| {
|
||||
let clicked = ui
|
||||
.add_enabled_ui(ready, |ui| ui::accent_button(ui, "Sign in"))
|
||||
.inner
|
||||
.clicked();
|
||||
if ready && (clicked || submitted) {
|
||||
panel.busy = true;
|
||||
panel.error = None;
|
||||
actions.push(Action::SignIn {
|
||||
username: panel.username.trim().to_owned(),
|
||||
password: panel.password.clone(),
|
||||
});
|
||||
}
|
||||
busy_line(ui, panel, "signing in…");
|
||||
});
|
||||
}
|
||||
|
||||
fn code_form(ui: &mut egui::Ui, panel: &mut AccountPanel, actions: &mut Vec<Action>) {
|
||||
ui.label(ui::muted("Two-factor code from your authenticator app"));
|
||||
let field = ui.add(
|
||||
egui::TextEdit::singleline(&mut panel.code)
|
||||
.hint_text("123456")
|
||||
.desired_width(160.0),
|
||||
);
|
||||
field.request_focus();
|
||||
ui.add_space(theme::space::L);
|
||||
error_line(ui, panel);
|
||||
let ready = !panel.code.trim().is_empty() && !panel.busy;
|
||||
let submitted = field.lost_focus() && ui.input(|input| input.key_pressed(egui::Key::Enter));
|
||||
ui.horizontal(|ui| {
|
||||
let clicked = ui
|
||||
.add_enabled_ui(ready, |ui| ui::accent_button(ui, "Continue"))
|
||||
.inner
|
||||
.clicked();
|
||||
if ready && (clicked || submitted) {
|
||||
panel.busy = true;
|
||||
actions.push(Action::SubmitSecondFactor(panel.code.trim().to_owned()));
|
||||
}
|
||||
if ui.button("Cancel").clicked() {
|
||||
actions.push(Action::CancelSignIn);
|
||||
}
|
||||
busy_line(ui, panel, "checking…");
|
||||
});
|
||||
}
|
||||
|
||||
fn mailbox_form(ui: &mut egui::Ui, panel: &mut AccountPanel, actions: &mut Vec<Action>) {
|
||||
ui.label(ui::muted(
|
||||
"This account has a separate mailbox password. It unlocks your files, and is kept \
|
||||
in your system keyring.",
|
||||
));
|
||||
ui.add_space(theme::space::S);
|
||||
let field = ui.add(
|
||||
egui::TextEdit::singleline(&mut panel.mailbox)
|
||||
.password(true)
|
||||
.hint_text("Mailbox password")
|
||||
.desired_width(f32::INFINITY),
|
||||
);
|
||||
ui.add_space(theme::space::L);
|
||||
error_line(ui, panel);
|
||||
let ready = !panel.mailbox.is_empty() && !panel.busy;
|
||||
let submitted = field.lost_focus() && ui.input(|input| input.key_pressed(egui::Key::Enter));
|
||||
ui.horizontal(|ui| {
|
||||
let clicked = ui
|
||||
.add_enabled_ui(ready, |ui| ui::accent_button(ui, "Unlock"))
|
||||
.inner
|
||||
.clicked();
|
||||
if ready && (clicked || submitted) {
|
||||
panel.busy = true;
|
||||
actions.push(Action::SubmitMailboxPassword(panel.mailbox.clone()));
|
||||
}
|
||||
if ui.button("Cancel").clicked() {
|
||||
actions.push(Action::CancelSignIn);
|
||||
}
|
||||
busy_line(ui, panel, "unlocking…");
|
||||
});
|
||||
}
|
||||
|
||||
fn signed_in(
|
||||
ui: &mut egui::Ui,
|
||||
panel: &mut AccountPanel,
|
||||
username: &str,
|
||||
actions: &mut Vec<Action>,
|
||||
) {
|
||||
ui.horizontal(|ui| {
|
||||
ui.vertical(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!(
|
||||
"{} {username}",
|
||||
egui_phosphor::regular::USER_CIRCLE
|
||||
))
|
||||
.strong(),
|
||||
);
|
||||
let status = match (&panel.sync_error, &panel.synced) {
|
||||
(Some(error), _) => format!("Watch history did not sync: {error}"),
|
||||
(None, Some((at, report))) => sync_line(*at, report, unix_now()),
|
||||
(None, None) => "Watch history syncs with your Drive".to_owned(),
|
||||
};
|
||||
ui.label(ui::muted(status));
|
||||
});
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
if ui
|
||||
.add(
|
||||
egui::Button::new(format!("{} Sign out", egui_phosphor::regular::SIGN_OUT))
|
||||
.fill(theme::card_hover()),
|
||||
)
|
||||
.clicked()
|
||||
{
|
||||
actions.push(Action::SignOut);
|
||||
}
|
||||
if ui
|
||||
.button(format!(
|
||||
"{} Sync now",
|
||||
egui_phosphor::regular::ARROWS_CLOCKWISE
|
||||
))
|
||||
.clicked()
|
||||
{
|
||||
actions.push(Action::SyncNow);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/// "Synced 3 min ago · 2 positions from other devices".
|
||||
fn sync_line(at: i64, report: &SyncReport, now: i64) -> String {
|
||||
let ago = (now - at).max(0);
|
||||
let when = match ago {
|
||||
0..60 => "just now".to_owned(),
|
||||
60..3600 => format!("{} min ago", ago / 60),
|
||||
_ => format!("{} h ago", ago / 3600),
|
||||
};
|
||||
let mut line = format!("Synced {when}");
|
||||
if report.applied > 0 {
|
||||
line.push_str(&format!(
|
||||
" · {} from other devices",
|
||||
ui::library::plural(report.applied, "position")
|
||||
));
|
||||
}
|
||||
line
|
||||
}
|
||||
|
||||
fn error_line(ui: &mut egui::Ui, panel: &AccountPanel) {
|
||||
if let Some(error) = &panel.error {
|
||||
ui.label(theme::Role::Caption.rich(error).color(theme::danger()));
|
||||
ui.add_space(theme::space::S);
|
||||
}
|
||||
}
|
||||
|
||||
fn busy_line(ui: &mut egui::Ui, panel: &AccountPanel, text: &str) {
|
||||
if panel.busy {
|
||||
ui.add(egui::Spinner::new().size(14.0));
|
||||
ui.label(ui::muted(text));
|
||||
}
|
||||
}
|
||||
|
||||
/// Browse the account's Drive and add a folder of it to the library.
|
||||
pub fn browser(
|
||||
ui: &mut egui::Ui,
|
||||
panel: &mut AccountPanel,
|
||||
shares: &[pstr_core::Share],
|
||||
actions: &mut Vec<Action>,
|
||||
) {
|
||||
if !matches!(panel.status, AccountStatus::SignedIn(_)) {
|
||||
return;
|
||||
}
|
||||
ui.add_space(theme::space::XXL);
|
||||
ui::section(ui, "Add from your Drive");
|
||||
let browser = &mut panel.browser;
|
||||
if !browser.open {
|
||||
ui.label(ui::muted(
|
||||
"A folder of your own Drive becomes a share like any link: crawled, browsable and \
|
||||
streamed through your account.",
|
||||
));
|
||||
ui.add_space(theme::space::L);
|
||||
if ui
|
||||
.button(format!(
|
||||
"{} Browse your Drive",
|
||||
egui_phosphor::regular::FOLDER
|
||||
))
|
||||
.clicked()
|
||||
{
|
||||
browser.open = true;
|
||||
if browser.places.is_none() {
|
||||
browser.loading = true;
|
||||
actions.push(Action::BrowsePlaces);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
card(ui, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
if !browser.trail.is_empty()
|
||||
&& ui
|
||||
.button(egui_phosphor::regular::ARROW_LEFT)
|
||||
.on_hover_text("Up a folder")
|
||||
.clicked()
|
||||
{
|
||||
browser.up(actions);
|
||||
}
|
||||
let mut crumbs = vec!["Drive".to_owned()];
|
||||
crumbs.extend(browser.trail.iter().map(|(name, _)| name.clone()));
|
||||
ui.label(
|
||||
egui::RichText::new(
|
||||
crumbs.join(&format!(" {} ", egui_phosphor::regular::CARET_RIGHT)),
|
||||
)
|
||||
.strong(),
|
||||
);
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
if ui.button("Close").clicked() {
|
||||
browser.open = false;
|
||||
}
|
||||
});
|
||||
});
|
||||
ui.add_space(theme::space::M);
|
||||
|
||||
if let Some(error) = &browser.error {
|
||||
ui.label(theme::Role::Caption.rich(error).color(theme::danger()));
|
||||
ui.add_space(theme::space::S);
|
||||
}
|
||||
if browser.loading {
|
||||
ui.horizontal(|ui| {
|
||||
ui.add(egui::Spinner::new().size(14.0));
|
||||
ui.label(ui::muted("listing…"));
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
let mut entered = None;
|
||||
egui::ScrollArea::vertical()
|
||||
.max_height(320.0)
|
||||
.auto_shrink([false, true])
|
||||
.show(ui, |ui| match browser.trail.last() {
|
||||
None => {
|
||||
for place in browser.places.iter().flatten() {
|
||||
let icon = match place.kind {
|
||||
PlaceKind::MyFiles => egui_phosphor::regular::HARD_DRIVES,
|
||||
PlaceKind::Device => egui_phosphor::regular::DESKTOP,
|
||||
PlaceKind::SharedWithMe => egui_phosphor::regular::USERS,
|
||||
};
|
||||
if row(ui, icon, &place.name, None, true).clicked() {
|
||||
entered = Some((place.name.clone(), place.uid.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(_) => {
|
||||
let entries = browser
|
||||
.entries
|
||||
.as_ref()
|
||||
.map(|(_, entries)| entries.as_slice());
|
||||
if entries.is_some_and(<[DriveEntry]>::is_empty) {
|
||||
ui.label(ui::muted("This folder is empty."));
|
||||
}
|
||||
for entry in entries.unwrap_or_default() {
|
||||
let (icon, detail) = if entry.is_folder {
|
||||
(egui_phosphor::regular::FOLDER, None)
|
||||
} else if entry
|
||||
.media_type
|
||||
.as_deref()
|
||||
.is_some_and(|media| media.starts_with("video/"))
|
||||
{
|
||||
(
|
||||
egui_phosphor::regular::FILE_VIDEO,
|
||||
entry.size.map(format_size),
|
||||
)
|
||||
} else {
|
||||
(egui_phosphor::regular::FILE, entry.size.map(format_size))
|
||||
};
|
||||
if row(ui, icon, &entry.name, detail.as_deref(), entry.is_folder).clicked()
|
||||
&& entry.is_folder
|
||||
{
|
||||
entered = Some((entry.name.clone(), entry.uid.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
if let Some((name, uid)) = entered {
|
||||
browser.enter(name, uid, actions);
|
||||
}
|
||||
|
||||
if let Some((name, uid)) = browser.trail.last() {
|
||||
ui.add_space(theme::space::L);
|
||||
let added = shares.iter().any(|share| {
|
||||
share
|
||||
.folder
|
||||
.as_ref()
|
||||
.is_some_and(|folder| folder.uid() == *uid)
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
if added {
|
||||
ui.label(ui::muted("This folder is already in the library."));
|
||||
} else if ui::accent_button(ui, "Add this folder").clicked() {
|
||||
actions.push(Action::AddAccountFolder {
|
||||
name: name.clone(),
|
||||
uid: uid.clone(),
|
||||
});
|
||||
browser.open = false;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// One line of the browser. Only folders and places are clickable.
|
||||
fn row(
|
||||
ui: &mut egui::Ui,
|
||||
icon: &str,
|
||||
name: &str,
|
||||
detail: Option<&str>,
|
||||
clickable: bool,
|
||||
) -> egui::Response {
|
||||
let mut text = egui::text::LayoutJob::default();
|
||||
let body = ui.style().text_styles[&egui::TextStyle::Body].clone();
|
||||
text.append(
|
||||
&format!("{icon} {name}"),
|
||||
0.0,
|
||||
egui::TextFormat::simple(
|
||||
body.clone(),
|
||||
if clickable {
|
||||
theme::text()
|
||||
} else {
|
||||
theme::muted()
|
||||
},
|
||||
),
|
||||
);
|
||||
if let Some(detail) = detail {
|
||||
text.append(
|
||||
&format!(" {detail}"),
|
||||
0.0,
|
||||
egui::TextFormat::simple(body, theme::muted()),
|
||||
);
|
||||
}
|
||||
let sense = if clickable {
|
||||
egui::Sense::click()
|
||||
} else {
|
||||
egui::Sense::hover()
|
||||
};
|
||||
let response = ui.add(egui::Label::new(text).sense(sense).truncate());
|
||||
if clickable && response.hovered() {
|
||||
ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
|
||||
}
|
||||
response
|
||||
}
|
||||
|
||||
fn format_size(bytes: i64) -> String {
|
||||
let bytes = bytes.max(0) as f64;
|
||||
const GIB: f64 = 1024.0 * 1024.0 * 1024.0;
|
||||
const MIB: f64 = 1024.0 * 1024.0;
|
||||
if bytes >= GIB {
|
||||
format!("{:.1} GiB", bytes / GIB)
|
||||
} else {
|
||||
format!("{:.0} MiB", bytes / MIB)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn unix_now() -> i64 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|since| since.as_secs() as i64)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_sync_line_says_how_long_ago_and_what_came_in() {
|
||||
let quiet = SyncReport::default();
|
||||
assert_eq!(sync_line(100, &quiet, 130), "Synced just now");
|
||||
assert_eq!(sync_line(100, &quiet, 400), "Synced 5 min ago");
|
||||
let busy = SyncReport {
|
||||
applied: 2,
|
||||
..SyncReport::default()
|
||||
};
|
||||
assert_eq!(
|
||||
sync_line(0, &busy, 7200),
|
||||
"Synced 2 h ago · 2 positions from other devices"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signing_out_forgets_what_was_typed_and_browsed() {
|
||||
let mut panel = AccountPanel {
|
||||
password: "secret".into(),
|
||||
mailbox: "also secret".into(),
|
||||
..AccountPanel::default()
|
||||
};
|
||||
panel.browser.open = true;
|
||||
panel.set_status(AccountStatus::SignedOut);
|
||||
assert!(panel.password.is_empty() && panel.mailbox.is_empty());
|
||||
assert!(!panel.browser.open);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_listing_for_a_folder_already_left_is_dropped() {
|
||||
let uid = |link: &str| {
|
||||
NodeUid::new(
|
||||
pstr_core::proton_sdk::ids::VolumeId::new("v".to_owned()),
|
||||
pstr_core::proton_sdk::ids::LinkId::new(link.to_owned()),
|
||||
)
|
||||
};
|
||||
let mut browser = DriveBrowser {
|
||||
trail: vec![("b".into(), uid("b"))],
|
||||
loading: true,
|
||||
..DriveBrowser::default()
|
||||
};
|
||||
browser.folder_arrived(uid("a"), Vec::new());
|
||||
assert!(browser.loading && browser.entries.is_none());
|
||||
browser.folder_arrived(uid("b"), Vec::new());
|
||||
assert!(!browser.loading && browser.entries.is_some());
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,7 @@
|
||||
//! mutating the library it is iterating: pages collect [`Action`]s and the app
|
||||
//! applies them after the frame is drawn.
|
||||
|
||||
pub mod account;
|
||||
pub mod downloads;
|
||||
pub mod history;
|
||||
pub mod library;
|
||||
|
||||
@@ -18,6 +18,7 @@ pub fn show(
|
||||
shares: &[Share],
|
||||
library: &Library,
|
||||
form: &mut ShareForm,
|
||||
account: &mut ui::account::AccountPanel,
|
||||
actions: &mut Vec<Action>,
|
||||
) {
|
||||
egui::ScrollArea::vertical()
|
||||
@@ -40,6 +41,10 @@ pub fn show(
|
||||
|
||||
ui.add_space(theme::space::XXL);
|
||||
add_form(ui, shares, form, actions);
|
||||
|
||||
ui.add_space(theme::space::XXL);
|
||||
ui::account::section(ui, account, actions);
|
||||
ui::account::browser(ui, account, shares, actions);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -56,6 +61,9 @@ fn share_row(ui: &mut egui::Ui, share: &Share, titles: usize, actions: &mut Vec<
|
||||
// What is in it, rather than what it is called inside the
|
||||
// app. The id is still a hover away for a bug report.
|
||||
let mut detail = ui::library::plural(titles, "title");
|
||||
if share.folder.is_some() {
|
||||
detail.push_str(" · from your Drive");
|
||||
}
|
||||
if share.has_custom_password {
|
||||
detail.push_str(" · password protected");
|
||||
}
|
||||
@@ -211,6 +219,7 @@ mod tests {
|
||||
name: "anime".into(),
|
||||
token: token.into(),
|
||||
has_custom_password: false,
|
||||
folder: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user