Improve `download_progress` example

- Use `reqwest` with `Response::chunk` to notify progress.
- Turn example state into an enum

1 files changed, 46 insertions, 51 deletions

diff --git a/examples/download_progress/src/downloader.rs b/examples/download_progress/src/downloader.rs
index 62f943fd..3b54341e 100644
--- a/examples/download_progress/src/downloader.rs
+++ b/examples/download_progress/src/downloader.rs
@@ -1,7 +1,7 @@
 use iced_futures::futures;
 
 // Just a little utility function
-pub fn file<T: ToString>(url: T) -> iced::Subscription<DownloadMessage> {
+pub fn file<T: ToString>(url: T) -> iced::Subscription<Progress> {
     iced::Subscription::from_recipe(Downloader {
         url: url.to_string(),
     })
@@ -16,7 +16,7 @@ impl<H, I> iced_native::subscription::Recipe<H, I> for Downloader
 where
     H: std::hash::Hasher,
 {
-    type Output = DownloadMessage;
+    type Output = Progress;
 
     fn hash(&self, state: &mut H) {
         use std::hash::Hash;
@@ -27,73 +27,68 @@ where
         self: Box<Self>,
         _input: futures::stream::BoxStream<'static, I>,
     ) -> futures::stream::BoxStream<'static, Self::Output> {
-        use isahc::prelude::*;
-
         Box::pin(futures::stream::unfold(
-            DownloadState::Ready(self.url),
+            State::Ready(self.url),
             |state| async move {
                 match state {
-                    DownloadState::Ready(url) => {
-                        let resp = Request::get(&url)
-                            .metrics(true)
-                            .body(())
-                            .unwrap()
-                            .send_async()
-                            .await
-                            .unwrap();
-                        let metrics = resp.metrics().unwrap().clone();
-                        // If you actually want to download:
-                        /*let file = async_std::fs::File::create("download.bin")
-                        .await
-                        .unwrap();*/
-
-                        async_std::task::spawn(async_std::io::copy(
-                            resp.into_body(),
-                            async_std::io::sink(), //file
-                        ));
+                    State::Ready(url) => {
+                        let response = reqwest::get(&url).await;
 
-                        Some((
-                            DownloadMessage::DownloadStarted,
-                            DownloadState::Downloading(metrics),
-                        ))
+                        match response {
+                            Ok(response) => Some((
+                                Progress::Started,
+                                State::Downloading {
+                                    total: response.content_length().unwrap(),
+                                    downloaded: 0,
+                                    response,
+                                },
+                            )),
+                            Err(_) => None,
+                        }
                     }
-                    DownloadState::Downloading(metrics) => {
-                        async_std::task::sleep(
-                            std::time::Duration::from_millis(100),
-                        )
-                        .await;
+                    State::Downloading {
+                        mut response,
+                        total,
+                        downloaded,
+                    } => match response.chunk().await {
+                        Ok(Some(chunk)) => {
+                            let downloaded = downloaded + chunk.len() as u64;
 
-                        let percentage = metrics.download_progress().0 * 100
-                            / metrics.download_progress().1;
+                            let percentage =
+                                (downloaded as f32 / total as f32) * 100.0;
 
-                        if percentage == 100 {
                             Some((
-                                DownloadMessage::Done,
-                                DownloadState::Finished,
-                            ))
-                        } else {
-                            Some((
-                                DownloadMessage::Downloading(percentage),
-                                DownloadState::Downloading(metrics),
+                                Progress::Advanced(percentage),
+                                State::Downloading {
+                                    response,
+                                    total,
+                                    downloaded,
+                                },
                             ))
                         }
-                    }
-                    DownloadState::Finished => None,
+                        Ok(None) => Some((Progress::Finished, State::Finished)),
+                        Err(_) => None,
+                    },
+                    State::Finished => None,
                 }
             },
         ))
     }
 }
 
-#[derive(Debug)]
-pub enum DownloadMessage {
-    DownloadStarted,
-    Downloading(u64),
-    Done,
+#[derive(Debug, Clone)]
+pub enum Progress {
+    Started,
+    Advanced(f32),
+    Finished,
 }
 
-pub enum DownloadState {
+pub enum State {
     Ready(String),
-    Downloading(isahc::Metrics),
+    Downloading {
+        response: reqwest::Response,
+        total: u64,
+        downloaded: u64,
+    },
     Finished,
 }