debug.ts

import { inject, injectable } from 'inversify';
import { Event, Emitter } from '@theia/core/lib/common/event';
import { HostedPluginSupport } from '@theia/plugin-ext/lib/hosted/browser/hosted-plugin';
import { ArduinoToolbar } from '../toolbar/arduino-toolbar';
import { NotificationCenter } from '../notification-center';
import { Board, BoardsService, ExecutableService } from '../../common/protocol';
import { BoardsServiceProvider } from '../boards/boards-service-provider';
import {
  URI,
  Command,
  CommandRegistry,
  SketchContribution,
  TabBarToolbarRegistry,
} from './contribution';

@injectable()
export class Debug extends SketchContribution {
  @inject(HostedPluginSupport)
  protected hostedPluginSupport: HostedPluginSupport;

  @inject(NotificationCenter)
  protected readonly notificationCenter: NotificationCenter;

  @inject(ExecutableService)
  protected readonly executableService: ExecutableService;

  @inject(BoardsService)
  protected readonly boardService: BoardsService;

  @inject(BoardsServiceProvider)
  protected readonly boardsServiceProvider: BoardsServiceProvider;

  /**
   * If `undefined`, debugging is enabled. Otherwise, the reason why it's disabled.
   */
  protected _disabledMessages?: string = 'No board selected'; // Initial pessimism.
  protected disabledMessageDidChangeEmitter = new Emitter<string | undefined>();
  protected onDisabledMessageDidChange =
    this.disabledMessageDidChangeEmitter.event;

  protected get disabledMessage(): string | undefined {
    return this._disabledMessages;
  }
  protected set disabledMessage(message: string | undefined) {
    this._disabledMessages = message;
    this.disabledMessageDidChangeEmitter.fire(this._disabledMessages);
  }

  protected readonly debugToolbarItem = {
    id: Debug.Commands.START_DEBUGGING.id,
    command: Debug.Commands.START_DEBUGGING.id,
    tooltip: `${
      this.disabledMessage
        ? `Debug - ${this.disabledMessage}`
        : 'Start Debugging'
    }`,
    priority: 3,
    onDidChange: this.onDisabledMessageDidChange as Event<void>,
  };

  onStart(): void {
    this.onDisabledMessageDidChange(
      () =>
        (this.debugToolbarItem.tooltip = `${
          this.disabledMessage
            ? `Debug - ${this.disabledMessage}`
            : 'Start Debugging'
        }`)
    );
    const refreshState = async (
      board: Board | undefined = this.boardsServiceProvider.boardsConfig
        .selectedBoard
    ) => {
      if (!board) {
        this.disabledMessage = 'No board selected';
        return;
      }
      const fqbn = board.fqbn;
      if (!fqbn) {
        this.disabledMessage = `Platform is not installed for '${board.name}'`;
        return;
      }
      const details = await this.boardService.getBoardDetails({ fqbn });
      if (!details) {
        this.disabledMessage = `Platform is not installed for '${board.name}'`;
        return;
      }
      const { debuggingSupported } = details;
      if (!debuggingSupported) {
        this.disabledMessage = `Debugging is not supported by '${board.name}'`;
      } else {
        this.disabledMessage = undefined;
      }
    };
    this.boardsServiceProvider.onBoardsConfigChanged(({ selectedBoard }) =>
      refreshState(selectedBoard)
    );
    this.notificationCenter.onPlatformInstalled(() => refreshState());
    this.notificationCenter.onPlatformUninstalled(() => refreshState());
    refreshState();
  }

  registerCommands(registry: CommandRegistry): void {
    registry.registerCommand(Debug.Commands.START_DEBUGGING, {
      execute: () => this.startDebug(),
      isVisible: (widget) =>
        ArduinoToolbar.is(widget) && widget.side === 'left',
      isEnabled: () => !this.disabledMessage,
    });
  }

  registerToolbarItems(registry: TabBarToolbarRegistry): void {
    registry.registerItem(this.debugToolbarItem);
  }

  protected async startDebug(
    board: Board | undefined = this.boardsServiceProvider.boardsConfig
      .selectedBoard
  ): Promise<void> {
    if (!board) {
      return;
    }
    const { name, fqbn } = board;
    if (!fqbn) {
      return;
    }
    await this.hostedPluginSupport.didStart;
    const [sketch, executables] = await Promise.all([
      this.sketchServiceClient.currentSketch(),
      this.executableService.list(),
    ]);
    if (!sketch) {
      return;
    }
    const ideTempFolderUri = await this.sketchService.getIdeTempFolderUri(
      sketch
    );
    const [cliPath, sketchPath, configPath] = await Promise.all([
      this.fileService.fsPath(new URI(executables.cliUri)),
      this.fileService.fsPath(new URI(sketch.uri)),
      this.fileService.fsPath(new URI(ideTempFolderUri)),
    ]);
    const config = {
      cliPath,
      board: {
        fqbn,
        name,
      },
      sketchPath,
      configPath,
    };
    return this.commandService.executeCommand('arduino.debug.start', config);
  }
}

export namespace Debug {
  export namespace Commands {
    export const START_DEBUGGING: Command = {
      id: 'arduino-start-debug',
      label: 'Start Debugging',
      category: 'Arduino',
    };
  }
}