From 956d9ccbb1e6b240f3e434acaab9ad544df41102 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ensar=20Saraj=C4=8Di=C4=87?= Date: Tue, 1 Oct 2024 14:23:24 +0200 Subject: [PATCH] Add directory related functions to `AndroidAssetReader` (#11495) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # Objective - Fixes #9968 ## Solution - Uses [open_dir](https://docs.rs/ndk/latest/ndk/asset/struct.AssetManager.html#method.open_dir) to read directories and collects child list, since it can't be shared across threads. - For `is_directory`, uses result of [open](https://docs.rs/ndk/latest/ndk/asset/struct.AssetManager.html#method.open), which will fail for directories. I tried using the result of `open_dir` for this, but it was successful for files too, which made loading folders return empty lists, since `open_dir` was successful and treated all files as empty directories. - Ignoring `meta` files was copied from filesystem implementation --- ## Changelog - Fixed: Android's AssetReader implementation now supports read_directory and is_directory. ## Notes I noticed late that there was the #9968 issue (I only noticed #9591), so I have also missed that a PR was already open (#9969). Feel free to copy over the fixes from this one over there. The only difference I notice between these 2, is that I have used `open` instead of `open_dir` for `is_directory` implementation. I have tried with `open_dir` too, but unfortunately that didn't work. I tested this on an actual device, using the mobile example, by making some minor changes: ```rust #[derive(Resource)] struct FolderAssets(Handle); // the `bevy_main` proc_macro generates the required boilerplate for iOS and Android #[bevy_main] fn main() { // ... .add_systems(Startup, (setup_scene, load_music_files)) .add_systems( Update, // Removed the handle_lifetime since AudioBundle is added later (touch_camera, button_handler, setup_music), ); // ... } fn load_music_files(asset_server: Res, mut commands: Commands) { let sounds = asset_server.load_folder("sounds"); commands.insert_resource(FolderAssets(sounds)); } fn setup_music( mut commands: Commands, folders: Res>, mut loaded_event: EventReader>, ) { for event in loaded_event.read() { if let AssetEvent::LoadedWithDependencies { id } = event { if let Some(folder) = folders.get(*id) { warn!("Folder items: {:?}", folder.handles); if let Some(source) = folder.handles.first() { commands.spawn(AudioBundle { source: source.clone().typed::(), settings: PlaybackSettings::LOOP, }); } } } } } ``` --------- Co-authored-by: Kanabenki Co-authored-by: François Mockers --- crates/bevy_asset/src/io/android.rs | 65 ++++++++++++++++++++++------- 1 file changed, 51 insertions(+), 14 deletions(-) diff --git a/crates/bevy_asset/src/io/android.rs b/crates/bevy_asset/src/io/android.rs index aa708f56ba724..c1f3a9b1a28fb 100644 --- a/crates/bevy_asset/src/io/android.rs +++ b/crates/bevy_asset/src/io/android.rs @@ -1,16 +1,15 @@ -use crate::io::{ - get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader, -}; -use alloc::ffi::CString; +use crate::io::{get_meta_path, AssetReader, AssetReaderError, PathStream, Reader, VecReader}; use bevy_utils::tracing::error; -use std::path::Path; +use futures_lite::stream; +use std::{ffi::CString, path::Path}; /// [`AssetReader`] implementation for Android devices, built on top of Android's [`AssetManager`]. /// /// Implementation details: /// -/// - [`load_path`](AssetIo::load_path) uses the [`AssetManager`] to load files. -/// - [`read_directory`](AssetIo::read_directory) always returns an empty iterator. +/// - All functions use the [`AssetManager`] to load files. +/// - [`is_directory`](AssetReader::is_directory) tries to open the path +/// as a normal file and treats an error as if the path is a directory. /// - Watching for changes is not supported. The watcher method will do nothing. /// /// [AssetManager]: https://developer.android.com/reference/android/content/res/AssetManager @@ -46,15 +45,53 @@ impl AssetReader for AndroidAssetReader { async fn read_directory<'a>( &'a self, - _path: &'a Path, + path: &'a Path, ) -> Result, AssetReaderError> { - let stream: Box = Box::new(EmptyPathStream); - error!("Reading directories is not supported with the AndroidAssetReader"); - Ok(stream) + 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::>(); + + let read_dir: Box = Box::new(stream::iter(mapped_stream)); + Ok(read_dir) } - async fn is_directory<'a>(&'a self, _path: &'a Path) -> Result { - error!("Reading directories is not supported with the AndroidAssetReader"); - Ok(false) + async fn is_directory<'a>( + &'a self, + path: &'a Path, + ) -> std::result::Result { + let asset_manager = bevy_winit::ANDROID_APP + .get() + .expect("Bevy must be setup with the #[bevy_main] macro on Android") + .asset_manager(); + // HACK: `AssetManager` does not provide a way to check if path + // points to a directory or a file + // `open_dir` succeeds for both files and directories and will only + // fail if the path does not exist at all + // `open` will fail for directories, but it will work for files + // The solution here was to first use `open_dir` to eliminate the case + // when the path does not exist at all, and then to use `open` to + // see if that path is a file or a directory + let cpath = CString::new(path.to_str().unwrap()).unwrap(); + let _ = asset_manager + .open_dir(&cpath) + .ok_or(AssetReaderError::NotFound(path.to_path_buf()))?; + Ok(asset_manager.open(&cpath).is_none()) } }