fix: clamp negative playtime (#6519)

* fix: clamp negative playtime

* fix: remove triggers use instant

packages/app-lib/src/state/instances/adapters/sqlite/instance_rows.rs

@@ -3,7 +3,7 @@
 use crate::state::instances::{
     ContentSet, ContentSetStatus, ContentSourceKind, Instance,
     InstanceLaunchContext, InstanceLaunchOverrides,
-    InstanceLaunchOverridesData, InstanceLink,
+    InstanceLaunchOverridesData, InstanceLink, playtime_to_storage,
 };
 use crate::state::{
     InstanceInstallStage, LauncherFeatureVersion, ModLoader, ReleaseChannel,
@@ -831,8 +831,12 @@ pub(crate) async fn insert_instance(
     let created = instance.created.timestamp();
     let modified = instance.modified.timestamp();
     let last_played = instance.last_played.map(|value| value.timestamp());
-    let submitted_time_played = instance.submitted_time_played as i64;
-    let recent_time_played = instance.recent_time_played as i64;
+    let submitted_time_played = playtime_to_storage(
+        instance.submitted_time_played,
+        "submitted_time_played",
+    )?;
+    let recent_time_played =
+        playtime_to_storage(instance.recent_time_played, "recent_time_played")?;
 
     sqlx::query!(
         "
@@ -887,8 +891,12 @@ pub(crate) async fn update_instance(
     let icon_path = instance.icon_path.as_deref();
     let modified = instance.modified.timestamp();
     let last_played = instance.last_played.map(|value| value.timestamp());
-    let submitted_time_played = instance.submitted_time_played as i64;
-    let recent_time_played = instance.recent_time_played as i64;
+    let submitted_time_played = playtime_to_storage(
+        instance.submitted_time_played,
+        "submitted_time_played",
+    )?;
+    let recent_time_played =
+        playtime_to_storage(instance.recent_time_played, "recent_time_played")?;
 
     sqlx::query!(
         "

packages/app-lib/src/state/instances/commands/launch_context.rs

@@ -1,6 +1,6 @@
 use crate::state::InstanceInstallStage;
 use crate::state::instances::{
-    InstanceLaunchContext, adapters::sqlite::instance_rows,
+    InstanceLaunchContext, adapters::sqlite::instance_rows, playtime_to_storage,
 };
 use chrono::{DateTime, Utc};
 use sqlx::SqlitePool;
@@ -120,16 +120,31 @@ pub(crate) async fn add_instance_recent_playtime(
     seconds: u64,
     pool: &SqlitePool,
 ) -> crate::Result<()> {
-    let seconds = seconds as i64;
+    if seconds == 0 {
+        return Ok(());
+    }
+
+    let seconds = playtime_to_storage(seconds, "recent_time_played")?;
+    let max_playtime = i64::MAX;
+    let max_playtime_before_increment = max_playtime - seconds;
     let modified = Utc::now().timestamp();
 
     sqlx::query!(
         "
 		UPDATE instances
-		SET recent_time_played = recent_time_played + ?, modified = ?
+		SET
+			recent_time_played = CASE
+				WHEN recent_time_played < 0 THEN ?
+				WHEN recent_time_played > ? THEN ?
+				ELSE recent_time_played + ?
+			END,
+			modified = ?
 		WHERE id = ?
 		",
         seconds,
+        max_playtime_before_increment,
+        max_playtime,
+        seconds,
         modified,
         instance_id,
     )
@@ -144,19 +159,33 @@ pub(crate) async fn mark_instance_playtime_submitted(
     recent_time_played: u64,
     pool: &SqlitePool,
 ) -> crate::Result<()> {
-    let recent_time_played = recent_time_played as i64;
+    if recent_time_played == 0 {
+        return Ok(());
+    }
+
+    let recent_time_played =
+        playtime_to_storage(recent_time_played, "recent_time_played")?;
+    let max_playtime = i64::MAX;
+    let max_playtime_before_increment = max_playtime - recent_time_played;
     let modified = Utc::now().timestamp();
 
     sqlx::query!(
         "
 		UPDATE instances
 		SET
-			submitted_time_played = submitted_time_played + ?,
+			submitted_time_played = CASE
+				WHEN submitted_time_played < 0 THEN ?
+				WHEN submitted_time_played > ? THEN ?
+				ELSE submitted_time_played + ?
+			END,
 			recent_time_played = 0,
 			modified = ?
 		WHERE id = ?
 		",
         recent_time_played,
+        max_playtime_before_increment,
+        max_playtime,
+        recent_time_played,
         modified,
         instance_id,
     )

packages/app-lib/src/state/instances/model/instance.rs

@@ -20,3 +20,15 @@ pub struct Instance {
     pub submitted_time_played: u64,
     pub recent_time_played: u64,
 }
+
+pub(crate) fn playtime_to_storage(
+    value: u64,
+    column: &str,
+) -> crate::Result<i64> {
+    i64::try_from(value).map_err(|_| {
+        crate::ErrorKind::InputError(format!(
+            "Expected {column} to fit in SQLite INTEGER"
+        ))
+        .into()
+    })
+}

packages/app-lib/src/state/legacy_converter.rs

@@ -3,7 +3,7 @@ use crate::jre::check_jre;
 use crate::prelude::ModLoader;
 use crate::state;
 use crate::state::instances::{
-    InstanceLaunchOverrides, InstanceLaunchOverridesData,
+    InstanceLaunchOverrides, InstanceLaunchOverridesData, playtime_to_storage,
 };
 use crate::state::{
     CacheValue, CachedEntry, CachedFile, CachedFileHash, CachedFileUpdate,
@@ -443,8 +443,12 @@ where
     let created = input.created.timestamp();
     let modified = input.modified.timestamp();
     let last_played = input.last_played.map(|value| value.timestamp());
-    let submitted_time_played = input.submitted_time_played as i64;
-    let recent_time_played = input.recent_time_played as i64;
+    let submitted_time_played = playtime_to_storage(
+        input.submitted_time_played,
+        "submitted_time_played",
+    )?;
+    let recent_time_played =
+        playtime_to_storage(input.recent_time_played, "recent_time_played")?;
 
     sqlx::query!(
         "

packages/app-lib/src/state/process.rs

@@ -17,6 +17,7 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
 use std::sync::LazyLock;
+use std::time::Instant;
 #[cfg(feature = "tauri")]
 use tauri::Emitter;
 use tempfile::TempDir;
@@ -752,46 +753,46 @@ impl Process {
         uuid: Uuid,
     ) -> crate::Result<()> {
         async fn update_playtime(
-            last_updated_playtime: &mut DateTime<Utc>,
+            last_updated_playtime: &mut Instant,
             instance_id: &str,
             force_update: bool,
         ) {
-            let diff = Utc::now()
-                .signed_duration_since(*last_updated_playtime)
-                .num_seconds();
-            if diff >= 60 || force_update {
-                let state = match crate::State::get().await {
-                    Ok(state) => state,
-                    Err(e) => {
-                        tracing::warn!(
-                            "Failed to get state for playtime update on instance {}: {}",
-                            instance_id,
-                            e
-                        );
-                        return;
-                    }
-                };
-                if let Err(e) =
-					crate::state::instances::commands::add_instance_recent_playtime(
-                        instance_id,
-                        diff as u64,
-                        &state.pool,
-                    )
-                    .await
-                {
+            let elapsed = last_updated_playtime.elapsed().as_secs();
+            if elapsed == 0 || (!force_update && elapsed < 60) {
+                return;
+            }
+
+            let state = match crate::State::get().await {
+                Ok(state) => state,
+                Err(e) => {
                     tracing::warn!(
-                        "Failed to update playtime for instance {}: {}",
+                        "Failed to get state for playtime update on instance {}: {}",
                         instance_id,
                         e
                     );
+                    return;
                 }
-                *last_updated_playtime = Utc::now();
+            };
+            if let Err(e) =
+                crate::state::instances::commands::add_instance_recent_playtime(
+                    instance_id,
+                    elapsed,
+                    &state.pool,
+                )
+                .await
+            {
+                tracing::warn!(
+                    "Failed to update playtime for instance {}: {}",
+                    instance_id,
+                    e
+                );
             }
+            *last_updated_playtime = Instant::now();
         }
 
         // Wait on current Minecraft Child
         let mc_exit_status;
-        let mut last_updated_playtime = Utc::now();
+        let mut last_updated_playtime = Instant::now();
 
         let state = crate::State::get().await?;
         loop {