fix: keep settings across reinstalls and put a setup on its build's channel

A fresh nightly install stayed on the stable update channel, the default
of the settings, and so never updated again until a stable release passed
its version. A reinstall did not help either: Velopack's setup replaces
the whole install folder, and the cfg folder with the settings lived in
it.

The nightly workflow now passes -p:UpdateChannel=Nightly, which the app
carries as a compile constant. The first launch after a setup, which
Velopack signals through its first run hook, puts the update channel on
the channel of the installed build. Updates do not run this, so a channel
picked in the settings survives them.

Installed builds keep cfg (settings, logs, detections, the webview
profile) in the roaming AppData folder instead of the install folder and
move an existing cfg there once. Development builds keep using the cfg
folder next to their output.

libobs is also pointed at its data and module folders by full path. The
relative paths only worked when the working directory was the app folder,
which is the case for the shortcuts but not for any other way of starting
it.

Author: lulzsun

.github/workflows/dotnet.yml

@@ -117,7 +117,7 @@ jobs:
       - name: Build RePlays
         env:
           CI: false
-        run: dotnet publish /p:Configuration=Release /p:Version=${{needs.prep.outputs.version}} /p:PublishProfile=FolderProfile -v d
+        run: dotnet publish /p:Configuration=Release /p:Version=${{needs.prep.outputs.version}} /p:UpdateChannel=Nightly /p:PublishProfile=FolderProfile -v d
 
       - name: Append version to setup file
         run: ren ./bin/Deployment/Releases/RePlays-win-Setup.exe RePlaysSetup-${{needs.prep.outputs.version}}.exe

Classes/Program.cs

@@ -73,6 +73,7 @@ static void Main(string[] args) {
             // there the migration done by "Update.exe start" (see Updater.Restart) takes care of it
             VelopackApp.Build()
                 .SetLogger(new VelopackLogger())
+                .OnFirstRun(_ => Updater.firstRunAfterSetup = true)
                 .SetAutoApplyOnStartup(!Updater.IsSquirrelLayout())
                 .Run();
 
@@ -114,6 +115,7 @@ static void Main(string[] args) {
             }
 #endif
             SettingsService.LoadSettings();
+            Updater.ApplyBuildChannel();
             SettingsService.UpdateGpuManufacturer();
             SettingsService.SaveSettings();
             StorageService.ManageStorage();

Classes/Recorders/LibObsRecorder.cs

@@ -201,8 +201,11 @@ public override void Start() {
             if (!obs_startup("en-US", null, IntPtr.Zero)) {
                 throw new Exception("error on libobs startup");
             }
-            obs_add_data_path("./data/libobs/");
-            obs_add_module_path("./obs-plugins/64bit/", "./data/obs-plugins/%module%/");
+            // full paths: libobs resolves relative ones against the working directory, which is
+            // only the app folder when RePlays is started through one of its shortcuts
+            var appDir = AppContext.BaseDirectory.Replace(Path.DirectorySeparatorChar, '/').TrimEnd('/');
+            obs_add_data_path(appDir + "/data/libobs/");
+            obs_add_module_path(appDir + "/obs-plugins/64bit/", appDir + "/data/obs-plugins/%module%/");
 
             ResetAudio();
             ResetVideo();

Classes/Utils/Helpers.cs

@@ -114,11 +114,53 @@ public static string GetTempFolder() {
             return tempSaveDir;
         }
 
+        static string cfgFolder;
+        static readonly object cfgFolderLock = new();
+
+        // settings, logs, detections and the webview profile. they used to live in the install
+        // folder (cfg next to the current version), which velopack's setup wipes when it installs
+        // over an existing install. an installed RePlays keeps them in the roaming AppData folder
+        // (AppData/Roaming/RePlays) instead and moves what it finds in the old place there once.
+        // a development build is not installed and keeps using the cfg folder next to its output
         public static string GetCfgFolder() {
-            var cfgDir = Path.Join(GetStartupPath(), @"../cfg/");
-            if (!Directory.Exists(cfgDir))
-                Directory.CreateDirectory(cfgDir);
-            return cfgDir;
+            lock (cfgFolderLock) {
+                if (cfgFolder != null) return cfgFolder;
+                var legacyDir = Path.GetFullPath(Path.Join(GetStartupPath(), @"../cfg/"));
+                var installed = File.Exists(Path.Join(GetStartupPath(), @"../Update.exe"));
+                if (!installed) {
+                    Directory.CreateDirectory(legacyDir);
+                    return cfgFolder = legacyDir;
+                }
+                var dir = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"RePlays/");
+                string moved = null;
+                if (!File.Exists(Path.Join(dir, "userSettings.json")) && File.Exists(Path.Join(legacyDir, "userSettings.json"))) {
+                    try {
+                        CopyDirectory(legacyDir, dir);
+                        moved = $"Moved the cfg folder from {legacyDir} to {dir}";
+                        try {
+                            Directory.Delete(legacyDir, true);
+                        }
+                        catch (Exception exception) {
+                            moved += $" (the old folder could not be removed: {exception.Message})";
+                        }
+                    }
+                    catch (Exception exception) {
+                        moved = $"Could not move the cfg folder from {legacyDir} to {dir}: {exception.Message}";
+                    }
+                }
+                Directory.CreateDirectory(dir);
+                cfgFolder = dir;
+                if (moved != null) Logger.WriteLine(moved);
+                return cfgFolder;
+            }
+        }
+
+        static void CopyDirectory(string source, string destination) {
+            Directory.CreateDirectory(destination);
+            foreach (var file in Directory.EnumerateFiles(source))
+                File.Copy(file, Path.Join(destination, Path.GetFileName(file)), true);
+            foreach (var directory in Directory.EnumerateDirectories(source))
+                CopyDirectory(directory, Path.Join(destination, Path.GetFileName(directory)));
         }
 
         public static string GetResourcesFolder() {

Classes/Utils/Updater.cs

@@ -14,6 +14,14 @@ internal sealed class Updater {
         public static string currentVersion = "?";
         public static string latestVersion = "Offline";
         public static bool applyingUpdate { get; internal set; }
+        // the release channel this build was made for (UpdateChannel property in RePlays.csproj)
+#if NIGHTLY
+        public const string BuildChannel = "Nightly";
+#else
+        public const string BuildChannel = "Stable";
+#endif
+        // set by the velopack first run hook: this launch is the first after a setup ran
+        public static bool firstRunAfterSetup;
         // the manager of the most recent update check, kept so a restart can install the update it downloaded
         static UpdateManager manager;
 
@@ -40,6 +48,20 @@ public static bool IsSquirrelLayout() {
             return folder.StartsWith("app-", StringComparison.OrdinalIgnoreCase);
         }
 
+        // running a setup is a deliberate choice of channel: a nightly setup installs a version
+        // that no stable release reaches for a long time, so left on the stable channel (the
+        // default of a fresh install, or whatever a reinstall finds in the settings) it would
+        // never update again. so the first launch after a setup puts the update channel on the
+        // channel of the installed build. updates do not run this, a channel picked in the
+        // settings survives them
+        public static void ApplyBuildChannel() {
+            if (!firstRunAfterSetup) return;
+            var settings = SettingsService.Settings.generalSettings;
+            if (settings.updateChannel == BuildChannel) return;
+            Logger.WriteLine($"First run after the setup of a {BuildChannel} build, switching the update channel from {settings.updateChannel} to {BuildChannel}");
+            settings.updateChannel = BuildChannel;
+        }
+
         public static async void CheckForUpdates(bool forceUpdate = false) {
             if (applyingUpdate) {
                 Logger.WriteLine($"Currently in the middle of applying an update. Cannot check for updates.");

RePlays.csproj

@@ -62,6 +62,14 @@
     <DefineConstants>TRACE;DEBUG</DefineConstants>
   </PropertyGroup>
 
+  <!-- the release channel this build is made for, Stable or Nightly. the nightly workflow
+       passes -p:UpdateChannel=Nightly. the first launch after a setup puts the app's update
+       channel on it (see Updater.ApplyBuildChannel) -->
+  <PropertyGroup>
+    <UpdateChannel Condition=" '$(UpdateChannel)' == '' ">Stable</UpdateChannel>
+    <DefineConstants Condition=" '$(UpdateChannel)' == 'Nightly' ">$(DefineConstants);NIGHTLY</DefineConstants>
+  </PropertyGroup>
+
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <DebugSymbols>false</DebugSymbols>
   </PropertyGroup>