👔 (webhid): Update reconnection logic

Author: valpinkman

packages/transport/web-hid/src/api/transport/WebHidDeviceConnection.test.ts

@@ -11,7 +11,6 @@ import {
 import { Left, Right } from "purify-ts";
 
 import { RECONNECT_DEVICE_TIMEOUT } from "@api/data/WebHidConfig";
-import { WebHidSendReportError } from "@api/model/Errors";
 import { hidDeviceStubBuilder } from "@api/model/HIDDevice.stub";
 
 import { WebHidDeviceConnection } from "./WebHidDeviceConnection";
@@ -130,12 +129,14 @@ describe("WebHidDeviceConnection", () => {
           } as HIDInputReportEvent),
         ),
       );
+
       const connection = new WebHidDeviceConnection(
         { device, apduSender, apduReceiver, onConnectionTerminated, deviceId },
         logger,
       );
 
       let hasResolved = false;
+
       const responsePromise = connection
         .sendApdu(Uint8Array.from([]), true)
         .then((response) => {
@@ -283,7 +284,12 @@ describe("WebHidDeviceConnection", () => {
 
       const response = await responsePromise;
 
-      expect(response).toEqual(Left(new WebHidSendReportError()));
+      expect(response).toEqual(
+        Right({
+          statusCode: new Uint8Array([0x55, 0x15]),
+          data: new Uint8Array([]),
+        }),
+      );
     });
   });
 });

packages/transport/web-hid/src/api/transport/WebHidDeviceConnection.ts

@@ -47,8 +47,8 @@ export class WebHidDeviceConnection implements DeviceConnection {
   private waitingForReconnection = false;
   /** Timeout to wait for the device to reconnect */
   private lostConnectionTimeout: Timer | null = null;
-  /** Time since disconnection */
-  private timeSinceDisconnection: Maybe<number> = Nothing;
+  /** Timestamp when the device was reconnected */
+  private timeOfReconnection: Maybe<number> = Nothing;
   /** Flag to indicate if the connection is terminated */
   private terminated = false;
 
@@ -133,6 +133,9 @@ export class WebHidDeviceConnection implements DeviceConnection {
       this._logger.debug("Sending Frame", {
         data: { frame: frame.getRawData() },
       });
+
+      await this.waitUntilDeviceIsReady();
+
       try {
         await this._device.sendReport(0, frame.getRawData());
       } catch (error) {
@@ -144,6 +147,18 @@ export class WebHidDeviceConnection implements DeviceConnection {
     return resultPromise;
   }
 
+  private async waitUntilDeviceIsReady() {
+    if (this.timeOfReconnection.isJust()) {
+      const timeSinceReconnection =
+        Date.now() - this.timeOfReconnection.extract();
+      if (timeSinceReconnection < 3000) {
+        await new Promise((res) =>
+          setTimeout(() => res(undefined), 3000 - timeSinceReconnection),
+        );
+      }
+    }
+  }
+
   private receiveHidInputReport(event: HIDInputReportEvent) {
     const data = new Uint8Array(event.data.buffer);
     this._logger.debug("Received Frame", {
@@ -178,14 +193,21 @@ export class WebHidDeviceConnection implements DeviceConnection {
       const sub = this.reconnectionSubject.subscribe({
         next: (res) => {
           if (waitingForDeviceResponse) {
-            this._sendApduSubject.error(new WebHidSendReportError());
+            this._sendApduSubject.error(
+              new WebHidSendReportError(
+                new Error(
+                  "Device disconnected while waiting for device repsonse",
+                ),
+              ),
+            );
           }
 
           if (res === "success") {
             resolve(Right(undefined));
           } else {
             resolve(Left(res));
           }
+
           sub.unsubscribe();
         },
       });
@@ -198,7 +220,6 @@ export class WebHidDeviceConnection implements DeviceConnection {
    * */
   public lostConnection() {
     this._logger.info("⏱️ Lost connection, starting timer");
-    this.timeSinceDisconnection = Maybe.of(Date.now());
     this.waitingForReconnection = true;
     this.lostConnectionTimeout = setTimeout(() => {
       this._logger.info("❌ Disconnection timeout, terminating connection");
@@ -212,24 +233,13 @@ export class WebHidDeviceConnection implements DeviceConnection {
     this._device.oninputreport = (event) => this.receiveHidInputReport(event);
 
     if (this.lostConnectionTimeout) {
-      this._logger.info("⏱️🔌 Device reconnected");
       clearTimeout(this.lostConnectionTimeout);
     }
 
     await device.open();
+    this._logger.info("⏱️🔌 Device reconnected");
 
-    if (this._pendingApdu.isJust()) {
-      if (this.timeSinceDisconnection.isJust()) {
-        const now = Date.now();
-        const timeSinceDisconnection =
-          now - this.timeSinceDisconnection.extract();
-        // 3 seconds timeout
-        if (timeSinceDisconnection > RECONNECT_DEVICE_TIMEOUT / 2) {
-          this._sendApduSubject.error(new WebHidSendReportError());
-        }
-      }
-      this.timeSinceDisconnection = Nothing;
-    }
+    this.timeOfReconnection = Maybe.of(Date.now());
 
     this.waitingForReconnection = false;
     this.reconnectionSubject.next("success");