Add directory related functions to AndroidAssetReader (#11495)

# 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<LoadedFolder>);

// 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<AssetServer>, mut commands: Commands) {
    let sounds = asset_server.load_folder("sounds");
    commands.insert_resource(FolderAssets(sounds));
}

fn setup_music(
    mut commands: Commands,
    folders: Res<Assets<LoadedFolder>>,
    mut loaded_event: EventReader<AssetEvent<LoadedFolder>>,
) {
    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::<AudioSource>(),
                        settings: PlaybackSettings::LOOP,
                    });
                }
            }
        }
    }
}
```

---------

Co-authored-by: Kanabenki <lucien.menassol@gmail.com>
Co-authored-by: François Mockers <francois.mockers@vleue.com>

crates/bevy_asset/src/io/android.rs

@@ -1,16 +1,15 @@
-use crate::io::{
+use crate::io::{get_meta_path, AssetReader, AssetReaderError, PathStream, Reader, VecReader};
-    get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader,
-};
-use alloc::ffi::CString;
 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.
+/// - All functions use the [`AssetManager`] to load files.
-/// - [`read_directory`](AssetIo::read_directory) always returns an empty iterator.
+/// - [`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<Box<PathStream>, AssetReaderError> {
-        let stream: Box<PathStream> = Box::new(EmptyPathStream);
+        let asset_manager = bevy_winit::ANDROID_APP
-        error!("Reading directories is not supported with the AndroidAssetReader");
+            .get()
-        Ok(stream)
+            .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)
     }
 
-    async fn is_directory<'a>(&'a self, _path: &'a Path) -> Result<bool, AssetReaderError> {
+    async fn is_directory<'a>(
-        error!("Reading directories is not supported with the AndroidAssetReader");
+        &'a self,
-        Ok(false)
+        path: &'a Path,
+    ) -> std::result::Result<bool, AssetReaderError> {
+        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())
     }
 }