get serial connection status from BE

Author: fstasi

arduino-ide-extension/src/browser/contributions/burn-bootloader.ts

@@ -81,7 +81,7 @@ export class BurnBootloader extends SketchContribution {
     } catch (e) {
       this.messageService.error(e.toString());
     } finally {
-      if (this.serialConnection.isSerialOpen()) {
+      if (this.serialConnection.widgetsAttached()) {
         await this.serialConnection.connect();
       }
     }

arduino-ide-extension/src/browser/contributions/upload-sketch.ts

@@ -283,7 +283,7 @@ export class UploadSketch extends SketchContribution {
       this.onDidChangeEmitter.fire();
 
       if (
-        this.serialConnection.isSerialOpen() &&
+        this.serialConnection.widgetsAttached() &&
         this.serialConnection.serialConfig
       ) {
         const { board, port } = this.serialConnection.serialConfig;

arduino-ide-extension/src/browser/serial/plotter/plotter-frontend-contribution.ts

@@ -87,15 +87,15 @@ export class PlotterFrontendContribution extends Contribution {
     }
   }
 
-  protected open(wsPort: number): void {
+  protected async open(wsPort: number): Promise<void> {
     const initConfig: Partial<SerialPlotter.Config> = {
       baudrates: SerialConfig.BaudRates.map((b) => b),
       currentBaudrate: this.model.baudRate,
       currentLineEnding: this.model.lineEnding,
       darkTheme: this.themeService.getCurrentTheme().type === 'dark',
       wsPort,
       interpolate: this.model.interpolate,
-      connected: this.serialConnection.connected,
+      connected: await this.serialConnection.isBESerialConnected(),
       serialPort: this.boardsServiceProvider.boardsConfig.selectedPort?.address,
     };
     const urlWithParams = queryString.stringifyUrl(

arduino-ide-extension/src/browser/serial/serial-connection-manager.ts

@@ -24,7 +24,6 @@ import { nls } from '@theia/core/lib/common/nls';
 @injectable()
 export class SerialConnectionManager {
   protected _state: Serial.State = [];
-  protected _connected = false;
   protected config: Partial<SerialConfig> = {
     board: undefined,
     port: undefined,
@@ -89,8 +88,11 @@ export class SerialConnectionManager {
     );
 
     // Handles the `baudRate` changes by reconnecting if required.
-    this.serialModel.onChange(({ property }) => {
-      if (property === 'baudRate' && this.connected) {
+    this.serialModel.onChange(async ({ property }) => {
+      if (
+        property === 'baudRate' &&
+        (await this.serialService.isSerialPortOpen())
+      ) {
         const { boardsConfig } = this.boardsServiceProvider;
         this.handleBoardConfigChange(boardsConfig);
       }
@@ -129,7 +131,7 @@ export class SerialConnectionManager {
     });
     if (
       configHasChanged &&
-      this.isSerialOpen() &&
+      this.widgetsAttached() &&
       !(await this.core.isUploading())
     ) {
       this.serialService.updateWsConfigParam({
@@ -188,9 +190,12 @@ export class SerialConnectionManager {
     const oldState = deepClone(this._state);
     let status = Status.OK;
 
-    if (this.isSerialOpen(oldState) && !this.isSerialOpen(newState)) {
+    if (this.widgetsAttached(oldState) && !this.widgetsAttached(newState)) {
       status = await this.disconnect();
-    } else if (!this.isSerialOpen(oldState) && this.isSerialOpen(newState)) {
+    } else if (
+      !this.widgetsAttached(oldState) &&
+      this.widgetsAttached(newState)
+    ) {
       if (await this.core.isUploading()) {
         this.messageService.error(`Cannot open serial port when uploading`);
         return Status.NOT_CONNECTED;
@@ -205,7 +210,7 @@ export class SerialConnectionManager {
     return this._state;
   }
 
-  isSerialOpen(state?: Serial.State): boolean {
+  widgetsAttached(state?: Serial.State): boolean {
     return (state ? state : this._state).length > 0;
   }
 
@@ -215,15 +220,10 @@ export class SerialConnectionManager {
       : undefined;
   }
 
-  get connected(): boolean {
-    return this._connected;
+  async isBESerialConnected(): Promise<boolean> {
+    return await this.serialService.isSerialPortOpen();
   }
 
-  set connected(c: boolean) {
-    this._connected = c;
-    this.serialService.updateWsConfigParam({ connected: c });
-    this.onConnectionChangedEmitter.fire(this._connected);
-  }
   /**
    * Called when a client opens the serial from the GUI
    *
@@ -275,8 +275,8 @@ export class SerialConnectionManager {
   /**
    * Handles error on the SerialServiceClient and try to reconnect, eventually
    */
-  handleError(error: SerialError): void {
-    if (!this.connected) return;
+  async handleError(error: SerialError): Promise<void> {
+    if (!(await this.serialService.isSerialPortOpen())) return;
     const { code, config } = error;
     const { board, port } = config;
     const options = { timeout: 3000 };
@@ -329,9 +329,8 @@ export class SerialConnectionManager {
         break;
       }
     }
-    this.connected = false;
 
-    if (this.isSerialOpen()) {
+    if (this.widgetsAttached()) {
       if (this.serialErrors.length >= 10) {
         this.messageService.warn(
           nls.localize(
@@ -371,7 +370,8 @@ export class SerialConnectionManager {
   }
 
   async connect(): Promise<Status> {
-    if (this.connected) return Status.ALREADY_CONNECTED;
+    if (await this.serialService.isSerialPortOpen())
+      return Status.ALREADY_CONNECTED;
     if (!isSerialConfig(this.config)) return Status.NOT_CONNECTED;
 
     console.info(
@@ -381,7 +381,6 @@ export class SerialConnectionManager {
     );
     const connectStatus = await this.serialService.connect(this.config);
     if (Status.isOK(connectStatus)) {
-      this.connected = true;
       console.info(
         `<<< Serial connection created for ${Board.toString(this.config.board, {
           useFqbn: false,
@@ -393,14 +392,13 @@ export class SerialConnectionManager {
   }
 
   async disconnect(): Promise<Status> {
-    if (!this.connected) {
+    if (!(await this.serialService.isSerialPortOpen())) {
       return Status.OK;
     }
 
     console.log('>>> Disposing existing serial connection...');
     const status = await this.serialService.disconnect();
     if (Status.isOK(status)) {
-      this.connected = false;
       console.log(
         `<<< Disposed serial connection. Was: ${Serial.Config.toString(
           this.config
@@ -424,7 +422,7 @@ export class SerialConnectionManager {
    * It is a NOOP if connected.
    */
   async send(data: string): Promise<Status> {
-    if (!this.connected) {
+    if (!(await this.serialService.isSerialPortOpen())) {
       return Status.NOT_CONNECTED;
     }
     return new Promise<Status>((resolve) => {

arduino-ide-extension/src/common/protocol/serial-service.ts

@@ -27,6 +27,7 @@ export interface SerialService extends JsonRpcServer<SerialServiceClient> {
   disconnect(): Promise<Status>;
   sendMessageToSerial(message: string): Promise<Status>;
   updateWsConfigParam(config: Partial<SerialPlotter.Config>): Promise<void>;
+  isSerialPortOpen(): Promise<boolean>;
 }
 
 export interface SerialConfig {

arduino-ide-extension/src/node/serial/serial-service-impl.ts

@@ -82,6 +82,10 @@ export class SerialServiceImpl implements SerialService {
   protected onMessageReceived: Disposable | null;
   protected flushMessagesInterval: NodeJS.Timeout | null;
 
+  async isSerialPortOpen(): Promise<boolean> {
+    return !!this.serialConnection;
+  }
+
   setClient(client: SerialServiceClient | undefined): void {
     this.client = client;
   }
@@ -140,6 +144,8 @@ export class SerialServiceImpl implements SerialService {
       }).bind(this)
     );
 
+    this.updateWsConfigParam({ connected: !!this.serialConnection });
+
     this.client?.notifyWebSocketChanged(
       this.webSocketService.getAddress().port
     );
@@ -280,6 +286,7 @@ export class SerialServiceImpl implements SerialService {
       this.serialConnection = undefined;
       return Status.OK;
     } finally {
+      this.updateWsConfigParam({ connected: !!this.serialConnection });
       this.messages.length = 0;
     }
   }

arduino-ide-extension/src/test/browser/serial-connection-manager.test.ts

@@ -147,7 +147,7 @@ describe.only('SerialConnectionManager', () => {
         it('should do nothing', async () => {
           const status = await subject.disconnect();
           expect(status).to.be.ok;
-          expect(subject.connected).to.be.false;
+          expect(await subject.isBESerialConnected()).to.be.false;
         });
       });
       context('and the config changes', () => {
@@ -188,17 +188,17 @@ describe.only('SerialConnectionManager', () => {
               serialService.verify((m) => m.disconnect(), Times.never());
               serialService.verify((m) => m.connect(It.isAny()), Times.once());
               expect(status).to.be.ok;
-              expect(subject.connected).to.be.true;
+              expect(await subject.isBESerialConnected()).to.be.true;
               expect(subject.getWsPort()).to.equal(wsPort);
-              expect(subject.isSerialOpen()).to.be.true;
+              expect(subject.widgetsAttached()).to.be.true;
               expect(subject.isWebSocketConnected()).to.be.false;
             });
             context('and it tries to open the serial monitor', () => {
               let status: Status;
               beforeEach(async () => {
                 status = await subject.openSerial(Serial.Type.Monitor);
               });
-              it('should open it using the same serial connection', () => {
+              it('should open it using the same serial connection', async () => {
                 messageService.verify(
                   (m) => m.error(It.isAnyString()),
                   Times.never()
@@ -209,8 +209,8 @@ describe.only('SerialConnectionManager', () => {
                   Times.once()
                 );
                 expect(status).to.be.ok;
-                expect(subject.connected).to.be.true;
-                expect(subject.isSerialOpen()).to.be.true;
+                expect(await subject.isBESerialConnected()).to.be.true;
+                expect(subject.widgetsAttached()).to.be.true;
               });
               it('should create a websocket connection', () => {
                 expect(subject.getWsPort()).to.equal(wsPort);
@@ -220,7 +220,7 @@ describe.only('SerialConnectionManager', () => {
                 beforeEach(async () => {
                   status = await subject.closeSerial(Serial.Type.Plotter);
                 });
-                it('should close the plotter without disconnecting from the serial', () => {
+                it('should close the plotter without disconnecting from the serial', async () => {
                   messageService.verify(
                     (m) => m.error(It.isAnyString()),
                     Times.never()
@@ -231,8 +231,8 @@ describe.only('SerialConnectionManager', () => {
                     Times.once()
                   );
                   expect(status).to.be.ok;
-                  expect(subject.connected).to.be.true;
-                  expect(subject.isSerialOpen()).to.be.true;
+                  expect(await subject.isBESerialConnected()).to.be.true;
+                  expect(subject.widgetsAttached()).to.be.true;
                   expect(subject.getWsPort()).to.equal(wsPort);
                 });
                 it('should not close the websocket connection', () => {
@@ -243,7 +243,7 @@ describe.only('SerialConnectionManager', () => {
                 beforeEach(async () => {
                   status = await subject.closeSerial(Serial.Type.Monitor);
                 });
-                it('should close the monitor without disconnecting from the serial', () => {
+                it('should close the monitor without disconnecting from the serial', async () => {
                   messageService.verify(
                     (m) => m.error(It.isAnyString()),
                     Times.never()
@@ -254,9 +254,9 @@ describe.only('SerialConnectionManager', () => {
                     Times.once()
                   );
                   expect(status).to.be.ok;
-                  expect(subject.connected).to.be.true;
+                  expect(await subject.isBESerialConnected()).to.be.true;
                   expect(subject.getWsPort()).to.equal(wsPort);
-                  expect(subject.isSerialOpen()).to.be.true;
+                  expect(subject.widgetsAttached()).to.be.true;
                 });
                 it('should close the websocket connection', () => {
                   expect(subject.isWebSocketConnected()).to.be.false;
@@ -267,7 +267,7 @@ describe.only('SerialConnectionManager', () => {
               beforeEach(async () => {
                 status = await subject.closeSerial(Serial.Type.Plotter);
               });
-              it('should successfully disconnect from the serial', () => {
+              it('should successfully disconnect from the serial', async () => {
                 messageService.verify(
                   (m) => m.error(It.isAnyString()),
                   Times.never()
@@ -278,9 +278,9 @@ describe.only('SerialConnectionManager', () => {
                   Times.once()
                 );
                 expect(status).to.be.ok;
-                expect(subject.connected).to.be.false;
+                expect(await subject.isBESerialConnected()).to.be.false;
                 expect(subject.getWsPort()).to.be.undefined;
-                expect(subject.isSerialOpen()).to.be.false;
+                expect(subject.widgetsAttached()).to.be.false;
                 expect(subject.isWebSocketConnected()).to.be.false;
               });
             });
@@ -337,9 +337,9 @@ describe.only('SerialConnectionManager', () => {
                 Times.once()
               );
               expect(status).to.be.false;
-              expect(subject.connected).to.be.false;
+              expect(await subject.isBESerialConnected()).to.be.false;
               expect(subject.getWsPort()).to.be.undefined;
-              expect(subject.isSerialOpen()).to.be.true;
+              expect(subject.widgetsAttached()).to.be.true;
             });
 
             context(
@@ -360,9 +360,9 @@ describe.only('SerialConnectionManager', () => {
                     (m) => m.connect(It.isValue(anotherSerialConfig)),
                     Times.once()
                   );
-                  expect(subject.connected).to.be.true;
+                  expect(await subject.isBESerialConnected()).to.be.true;
                   expect(subject.getWsPort()).to.equal(wsPort);
-                  expect(subject.isSerialOpen()).to.be.true;
+                  expect(subject.widgetsAttached()).to.be.true;
                   expect(subject.isWebSocketConnected()).to.be.false;
                 });
               }