added DXVK installation from GUI and made some refactor

babylonia_terminal_launcher/lib/models/dxvk.dart

@@ -0,0 +1,55 @@
+import 'package:fixnum/fixnum.dart';
+import 'package:flutter/material.dart';
+
+import './../messages/steps/dxvk.pb.dart';
+import './../providers/providers.dart';
+
+enum DXVKInstallationState {
+  idle,
+  downloading,
+  decompressing,
+}
+
+class DXVK with ChangeNotifier {
+  DXVKInstallationState protonState = DXVKInstallationState.idle;
+
+  Int64 currentProgress = Int64(0);
+  Int64 maxProgress = Int64(0);
+
+  Future startInstallation(
+      GameStateProvider gameStateProvider, String protonVersion) async {
+    notifyListeners();
+
+    StartDXVKInstallation(protonVersion: protonVersion).sendSignalToRust();
+    final progressStream = DXVKDownloadProgress.rustSignalStream;
+    await for (final rustSignal in progressStream) {
+      currentProgress = rustSignal.message.current;
+      maxProgress = rustSignal.message.max;
+
+      if (protonState == DXVKInstallationState.idle) {
+        protonState = DXVKInstallationState.downloading;
+      }
+
+      notifyListeners();
+
+      if (currentProgress >= maxProgress) {
+        break;
+      }
+    }
+
+    final notificationDecompressingStream =
+        NotifyDXVKStartDecompressing.rustSignalStream;
+    await for (final _ in notificationDecompressingStream) {
+      protonState = DXVKInstallationState.decompressing;
+      notifyListeners();
+      break;
+    }
+
+    final notificationInstalledStream =
+        NotifiyDXVKSuccessfullyInstalled.rustSignalStream;
+    await for (final _ in notificationInstalledStream) {
+      gameStateProvider.updateGameState();
+      break;
+    }
+  }
+}

babylonia_terminal_launcher/lib/models/github.dart

@@ -2,6 +2,8 @@ import 'package:babylonia_terminal_launcher/messages/github.pb.dart';
 
 class Github {
   static bool _isFetchingProtonVersions = false;
+  static bool _isFetchingDXVKVersions = false;
+
   static Future<List<String>> getProtonVersions() async {
     if (!_isFetchingProtonVersions) {
       _isFetchingProtonVersions = true;
@@ -15,4 +17,18 @@ class Github {
     }
     return [];
   }
+
+  static Future<List<String>> getDXVKVersions() async {
+    if (!_isFetchingDXVKVersions) {
+      _isFetchingDXVKVersions = true;
+      AskDXVKVersions().sendSignalToRust();
+      final stream = DXVKVersions.rustSignalStream;
+
+      await for (final rustSignal in stream) {
+        _isFetchingDXVKVersions = false;
+        return rustSignal.message.versions;
+      }
+    }
+    return [];
+  }
 }

babylonia_terminal_launcher/lib/models/proton.dart

@@ -1,6 +1,5 @@
 import 'package:fixnum/fixnum.dart';
 import 'package:flutter/material.dart';
-import 'package:provider/provider.dart';
 
 import './../messages/steps/proton.pb.dart';
 import './../providers/providers.dart';

babylonia_terminal_launcher/lib/screens/setups/steps_screen.dart

@@ -7,6 +7,7 @@ import './../../providers/providers.dart';
 import './../../widgets/selectable_yaru_expansion_panel.dart';
 import './../../widgets/simple_button.dart';
 import './../../widgets/steps/proton_steps_widget.dart';
+import './../../widgets/steps/dxvk_steps_widget.dart';
 
 class StepsScreen extends StatelessWidget {
   StepsScreen({super.key});
@@ -47,10 +48,7 @@ class StepsScreen extends StatelessWidget {
                 ],
                 children: const [
                   ProtonSteps(),
-                  Padding(
-                    padding: EdgeInsets.all(40.0),
-                    child: Text("DXVK"),
-                  ),
+                  DXVKSteps(),
                   Padding(
                     padding: EdgeInsets.all(40.0),
                     child: Text("Dependecies"),

babylonia_terminal_launcher/lib/widgets/steps/dxvk_steps_widget.dart

@@ -0,0 +1,156 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:yaru/widgets.dart';
+
+import './../../models/github.dart';
+import './../../models/dxvk.dart';
+import './../../widgets/simple_button.dart';
+import './../../providers/providers.dart';
+
+class DXVKSteps extends StatefulWidget {
+  const DXVKSteps({super.key});
+
+  @override
+  State<DXVKSteps> createState() => _DXVKStepsState();
+}
+
+class _DXVKStepsState extends State<DXVKSteps> {
+  final DXVK proton = DXVK();
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: const EdgeInsets.all(20.0),
+      child: ChangeNotifierProvider(
+        create: (_) => proton,
+        child: Builder(
+          builder: (context) {
+            switch (Provider.of<DXVK>(context).protonState) {
+              case DXVKInstallationState.idle:
+                return const InstallDXVK();
+              case DXVKInstallationState.downloading:
+                return const DXVKDownloadProgress();
+              case DXVKInstallationState.decompressing:
+                return const Row(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    Padding(
+                      padding: EdgeInsets.all(8.0),
+                      child: CircularProgressIndicator(),
+                    ),
+                    Text('Installing...'),
+                  ],
+                );
+            }
+          },
+        ),
+      ),
+    );
+  }
+}
+
+class InstallDXVK extends StatefulWidget {
+  const InstallDXVK({super.key});
+
+  @override
+  State<InstallDXVK> createState() => _InstallDXVKState();
+}
+
+class _InstallDXVKState extends State<InstallDXVK> {
+  bool hasLoaded = false;
+  bool isLoading = false;
+  late List<String> protonVersions;
+  String? selectedValue;
+  bool canInstall = true;
+
+  @override
+  void didChangeDependencies() async {
+    if (!hasLoaded) {
+      isLoading = true;
+      protonVersions = await Github.getDXVKVersions();
+      setState(() {
+        isLoading = false;
+        hasLoaded = true;
+      });
+    }
+
+    super.didChangeDependencies();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (hasLoaded && selectedValue == null) {
+      selectedValue = protonVersions.first;
+    }
+
+    return isLoading
+        ? const Row(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              Padding(
+                padding: EdgeInsets.all(8.0),
+                child: CircularProgressIndicator(),
+              ),
+              Text('Fetching versions...'),
+            ],
+          )
+        : Row(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              YaruPopupMenuButton(
+                initialValue: selectedValue,
+                itemBuilder: (_) => protonVersions
+                    .map(
+                      (e) => PopupMenuItem(
+                        value: e,
+                        child: Text(e),
+                      ),
+                    )
+                    .toList(),
+                onSelected: (v) => setState(() {
+                  selectedValue = v;
+                }),
+                child: Text(selectedValue!),
+              ),
+              Padding(
+                padding: const EdgeInsets.only(left: 8.0),
+                child: SimpleButton(
+                  onPressed: canInstall
+                      ? () {
+                          Provider.of<DXVK>(context, listen: false)
+                              .startInstallation(
+                                  Provider.of<GameStateProvider>(context,
+                                      listen: false),
+                                  selectedValue!);
+                          setState(() {
+                            canInstall = false;
+                          });
+                        }
+                      : null,
+                  child: const Text("Install"),
+                ),
+              ),
+            ],
+          );
+  }
+}
+
+class DXVKDownloadProgress extends StatelessWidget {
+  const DXVKDownloadProgress({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final provider = Provider.of<DXVK>(context);
+    final pourcent =
+        (provider.currentProgress.toInt() / provider.maxProgress.toInt()) * 100;
+
+    return Column(
+      children: [
+        Text("Downloaded: ${pourcent.toStringAsFixed(2)}%"),
+        YaruLinearProgressIndicator(
+          value: pourcent / 100,
+        ),
+      ],
+    );
+  }
+}

babylonia_terminal_launcher/lib/widgets/steps/proton_steps_widget.dart

@@ -61,6 +61,7 @@ class _InstallProtonState extends State<InstallProton> {
   bool isLoading = false;
   late List<String> protonVersions;
   String? selectedValue;
+  bool canInstall = true;
 
   @override
   void didChangeDependencies() async {
@@ -114,11 +115,18 @@ class _InstallProtonState extends State<InstallProton> {
               Padding(
                 padding: const EdgeInsets.only(left: 8.0),
                 child: SimpleButton(
-                  onPressed: () => Provider.of<Proton>(context, listen: false)
-                      .startInstallation(
-                          Provider.of<GameStateProvider>(context,
-                              listen: false),
-                          selectedValue!),
+                  onPressed: canInstall
+                      ? () {
+                          Provider.of<Proton>(context, listen: false)
+                              .startInstallation(
+                                  Provider.of<GameStateProvider>(context,
+                                      listen: false),
+                                  selectedValue!);
+                          setState(() {
+                            canInstall = false;
+                          });
+                        }
+                      : null,
                   child: const Text("Install"),
                 ),
               ),

babylonia_terminal_launcher/messages/github.proto

@@ -8,3 +8,11 @@ message AskProtonVersions {}
 message ProtonVersions {
     repeated string versions = 1;
 }
+
+// [RINF:DART-SIGNAL]
+message AskDXVKVersions {}
+
+// [RINF:RUST-SIGNAL]
+message DXVKVersions {
+    repeated string versions = 1;
+}

babylonia_terminal_launcher/messages/steps/dxvk.proto

@@ -0,0 +1,19 @@
+syntax = "proto3";
+package dxvk;
+
+// [RINF:RUST-SIGNAL]
+message DXVKDownloadProgress {
+    uint64 current = 1;
+    uint64 max = 2;
+}
+
+// [RINF:DART-SIGNAL]
+message StartDXVKInstallation {
+    string protonVersion = 1;
+};
+
+// [RINF:RUST-SIGNAL]
+message NotifyDXVKStartDecompressing {}
+
+// [RINF:RUST-SIGNAL]
+message NotifiyDXVKSuccessfullyInstalled {}

babylonia_terminal_launcher/native/hub/src/dxvk.rs

@@ -0,0 +1,127 @@
+use std::thread;
+
+use babylonia_terminal_sdk::{
+    components::{
+        dxvk_component::{DXVK_DEV, DXVK_REPO},
+        proton_component::ProtonComponent,
+    },
+    game_manager::GameManager,
+    game_state::GameState,
+    utils::github_requester::{GithubRelease, GithubRequester},
+};
+use tokio_with_wasm::tokio;
+
+use crate::{
+    github::GithubInfo,
+    messages::{
+        error::ReportError,
+        steps::dxvk::{
+            DxvkDownloadProgress, NotifiyDxvkSuccessfullyInstalled, NotifyDxvkStartDecompressing,
+            StartDxvkInstallation,
+        },
+    },
+};
+
+pub async fn listen_dxvk_installation() {
+    let mut receiver = StartDxvkInstallation::get_dart_signal_receiver();
+    while let Some(info) = receiver.recv().await {
+        let releases: Result<Vec<GithubRelease>, _> =
+            GithubInfo::get_github_releases(DXVK_DEV, DXVK_REPO).await;
+        if releases.is_err() {
+            ReportError {
+                error_message: format!("When fetching DXVK versions : {}", releases.unwrap_err()),
+            }
+            .send_signal_to_dart();
+            continue;
+        }
+
+        let checked_releases = releases.unwrap();
+        let release_index = checked_releases
+            .iter()
+            .position(|v| v.tag_name == info.message.proton_version);
+
+        if release_index.is_none() {
+            ReportError {
+                error_message: "Failed to find DXVK version".to_string(),
+            }
+            .send_signal_to_dart();
+            continue;
+        }
+
+        let proton_component = ProtonComponent::new(GameState::get_config().await.config_dir);
+        let proton = proton_component.init_proton();
+        if let Err(e) = proton {
+            ReportError {
+                error_message: format!("Failed to initialize DXVK : {}", e),
+            }
+            .send_signal_to_dart();
+            continue;
+        }
+
+        thread::spawn(move || {
+            tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(async {
+                    match GameManager::install_dxvk(
+                        &proton.unwrap(),
+                        GameState::get_config().await.config_dir,
+                        release_index.unwrap(),
+                        Some(DownloadReporter::create()),
+                    )
+                    .await
+                    {
+                        Err(e) => ReportError {
+                            error_message: format!("Failed to install DXVK : {}", e),
+                        }
+                        .send_signal_to_dart(),
+                        Ok(_) => NotifiyDxvkSuccessfullyInstalled {}.send_signal_to_dart(),
+                    }
+                });
+        });
+    }
+}
+
+struct DownloadReporterPrivate {
+    max_progress: Option<u64>,
+}
+
+struct DownloadReporter {
+    private: std::sync::Mutex<Option<DownloadReporterPrivate>>,
+}
+
+impl DownloadReporter {
+    pub fn create() -> std::sync::Arc<Self> {
+        std::sync::Arc::new(Self {
+            private: std::sync::Mutex::new(None),
+        })
+    }
+}
+
+impl downloader::progress::Reporter for DownloadReporter {
+    fn setup(&self, max_progress: Option<u64>, _: &str) {
+        let private = DownloadReporterPrivate { max_progress };
+
+        let mut guard = self.private.lock().unwrap();
+        *guard = Some(private);
+    }
+
+    fn progress(&self, current: u64) {
+        if let Some(p) = self.private.lock().unwrap().as_mut() {
+            DxvkDownloadProgress {
+                current,
+                max: p.max_progress.unwrap(),
+            }
+            .send_signal_to_dart();
+        }
+    }
+
+    fn set_message(&self, _: &str) {}
+
+    fn done(&self) {
+        NotifyDxvkStartDecompressing {}.send_signal_to_dart();
+        let mut guard = self.private.lock().unwrap();
+        *guard = None;
+    }
+}

babylonia_terminal_launcher/native/hub/src/github.rs

@@ -1,13 +1,14 @@
-use std::fmt::format;
-
 use babylonia_terminal_sdk::{
-    components::proton_component::{PROTON_DEV, PROTON_REPO},
+    components::{
+        dxvk_component::{DXVK_DEV, DXVK_REPO},
+        proton_component::{PROTON_DEV, PROTON_REPO},
+    },
     utils::github_requester::{GithubRelease, GithubRequester},
 };
 
 use crate::messages::{
     error::ReportError,
-    github::{AskProtonVersions, ProtonVersions},
+    github::{AskDxvkVersions, AskProtonVersions, DxvkVersions, ProtonVersions},
 };
 
 #[warn(dead_code)]
@@ -36,3 +37,21 @@ pub async fn listen_proton_version() {
         }
     }
 }
+
+pub async fn listen_dxvk_version() {
+    let mut receiver = AskDxvkVersions::get_dart_signal_receiver();
+    while let Some(_) = receiver.recv().await {
+        let releases: Result<Vec<GithubRelease>, _> =
+            GithubInfo::get_github_releases(DXVK_DEV, DXVK_REPO).await;
+        match releases {
+            Ok(r) => DxvkVersions {
+                versions: r.iter().map(|v| v.tag_name.to_owned()).collect(),
+            }
+            .send_signal_to_dart(),
+            Err(e) => ReportError {
+                error_message: format!("When fetching dxvk versions : {}", e),
+            }
+            .send_signal_to_dart(),
+        }
+    }
+}

babylonia_terminal_launcher/native/hub/src/lib.rs

@@ -1,13 +1,7 @@
-//! This `hub` crate is the
-//! entry point of the Rust logic.
-
-use proton::listen_proton_installation;
-// This `tokio` will be used by Rinf.
-// You can replace it with the original `tokio`
-// if you're not targeting the web.
 use tokio_with_wasm::tokio;
 
 mod config;
+mod dxvk;
 mod game_state;
 mod github;
 mod messages;
@@ -15,19 +9,16 @@ mod proton;
 
 rinf::write_interface!();
 
-// Always use non-blocking async functions
-// such as `tokio::fs::File::open`.
-// If you really need to use blocking code,
-// use `tokio::task::spawn_blocking`.
 async fn main() {
-    // Repeat `tokio::spawn` anywhere in your code
-    // if more concurrent tasks are needed.
-    //tokio::spawn(sample_functions::tell_numbers());
-    //tokio::spawn(sample_functions::stream_fractal());
-    //tokio::spawn(sample_functions::run_debug_tests());
+    //config
     tokio::spawn(game_state::listen_game_state());
     tokio::spawn(config::listen_config());
-    tokio::spawn(config::listen_config());
+
+    //github
     tokio::spawn(github::listen_proton_version());
+    tokio::spawn(github::listen_dxvk_version());
+
+    //installation
     tokio::spawn(proton::listen_proton_installation());
+    tokio::spawn(dxvk::listen_dxvk_installation());
 }

babylonia_terminal_launcher/native/hub/src/proton.rs

@@ -1,19 +1,16 @@
-use std::{future::Future, thread};
+use std::thread;
 
 use babylonia_terminal_sdk::{
     components::{
-        self,
         component_downloader::ComponentDownloader,
-        proton_component::{self, ProtonComponent, PROTON_DEV, PROTON_REPO},
+        proton_component::{ProtonComponent, PROTON_DEV, PROTON_REPO},
     },
+    game_manager::GameManager,
     game_state::GameState,
     utils::github_requester::{GithubRelease, GithubRequester},
 };
 use rinf::debug_print;
-use tokio_with_wasm::tokio::{
-    self,
-    task::{spawn_blocking, spawn_local},
-};
+use tokio_with_wasm::tokio;
 
 use crate::{
     github::GithubInfo,
@@ -52,49 +49,32 @@ pub async fn listen_proton_installation() {
             continue;
         }
 
-        let mut proton_component = ProtonComponent::new(GameState::get_config().await.config_dir);
-
-        proton_component.set_github_release_index(release_index.unwrap());
-
-        thread::spawn(|| {
+        thread::spawn(move || {
             tokio::runtime::Builder::new_current_thread()
                 .enable_all()
                 .build()
                 .unwrap()
                 .block_on(async {
-                    install_proton(proton_component).await;
+                    match GameManager::install_wine(
+                        GameState::get_config().await.config_dir,
+                        release_index.unwrap(),
+                        Some(DownloadReporter::create()),
+                    )
+                    .await
+                    {
+                        Err(e) => ReportError {
+                            error_message: format!("Failed to install Proton : {}", e),
+                        }
+                        .send_signal_to_dart(),
+                        Ok(_) => NotifiyProtonSuccessfullyInstalled {}.send_signal_to_dart(),
+                    }
                 });
         });
     }
 }
 
-pub async fn install_proton(component: ProtonComponent) {
-    debug_print!("starting !!!!");
-    match component.install(Some(DownloadReporter::create())).await {
-        Err(e) => ReportError {
-            error_message: format!("Failed to install Proton : {}", e),
-        }
-        .send_signal_to_dart(),
-        Ok(_) => {
-            let mut config = GameState::get_config().await;
-            config.is_wine_installed = true;
-            let result = GameState::save_config(config).await;
-            if let Err(e) = result {
-                ReportError {
-                    error_message: format!("Failed to update config : {}", e),
-                }
-                .send_signal_to_dart();
-            }
-
-            NotifiyProtonSuccessfullyInstalled {}.send_signal_to_dart()
-        }
-    }
-}
-
 struct DownloadReporterPrivate {
     max_progress: Option<u64>,
-    last_current: u64,
-    message: String,
 }
 
 struct DownloadReporter {
@@ -110,12 +90,8 @@ impl DownloadReporter {
 }
 
 impl downloader::progress::Reporter for DownloadReporter {
-    fn setup(&self, max_progress: Option<u64>, message: &str) {
-        let private = DownloadReporterPrivate {
-            max_progress,
-            last_current: 0,
-            message: message.to_owned(),
-        };
+    fn setup(&self, max_progress: Option<u64>, _: &str) {
+        let private = DownloadReporterPrivate { max_progress };
 
         let mut guard = self.private.lock().unwrap();
         *guard = Some(private);
@@ -124,7 +100,7 @@ impl downloader::progress::Reporter for DownloadReporter {
     fn progress(&self, current: u64) {
         if let Some(p) = self.private.lock().unwrap().as_mut() {
             ProtonDownloadProgress {
-                current: current,
+                current,
                 max: p.max_progress.unwrap(),
             }
             .send_signal_to_dart();