spotlit 0.1.4

A cross-platform desktop wallpaper companion for Windows Spotlight and Bing wallpapers.
Documentation
use std::{cell::RefCell, collections::VecDeque};

use slint::Image;

const DISPLAY_PREVIEW_CACHE_LIMIT: usize = 2;
pub(crate) const LIST_THUMBNAIL_CACHE_LIMIT: usize = 24;

thread_local! {
    static DISPLAY_PREVIEWS: RefCell<ImageCache> =
        RefCell::new(ImageCache::new(DISPLAY_PREVIEW_CACHE_LIMIT));
    static LIST_THUMBNAILS: RefCell<ImageCache> =
        RefCell::new(ImageCache::new(LIST_THUMBNAIL_CACHE_LIMIT));
}

pub(crate) fn remember_display_preview(id: &str, preview_path: &str, image: &Image) {
    DISPLAY_PREVIEWS.with_borrow_mut(|cache| cache.remember(id, preview_path, image));
}

pub(crate) fn display_preview(id: &str, preview_path: &str) -> Option<Image> {
    DISPLAY_PREVIEWS.with_borrow_mut(|cache| cache.get(id, preview_path))
}

pub(crate) fn remember_list_thumbnail(id: &str, preview_path: &str, image: &Image) {
    LIST_THUMBNAILS.with_borrow_mut(|cache| cache.remember(id, preview_path, image));
}

pub(crate) fn list_thumbnail(id: &str, preview_path: &str) -> Option<Image> {
    LIST_THUMBNAILS.with_borrow_mut(|cache| cache.get(id, preview_path))
}

pub(crate) fn list_thumbnail_by_path(preview_path: &str) -> Option<Image> {
    LIST_THUMBNAILS.with_borrow_mut(|cache| cache.get_by_preview_path(preview_path))
}

pub(crate) fn release_decoded_images() {
    DISPLAY_PREVIEWS.with_borrow_mut(ImageCache::clear);
    LIST_THUMBNAILS.with_borrow_mut(ImageCache::clear);
}

struct ImageCache {
    limit: usize,
    images: VecDeque<CachedImage>,
}

impl ImageCache {
    fn new(limit: usize) -> Self {
        Self {
            limit,
            images: VecDeque::new(),
        }
    }

    fn remember(&mut self, id: &str, preview_path: &str, image: &Image) {
        if id.is_empty() || preview_path.is_empty() || !image_has_pixels(image) || self.limit == 0 {
            return;
        }

        self.remove(id, preview_path);
        self.images.push_back(CachedImage {
            id: id.to_string(),
            preview_path: preview_path.to_string(),
            image: image.clone(),
        });

        while self.images.len() > self.limit {
            self.images.pop_front();
        }
    }

    fn get(&mut self, id: &str, preview_path: &str) -> Option<Image> {
        let position = self
            .images
            .iter()
            .position(|image| image.id == id && image.preview_path == preview_path)?;
        let image = self.images.remove(position)?;
        let result = image.image.clone();
        self.images.push_back(image);
        Some(result)
    }

    fn get_by_preview_path(&mut self, preview_path: &str) -> Option<Image> {
        if preview_path.is_empty() {
            return None;
        }

        let position = self
            .images
            .iter()
            .position(|image| image.preview_path == preview_path)?;
        let image = self.images.remove(position)?;
        let result = image.image.clone();
        self.images.push_back(image);
        Some(result)
    }

    fn remove(&mut self, id: &str, preview_path: &str) {
        if let Some(position) = self
            .images
            .iter()
            .position(|image| image.id == id && image.preview_path == preview_path)
        {
            self.images.remove(position);
        }
    }

    fn clear(&mut self) {
        self.images.clear();
    }
}

struct CachedImage {
    id: String,
    preview_path: String,
    image: Image,
}

fn image_has_pixels(image: &Image) -> bool {
    let size = image.size();
    size.width > 0 && size.height > 0
}

#[cfg(test)]
mod tests {
    use slint::{Image, Rgba8Pixel, SharedPixelBuffer};

    use super::{ImageCache, release_decoded_images};

    #[test]
    fn cache_returns_images_by_id_and_preview_path() {
        let mut cache = ImageCache::new(2);
        let image = test_image();

        cache.remember("first", "first.jpg", &image);

        assert!(cache.get("first", "first.jpg").is_some());
        assert!(cache.get("first", "other.jpg").is_none());
        assert!(cache.get("other", "first.jpg").is_none());
    }

    #[test]
    fn cache_evicts_least_recently_used_image() {
        let mut cache = ImageCache::new(2);
        let image = test_image();

        cache.remember("first", "first.jpg", &image);
        cache.remember("second", "second.jpg", &image);
        assert!(cache.get("first", "first.jpg").is_some());
        cache.remember("third", "third.jpg", &image);

        assert!(cache.get("first", "first.jpg").is_some());
        assert!(cache.get("second", "second.jpg").is_none());
        assert!(cache.get("third", "third.jpg").is_some());
    }

    #[test]
    fn cache_can_reuse_image_by_preview_path() {
        let mut cache = ImageCache::new(2);
        let image = test_image();

        cache.remember("first-id", "shared.jpg", &image);

        assert!(cache.get_by_preview_path("shared.jpg").is_some());
        assert!(cache.get_by_preview_path("missing.jpg").is_none());
    }

    #[test]
    fn cache_can_be_cleared() {
        let mut cache = ImageCache::new(2);
        let image = test_image();

        cache.remember("first", "first.jpg", &image);
        cache.clear();

        assert!(cache.get("first", "first.jpg").is_none());
    }

    #[test]
    fn decoded_image_release_clears_thread_local_caches() {
        let image = test_image();

        super::remember_display_preview("display", "display.jpg", &image);
        super::remember_list_thumbnail("thumb", "thumb.jpg", &image);

        release_decoded_images();

        assert!(super::display_preview("display", "display.jpg").is_none());
        assert!(super::list_thumbnail("thumb", "thumb.jpg").is_none());
    }

    fn test_image() -> Image {
        let mut buffer = SharedPixelBuffer::<Rgba8Pixel>::new(1, 1);
        buffer
            .make_mut_bytes()
            .copy_from_slice(&[255, 255, 255, 255]);
        Image::from_rgba8(buffer)
    }
}