jiggler settings now persist

config.go

@@ -48,10 +48,9 @@ var defaultConfig = &Config{
 	DisplayDimAfterSec:   120,  // 2 minutes
 	DisplayOffAfterSec:   1800, // 30 minutes
 	JigglerConfig: &JigglerConfig{
-		ActiveAfterSeconds: 20,
+		InactivityLimitSeconds: 20,
-		JitterEnabled:      false,
+		JitterPercentage:       0.0,
-		JitterPercentage:   .25,
+		ScheduleCronTab:        "*/5 * * * * *",
-		ScheduleCronTab:    "*/5 * * * * *",
 	},
 	TLSMode: "",
 	UsbConfig: &usbgadget.Config{

jiggler.go

@@ -7,10 +7,9 @@ import (
 )
 
 type JigglerConfig struct {
-	ActiveAfterSeconds int     `json:"active_after_seconds"`
+	InactivityLimitSeconds float64 `json:"inactivity_limit_seconds"`
-	JitterEnabled      bool    `json:"jitter_enabled"`
+	JitterPercentage       float64 `json:"jitter_percentage"`
-	JitterPercentage   float64 `json:"jitter_percentage"`
+	ScheduleCronTab        string  `json:"schedule_cron_tab"`
-	ScheduleCronTab    string  `json:"schedule_cron_tab"`
 }
 
 var lastUserInput = time.Now()
@@ -94,13 +93,13 @@ func runJigglerCronTab() error {
 
 func runJiggler() {
 	if jigglerEnabled {
-		if config.JigglerConfig.JitterEnabled {
+		if config.JigglerConfig.JitterPercentage != 0 {
 			jitter := calculateJitterDuration(jobDelta)
 			logger.Infof("Jitter enabled, Sleeping for %v", jitter)
 			time.Sleep(jitter)
 		}
-		activeAfterSeconds := config.JigglerConfig.ActiveAfterSeconds
+		inactivitySeconds := config.JigglerConfig.InactivityLimitSeconds
-		if time.Since(lastUserInput) > time.Duration(activeAfterSeconds)*time.Second {
+		if time.Since(lastUserInput) > time.Duration(inactivitySeconds)*time.Second {
 			//TODO: change to rel mouse
 			err := rpcAbsMouseReport(1, 1, 0)
 			if err != nil {

jsonrpc.go

@@ -807,7 +807,7 @@ var rpcHandlers = map[string]RPCHandler{
 	"rpcMountBuiltInImage":   {Func: rpcMountBuiltInImage, Params: []string{"filename"}},
 	"setJigglerState":        {Func: rpcSetJigglerState, Params: []string{"enabled"}},
 	"getJigglerState":        {Func: rpcGetJigglerState},
-	"setJigglerConfig":       {Func: rpcSetJigglerConfig, Params: []string{"setJigglerConfig"}},
+	"setJigglerConfig":       {Func: rpcSetJigglerConfig, Params: []string{"jigglerConfig"}},
 	"getJigglerConfig":       {Func: rpcGetJigglerConfig},
 	"sendWOLMagicPacket":     {Func: rpcSendWOLMagicPacket, Params: []string{"macAddress"}},
 	"getStreamQualityFactor": {Func: rpcGetStreamQualityFactor},

ui/src/components/JigglerSetting.tsx

@@ -7,8 +7,7 @@ import { useJsonRpc } from "../hooks/useJsonRpc";
 import notifications from "../notifications";
 
 export interface JigglerConfig {
-  active_after_seconds: number;
+  inactivity_limit_seconds: number;
-  jitter_enabled: boolean;
   jitter_percentage: number;
   schedule_cron_tab: string;
 }
@@ -18,26 +17,25 @@ export function JigglerSetting() {
   const [loading, setLoading] = useState(false);
 
   const [jigglerConfigState, setJigglerConfigState] = useState<JigglerConfig>({
-    active_after_seconds: 0,
+    inactivity_limit_seconds: 20.0,
-    jitter_enabled: false,
+    jitter_percentage:        0.0,
-    jitter_percentage: 0.0,
+    schedule_cron_tab:        "*/20 * * * * *"
-    schedule_cron_tab: "*/20 * * * * *"
   });
 
-  useEffect(() => {
+  const syncJigglerConfig = useCallback(() => {
     send("getJigglerConfig", {}, resp => {
       if ("error" in resp) return;
       setJigglerConfigState(resp.result as JigglerConfig);
     });
   }, [send]);
 
-  // const handleJigglerActiveAfterSecondsChange = (value: number) => {
+  useEffect(() => {
-  //   setJigglerConfig({ ...jigglerConfig, active_after_seconds: value });
+    syncJigglerConfig()
-  // };
+  }, [send, syncJigglerConfig]);
-  //
+
-  // const handleJigglerJitterEnabledChange = (value: boolean) => {
+  const handleJigglerInactivityLimitSecondsChange = (value: string) => {
-  //   setJigglerConfig({ ...jigglerConfig, jitter_enabled: value });
+    setJigglerConfigState({ ...jigglerConfigState, inactivity_limit_seconds: Number(value) });
-  // };
+  };
   //
   // const handleJigglerJitterPercentageChange = (value: number) => {
   //   setJigglerConfig({ ...jigglerConfig, jitter_percentage: value });
@@ -48,24 +46,24 @@ export function JigglerSetting() {
   };
 
   const handleJigglerConfigChange = useCallback(
-      (jigglerConfig: JigglerConfig) => {
+    (jigglerConfig: JigglerConfig) => {
-        setLoading(true);
+      setLoading(true);
-        send("setJigglerConfig", { jigglerConfig }, async resp => {
+      send("setJigglerConfig", { jigglerConfig }, async resp => {
-          if ("error" in resp) {
+        if ("error" in resp) {
-            notifications.error(
+          notifications.error(
-                `Failed to set jiggler config: ${resp.error.data || "Unknown error"}`,
+              `Failed to set jiggler config: ${resp.error.data || "Unknown error"}`,
-            );
-            setLoading(false);
-            return;
-          }
-
-          setLoading(false);
-          notifications.success(
-              `Jiggler Config successfully updated`,
           );
-        });
+          setLoading(false);
-      },
+          return;
-      [send],
+        }
+        setLoading(false);
+        notifications.success(
+          `Jiggler Config successfully updated`,
+        );
+        syncJigglerConfig();
+      });
+    },
+    [send, syncJigglerConfig],
   );
 
   return (
@@ -74,10 +72,17 @@ export function JigglerSetting() {
         <InputFieldWithLabel
           required
           label="Jiggler Schedule"
-          placeholder="Enter Crontab"
+          placeholder="*/20 * * * * * (Every 20 seconds)"
-          defaultValue={jigglerConfigState?.schedule_cron_tab}
+          value={jigglerConfigState?.schedule_cron_tab}
           onChange={e => handleJigglerScheduleCronTabChange(e.target.value)}
         />
+        <InputFieldWithLabel
+          required
+          label="Inactivity Limit (Seconds)"
+          placeholder="20"
+          value={jigglerConfigState?.inactivity_limit_seconds}
+          onChange={e => handleJigglerInactivityLimitSecondsChange(e.target.value)}
+        />
       </div>
       <div className="mt-6 flex gap-x-2">
         <Button

ui/src/routes/devices.$id.settings.mouse.tsx

@@ -12,7 +12,8 @@ import { FeatureFlag } from "../components/FeatureFlag";
 import { SelectMenuBasic } from "../components/SelectMenuBasic";
 import { useFeatureFlag } from "../hooks/useFeatureFlag";
 import { SettingsItem } from "./devices.$id.settings";
-import {JigglerSetting} from "@components/JigglerSetting";
+import { JigglerSetting } from "@components/JigglerSetting";
+import { SettingsSectionHeader } from "@components/SettingsSectionHeader";
 
 type ScrollSensitivity = "low" | "default" | "high";
 
@@ -130,12 +131,16 @@ export default function SettingsKeyboardMouseRoute() {
             onChange={e => handleJigglerChange(e.target.checked)}
           />
         </SettingsItem>
-        <SettingsItem
+
-          title="Jiggler Settings"
+        {jiggler && (
-          description="Configure jiggler for advanced functionality"
+          <>
-        >
+            <SettingsSectionHeader
-          <JigglerSetting />
+              title="Jiggler Config"
-        </SettingsItem>
+              description="Control the jiggler schedule"
+            />
+            <JigglerSetting />
+          </>
+        )}
         <div className="space-y-4">
           <SettingsItem title="Modes" description="Choose the mouse input mode" />
           <div className="flex items-center gap-4">