export async function activate()

in src/extension.ts [352:607]
227 lines of code
4 McCabe index (conditional complexity)

export async function activate(context: vscode.ExtensionContext): Promise<void> {
  printHello(context);

  const channelName = "Azure IoT Device Workbench";
  const outputChannel: vscode.OutputChannel = vscode.window.createOutputChannel(channelName);
  telemetryWorker = TelemetryWorker.getInstance(context);
  context.subscriptions.push(telemetryWorker);

  // Load iot Project here and do not ask to new an iot project when no iot
  // project open since no command has been triggered yet.
  const telemetryContext = telemetryWorker.createContext();
  await constructAndLoadIoTProject(context, outputChannel, telemetryContext, true);

  const deviceOperator = new DeviceOperator();
  const azureOperator = new AzureOperator();
  const exampleExplorer = new exampleExplorerModule.ExampleExplorer();

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.InitializeProject,
    EventNames.createNewProjectEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      const projectInitializer = new ProjectInitializer();
      return projectInitializer.InitializeProject(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.ConfigureProjectEnvironment,
    EventNames.configProjectEnvironmentEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      const projectEnvConfiger = new ProjectEnvironmentConfiger();
      return projectEnvConfiger.configureCmakeProjectEnvironment(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.AzureProvision,
    EventNames.azureProvisionEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return azureOperator.provision(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.AzureDeploy,
    EventNames.azureDeployEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return azureOperator.deploy(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.DeviceCompile,
    EventNames.deviceCompileEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return deviceOperator.compile(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.DeviceUpload,
    EventNames.deviceUploadEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return deviceOperator.upload(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.ConfigureDevice,
    EventNames.configDeviceSettingsEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return deviceOperator.configDeviceSettings(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.Examples,
    EventNames.openExamplePageEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      _outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      return exampleExplorer.selectBoard(context, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.ExampleInitialize,
    EventNames.loadExampleEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext,
      name?: string,
      url?: string,
      boardId?: string
    ): Promise<void> => {
      return exampleExplorer.initializeExample(context, outputChannel, telemetryContext, name, url, boardId);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.SendTelemetry,
    EventNames.openTutorial,
    true,
    async () => {
      // Do nothing.
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.IotPnPGenerateCode,
    EventNames.scaffoldDeviceStubEvent,
    true,
    async (
      context: vscode.ExtensionContext,
      outputChannel: vscode.OutputChannel,
      telemetryContext: TelemetryContext
    ): Promise<void> => {
      const codeGenerator = new CodeGeneratorCore();
      return codeGenerator.generateDeviceCodeStub(context, outputChannel, telemetryContext);
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.Help,
    EventNames.help,
    true,
    async () => {
      const boardId = ConfigHandler.get<string>(ConfigKey.boardId);

      if (boardId) {
        const boardListFolderPath = context.asAbsolutePath(
          path.join(FileNames.resourcesFolderName, FileNames.templatesFolderName)
        );
        const boardProvider = new BoardProvider(boardListFolderPath);
        const board = boardProvider.find({ id: boardId });

        if (board && board.helpUrl) {
          await vscode.commands.executeCommand(VscodeCommands.VscodeOpen, vscode.Uri.parse(board.helpUrl));
          return;
        }
      }
      const workbenchHelpUrl = "https://github.com/microsoft/vscode-iot-workbench/blob/master/README.md";
      await vscode.commands.executeCommand(VscodeCommands.VscodeOpen, vscode.Uri.parse(workbenchHelpUrl));
      return;
    }
  );

  initCommandWithTelemetry(
    context,
    telemetryWorker,
    outputChannel,
    WorkbenchCommands.Workbench,
    EventNames.setProjectDefaultPath,
    true,
    async () => {
      RemoteExtension.ensureLocalBeforeRunCommand("set default project path", context);
      const settings = await IoTWorkbenchSettings.getInstance();
      await settings.setWorkbenchPath();
      return;
    }
  );

  initCommand(context, WorkbenchCommands.OpenUri, async (uri: string) => {
    vscode.commands.executeCommand(VscodeCommands.VscodeOpen, vscode.Uri.parse(uri));
  });

  initCommand(context, WorkbenchCommands.HttpRequest, async (uri: string) => {
    const res = await request(uri);
    return res;
  });

  // delay to detect usb
  setTimeout(() => {
    enableUsbDetector(context, outputChannel);
  }, 200);

  // init DigitalTwin part
  // Deprecate digital twin feature in workbench.
  // initDigitalTwin(context, outputChannel);
}