android.rs

use crate::io::{get_meta_path, AssetReader, AssetReaderError, PathStream, Reader, VecReader};
use bevy_utils::BoxedFuture;
use futures_lite::stream;
use std::{ffi::CString, path::Path};

/// [`AssetReader`] implementation for Android devices, built on top of Android's [`AssetManager`].
///
/// Implementation details:
///
/// - All functions use the [`AssetManager`] to load files.
/// - [`is_directory`](AssetReader::is_directory) tris to open the path
/// as a normal file and treats error as if the path is directory.
/// - Watching for changes is not supported. The watcher method will do nothing.
///
/// [AssetManager]: https://developer.android.com/reference/android/content/res/AssetManager
pub struct AndroidAssetReader;

impl AssetReader for AndroidAssetReader {
    fn read<'a>(
        &'a self,
        path: &'a Path,
    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
        Box::pin(async move {
            let asset_manager = bevy_winit::ANDROID_APP
                .get()
                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
                .asset_manager();
            let mut opened_asset = asset_manager
                .open(&CString::new(path.to_str().unwrap()).unwrap())
                .ok_or(AssetReaderError::NotFound(path.to_path_buf()))?;
            let bytes = opened_asset.buffer()?;
            let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
            Ok(reader)
        })
    }

    fn read_meta<'a>(
        &'a self,
        path: &'a Path,
    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
        Box::pin(async move {
            let meta_path = get_meta_path(path);
            let asset_manager = bevy_winit::ANDROID_APP
                .get()
                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
                .asset_manager();
            let mut opened_asset = asset_manager
                .open(&CString::new(meta_path.to_str().unwrap()).unwrap())
                .ok_or(AssetReaderError::NotFound(meta_path))?;
            let bytes = opened_asset.buffer()?;
            let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
            Ok(reader)
        })
    }

    fn read_directory<'a>(
        &'a self,
        path: &'a Path,
    ) -> BoxedFuture<'a, Result<Box<PathStream>, AssetReaderError>> {
        Box::pin(async move {
            let asset_manager = bevy_winit::ANDROID_APP
                .get()
                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
                .asset_manager();
            let opened_assets_dir = asset_manager
                .open_dir(&CString::new(path.to_str().unwrap()).unwrap())
                .ok_or(AssetReaderError::NotFound(path.to_path_buf()))?;

            let mapped_stream = opened_assets_dir
                .filter_map(move |f| {
                    let file_path = path.join(Path::new(f.to_str().unwrap()));
                    // filter out meta files as they are not considered assets
                    if let Some(ext) = file_path.extension().and_then(|e| e.to_str()) {
                        if ext.eq_ignore_ascii_case("meta") {
                            return None;
                        }
                    }
                    Some(file_path.to_owned())
                })
                .collect::<Vec<_>>();

            let read_dir: Box<PathStream> = Box::new(stream::iter(mapped_stream));
            Ok(read_dir)
        })
    }

    fn is_directory<'a>(
        &'a self,
        path: &'a Path,
    ) -> BoxedFuture<'a, std::result::Result<bool, AssetReaderError>> {
        Box::pin(async move {
            let asset_manager = bevy_winit::ANDROID_APP
                .get()
                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
                .asset_manager();
            Ok(asset_manager
                .open(&CString::new(path.to_str().unwrap()).unwrap())
                .map_or(true, |_| false))
        })
    }
}