Method export

src/storage.rs:138–351

(&self, path: &str)

    }

    pub async fn export(&self, path: &str) -> Result<(), String> {
        #[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
        {
            let full_path = self.resolve_path(path)?;
            let bytes = std::fs::read(&full_path).map_err(|e| e.to_string())?;

            let normalized_path = normalize_relative_path(path, "storage export path")?;
            let file_name = normalized_path
                .rsplit('/')
                .next()
                .filter(|s| !s.is_empty())
                .ok_or_else(|| "Invalid export file name".to_owned())?;

            let target_path = rfd::FileDialog::new()
                .set_file_name(file_name)
                .save_file()
                .ok_or_else(|| "Export canceled".to_owned())?;

            std::fs::write(target_path, bytes).map_err(|e| e.to_string())?;
            Ok(())
        }

        #[cfg(target_os = "android")]
        {
            let full_path = self.resolve_path(path)?;
            std::fs::metadata(&full_path).map_err(|e| e.to_string())?;

            let normalized_path = normalize_relative_path(path, "storage export path")?;
            let file_name = normalized_path
                .rsplit('/')
                .next()
                .filter(|s| !s.is_empty())
                .ok_or_else(|| "Invalid export file name".to_owned())?;

            let full_path_string = full_path.to_string_lossy().into_owned();
            let source_path_c =
                std::ffi::CString::new(full_path_string).map_err(|_| {
                    "Export path contains unsupported NUL byte".to_owned()
                })?;
            let file_name_c = std::ffi::CString::new(file_name).map_err(|_| {
                "Export file name contains unsupported NUL byte".to_owned()
            })?;
            let mime_type_c = std::ffi::CString::new(guess_mime_type(&normalized_path))
                .map_err(|_| "Export MIME type contains unsupported NUL byte".to_owned())?;

            unsafe {
                let env = macroquad::miniquad::native::android::attach_jni_env();
                let activity = macroquad::miniquad::native::android::ACTIVITY;
                if activity.is_null() {
                    return Err("Android activity is not available".to_owned());
                }

                let get_object_class = (**env).GetObjectClass.unwrap();
                let get_method_id = (**env).GetMethodID.unwrap();
                let call_void_method = (**env).CallVoidMethod.unwrap();
                let new_string_utf = (**env).NewStringUTF.unwrap();
                let delete_local_ref = (**env).DeleteLocalRef.unwrap();
                let exception_check = (**env).ExceptionCheck.unwrap();