feat: new window inherits the custom board options

A new startup task ensures setting any custom board menu selection in a
new sketch window.

Closes #2271

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

Diff for: arduino-ide-extension/src/browser/arduino-ide-frontend-module.ts

@@ -454,6 +454,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
   // To be able to track, and update the menu based on the core settings (aka. board details) of the currently selected board.
   bind(BoardsDataStore).toSelf().inSingletonScope();
   bind(FrontendApplicationContribution).toService(BoardsDataStore);
+  bind(CommandContribution).toService(BoardsDataStore);
+  bind(StartupTaskProvider).toService(BoardsDataStore); // to inherit the boards config options, programmer, etc in a new window
+
   // Logger for the Arduino daemon
   bind(ILogger)
     .toDynamicValue((ctx) => {

Diff for: arduino-ide-extension/src/browser/boards/boards-data-store.ts

@@ -1,5 +1,11 @@
 import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application';
+import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 import { StorageService } from '@theia/core/lib/browser/storage-service';
+import type {
+  Command,
+  CommandContribution,
+  CommandRegistry,
+} from '@theia/core/lib/common/command';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { ILogger } from '@theia/core/lib/common/logger';
@@ -10,12 +16,23 @@ import {
   BoardsService,
   ConfigOption,
   Programmer,
+  isBoardIdentifierChangeEvent,
 } from '../../common/protocol';
 import { notEmpty } from '../../common/utils';
+import type {
+  StartupTask,
+  StartupTaskProvider,
+} from '../../electron-common/startup-task';
 import { NotificationCenter } from '../notification-center';
+import { BoardsServiceProvider } from './boards-service-provider';
 
 @injectable()
-export class BoardsDataStore implements FrontendApplicationContribution {
+export class BoardsDataStore
+  implements
+    FrontendApplicationContribution,
+    StartupTaskProvider,
+    CommandContribution
+{
   @inject(ILogger)
   @named('store')
   private readonly logger: ILogger;
@@ -28,44 +45,101 @@ export class BoardsDataStore implements FrontendApplicationContribution {
   // In other words, store the data (such as the board configs) per sketch, not per IDE2 installation. https://github.com/arduino/arduino-ide/issues/2240
   @inject(StorageService)
   private readonly storageService: StorageService;
+  @inject(BoardsServiceProvider)
+  private readonly boardsServiceProvider: BoardsServiceProvider;
+  @inject(FrontendApplicationStateService)
+  private readonly appStateService: FrontendApplicationStateService;
 
-  private readonly onChangedEmitter = new Emitter<string[]>();
-  private readonly toDispose = new DisposableCollection(this.onChangedEmitter);
+  private readonly onDidChangeEmitter =
+    new Emitter<BoardsDataStoreChangeEvent>();
+  private readonly toDispose = new DisposableCollection(
+    this.onDidChangeEmitter
+  );
+  private _selectedBoardData: BoardsDataStoreChange | undefined;
 
   onStart(): void {
-    this.toDispose.push(
+    this.toDispose.pushAll([
+      this.boardsServiceProvider.onBoardsConfigDidChange(async (event) => {
+        if (isBoardIdentifierChangeEvent(event)) {
+          this._selectedBoardData = await this.getSelectedBoardData(
+            event.selectedBoard?.fqbn
+          );
+        }
+      }),
       this.notificationCenter.onPlatformDidInstall(async ({ item }) => {
-        const dataDidChangePerFqbn: string[] = [];
+        const changes: BoardsDataStoreChange[] = [];
         for (const fqbn of item.boards
           .map(({ fqbn }) => fqbn)
-          .filter(notEmpty)
-          .filter((fqbn) => !!fqbn)) {
+          .filter(notEmpty)) {
           const key = this.getStorageKey(fqbn);
-          let data = await this.storageService.getData<ConfigOption[]>(key);
-          if (!data || !data.length) {
+          const storedData =
+            await this.storageService.getData<BoardsDataStore.Data>(key);
+          if (!storedData) {
             const details = await this.getBoardDetailsSafe(fqbn);
             if (details) {
-              data = details.configOptions;
-              if (data.length) {
-                await this.storageService.setData(key, data);
-                dataDidChangePerFqbn.push(fqbn);
-              }
+              const data = createDataStoreEntry(details);
+              await this.storageService.setData(key, data);
+              changes.push({ fqbn, data });
             }
           }
         }
-        if (dataDidChangePerFqbn.length) {
-          this.fireChanged(...dataDidChangePerFqbn);
+        if (changes.length) {
+          this.fireChanged(...changes);
         }
-      })
-    );
+      }),
+    ]);
+    Promise.all([
+      this.boardsServiceProvider.ready,
+      this.appStateService.reachedState('ready'),
+    ]).then(async () => {
+      const fqbn = this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
+      this._selectedBoardData = await this.getSelectedBoardData(fqbn);
+    });
+  }
+
+  private async getSelectedBoardData(
+    fqbn: string | undefined
+  ): Promise<BoardsDataStoreChange | undefined> {
+    if (!fqbn) {
+      return undefined;
+    } else {
+      const data = await this.getData(fqbn);
+      if (data === BoardsDataStore.Data.EMPTY) {
+        return undefined;
+      }
+      return { fqbn, data };
+    }
   }
 
   onStop(): void {
     this.toDispose.dispose();
   }
 
-  get onChanged(): Event<string[]> {
-    return this.onChangedEmitter.event;
+  registerCommands(registry: CommandRegistry): void {
+    registry.registerCommand(USE_INHERITED_DATA, {
+      execute: async (arg: unknown) => {
+        if (isBoardsDataStoreChange(arg)) {
+          await this.setData(arg);
+          this.fireChanged(arg);
+        }
+      },
+    });
+  }
+
+  tasks(): StartupTask[] {
+    if (!this._selectedBoardData) {
+      return [];
+    }
+    return [
+      {
+        command: USE_INHERITED_DATA.id,
+        args: [this._selectedBoardData],
+      },
+    ];
+  }
+
+  get onDidChange(): Event<BoardsDataStoreChangeEvent> {
+    return this.onDidChangeEmitter.event;
   }
 
   async appendConfigToFqbn(
@@ -84,22 +158,19 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     }
 
     const key = this.getStorageKey(fqbn);
-    let data = await this.storageService.getData<
+    const storedData = await this.storageService.getData<
       BoardsDataStore.Data | undefined
     >(key, undefined);
-    if (BoardsDataStore.Data.is(data)) {
-      return data;
+    if (BoardsDataStore.Data.is(storedData)) {
+      return storedData;
     }
 
     const boardDetails = await this.getBoardDetailsSafe(fqbn);
     if (!boardDetails) {
       return BoardsDataStore.Data.EMPTY;
     }
 
-    data = {
-      configOptions: boardDetails.configOptions,
-      programmers: boardDetails.programmers,
-    };
+    const data = createDataStoreEntry(boardDetails);
     await this.storageService.setData(key, data);
     return data;
   }
@@ -111,17 +182,15 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     fqbn: string;
     selectedProgrammer: Programmer;
   }): Promise<boolean> {
-    const data = deepClone(await this.getData(fqbn));
-    const { programmers } = data;
+    const storedData = deepClone(await this.getData(fqbn));
+    const { programmers } = storedData;
     if (!programmers.find((p) => Programmer.equals(selectedProgrammer, p))) {
       return false;
     }
 
-    await this.setData({
-      fqbn,
-      data: { ...data, selectedProgrammer },
-    });
-    this.fireChanged(fqbn);
+    const data = { ...storedData, selectedProgrammer };
+    await this.setData({ fqbn, data });
+    this.fireChanged({ fqbn, data });
     return true;
   }
 
@@ -153,17 +222,12 @@ export class BoardsDataStore implements FrontendApplicationContribution {
       return false;
     }
     await this.setData({ fqbn, data });
-    this.fireChanged(fqbn);
+    this.fireChanged({ fqbn, data });
     return true;
   }
 
-  protected async setData({
-    fqbn,
-    data,
-  }: {
-    fqbn: string;
-    data: BoardsDataStore.Data;
-  }): Promise<void> {
+  protected async setData(change: BoardsDataStoreChange): Promise<void> {
+    const { fqbn, data } = change;
     const key = this.getStorageKey(fqbn);
     return this.storageService.setData(key, data);
   }
@@ -176,7 +240,7 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     fqbn: string
   ): Promise<BoardDetails | undefined> {
     try {
-      const details = this.boardsService.getBoardDetails({ fqbn });
+      const details = await this.boardsService.getBoardDetails({ fqbn });
       return details;
     } catch (err) {
       if (
@@ -197,8 +261,8 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     }
   }
 
-  protected fireChanged(...fqbn: string[]): void {
-    this.onChangedEmitter.fire(fqbn);
+  protected fireChanged(...changes: BoardsDataStoreChange[]): void {
+    this.onDidChangeEmitter.fire({ changes });
   }
 }
 
@@ -224,3 +288,32 @@ export namespace BoardsDataStore {
     }
   }
 }
+
+function createDataStoreEntry(details: BoardDetails): BoardsDataStore.Data {
+  return {
+    configOptions: details.configOptions.slice(),
+    programmers: details.programmers.slice(),
+  };
+}
+
+export interface BoardsDataStoreChange {
+  readonly fqbn: string;
+  readonly data: BoardsDataStore.Data;
+}
+
+function isBoardsDataStoreChange(arg: unknown): arg is BoardsDataStoreChange {
+  return (
+    typeof arg === 'object' &&
+    arg !== null &&
+    typeof (<BoardsDataStoreChange>arg).fqbn === 'string' &&
+    typeof (<BoardsDataStoreChange>arg).data === 'object' // TODO: better type guard!
+  );
+}
+
+export interface BoardsDataStoreChangeEvent {
+  readonly changes: readonly BoardsDataStoreChange[];
+}
+
+const USE_INHERITED_DATA: Command = {
+  id: 'arduino-use-inherited-boards-data',
+};

Diff for: arduino-ide-extension/src/browser/contributions/boards-data-menu-updater.ts

@@ -35,7 +35,7 @@ export class BoardsDataMenuUpdater extends Contribution {
   private readonly toDisposeOnBoardChange = new DisposableCollection();
 
   override onStart(): void {
-    this.boardsDataStore.onChanged(() =>
+    this.boardsDataStore.onDidChange(() =>
       this.updateMenuActions(
         this.boardsServiceProvider.boardsConfig.selectedBoard
       )

Diff for: arduino-ide-extension/src/browser/contributions/ino-language.ts

@@ -90,21 +90,21 @@ export class InoLanguage extends SketchContribution {
       this.notificationCenter.onPlatformDidInstall(() => forceRestart()),
       this.notificationCenter.onPlatformDidUninstall(() => forceRestart()),
       this.notificationCenter.onDidReinitialize(() => forceRestart()),
-      this.boardDataStore.onChanged((dataChangePerFqbn) => {
+      this.boardDataStore.onDidChange((event) => {
         if (this.languageServerFqbn) {
           const sanitizedFqbn = sanitizeFqbn(this.languageServerFqbn);
           if (!sanitizeFqbn) {
             throw new Error(
               `Failed to sanitize the FQBN of the running language server. FQBN with the board settings was: ${this.languageServerFqbn}`
             );
           }
-          const matchingFqbn = dataChangePerFqbn.find(
-            (fqbn) => sanitizedFqbn === fqbn
+          const matchingChange = event.changes.find(
+            (change) => change.fqbn === sanitizedFqbn
           );
           const { boardsConfig } = this.boardsServiceProvider;
           if (
-            matchingFqbn &&
-            boardsConfig.selectedBoard?.fqbn === matchingFqbn
+            matchingChange &&
+            boardsConfig.selectedBoard?.fqbn === matchingChange.fqbn
           ) {
             start(boardsConfig.selectedBoard);
           }

Diff for: arduino-ide-extension/src/browser/contributions/update-arduino-state.ts

@@ -65,10 +65,13 @@ export class UpdateArduinoState extends SketchContribution {
           this.updateCompileSummary(args[0]);
         }
       }),
-      this.boardsDataStore.onChanged((fqbn) => {
+      this.boardsDataStore.onDidChange((event) => {
         const selectedFqbn =
           this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
-        if (selectedFqbn && fqbn.includes(selectedFqbn)) {
+        if (
+          selectedFqbn &&
+          event.changes.find((change) => change.fqbn === selectedFqbn)
+        ) {
           this.updateBoardDetails(selectedFqbn);
         }
       }),