From 793fcc11d36c4b030e5fa1ab3e7428802b7f2653 Mon Sep 17 00:00:00 2001 From: seydx Date: Tue, 15 Sep 2026 02:01:18 +0200 Subject: [PATCH 1/2] ignore state changes reported while a controller is being restored --- src/lib/model/ControllerStorage.spec.ts | 78 +++++++++++++++++++++++++ src/lib/model/ControllerStorage.ts | 25 ++++++-- 2 files changed, 99 insertions(+), 4 deletions(-) create mode 100644 src/lib/model/ControllerStorage.spec.ts diff --git a/src/lib/model/ControllerStorage.spec.ts b/src/lib/model/ControllerStorage.spec.ts new file mode 100644 index 000000000..5cecbd659 --- /dev/null +++ b/src/lib/model/ControllerStorage.spec.ts @@ -0,0 +1,78 @@ +import { Accessory } from "../Accessory"; +import { ControllerIdentifier, ControllerServiceMap, SerializableController, StateChangeDelegate } from "../controller"; +import * as uuid from "../util/uuid"; +import { ControllerStorage } from "./ControllerStorage"; + +interface State { + first?: string; + second?: string; +} + +// restores its state in two steps and reports a state change in between, like a controller whose +// characteristic updates during deserialize trigger its own change listeners +class SteppedController implements SerializableController { + state: State = {}; + private stateChangeDelegate?: StateChangeDelegate; + + controllerId(): ControllerIdentifier { + return "stepped"; + } + + constructServices(): ControllerServiceMap { + return {}; + } + + initWithServices(): void | ControllerServiceMap { + return undefined; + } + + configureServices(): void { + // nothing to configure + } + + handleControllerRemoved(): void { + // nothing to clean up + } + + serialize(): State | undefined { + return { ...this.state }; + } + + deserialize(serialized: State): void { + this.state.first = serialized.first; + this.stateChangeDelegate?.(); + this.state.second = serialized.second; + } + + setupStateChangeDelegate(delegate?: StateChangeDelegate): void { + this.stateChangeDelegate = delegate; + } + + handleFactoryReset(): void { + this.state = {}; + } +} + +describe("ControllerStorage", () => { + test("state changes reported while restoring do not overwrite the stored data", () => { + const accessory = new Accessory("Test", uuid.generate("controller-storage")); + const storage = new ControllerStorage(accessory); + const controller = new SteppedController(); + storage.trackController(controller); + + // @ts-expect-error: private access + storage.init([{ type: "stepped", controllerData: { data: { first: "a", second: "b" } } }]); + + expect(controller.state).toEqual({ first: "a", second: "b" }); + // @ts-expect-error: private access + expect(storage.controllerData.stepped.data).toEqual({ first: "a", second: "b" }); + + controller.state.second = "c"; + // @ts-expect-error: private access + storage.handleStateChange(controller); + // @ts-expect-error: private access + expect(storage.controllerData.stepped.data).toEqual({ first: "a", second: "c" }); + // @ts-expect-error: private access + clearTimeout(storage.queuedSaveTimeout); + }); +}); diff --git a/src/lib/model/ControllerStorage.ts b/src/lib/model/ControllerStorage.ts index 86c315291..cf6d5b820 100644 --- a/src/lib/model/ControllerStorage.ts +++ b/src/lib/model/ControllerStorage.ts @@ -47,6 +47,11 @@ export class ControllerStorage { private controllerData: Record = {}; private restoredAccessories?: Record; // indexed by accessory UUID + // deserializing a controller updates its characteristics, which can report state changes (its own, or + // those of another controller listening on a shared service) before the restore is complete. + // Those must not overwrite the stored data with a partially restored state. + private restoring = false; + private parent?: ControllerStorage; private linkedAccessories?: ControllerStorage[]; @@ -133,6 +138,9 @@ export class ControllerStorage { } private handleStateChange(controller: SerializableController) { + if (this.restoring) { + return; + } const id = controller.controllerId(); const serialized = controller.serialize(); @@ -174,11 +182,15 @@ export class ControllerStorage { this.accessoryUUID, controller.controllerId(), !!controllerData); if (controllerData) { + const wasRestoring = this.restoring; + this.restoring = true; try { controller.deserialize(controllerData.data); } catch (error) { console.warn(`Could not initialize controller of type '${controller.controllerId()}' from data stored on disk. Resetting to default: ${error.stack}`); controller.handleFactoryReset(); + } finally { + this.restoring = wasRestoring; } controllerData.purgeOnNextLoad = undefined; } @@ -202,10 +214,15 @@ export class ControllerStorage { } const restoredControllers: ControllerIdentifier[] = []; - this.trackedControllers.forEach(controller => { - this.restoreController(controller); - restoredControllers.push(controller.controllerId()); - }); + this.restoring = true; + try { + this.trackedControllers.forEach(controller => { + this.restoreController(controller); + restoredControllers.push(controller.controllerId()); + }); + } finally { + this.restoring = false; + } this.trackedControllers.splice(0, this.trackedControllers.length); // clear tracking list let purgedData = false; From fdc8fda2dd5c22680e19a222176e594c089c8283 Mon Sep 17 00:00:00 2001 From: seydx Date: Mon, 19 Oct 2026 22:17:53 +0200 Subject: [PATCH 2/2] save the factory reset when stored controller data can't be read --- src/lib/model/ControllerStorage.spec.ts | 36 ++++++++++++++++++++++++- src/lib/model/ControllerStorage.ts | 2 ++ 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/src/lib/model/ControllerStorage.spec.ts b/src/lib/model/ControllerStorage.spec.ts index 5cecbd659..bb322cf14 100644 --- a/src/lib/model/ControllerStorage.spec.ts +++ b/src/lib/model/ControllerStorage.spec.ts @@ -12,7 +12,7 @@ interface State { // characteristic updates during deserialize trigger its own change listeners class SteppedController implements SerializableController { state: State = {}; - private stateChangeDelegate?: StateChangeDelegate; + protected stateChangeDelegate?: StateChangeDelegate; controllerId(): ControllerIdentifier { return "stepped"; @@ -53,6 +53,22 @@ class SteppedController implements SerializableController { test("state changes reported while restoring do not overwrite the stored data", () => { const accessory = new Accessory("Test", uuid.generate("controller-storage")); @@ -75,4 +91,22 @@ describe("ControllerStorage", () => { // @ts-expect-error: private access clearTimeout(storage.queuedSaveTimeout); }); + + test("the reset after unreadable stored data is saved", () => { + const accessory = new Accessory("Test", uuid.generate("controller-storage-reset")); + const storage = new ControllerStorage(accessory); + const controller = new UnreadableController(); + storage.trackController(controller); + const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined); + + // @ts-expect-error: private access + storage.init([{ type: "unreadable", controllerData: { data: { first: "a", second: "b" } } }]); + + expect(warn).toHaveBeenCalledTimes(1); + // @ts-expect-error: private access + expect(storage.controllerData.unreadable.data).toEqual({}); + warn.mockRestore(); + // @ts-expect-error: private access + clearTimeout(storage.queuedSaveTimeout); + }); }); diff --git a/src/lib/model/ControllerStorage.ts b/src/lib/model/ControllerStorage.ts index cf6d5b820..98b77e2ae 100644 --- a/src/lib/model/ControllerStorage.ts +++ b/src/lib/model/ControllerStorage.ts @@ -188,6 +188,8 @@ export class ControllerStorage { controller.deserialize(controllerData.data); } catch (error) { console.warn(`Could not initialize controller of type '${controller.controllerId()}' from data stored on disk. Resetting to default: ${error.stack}`); + // the reset must be saved, otherwise the unreadable data stays on disk + this.restoring = false; controller.handleFactoryReset(); } finally { this.restoring = wasRestoring;