✨ (core): Device reconnection with 2s timeout

.changeset/rare-tips-stare.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/device-sdk-core": patch
+---
+
+Device reconnection on app change

packages/core/src/internal/discovery/use-case/ConnectUseCase.ts

@@ -9,7 +9,10 @@ import { loggerTypes } from "@internal/logger-publisher/di/loggerTypes";
 import { LoggerPublisherService } from "@internal/logger-publisher/service/LoggerPublisherService";
 import { usbDiTypes } from "@internal/usb/di/usbDiTypes";
 import type { UsbHidTransport } from "@internal/usb/transport/UsbHidTransport";
-import type { DisconnectHandler } from "@internal/usb/transport/WebUsbHidTransport";
+import {
+  DisconnectHandler,
+  ReconnectHandler,
+} from "@internal/usb/transport/WebUsbHidTransport";
 
 /**
  * The arguments for the ConnectUseCase.
@@ -45,18 +48,31 @@ export class ConnectUseCase {
     this._logger = loggerFactory("ConnectUseCase");
   }
 
-  private handleHardwareDisconnect: DisconnectHandler = (deviceId) => {
+  private handleDeviceDisconnect: DisconnectHandler = (deviceId) => {
     const deviceSessionOrError =
       this._sessionService.getDeviceSessionByDeviceId(deviceId);
     deviceSessionOrError.map((deviceSession) => {
       this._sessionService.removeDeviceSession(deviceSession.id);
     });
   };
 
+  private handleDeviceReconnect: ReconnectHandler = (
+    deviceId,
+    deviceConnection,
+  ) => {
+    const deviceSessionOrError =
+      this._sessionService.getDeviceSessionByDeviceId(deviceId);
+    deviceSessionOrError.map((deviceSession) => {
+      const { connectedDevice } = deviceSession;
+      connectedDevice.sendApdu = deviceConnection.sendApdu;
+    });
+  };
+
   async execute({ deviceId }: ConnectUseCaseArgs): Promise<DeviceSessionId> {
     const either = await this._usbHidTransport.connect({
       deviceId,
-      onDisconnect: this.handleHardwareDisconnect,
+      onDisconnect: this.handleDeviceDisconnect,
+      onReconnect: this.handleDeviceReconnect,
     });
 
     return either.caseOf({

packages/core/src/internal/usb/data/UsbHidConfig.ts

@@ -1,3 +1,4 @@
 // [SHOULD] Move it to device-model module
 export const LEDGER_VENDOR_ID = 0x2c97;
 export const FRAME_SIZE = 64;
+export const RECONNECT_DEVICE_TIMEOUT = 5000;

packages/core/src/internal/usb/model/InternalConnectedDevice.ts

@@ -16,7 +16,7 @@ export type ConnectedDeviceConstructorArgs = {
 export class InternalConnectedDevice {
   public readonly id: DeviceId;
   public readonly deviceModel: InternalDeviceModel;
-  public readonly sendApdu: SendApduFnType;
+  public sendApdu: SendApduFnType;
   public readonly type: ConnectionType;
 
   constructor({

packages/core/src/internal/usb/transport/UsbHidDeviceConnection.ts

@@ -52,7 +52,11 @@ export class UsbHidDeviceConnection implements DeviceConnection {
       this._logger.debug("Sending Frame", {
         data: { frame: frame.getRawData() },
       });
-      await this._device.sendReport(0, frame.getRawData());
+      try {
+        await this._device.sendReport(0, frame.getRawData());
+      } catch (error) {
+        this._logger.error("Error sending frame", { data: { error } });
+      }
     }
 
     return new Promise((resolve) => {

packages/core/src/internal/usb/transport/UsbHidTransport.ts

@@ -6,7 +6,10 @@ import { SdkError } from "@api/Error";
 import { ConnectError } from "@internal/usb/model/Errors";
 import { InternalConnectedDevice } from "@internal/usb/model/InternalConnectedDevice";
 import { InternalDiscoveredDevice } from "@internal/usb/model/InternalDiscoveredDevice";
-import type { DisconnectHandler } from "@internal/usb/transport/WebUsbHidTransport";
+import type {
+  DisconnectHandler,
+  ReconnectHandler,
+} from "@internal/usb/transport/WebUsbHidTransport";
 
 /**
  * Transport interface representing a USB HID communication
@@ -27,6 +30,7 @@ export interface UsbHidTransport {
   connect(params: {
     deviceId: DeviceId;
     onDisconnect: DisconnectHandler;
+    onReconnect: ReconnectHandler;
   }): Promise<Either<ConnectError, InternalConnectedDevice>>;
 
   disconnect(params: {

packages/core/src/internal/usb/transport/WebUsbHidTransport.test.ts

@@ -3,6 +3,7 @@ import { Left, Right } from "purify-ts";
 import { DeviceModel, DeviceModelId } from "@api/device/DeviceModel";
 import { StaticDeviceModelDataSource } from "@internal/device-model/data/StaticDeviceModelDataSource";
 import { DefaultLoggerPublisherService } from "@internal/logger-publisher/service/DefaultLoggerPublisherService";
+import { RECONNECT_DEVICE_TIMEOUT } from "@internal/usb/data/UsbHidConfig";
 import {
   DeviceNotRecognizedError,
   NoAccessibleDeviceError,
@@ -239,7 +240,11 @@ describe("WebUsbHidTransport", () => {
 
     describe("connect", () => {
       it("should throw UnknownDeviceError if no internal device", async () => {
-        const connectParams = { deviceId: "fake", onDisconnect: jest.fn() };
+        const connectParams = {
+          deviceId: "fake",
+          onDisconnect: jest.fn(),
+          onReconnect: jest.fn(),
+        };
 
         const connect = await transport.connect(connectParams);
 
@@ -249,7 +254,11 @@ describe("WebUsbHidTransport", () => {
       });
 
       it("should throw OpeningConnectionError if the device is already opened", async () => {
-        const device = { deviceId: "fake", onDisconnect: jest.fn() };
+        const device = {
+          deviceId: "fake",
+          onDisconnect: jest.fn(),
+          onReconnect: jest.fn(),
+        };
 
         const connect = await transport.connect(device);
 
@@ -275,6 +284,7 @@ describe("WebUsbHidTransport", () => {
               .connect({
                 deviceId: discoveredDevice.id,
                 onDisconnect: jest.fn(),
+                onReconnect: jest.fn(),
               })
               .then((value) => {
                 expect(value).toStrictEqual(
@@ -309,6 +319,7 @@ describe("WebUsbHidTransport", () => {
               .connect({
                 deviceId: discoveredDevice.id,
                 onDisconnect: jest.fn(),
+                onReconnect: jest.fn(),
               })
               .then((connectedDevice) => {
                 connectedDevice
@@ -341,6 +352,7 @@ describe("WebUsbHidTransport", () => {
               .connect({
                 deviceId: discoveredDevice.id,
                 onDisconnect: jest.fn(),
+                onReconnect: jest.fn(),
               })
               .then((connectedDevice) => {
                 connectedDevice
@@ -366,6 +378,9 @@ describe("WebUsbHidTransport", () => {
     });
 
     describe("disconnect", () => {
+      beforeAll(() => {
+        jest.useFakeTimers();
+      });
       it("should throw an error if the device is not connected", async () => {
         // given
         const connectedDevice = connectedDeviceStubBuilder();
@@ -389,6 +404,7 @@ describe("WebUsbHidTransport", () => {
               .connect({
                 deviceId: discoveredDevice.id,
                 onDisconnect: jest.fn(),
+                onReconnect: jest.fn(),
               })
               .then((connectedDevice) => {
                 connectedDevice
@@ -420,6 +436,8 @@ describe("WebUsbHidTransport", () => {
       it("should call disconnect handler if a connected device is unplugged", (done) => {
         // given
         const onDisconnect = jest.fn();
+        const onReconnect = jest.fn();
+        const disconnectSpy = jest.spyOn(transport, "disconnect");
         mockedRequestDevice.mockResolvedValueOnce([stubDevice]);
 
         // when
@@ -429,15 +447,17 @@ describe("WebUsbHidTransport", () => {
               .connect({
                 deviceId: discoveredDevice.id,
                 onDisconnect,
+                onReconnect,
               })
               .then(() => {
                 // @ts-expect-error trying to access private member
                 transport.handleDeviceDisconnectionEvent({
                   device: { productId: stubDevice.productId },
                 } as Event);
 
+                jest.advanceTimersByTime(RECONNECT_DEVICE_TIMEOUT);
                 // then
-                expect(onDisconnect).toHaveBeenCalled();
+                expect(disconnectSpy).toHaveBeenCalled();
                 done();
               })
               .catch((error) => {