desktop: Add Steamworks API as an optional ExternalInterface

Author: evilpie

Cargo.lock

@@ -54,6 +54,8 @@ unicode-bidi = "0.3.18"
 fontconfig = { version = "0.10.0", optional = true, features = ["dlopen"]}
 memmap2.workspace = true
 
+steamworks = { version = "0.12.0", optional = true }
+
 [target.'cfg(target_os = "linux")'.dependencies]
 ashpd = "0.11.0"
 

desktop/Cargo.toml

@@ -1,10 +1,14 @@
 mod external_interface;
 mod fscommand;
 mod navigator;
+#[cfg(feature = "steamworks")]
+mod steamworks_external_interface;
 mod ui;
 
 pub use external_interface::DesktopExternalInterfaceProvider;
 pub use fscommand::DesktopFSCommandProvider;
 pub use navigator::DesktopNavigatorInterface;
 pub use navigator::PathAllowList;
+#[cfg(feature = "steamworks")]
+pub use steamworks_external_interface::SteamWorksExternalInterfaceProvider;
 pub use ui::DesktopUiBackend;

desktop/src/backends.rs

@@ -0,0 +1,104 @@
+use ruffle_core::context::UpdateContext;
+use ruffle_core::external::{ExternalInterfaceProvider, Value as ExternalValue};
+use std::cell::RefCell;
+use steamworks::{AppId, Client};
+
+#[derive(Default)]
+pub struct SteamWorksExternalInterfaceProvider {
+    pub client: RefCell<Option<Client>>,
+}
+
+impl ExternalInterfaceProvider for SteamWorksExternalInterfaceProvider {
+    fn call_method(
+        &self,
+        _context: &mut UpdateContext<'_>,
+        name: &str,
+        args: &[ExternalValue],
+    ) -> ExternalValue {
+        let Some(ref client) = *self.client.borrow() else {
+            if name == "steamworks.client.init" {
+                let client = if let [ExternalValue::Number(id)] = args {
+                    Client::init_app(AppId(*id as u32))
+                } else {
+                    Client::init()
+                };
+
+                match client {
+                    Ok(client) => {
+                        self.client.replace(Some(client));
+                    }
+                    Err(err) => tracing::warn!("Client::init failed: {err}"),
+                }
+            } else {
+                tracing::warn!(
+                    "Steamworks client not initialized! Expected call to steamworks.client.init."
+                );
+            }
+
+            return ExternalValue::Undefined;
+        };
+
+        // API is heavily inspired by https://github.com/ceifa/steamworks.js/
+
+        match name {
+            "steamworks.utils.getAppId" => ExternalValue::Number(client.utils().app_id().0 as f64),
+            "steamworks.utils.isSteamRunningOnSteamDeck" => {
+                ExternalValue::Bool(client.utils().is_steam_running_on_steam_deck())
+            }
+
+            "steamworks.localplayer.getSteamId" => {
+                ExternalValue::String(client.user().steam_id().steamid32())
+            }
+            "steamworks.localplayer.getName" => ExternalValue::String(client.friends().name()),
+            "steamworks.localplayer.getLevel" => {
+                ExternalValue::Number(client.user().level() as f64)
+            }
+            "steamworks.localplayer.getIpCountry" => {
+                ExternalValue::String(client.utils().ip_country())
+            }
+
+            "steamworks.achievement.activate" => {
+                let [ExternalValue::String(achievement)] = args else {
+                    tracing::warn!("steamworks.achievement.activate: Expected string argument");
+                    return ExternalValue::Undefined;
+                };
+
+                ExternalValue::Bool(
+                    client
+                        .user_stats()
+                        .achievement(&achievement)
+                        .set()
+                        .and_then(|_| client.user_stats().store_stats())
+                        .is_ok(),
+                )
+            }
+            "steamworks.achievement.isActivated" => {
+                let [ExternalValue::String(achievement)] = args else {
+                    tracing::warn!("steamworks.achievement.isActivated: Expected string argument");
+                    return ExternalValue::Undefined;
+                };
+
+                ExternalValue::Bool(
+                    client
+                        .user_stats()
+                        .achievement(&achievement)
+                        .get()
+                        .unwrap_or(false),
+                )
+            }
+
+            _ => {
+                tracing::warn!(
+                    "Trying to call unknown SteamWorksExternalInterfaceProvider method: {name}"
+                );
+                ExternalValue::Undefined
+            }
+        }
+    }
+
+    fn on_callback_available(&self, _name: &str) {}
+
+    fn get_id(&self) -> Option<String> {
+        None
+    }
+}

desktop/src/backends/steamworks_external_interface.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "steamworks")]
+use crate::backends::SteamWorksExternalInterfaceProvider;
 use crate::backends::{
     DesktopExternalInterfaceProvider, DesktopFSCommandProvider, DesktopNavigatorInterface,
     DesktopUiBackend,
@@ -284,6 +286,13 @@ impl ActivePlayer {
             builder = builder.with_external_interface(Box::new(DesktopExternalInterfaceProvider {
                 spoof_url: opt.player.spoof_url.clone(),
             }));
+        } else {
+            #[cfg(feature = "steamworks")]
+            {
+                builder = builder.with_external_interface(Box::new(
+                    SteamWorksExternalInterfaceProvider::default(),
+                ));
+            }
         }
 
         if !opt.gamepad_button_mapping.is_empty() {