Initial commit

src/main.rs

@@ -0,0 +1,218 @@
+// Prevent console window in addition to Slint window in Windows release builds when, e.g., starting the app via file manager. Ignored on other platforms.
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use clap::Parser;
+use immich_sdk::AssetId;
+use kameo::actor::{ActorRef, Spawn};
+use slint::{
+    ComponentHandle as _, Model, ModelRc, SharedPixelBuffer, SharedString, ToSharedString,
+    VecModel, Weak,
+};
+use tracing::Level;
+
+use crate::{
+    api::{Api, GetAssetThumbnail, GetTimeBucket, GetTimeBuckets, TimeBucketKey},
+    ui::AppWindow,
+};
+
+mod api;
+mod thumbhash;
+
+mod ui {
+    slint::include_modules!();
+}
+
+#[derive(clap::Parser)]
+struct Opt {
+    #[clap(long, env = "IMMICH_BASE_URL")]
+    pub immich_base_url: String,
+
+    #[clap(long, env = "IMMICH_API_KEY")]
+    pub immich_api_key: String,
+}
+
+// enum ApiReq<M: Send + 'static>
+// where
+//     Api: Message<M>,
+// {
+//     AskRequest(
+//         AskRequest<
+//             'static,
+//             Api,
+//             M,
+//             kameo::request::WithoutRequestTimeout,
+//             kameo::request::WithoutRequestTimeout,
+//         >,
+//     ),
+//     PendingReply(PendingReply<M, <Api as Message<M>>::Reply>),
+// }
+
+// enum ApiReqs {
+//     GetBuckets(ApiReq<GetTimeBuckets>),
+//     GetBucket(ApiReq<GetTimeBucket>),
+// }
+
+fn main() -> anyhow::Result<()> {
+    let opt = Opt::parse();
+
+    tracing_subscriber::fmt()
+        .with_max_level(Level::DEBUG)
+        .init();
+
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let _rt_guard = runtime.enter();
+
+    let immich_config =
+        immich_sdk::Config::new(opt.immich_base_url).with_api_key(opt.immich_api_key);
+    let api = Api::new(immich_sdk::Client::new(immich_config).unwrap());
+    let api_ = Api::spawn(api);
+
+    let app = ui::AppWindow::new()?;
+
+    let app_weak = app.as_weak();
+    let api = api_.clone();
+    tokio::spawn(async move {
+        let Ok(buckets) = api.ask(GetTimeBuckets).await else {
+            return;
+        };
+
+        for bucket in buckets.iter() {
+            load_bucket(bucket.key.clone(), app_weak.clone(), api.clone());
+        }
+
+        let _ = app_weak.upgrade_in_event_loop(move |app| {
+            let preview_image = slint::Image::from_rgb8(SharedPixelBuffer::clone_from_slice(
+                &[0x33, 0x33, 0x33], // a single dark gray pixel
+                1,
+                1,
+            ));
+
+            let global = app.global::<ui::Global>();
+            let buckets = buckets
+                .into_iter()
+                .map(|bucket| ui::ImageBucket {
+                    key: bucket.key.to_shared_string(),
+                    title: bucket.key.to_shared_string(), // TODO: format
+                    count: bucket.count as i32,
+                    previews: ModelRc::new(
+                        (0..bucket.count)
+                            .map(|_| ui::ImagePreview {
+                                asset_id: SharedString::new(),
+                                image: preview_image.clone(),
+                                kind: ui::PreviewKind::None,
+                            })
+                            .collect::<VecModel<_>>(),
+                    ),
+                })
+                .collect::<VecModel<_>>();
+            global.set_image_buckets(ModelRc::new(buckets));
+        });
+    });
+
+    // FIXME: visibility-based callbacks are broken
+    // let app_weak = app.as_weak();
+    // let api = api_.clone();
+    // global.on_bucket_view_state(move |key, new_state| {
+    //     eprintln!("{key} => {new_state:?}");
+
+    //     // TODO
+    //     if new_state == ui::ViewState::Hidden {
+    //         return;
+    //     }
+    // });
+
+    app.run()?;
+
+    Ok(())
+}
+
+fn load_bucket(time_bucket: TimeBucketKey, app_weak: Weak<AppWindow>, api: ActorRef<Api>) {
+    tokio::spawn(async move {
+        let Ok(api_bucket) = api
+            .ask(GetTimeBucket {
+                time_bucket: time_bucket.clone(),
+            })
+            .await
+        else {
+            return;
+        };
+
+        let _ = app_weak.upgrade_in_event_loop(move |app| {
+            let global = app.global::<ui::Global>();
+
+            let buckets = global.get_image_buckets();
+            let buckets = buckets
+                .as_any()
+                .downcast_ref::<VecModel<ui::ImageBucket>>()
+                .unwrap();
+
+            let Some(i) = buckets.iter().position(|b| &b.key == &time_bucket) else {
+                return;
+            };
+            let mut bucket = buckets.row_data(i).expect("i is in the list");
+            bucket.previews = ModelRc::new(
+                api_bucket
+                    .entries
+                    .iter()
+                    .map(|entry| ui::ImagePreview {
+                        asset_id: entry.id.to_shared_string(), // slint doesn't have a uuid type
+                        kind: ui::PreviewKind::Thumbhash,
+                        // TODO: don't unwrap
+                        image: entry
+                            .thumbhash
+                            .clone()
+                            .map(slint::Image::from_rgba8)
+                            .unwrap(),
+                    })
+                    .collect::<VecModel<_>>(),
+            );
+            buckets.set_row_data(i, bucket);
+
+            for entry in api_bucket.entries.iter() {
+                load_thumbnail(time_bucket.clone(), entry.id, app.as_weak(), api.clone());
+            }
+        });
+    });
+}
+
+fn load_thumbnail(
+    time_bucket: TimeBucketKey,
+    id: AssetId,
+    app_weak: Weak<AppWindow>,
+    api: ActorRef<Api>,
+) {
+    tokio::spawn(async move {
+        tracing::debug!("Fetching thumbnail for {id}");
+        let thumbnail = match api.ask(GetAssetThumbnail { id }).await {
+            Ok(thumbnail) => thumbnail,
+            Err(e) => {
+                tracing::error!("{e:?}");
+                return;
+            }
+        };
+
+        let _ = app_weak.upgrade_in_event_loop(move |app| {
+            let global = app.global::<ui::Global>();
+
+            let buckets = global.get_image_buckets();
+            let buckets = buckets
+                .as_any()
+                .downcast_ref::<VecModel<ui::ImageBucket>>()
+                .unwrap();
+
+            let Some(i) = buckets.iter().position(|b| &b.key == &time_bucket) else {
+                return;
+            };
+            let bucket = buckets.row_data(i).expect("i is in the list");
+
+            let id_str = id.to_string();
+            let Some(i) = bucket.previews.iter().position(|p| &p.asset_id == &id_str) else {
+                return;
+            };
+            let mut preview = bucket.previews.row_data(i).expect("i is in the list");
+            preview.image = slint::Image::from_rgba8(thumbnail.thumbnail.clone());
+            preview.kind = ui::PreviewKind::Thumbnail;
+            bucket.previews.set_row_data(i, preview);
+        });
+    });
+}