Settings API for loader, preview branch select

backend/main.py

@@ -18,6 +18,7 @@ from injector import inject_to_tab, tab_has_global_var
 from loader import Loader
 from updater import Updater
 from utilities import Utilities
+from settings import SettingsManager
 
 # Ensure USER and GROUP vars are set first.
 # TODO: This isn't the best way to do this but supports the current
@@ -48,9 +49,6 @@ async def chown_plugin_dir(_):
     if code_chown != 0 or code_chmod != 0:
         logger.error(f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod: {code_chmod})")
 
-def remote_debugging_allowed():
-    return path.exists(HOMEBREW_PATH + "/allow_remote_debugging")
-
 class PluginManager:
     def __init__(self) -> None:
         self.loop = get_event_loop()
@@ -62,6 +60,7 @@ class PluginManager:
         })
         self.plugin_loader = Loader(self.web_app, CONFIG["plugin_path"], self.loop, CONFIG["live_reload"])
         self.plugin_browser = PluginBrowser(CONFIG["plugin_path"], self.web_app, self.plugin_loader.plugins)
+        self.settings = SettingsManager("loader", path.join(HOMEBREW_PATH, "settings"))
         self.utilities = Utilities(self)
         self.updater = Updater(self)
 
@@ -70,7 +69,7 @@ class PluginManager:
             self.web_app.on_startup.append(chown_plugin_dir)
         self.loop.create_task(self.loader_reinjector())
         self.loop.create_task(self.load_plugins())
-        if not remote_debugging_allowed():
+        if not self.settings.getSetting("cef_forward", False):
             self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
         self.loop.set_exception_handler(self.exception_handler)
         self.web_app.add_routes([get("/auth/token", self.get_auth_token)])

backend/settings.py

@@ -0,0 +1,38 @@
+from os import path, mkdir
+from json import load, dump
+
+class SettingsManager:
+    def __init__(self, name, settings_directory) -> None:
+        self.path = path.join(settings_directory, name + ".json")
+
+        if not path.exists(settings_directory):
+            mkdir(settings_directory)
+
+        self.settings = {}
+
+        try:
+            open(self.path, "x")
+        except FileExistsError as e:
+            self.read()
+            pass
+
+    def read(self):
+        try:
+            with open(self.path, "r") as file:
+                self.settings = load(file)
+        except Exception as e:
+            print(e)
+            pass
+
+    def commit(self):
+        with open(self.path, "w+") as file:
+            dump(self.settings, file, indent=4)
+
+    def getSetting(self, key, default):
+        if key in self.settings:
+            return self.settings[key]
+        return default
+
+    def setSetting(self, key, value):
+        self.settings[key] = value
+        self.commit()

backend/utilities.py

@@ -20,7 +20,8 @@ class Utilities:
             "remove_css_from_tab": self.remove_css_from_tab,
             "allow_remote_debugging": self.allow_remote_debugging,
             "disallow_remote_debugging": self.disallow_remote_debugging,
-            "remote_debugging_allowed": self.remote_debugging_allowed
+            "set_setting": self.set_setting,
+            "get_setting": self.get_setting
         }
 
         if context:
@@ -138,9 +139,11 @@ class Utilities:
                 "result": e
             }
 
+    async def get_setting(self, key, default):
+        return self.context.settings.getSetting(key, default)
 
-    async def remote_debugging_allowed(self):
+    async def set_setting(self, key, value):
-        return await helpers.is_systemd_unit_active(helpers.REMOTE_DEBUGGER_UNIT)
+        return self.context.settings.setSetting(key, value)
 
     async def allow_remote_debugging(self):
         await helpers.start_systemd_unit(helpers.REMOTE_DEBUGGER_UNIT)

frontend/src/components/settings/pages/general/BranchSelect.tsx

@@ -0,0 +1,33 @@
+import { Dropdown, Field } from 'decky-frontend-lib';
+import { FunctionComponent } from 'react';
+
+import { useSetting } from '../../../../utils/hooks/useSetting';
+
+enum UpdateBranch {
+  Stable,
+  Prerelease,
+  Nightly,
+}
+
+const BranchSelect: FunctionComponent<{}> = () => {
+  const [selectedBranch, setSelectedBranch] = useSetting<UpdateBranch>('branch', UpdateBranch.Prerelease);
+
+  return (
+    <Field label="Update Channel">
+      <Dropdown
+        rgOptions={Object.values(UpdateBranch)
+          .filter((branch) => typeof branch == 'string')
+          .map((branch) => ({
+            label: branch,
+            data: UpdateBranch[branch],
+          }))}
+        selectedOption={selectedBranch}
+        onChange={(newVal) => {
+          setSelectedBranch(newVal.data);
+        }}
+      />
+    </Field>
+  );
+};
+
+export default BranchSelect;

frontend/src/components/settings/pages/general/RemoteDebugging.tsx

@@ -1,15 +1,10 @@
 import { Field, Toggle } from 'decky-frontend-lib';
-import { useEffect, useState } from 'react';
 import { FaBug } from 'react-icons/fa';
 
+import { useSetting } from '../../../../utils/hooks/useSetting';
+
 export default function RemoteDebuggingSettings() {
-  const [allowRemoteDebugging, setAllowRemoteDebugging] = useState<boolean>(false);
+  const [allowRemoteDebugging, setAllowRemoteDebugging] = useSetting<boolean>('cef_forward', false);
-  useEffect(() => {
-    (async () => {
-      const res = (await window.DeckyPluginLoader.callServerMethod('remote_debugging_allowed')) as { result: boolean };
-      setAllowRemoteDebugging(res.result);
-    })();
-  }, []);
 
   return (
     <Field
@@ -22,7 +17,7 @@ export default function RemoteDebuggingSettings() {
       icon={<FaBug style={{ display: 'block' }} />}
     >
       <Toggle
-        value={allowRemoteDebugging}
+        value={allowRemoteDebugging || false}
         onChange={(toggleValue) => {
           setAllowRemoteDebugging(toggleValue);
           if (toggleValue) window.DeckyPluginLoader.callServerMethod('allow_remote_debugging');

frontend/src/components/settings/pages/general/Updater.tsx

@@ -6,9 +6,10 @@ import { VerInfo, callUpdaterMethod, finishUpdate } from '../../../../updater';
 import { useDeckyState } from '../../../DeckyState';
 
 export default function UpdaterSettings() {
+  const { isLoaderUpdating, setIsLoaderUpdating } = useDeckyState();
+
   const [versionInfo, setVersionInfo] = useState<VerInfo | null>(null);
   const [checkingForUpdates, setCheckingForUpdates] = useState<boolean>(false);
-  const { isLoaderUpdating, setIsLoaderUpdating } = useDeckyState();
   const [updateProgress, setUpdateProgress] = useState<number>(-1);
   const [reloading, setReloading] = useState<boolean>(false);
 

frontend/src/components/settings/pages/general/index.tsx

@@ -3,6 +3,7 @@ import { useState } from 'react';
 import { FaShapes } from 'react-icons/fa';
 
 import { installFromURL } from '../../../../store';
+import BranchSelect from './BranchSelect';
 import RemoteDebuggingSettings from './RemoteDebugging';
 import UpdaterSettings from './Updater';
 
@@ -21,6 +22,7 @@ export default function GeneralSettings() {
         />
       </Field> */}
       <UpdaterSettings />
+      <BranchSelect />
       <RemoteDebuggingSettings />
       <Field
         label="Manual plugin install"

frontend/src/utils/hooks/useSetting.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+
+interface GetSettingArgs<T> {
+  key: string;
+  default: T;
+}
+
+interface SetSettingArgs<T> {
+  key: string;
+  value: T;
+}
+
+export function useSetting<T>(key: string, def: T): [value: T | null, setValue: (value: T) => void] {
+  const [value, setValue] = useState(def);
+  const [ready, setReady] = useState<boolean>(false);
+
+  useEffect(() => {
+    (async () => {
+      const res = (await window.DeckyPluginLoader.callServerMethod('get_setting', {
+        key,
+        default: def,
+      } as GetSettingArgs<T>)) as { result: T };
+      setReady(true);
+      setValue(res.result);
+    })();
+  }, []);
+
+  useEffect(() => {
+    if (ready)
+      (async () => {
+        await window.DeckyPluginLoader.callServerMethod('set_setting', {
+          key,
+          value,
+        } as SetSettingArgs<T>);
+      })();
+  }, [value]);
+
+  return [value, setValue];
+}