@onekeyfe/hd-core 1.2.0-alpha.18 → 1.2.0-alpha.19

package/src/device/Device.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import semver from 'semver';
-import { Enum_Capability } from '@onekeyfe/hd-transport';
+import { DeviceRebootType, Enum_Capability } from '@onekeyfe/hd-transport';
 import {
   EDeviceType,
   ERRORS,
@@ -32,10 +32,23 @@ import {
 import { generateInstanceId } from '../utils/tracing';
 // eslint-disable-next-line import/no-cycle
 import { DeviceCommands } from './DeviceCommands';
+import { mergeDeviceFeaturesPatch } from './DeviceFeaturesState';
+import {
+  mapDeviceSettingsToState,
+  mapFeaturesToState,
+  mapProtocolV1OnekeyFeaturesToState,
+  mapProtocolV2DeviceInfoToState,
+  mapProtocolV2DeviceStatusToState,
+} from './DeviceStateMapper';
+import { projectFeatures } from './DeviceStateProjector';
+import { DeviceStateStore, createPublicDeviceState } from './DeviceStateStore';
 import { deviceWalletSessionStore } from './DeviceWalletSessionStore';
 import {
   type DeviceFirmwareRange,
   DeviceModelToTypes,
+  type DeviceStateEvent,
+  type DeviceStatePatch,
+  type DeviceStateUpdateSource,
   DeviceTypeToModels,
   type Device as DeviceTyped,
   EOneKeyDeviceMode,
@@ -52,12 +65,16 @@ import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
 import {
+  PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
+  PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST,
+  PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
 } from '../protocols/protocol-v2/features';
-import { buildProtocolV1FeaturesPayload, buildProtocolV2FeaturesPayload } from '../deviceProfile';
+import { buildProtocolV1FeaturesPayload } from '../deviceProfile';
 
 import type { PROTO } from '../constants';
+import type { DeviceStateReadOptions } from '../types/api/getDeviceState';
 import type {
   DeviceButtonRequestPayload,
   DeviceFeaturesPayload,
@@ -80,6 +97,8 @@ export type InitOptions = {
   deriveCardano?: boolean;
   connectProtocol?: HardwareConnectProtocol;
   protocolV2DeviceInfoTimeoutMs?: number;
+  /** 设备发现内部使用：返回列表前刷新 Protocol V2 运行时状态。 */
+  refreshRuntimeState?: boolean;
 };
 
 export type RunOptions = {
@@ -100,6 +119,7 @@ export interface DeviceEvents {
   [DEVICE.ATTACH_PIN_ON_DEVICE]: [Device, PassphraseRequestPayload?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
   [DEVICE.FEATURES]: [Device, DeviceFeaturesPayload];
+  [DEVICE.STATE]: [Device, DeviceStateEvent];
   [DEVICE.PASSPHRASE]: [
     Device,
     PassphraseRequestPayload,
@@ -186,22 +206,26 @@ export class Device extends EventEmitter {
    */
   private deviceAcquired = false;
 
-  /**
-   * 唯一设备状态缓存。
-   *
-   * V1 直接保存原生 Features；V2 保存由 DeviceInfoGet 映射出的
-   * Features 视图。Device 不再保存 profile，结构化 DeviceProfile 只作为
-   * getDeviceInfo() 的 API 返回值存在。
-   */
-  features: Features | undefined = undefined;
+  /** 唯一设备状态缓存。旧 Features 仅通过 getter/setter 做兼容投影。 */
+  private stateStore = new DeviceStateStore();
 
-  /**
-   * 是否需要更新设备信息。
-   *
-   * 历史名称保留用于兼容现有调用语义；对 V2 表示 features 需要由
-   * DeviceInfoGet 刷新。
-   */
-  featuresNeedsReload = false;
+  /** 物理重连或重启后，下一次初始化必须重新读取 DeviceInfo。 */
+  private protocolV2StateNeedsReload = false;
+
+  get state() {
+    return this.stateStore.getState();
+  }
+
+  get features(): Features | undefined {
+    return this.state ? projectFeatures(this.state) : undefined;
+  }
+
+  set features(features: Features | undefined) {
+    this.stateStore = new DeviceStateStore();
+    if (features) {
+      this.stateStore.update(mapFeaturesToState(features), 'compatibility');
+    }
+  }
 
   runPromise?: Deferred<void> | null;
 
@@ -267,6 +291,7 @@ export class Device extends EventEmitter {
     const deviceId = this.getCurrentDeviceId() || null;
 
     const { features } = this;
+    const state = this.state ? createPublicDeviceState(this.state) : undefined;
 
     return {
       /** Android uses Mac address, iOS uses uuid, USB uses uuid  */
@@ -283,9 +308,11 @@ export class Device extends EventEmitter {
       path: this.originalDescriptor?.path,
       bleName,
       name: bleName || label || `OneKey ${deviceType?.toUpperCase()}`,
+      displayName: label || bleName || `OneKey ${deviceType?.toUpperCase()}`,
       label: label || 'OneKey',
       mode: this.getMode(),
       features,
+      state,
       sessionId: this.features?.sessionId ?? null,
       firmwareVersion: this.getFirmwareVersion(),
       bleFirmwareVersion: this.getBLEFirmwareVersion(),
@@ -725,15 +752,16 @@ export class Device extends EventEmitter {
     // Protocol V2 不支持传统 Initialize，直接使用协议专用初始化流程。
     if (this.isProtocolV2()) {
       this.passphraseState = options?.passphraseState;
-      if (this.features && !this.featuresNeedsReload && !options?.initSession) {
-        if (this.features.bootloaderMode) {
+      if (this.state && !options?.initSession && !this.protocolV2StateNeedsReload) {
+        if (this.features?.bootloaderMode) {
           return;
         }
-        // 普通业务调用复用缓存。动态状态由显式 getFeatures/deviceStatusGet、
+        // 普通业务调用复用缓存。动态状态由显式 getDeviceState refresh、
         // 解锁流程和设备事件刷新，避免每个 SDK 方法都额外轮询 DeviceStatus。
         return;
       }
       await this._initializeProtocolV2(options);
+      this.protocolV2StateNeedsReload = false;
       return;
     }
 
@@ -797,17 +825,10 @@ export class Device extends EventEmitter {
         commands: this.commands,
         timeoutMs: options?.protocolV2DeviceInfoTimeoutMs,
       });
-      const deviceStatus = await requestProtocolV2DeviceStatus({
-        commands: this.commands,
-      }).catch(error => {
-        Log.debug('Protocol V2 status unavailable during initialization:', error);
-        return undefined;
-      });
       // 默认请求不含 SE/hash 数据，scope 如实标注为 basic；
-      // 完整数据由 getDeviceInfo(scope:'verify'|'full') 获取。
-      const features = this.updateProtocolV2Features(deviceInfo, deviceStatus);
+      // 完整版本与校验数据由公共 getDeviceState({ scope: 'firmware' }) 显式获取。
+      const features = this.updateProtocolV2Features(deviceInfo, null);
       Log.debug('Protocol V2 features:', features);
-      this.featuresNeedsReload = false;
     } catch (error) {
       Log.error('Protocol V2 initialization failed:', error);
       throw error;
@@ -819,10 +840,7 @@ export class Device extends EventEmitter {
       const deviceInfo = await requestProtocolV2DeviceInfo({
         commands: this.commands,
       });
-      const deviceStatus = await requestProtocolV2DeviceStatus({
-        commands: this.commands,
-      }).catch(() => undefined);
-      return this.updateProtocolV2Features(deviceInfo, deviceStatus);
+      return this.updateProtocolV2Features(deviceInfo, null);
     }
 
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
@@ -830,6 +848,70 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
+  async getDeviceState(params: DeviceStateReadOptions = {}) {
+    const refresh = new Set(params.refreshSections ?? []);
+    const getProtocolV2DeviceInfoRequest = () => {
+      if (refresh.has('verification')) return PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST;
+      if (refresh.has('versions')) return PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST;
+      return PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST;
+    };
+    let initializedWithDeviceInfo = false;
+
+    if (!this.state) {
+      if (this.isProtocolV2()) {
+        const deviceInfo = await requestProtocolV2DeviceInfo({
+          commands: this.commands,
+          request: getProtocolV2DeviceInfoRequest(),
+        });
+        this.updateState(mapProtocolV2DeviceInfoToState(deviceInfo), 'device-info');
+        initializedWithDeviceInfo = true;
+      } else {
+        await this.getFeatures();
+      }
+    } else if (!this.isProtocolV2() && refresh.size > 0) {
+      await this.getFeatures();
+    }
+
+    if (!this.isProtocolV2() && refresh.has('verification')) {
+      const { message } = await this.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+      this.updateState(mapProtocolV1OnekeyFeaturesToState(message), 'device-info');
+    }
+
+    if (this.isProtocolV2()) {
+      const refreshDeviceInfo =
+        refresh.has('identity') || refresh.has('versions') || refresh.has('verification');
+      if (refreshDeviceInfo && !initializedWithDeviceInfo) {
+        const deviceInfo = await requestProtocolV2DeviceInfo({
+          commands: this.commands,
+          request: getProtocolV2DeviceInfoRequest(),
+        });
+        this.updateState(
+          mapProtocolV2DeviceInfoToState(deviceInfo, this.state?.status.mode),
+          'device-info'
+        );
+      }
+
+      if (refresh.has('status') && this.state?.status.mode === 'normal') {
+        const status = await requestProtocolV2DeviceStatus({ commands: this.commands });
+        this.updateState(mapProtocolV2DeviceStatusToState(status), 'device-status');
+      }
+
+      if (refresh.has('settings') && this.state?.status.mode === 'normal') {
+        const { message } = await this.commands.typedCall(
+          'DeviceSettingsGet',
+          'DeviceSettings',
+          {}
+        );
+        this.updateState(mapDeviceSettingsToState(message), 'apply-settings');
+      }
+    }
+
+    if (!this.state) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
+    return params.includeRaw ? structuredClone(this.state) : createPublicDeviceState(this.state);
+  }
+
   _updateFeatures(protoFeatures: PROTO.Features | Features, initSession?: boolean) {
     const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
     let feat =
@@ -845,7 +927,7 @@ export class Device extends EventEmitter {
 
     feat = fixFeaturesFirmwareVersion(feat);
 
-    this.features = feat;
+    this.updateState(mapFeaturesToState(feat), 'initialize');
     const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
     if (previousCacheDeviceKey && nextCacheDeviceKey) {
       deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
@@ -853,42 +935,131 @@ export class Device extends EventEmitter {
     if (feat.deviceId && feat.sessionId) {
       this.setInternalState(feat.sessionId, initSession);
     }
-    this.featuresNeedsReload = false;
-    this.emit(DEVICE.FEATURES, this, feat);
+  }
+
+  updateState(patch: DeviceStatePatch, source: DeviceStateUpdateSource) {
+    const result = this.stateStore.update(patch, source);
+    if (result.changedKeys.length === 0) return result.state;
+
+    const event: DeviceStateEvent = {
+      connectId: this.getConnectId() ?? null,
+      state: createPublicDeviceState(result.state),
+      revision: result.revision,
+      source,
+      changedKeys: result.changedKeys,
+    };
+    Log.debug('Device state patch committed', {
+      source,
+      keys: result.changedKeys,
+    });
+    this.emit(DEVICE.STATE, this, event);
+    if (result.state.protocol === 'V1') {
+      this.emit(DEVICE.FEATURES, this, projectFeatures(result.state));
+    }
+    return result.state;
+  }
+
+  clearCachedSession(deviceId?: string, passphraseState?: string) {
+    const current = this.state;
+    if (!current?.session) return false;
+    if (deviceId && current.identity.deviceId !== deviceId) return false;
+    if (passphraseState && current.session.passphraseState !== passphraseState) return false;
+    return this.stateStore.clearSession('session-clear') !== undefined;
+  }
+
+  updateFeaturesPatch(patch: Partial<Features>, source: DeviceStateUpdateSource) {
+    const currentFeatures = this.features;
+    if (!currentFeatures) return undefined;
+
+    const features = mergeDeviceFeaturesPatch(currentFeatures, patch);
+    if (features === currentFeatures) return currentFeatures;
+
+    const normalized = fixFeaturesFirmwareVersion(features);
+    this.updateState(mapFeaturesToState(normalized), source);
+    return this.features;
   }
 
   updateProtocolV2Features(deviceInfo?: ProtocolV2DeviceInfo, deviceStatus?: DeviceStatus | null) {
     const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
-    const resolvedDeviceStatus =
-      deviceStatus === undefined
-        ? this.features?.raw?.protocolV2DeviceStatus
-        : deviceStatus ?? undefined;
-    const features = fixFeaturesFirmwareVersion(
-      buildProtocolV2FeaturesPayload({
-        deviceInfo,
-        deviceStatus: resolvedDeviceStatus,
-        previous: this.features,
-      })
-    );
-    this.features = features;
+    if (deviceStatus) {
+      this.updateState(mapProtocolV2DeviceStatusToState(deviceStatus), 'device-status');
+    }
+    if (deviceInfo) {
+      this.updateState(
+        mapProtocolV2DeviceInfoToState(deviceInfo, this.state?.status.mode),
+        'device-info'
+      );
+    }
     const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
     if (previousCacheDeviceKey && nextCacheDeviceKey) {
       deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
     }
-    this.featuresNeedsReload = false;
-    this.emit(DEVICE.FEATURES, this, features);
-    return features;
+    return this.features as Features;
   }
 
   updateProtocolV2Status(status: DeviceStatus) {
-    const previousDeviceInfo = this.features?.raw?.protocolV2DeviceInfo;
-    const previousStatus = this.features?.raw?.protocolV2DeviceStatus;
+    const previousDeviceInfo = this.state?.raw?.protocolV2DeviceInfo;
+    const previousStatus = this.state?.raw?.protocolV2DeviceStatus;
     return this.updateProtocolV2Features(previousDeviceInfo, {
       ...previousStatus,
       ...status,
     });
   }
 
+  markTransportDisconnected() {
+    if (!this.isProtocolV2()) return;
+    this.protocolV2StateNeedsReload = true;
+    this.clearPreInitialized();
+    this.clearCachedSession();
+  }
+
+  markProtocolV2Reboot(rebootType: DeviceRebootType) {
+    if (!this.isProtocolV2()) return;
+
+    this.protocolV2StateNeedsReload = true;
+    this.clearPreInitialized();
+    let loaderMode: 'bootloader' | 'romloader' | undefined;
+    if (rebootType === DeviceRebootType.Bootloader) {
+      loaderMode = 'bootloader';
+    } else if (rebootType === DeviceRebootType.Romloader) {
+      loaderMode = 'romloader';
+    }
+    if (loaderMode) {
+      this.updateState(
+        {
+          identity: { deviceId: null },
+          status: {
+            mode: loaderMode,
+            initialized: null,
+            unlocked: null,
+            firmwarePresent: null,
+            backupRequired: null,
+            noBackup: null,
+            unfinishedBackup: null,
+            recoveryMode: null,
+            passphraseProtection: null,
+            pinProtection: null,
+            attachToPinEnabled: null,
+            unlockedAttachPin: null,
+          },
+          session: null,
+          raw: { protocolV2DeviceStatus: null },
+        },
+        'transport-reconnect'
+      );
+      return;
+    }
+
+    this.updateState(
+      {
+        status: { mode: 'normal', unlocked: null },
+        session: null,
+        raw: { protocolV2DeviceStatus: null },
+      },
+      'transport-reconnect'
+    );
+  }
+
   /**
    * 暂时只在 acquire 后更新 Session ID
    * 后续看是否有需要依据 listen 返回结果更新
@@ -955,6 +1126,7 @@ export class Device extends EventEmitter {
             }
           }
         } catch (error) {
+          await this.release();
           this.runPromise = null;
           if (error instanceof HardwareError) {
             return Promise.reject(error);
@@ -1055,22 +1227,23 @@ export class Device extends EventEmitter {
   }
 
   getMode() {
-    if (this.features?.bootloaderMode) {
-      // bootloader mode
-      return EOneKeyDeviceMode.bootloader;
-    }
-
-    if (!this.features?.initialized) {
-      // not initialized
-      return EOneKeyDeviceMode.notInitialized;
+    switch (this.state?.status.mode) {
+      case 'bootloader':
+      case 'romloader':
+        return EOneKeyDeviceMode.bootloader;
+      case 'notInitialized':
+        return EOneKeyDeviceMode.notInitialized;
+      case 'backupMode':
+        return EOneKeyDeviceMode.backupMode;
+      case 'normal':
+        return EOneKeyDeviceMode.normal;
+      default:
+        break;
     }
 
-    if (this.features?.noBackup) {
-      // backup mode
-      return EOneKeyDeviceMode.backupMode;
-    }
-
-    // normal mode
+    if (this.features?.bootloaderMode) return EOneKeyDeviceMode.bootloader;
+    if (this.features?.initialized === false) return EOneKeyDeviceMode.notInitialized;
+    if (this.features?.noBackup) return EOneKeyDeviceMode.backupMode;
     return EOneKeyDeviceMode.normal;
   }
 
@@ -1165,6 +1338,7 @@ export class Device extends EventEmitter {
 
   async lockDevice(): Promise<Success> {
     const res = await this.commands.typedCall('LockDevice', 'Success', {});
+    this.updateState({ status: { unlocked: false } }, 'lock');
     return res.message;
   }
 
@@ -1194,12 +1368,7 @@ export class Device extends EventEmitter {
         throw error;
       }
 
-      const { message: status } = await this.commands.typedCall(
-        'DeviceStatusGet',
-        'DeviceStatus',
-        {}
-      );
-      return this.updateProtocolV2Status(status);
+      return this.updateFeaturesPatch({ unlocked: true }, 'unlock');
     }
 
     const firmwareVersion = this.getCurrentFirmwareVersionString() ?? '0.0.0';
@@ -1220,11 +1389,20 @@ export class Device extends EventEmitter {
     if (supportUnlock) {
       const res = await this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
       if (this.features) {
-        this.features.unlocked = res.message.unlocked == null ? null : res.message.unlocked;
-        this.features.unlockedAttachPin =
-          res.message.unlocked_attach_pin == null ? undefined : res.message.unlocked_attach_pin;
-        this.features.passphraseProtection =
-          res.message.passphrase_protection == null ? null : res.message.passphrase_protection;
+        this.updateState(
+          {
+            status: {
+              unlocked: res.message.unlocked == null ? null : res.message.unlocked,
+              unlockedAttachPin:
+                res.message.unlocked_attach_pin == null ? null : res.message.unlocked_attach_pin,
+              passphraseProtection:
+                res.message.passphrase_protection == null
+                  ? null
+                  : res.message.passphrase_protection,
+            },
+          },
+          'unlock'
+        );
 
         return Promise.resolve(this.features);
       }

package/src/device/DeviceFeaturesState.ts

@@ -0,0 +1,34 @@
+import type { Features } from '../types';
+
+export type DeviceFeaturesUpdateSource =
+  | 'device-info'
+  | 'device-status'
+  | 'device-settings-get'
+  | 'device-settings-set'
+  | 'apply-settings'
+  | 'unlock'
+  | 'cache';
+
+/**
+ * 合并设备状态的字段级 patch。
+ *
+ * `undefined` 表示本次响应未提供该字段，不覆盖缓存；`null` 表示设备明确
+ * 返回空值，需要写入缓存。raw 等对象字段由调用方构造完整值后再传入，
+ * 这里不做隐式深合并。
+ */
+export function mergeDeviceFeaturesPatch(previous: Features, patch: Partial<Features>): Features {
+  let next = previous;
+
+  for (const [key, value] of Object.entries(patch) as Array<
+    [keyof Features, Features[keyof Features] | undefined]
+  >) {
+    if (value !== undefined && !Object.is(previous[key], value)) {
+      if (next === previous) {
+        next = { ...previous };
+      }
+      (next as Record<keyof Features, Features[keyof Features]>)[key] = value;
+    }
+  }
+
+  return next;
+}

package/src/device/DevicePool.ts

@@ -106,6 +106,7 @@ export class DevicePool extends EventEmitter {
         if (exist) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
+          await this._refreshRuntimeState(device, initOptions);
           devices[connectId] = device;
           deviceList.push(device);
           await this._checkDevicePool(initOptions, connectId);
@@ -156,12 +157,36 @@ export class DevicePool extends EventEmitter {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
       await device.connect(initOptions?.connectProtocol);
-      await device.initialize(initOptions);
-      await device.release();
+      try {
+        await device.initialize(initOptions);
+        if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
+          await device.getDeviceState({ refreshSections: ['status'] });
+        }
+      } finally {
+        await device.release();
+      }
     }
     return device;
   }
 
+  static async _refreshRuntimeState(device: Device, initOptions?: InitOptions) {
+    if (!initOptions?.refreshRuntimeState || !device.isProtocolV2()) return;
+    let refreshError: unknown;
+    await device.run(
+      async () => {
+        try {
+          await device.getDeviceState({ refreshSections: ['status'] });
+        } catch (error) {
+          // Device.run 在回调正常结束后统一 release；随后再把真实读取错误交给调用方。
+          refreshError = error;
+        }
+      },
+      { connectProtocol: initOptions.connectProtocol }
+    );
+    if (refreshError instanceof Error) throw refreshError;
+    if (refreshError) throw new Error(String(refreshError));
+  }
+
   static async _checkDevicePool(initOptions?: InitOptions, connectId?: string) {
     await this._sendConnectMessage(initOptions, connectId);
     this._sendDisconnectMessage();
@@ -170,21 +195,21 @@ export class DevicePool extends EventEmitter {
   static async _sendConnectMessage(initOptions?: InitOptions, connectId?: string) {
     for (let i = this.connectedPool.length - 1; i >= 0; i--) {
       const descriptor = this.connectedPool[i];
-      if (connectId && descriptor.path !== connectId) {
-        continue;
+      if (!connectId || descriptor.path === connectId) {
+        const device = await this._createDevice(descriptor, initOptions);
+        Log.debug('emit DEVICE.CONNECT: ', device?.features);
+        this.emitter.emit(DEVICE.CONNECT, device);
+        this.connectedPool.splice(i, 1);
       }
-      const device = await this._createDevice(descriptor, initOptions);
-      Log.debug('emit DEVICE.CONNECT: ', device?.features);
-      this.emitter.emit(DEVICE.CONNECT, device);
-      this.connectedPool.splice(i, 1);
     }
   }
 
   static _sendDisconnectMessage() {
     for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
-      const descriptor = this.connectedPool[i];
+      const descriptor = this.disconnectPool[i];
       const device = descriptor?.path ? this.getDeviceByPath(descriptor.path) : null;
       if (device) {
+        device.markTransportDisconnected();
         this.emitter.emit(DEVICE.DISCONNECT, device);
       }
       this.disconnectPool.splice(i, 1);
@@ -224,6 +249,7 @@ export class DevicePool extends EventEmitter {
       }
 
       Log.debug('emit DEVICE.DISCONNECT: ', device.features);
+      device.markTransportDisconnected();
       this.emitter.emit(DEVICE.DISCONNECT, device);
     });
   }