Renaming Controller as Main (#748)

* refactoring private variables location in controller class

* removing extra layer of componentViewer main and changing controller name to main

* updating tests and files in accordance with new class names

---------

Co-authored-by: Thorsten de Buhr <[email protected]>

Author: omarArm

src/desktop/extension.ts

@@ -57,7 +57,7 @@ export const activate = async (context: vscode.ExtensionContext): Promise<void>
     // Live Watch view
     liveWatchTreeDataProvider.activate(gdbtargetDebugTracker);
     // Component Viewer
-    await componentViewer.activate(gdbtargetDebugTracker);
+    componentViewer.activate(gdbtargetDebugTracker);
 
     logger.debug('Extension Pack activated');
 };

src/views/component-viewer/component-viewer-controller.ts

@@ -15,18 +15,171 @@
  */
 
 import * as vscode from 'vscode';
-import { ComponentViewerController } from './component-viewer-controller';
-import { GDBTargetDebugTracker } from '../../debug-session';
+import { GDBTargetDebugTracker, GDBTargetDebugSession, SessionStackItem } from '../../debug-session';
+import { ComponentViewerInstance } from './component-viewer-instance';
+import { URI } from 'vscode-uri';
+import { ComponentViewerTreeDataProvider } from './component-viewer-tree-view';
+
 
 export class ComponentViewer {
-    private componentViewerController: ComponentViewerController;
+    private activeSession: GDBTargetDebugSession | undefined;
+    private instances: ComponentViewerInstance[] = [];
+    private componentViewerTreeDataProvider: ComponentViewerTreeDataProvider | undefined;
+    private _context: vscode.ExtensionContext;
+    private _instanceUpdateCounter: number = 0;
+    private _updateSemaphoreFlag: boolean = false;
+
+    public constructor(context: vscode.ExtensionContext) {
+        this._context = context;
+    }
+
+    public activate(tracker: GDBTargetDebugTracker): void {
+        /* Create Tree Viewer */
+        this.componentViewerTreeDataProvider = new ComponentViewerTreeDataProvider();
+        const treeProviderDisposable = vscode.window.registerTreeDataProvider('cmsis-debugger.componentViewer', this.componentViewerTreeDataProvider);
+        this._context.subscriptions.push(
+            treeProviderDisposable);
+        // Subscribe to debug tracker events to update active session
+        this.subscribetoDebugTrackerEvents(this._context, tracker);
+    }
+
+    protected async readScvdFiles(tracker: GDBTargetDebugTracker,session?: GDBTargetDebugSession): Promise<void> {
+        if (!session) {
+            return;
+        }
+        const cbuildRunReader = await session.getCbuildRun();
+        if (!cbuildRunReader) {
+            return;
+        }
+        // Get SCVD file paths from cbuild-run reader
+        const scvdFilesPaths: string [] = cbuildRunReader.getScvdFilePaths();
+        if (scvdFilesPaths.length === 0) {
+            return undefined;
+        }
+        const cbuildRunInstances: ComponentViewerInstance[] = [];
+        for (const scvdFilePath of scvdFilesPaths) {
+            const instance = new ComponentViewerInstance();
+            if (this.activeSession !== undefined) {
+                await instance.readModel(URI.file(scvdFilePath), this.activeSession, tracker);
+                cbuildRunInstances.push(instance);
+            }
+        }
+        this.instances = cbuildRunInstances;
+    }
+
+    private loadingCounter: number = 0;
+    private async loadCbuildRunInstances(session: GDBTargetDebugSession, tracker: GDBTargetDebugTracker) : Promise<void> {
+        this.loadingCounter++;
+        console.log(`Loading SCVD files from cbuild-run, attempt #${this.loadingCounter}`);
+        // Try to read SCVD files from cbuild-run file first
+        await this.readScvdFiles(tracker, session);
+        // Are there any SCVD files found in cbuild-run?
+        if (this.instances.length > 0) {
+            await this.updateInstances();
+            return;
+        }
+    }
+
+    private subscribetoDebugTrackerEvents(context: vscode.ExtensionContext, tracker: GDBTargetDebugTracker): void {
+        const onWillStopSessionDisposable = tracker.onWillStopSession(async (session) => {
+            await this.handleOnWillStopSession(session);
+        });
+        const onConnectedDisposable = tracker.onConnected(async (session) => {
+            await this.handleOnConnected(session, tracker);
+        });
+        const onDidChangeActiveStackItemDisposable = tracker.onDidChangeActiveStackItem(async (stackTraceItem) => {
+            await this.handleOnDidChangeActiveStackItem(stackTraceItem);
+        });
+        const onDidChangeActiveDebugSessionDisposable = tracker.onDidChangeActiveDebugSession(async (session) => {
+            await this.handleOnDidChangeActiveDebugSession(session);
+        });
+        const onStopped = tracker.onStopped(async (session) => {
+            await this.handleOnStopped(session.session);
+        });
+        // clear all disposables on extension deactivation
+        context.subscriptions.push(
+            onWillStopSessionDisposable,
+            onConnectedDisposable,
+            onDidChangeActiveStackItemDisposable,
+            onDidChangeActiveDebugSessionDisposable,
+            onStopped
+        );
+    }
+
+    private async handleOnStopped(session: GDBTargetDebugSession): Promise<void> {
+        // Clear active session if it is NOT the one being stopped
+        if (this.activeSession?.session.id !== session.session.id) {
+            this.activeSession = undefined;
+        }
+        // Update component viewer instance(s)
+        await this.updateInstances();
+    }
+
+    private async handleOnWillStopSession(session: GDBTargetDebugSession): Promise<void> {
+        // Clear active session if it is the one being stopped
+        if (this.activeSession?.session.id === session.session.id) {
+            this.activeSession = undefined;
+        }
+        // Update component viewer instance(s)
+        await this.updateInstances();
+    }
+
+    private async handleOnConnected(session: GDBTargetDebugSession, tracker: GDBTargetDebugTracker): Promise<void> {
+        // if new session is not the current active session, erase old instances and read the new ones
+        if (this.activeSession?.session.id !== session.session.id) {
+            this.instances = [];
+            this.componentViewerTreeDataProvider?.deleteModels();
+        }
+        // Update debug session
+        this.activeSession = session;
+        // Load SCVD files from cbuild-run
+        await this.loadCbuildRunInstances(session, tracker);
+        // Subscribe to refresh events of the started session
+        session.refreshTimer.onRefresh(async (refreshSession) => {
+            if (this.activeSession?.session.id === refreshSession.session.id) {
+                // Update component viewer instance(s)
+                await this.updateInstances();
+            }
+        });
+    }
+
+    private async handleOnDidChangeActiveStackItem(stackTraceItem: SessionStackItem): Promise<void> {
+        if ((stackTraceItem.item as vscode.DebugStackFrame).frameId !== undefined) {
+            // Update instance(s) with new stack frame info
+            await this.updateInstances();
+        }
+    }
 
-    public constructor( context: vscode.ExtensionContext
-    ) {
-        this.componentViewerController = new ComponentViewerController(context);
+    private async handleOnDidChangeActiveDebugSession(session: GDBTargetDebugSession | undefined): Promise<void> {
+        // Update debug session
+        this.activeSession = session;
+        // Update component viewer instance(s)
+        await this.updateInstances();
     }
 
-    public activate(tracker: GDBTargetDebugTracker) {
-        return this.componentViewerController.activate(tracker);
+    private async updateInstances(): Promise<void> {
+        if (this._updateSemaphoreFlag) {
+            return;
+        }
+        this._updateSemaphoreFlag = true;
+        this._instanceUpdateCounter = 0;
+        if (!this.activeSession) {
+            this.componentViewerTreeDataProvider?.deleteModels();
+            this._updateSemaphoreFlag = false;
+            return;
+        }
+        if (this.instances.length === 0) {
+            this._updateSemaphoreFlag = false;
+            return;
+        }
+        this.componentViewerTreeDataProvider?.resetModelCache();
+        for (const instance of this.instances) {
+            this._instanceUpdateCounter++;
+            console.log(`Updating Component Viewer Instance #${this._instanceUpdateCounter}`);
+            await instance.update();
+            this.componentViewerTreeDataProvider?.addGuiOut(instance.getGuiTree());
+        }
+        this.componentViewerTreeDataProvider?.showModelData();
+        this._updateSemaphoreFlag = false;
     }
 }

src/views/component-viewer/component-viewer-main.ts

@@ -74,7 +74,7 @@ export class ComponentViewerTreeDataProvider implements vscode.TreeDataProvider<
         this._objectOutRoots = [];
     }
 
-    public async addGuiOut(guiOut: ScvdGuiInterface[] | undefined) {
+    public addGuiOut(guiOut: ScvdGuiInterface[] | undefined) {
         if (guiOut !== undefined) {
             guiOut.forEach(item => this._scvdModel.push(item));
         }