Store/restore view states to/from settings.json

__mocks__/vscode.js

@@ -30,6 +30,11 @@ const StatusBarAlignment = {
     Right: 2
 };
 
+const ConfigurationTarget = {
+    Global: 1,
+    Workspace: 2,
+};
+
 const MockTreeItemCollapsibleState = { 
     None: 0, 
     Collapsed: 1, 
@@ -117,6 +122,8 @@ module.exports = {
     workspace: {
         getConfiguration: jest.fn(() => ({
             get: jest.fn(),
+            update: jest.fn().mockResolvedValue(undefined),
+            inspect: jest.fn().mockReturnValue(undefined),
         })),
         fs: {
             readFile: jest.fn(uri => {
@@ -162,4 +169,5 @@ module.exports = {
     },
     EnvironmentVariableMutatorType,
     StatusBarAlignment,
+    ConfigurationTarget,
 };

package.json

@@ -74,6 +74,11 @@
       ]
     },
     "commands": [
+      {
+        "command": "vscode-cmsis-debugger.resetDynamicViewState",
+        "title": "Reset All Dynamic View States",
+        "category": "CMSIS Debugger"
+      },
       {
         "command": "vscode-cmsis-debugger.openDisassemblyView",
         "title": "Open Disassembly View",
@@ -178,11 +183,13 @@
       {
         "command": "vscode-cmsis-debugger.componentViewer.enablePeriodicUpdate",
         "title": "Enable Periodic Update",
+        "icon": "$(sync)",
         "category": "Component Viewer"
       },
       {
         "command": "vscode-cmsis-debugger.componentViewer.disablePeriodicUpdate",
         "title": "Disable Periodic Update",
+        "icon": "$(sync-ignored)",
         "category": "Component Viewer"
       },
       {
@@ -218,11 +225,13 @@
       {
         "command": "vscode-cmsis-debugger.corePeripherals.enablePeriodicUpdate",
         "title": "Enable Periodic Update",
+        "icon": "$(sync)",
         "category": "Core Peripherals"
       },
       {
         "command": "vscode-cmsis-debugger.corePeripherals.disablePeriodicUpdate",
         "title": "Disable Periodic Update",
+        "icon": "$(sync-ignored)",
         "category": "Core Peripherals"
       },
       {
@@ -274,6 +283,10 @@
         }
       ],
       "commandPalette": [
+        {
+          "command": "vscode-cmsis-debugger.resetDynamicViewState",
+          "when": "true"
+        },
         {
           "command": "vscode-cmsis-debugger.openDisassemblyView",
           "when": "false"
@@ -414,12 +427,12 @@
         {
           "command": "vscode-cmsis-debugger.componentViewer.expandAll",
           "when": "view == cmsis-debugger.componentViewer",
-          "group": "navigation@3"
+          "group": "navigation@4"
         },
         {
           "command": "vscode-cmsis-debugger.corePeripherals.expandAll",
           "when": "view == cmsis-debugger.corePeripherals",
-          "group": "navigation@3"
+          "group": "navigation@4"
         },
         {
           "command": "vscode-cmsis-debugger.componentViewer.filterTree",
@@ -440,6 +453,26 @@
           "command": "vscode-cmsis-debugger.corePeripherals.clearFilter",
           "when": "view == cmsis-debugger.corePeripherals && corePeripherals.filterActive",
           "group": "navigation@2"
+        },
+        {
+          "command": "vscode-cmsis-debugger.componentViewer.disablePeriodicUpdate",
+          "when": "view == cmsis-debugger.componentViewer && componentViewer.periodicUpdateEnabled",
+          "group": "navigation@3"
+        },
+        {
+          "command": "vscode-cmsis-debugger.componentViewer.enablePeriodicUpdate",
+          "when": "view == cmsis-debugger.componentViewer && !componentViewer.periodicUpdateEnabled",
+          "group": "navigation@3"
+        },
+        {
+          "command": "vscode-cmsis-debugger.corePeripherals.disablePeriodicUpdate",
+          "when": "view == cmsis-debugger.corePeripherals && corePeripherals.periodicUpdateEnabled",
+          "group": "navigation@3"
+        },
+        {
+          "command": "vscode-cmsis-debugger.corePeripherals.enablePeriodicUpdate",
+          "when": "view == cmsis-debugger.corePeripherals && !corePeripherals.periodicUpdateEnabled",
+          "group": "navigation@3"
         }
       ],
       "view/item/context": [
@@ -556,7 +589,44 @@
           }
         }
       }
-    ]
+    ],
+    "configuration": {
+      "title": "CMSIS Debugger",
+      "properties": {
+        "vscode-cmsis-debugger.viewState": {
+          "type": "object",
+          "markdownDescription": "Persisted dynamic view state per debug configuration.",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "componentViewer": {
+                "type": "object",
+                "markdownDescription": "Persisted dynamic view state for the Component Viewer.",
+                "additionalProperties": false,
+                "properties": {
+                  "periodicUpdateEnabled": { "type": "boolean" },
+                  "filterPattern": { "type": "string" }
+                }
+              },
+              "corePeripherals": {
+                "type": "object",
+                "markdownDescription": "Persisted dynamic view state for the Core Peripherals view.",
+                "additionalProperties": false,
+                "properties": {
+                  "periodicUpdateEnabled": { "type": "boolean" },
+                  "filterPattern": { "type": "string" }
+                }
+              },
+              "cpuStates": {
+                "type": "boolean",
+                "markdownDescription": "Persisted CPU time enable/disable state."
+              }
+            }
+          }
+        }
+      }
+    }
   },
   "scripts": {
     "prepare": "npm run build",

src/cbuild-run/cbuild-run-reader.ts

@@ -108,4 +108,7 @@ export class CbuildRunReader {
         return pnameProcessors.map(p => p.pname!);
     }
 
+    public getTargetType(): string | undefined {
+        return this.cbuildRun?.['target-type'];
+    }
 }

src/debug-session/__test__/debug-session.factory.ts

@@ -20,8 +20,9 @@ import { GDBTargetDebugSession, GDBTargetDebugTracker, TargetState } from '..';
 export type OnRefreshCallback = (session: Session) => void;
 
 export type Session = {
-    session: { id: string };
-    getCbuildRun: () => Promise<{ getScvdFilePaths: () => string[] } | undefined>;
+    session: { id: string; configuration?: { name: string } };
+    getCbuildRun: () => Promise<{ getScvdFilePaths: () => string[]; getTargetType: () => string | undefined } | undefined>;
+    getConfigStateKey: () => Promise<string>;
     getPname: () => Promise<string | undefined>;
     refreshTimer: { onRefresh: (cb: OnRefreshCallback) => void };
     targetState?: TargetState;
@@ -88,11 +89,13 @@ export const debugSessionFactory = (
     // Ensure same object returned for multiple calls to getCbuildRun.
     const cbuildRunMock = hasCbuildRun ? {
         getContents: jest.fn(),
-        getScvdFilePaths: () => paths
+        getScvdFilePaths: () => paths,
+        getTargetType: jest.fn<string | undefined, []>(() => undefined),
     } : undefined;
     return {
-        session: { id },
-        getCbuildRun: async () => cbuildRunMock,
+        session: { id, configuration: { name: id } },
+        getCbuildRun: jest.fn().mockResolvedValue(cbuildRunMock),
+        getConfigStateKey: jest.fn().mockResolvedValue(id),
         getPname: async () => pname,
         refreshTimer: {
             onRefresh: jest.fn(),

src/debug-session/gdbtarget-debug-session.ts

@@ -109,6 +109,13 @@ export class GDBTargetDebugSession {
         return pname;
     }
 
+    public async getConfigStateKey(): Promise<string> {
+        const cbuildRun = await this.getCbuildRun();
+        const targetType = cbuildRun?.getTargetType();
+        const configStateKey = targetType ? `${targetType}::${this.session.configuration.name}` : this.session.configuration.name;
+        return configStateKey;
+    }
+
     /**
      * Check if first stop attempt for session is done by 'terminate' request.
      * Notes:

src/desktop/extension.ts

@@ -27,6 +27,7 @@ import { GenericCommands } from '../features/generic-commands';
 import { ComponentViewer } from '../views/component-viewer/component-viewer';
 import { ComponentViewerTreeDataProvider } from '../views/component-viewer/component-viewer-tree-view';
 import { CorePeripherals } from '../views/core-peripherals/core-peripherals';
+import { clearAllViewState } from '../views/dynamic-view-states';
 
 const BUILTIN_TOOLS_PATHS = [
     'tools/pyocd/pyocd',
@@ -85,6 +86,18 @@ export const activate = async (context: vscode.ExtensionContext): Promise<void>
         canCompleteActivation = false;
     }
 
+    // Register reset dynamic view state command
+    context.subscriptions.push(
+        vscode.commands.registerCommand('vscode-cmsis-debugger.resetDynamicViewState', async () => {
+            await clearAllViewState();
+            await Promise.all([
+                cpuStates.resetViewState(),
+                componentViewer.resetViewState(),
+                corePeripherals.resetViewState(),
+            ]);
+        })
+    );
+
     if (!canCompleteActivation) {
         logger.debug('CMSIS Debugger activation incomplete');
         // Let promise float, we reload the window.

src/features/cpu-states/cpu-states-statusbar-item.ts

@@ -66,6 +66,7 @@ export class CpuStatesStatusBarItem {
     }
 
     protected async handleItemCommand(): Promise<void> {
+        const cpuEnabled = this.cpuStates?.isEnabled ?? true;
         const items: QuickPickHandlerItem[] = [
             {
                 label: 'CPU Time',
@@ -76,7 +77,18 @@ export class CpuStatesStatusBarItem {
                 label: 'Reset CPU Time',
                 detail: 'Reset CPU execution time and history',
                 handler: () => vscode.commands.executeCommand(CpuStatesCommands.resetCpuTimeHistoryID)
-            }
+            },
+            cpuEnabled
+                ? {
+                    label: 'Disable CPU Timer',
+                    detail: 'Stop collecting CPU execution time',
+                    handler: () => vscode.commands.executeCommand(CpuStatesCommands.disableCpuTimer)
+                }
+                : {
+                    label: 'Enable CPU Timer',
+                    detail: 'Start collecting CPU execution time',
+                    handler: () => vscode.commands.executeCommand(CpuStatesCommands.enableCpuTimer)
+                }
         ];
         const selection = await vscode.window.showQuickPick(items);
         if (!selection) {

src/features/cpu-states/cpu-states.test.ts

@@ -443,13 +443,13 @@ describe('CpuStates', () => {
         it('enable cpu states sets enableCpuStates flag to true', async () => {
             cpuStates.activate(tracker);
             await cpuStates.enableCpuStates();
-            expect((cpuStates as unknown as { enableCpuStatesFlag: boolean }).enableCpuStatesFlag).toEqual(true);
+            expect(cpuStates.activeCpuStates?.enableCpuStatesFlag).toEqual(true);
         });
 
         it('disable cpu states sets enableCpuStates flag to false', async () => {
             cpuStates.activate(tracker);
             await cpuStates.disableCpuStates();
-            expect((cpuStates as unknown as { enableCpuStatesFlag: boolean }).enableCpuStatesFlag).toEqual(false);
+            expect(cpuStates.activeCpuStates?.enableCpuStatesFlag).toEqual(false);
         });
     });
 
@@ -488,5 +488,89 @@ describe('CpuStates', () => {
 
     });
 
+    describe('CPU timer enable/disable state persists to and restores from settings', () => {
+        beforeEach(() => {
+            jest.spyOn(gdbtargetDebugSession, 'getCbuildRun').mockResolvedValue({
+                getTargetType: () => 'My-Target',
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+        });
+
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+
+        it('restores CPU timer enabled state from settings on connect', async () => {
+            jest.spyOn(vscode.workspace, 'getConfiguration').mockReturnValue({
+                inspect: jest.fn().mockReturnValue({
+                    globalValue: {
+                        'My-Target::Debug': {
+                            cpuStates: false,
+                        },
+                    },
+                    workspaceValue: {},
+                }),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+            cpuStates.activate(tracker);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onWillStartSession.fire(gdbtargetDebugSession);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onDidChangeActiveDebugSession.fire(gdbtargetDebugSession);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onConnected.fire(gdbtargetDebugSession);
+            await waitForMs(0);
+
+            expect(cpuStates.activeCpuStates?.enableCpuStatesFlag).toEqual(false);
+        });
+
+        it('toolbar button state switches when changing the active debug session', async () => {
+            const executeCommandSpy = jest.spyOn(vscode.commands, 'executeCommand').mockResolvedValue(undefined);
+            const debugConfig2 = gdbTargetConfiguration({ name: 'Debug2' });
+            const debugSession2 = debugSessionFactory(debugConfig2, '{session-id-2}');
+            const gdbtargetDebugSession2 = new GDBTargetDebugSession(debugSession2);
+            cpuStates.activate(tracker);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onWillStartSession.fire(gdbtargetDebugSession);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onWillStartSession.fire(gdbtargetDebugSession2);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (cpuStates as any).sessionCpuStates.get(gdbtargetDebugSession2.session.id)!.enableCpuStatesFlag = false;
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onDidChangeActiveDebugSession.fire(gdbtargetDebugSession);
+            expect(executeCommandSpy).toHaveBeenCalledWith('setContext', 'vscode-cmsis-debugger.cpuTimerEnabled', true);
+            executeCommandSpy.mockClear();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onDidChangeActiveDebugSession.fire(gdbtargetDebugSession2);
+            expect(executeCommandSpy).toHaveBeenCalledWith('setContext', 'vscode-cmsis-debugger.cpuTimerEnabled', false);
+            executeCommandSpy.mockClear();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onDidChangeActiveDebugSession.fire(undefined);
+            expect(executeCommandSpy).toHaveBeenCalledWith('setContext', 'vscode-cmsis-debugger.cpuTimerEnabled', false);
+        });
+
+        it('re-enables sessions and updates the toolbar context', async () => {
+            jest.spyOn(vscode.workspace, 'getConfiguration').mockReturnValue({
+                update: jest.fn().mockResolvedValue(undefined),
+                inspect: jest.fn().mockReturnValue({ globalValue: {}, workspaceValue: {} }),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+            const executeCommandSpy = jest.spyOn(vscode.commands, 'executeCommand').mockResolvedValue(undefined);
+            cpuStates.activate(tracker);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (tracker as any)._onWillStartSession.fire(gdbtargetDebugSession);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (cpuStates as any).sessionCpuStates.get(gdbtargetDebugSession.session.id)!.enableCpuStatesFlag = false;
+            await cpuStates.resetViewState();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            expect((cpuStates as any).sessionCpuStates.get(gdbtargetDebugSession.session.id)!.enableCpuStatesFlag).toBe(true);
+            expect(executeCommandSpy).toHaveBeenCalledWith('setContext', 'vscode-cmsis-debugger.cpuTimerEnabled', true);
+        });
+
+    });
 });