@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/src/api/FirmwareUpdateV2.ts

@@ -276,94 +276,155 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
-    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
-    // Initialize left pending on the V1 transport is exactly what later times out
-    // and used to tear down the connection mid-firmware-upload.
-    let bleProbeInFlight = false;
+    // Bootloader probes can outlive the polling interval. Keep discovery and
+    // acquire serialized so concurrent ticks never race the same connection.
+    let probeInFlight = false;
 
     Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
     // check device goto bootloader mode
     let isFirstCheck = true;
     let checkCount = 0;
-    // eslint-disable-next-line prefer-const
+    let hasPromptedWebDevice = false;
+    let isPromptingWebDevice = false;
+    let isFinished = false;
+    let intervalTimer: ReturnType<typeof setInterval> | undefined;
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
 
     const deviceType = this.device?.getCurrentDeviceType();
     const isTouchOrProDevice = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
 
-    const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
-      async () => {
-        checkCount += 1;
-        Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
-        if (isTouchOrProDevice && isFirstCheck) {
-          isFirstCheck = false;
-          Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
-          await wait(3000);
-        }
+    const clearPollingTimers = () => {
+      if (intervalTimer !== undefined) {
+        clearInterval(intervalTimer);
+        intervalTimer = undefined;
+      }
+      if (timeoutTimer !== undefined) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = undefined;
+      }
+    };
 
-        if (
-          checkCount > 4 &&
-          DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-          !this.payload.skipWebDevicePrompt
-        ) {
-          clearInterval(intervalTimer);
-          clearTimeout(timeoutTimer);
+    const checkForBootloader = async (clearActiveTimers: boolean) => {
+      const found = await this._checkDeviceInBootloaderMode(
+        connectId,
+        clearActiveTimers ? intervalTimer : undefined,
+        clearActiveTimers ? timeoutTimer : undefined
+      );
+      if (found) {
+        isFinished = true;
+        clearPollingTimers();
+      }
+      return found;
+    };
 
-          try {
-            this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
-            const confirmed = await this._promptDeviceInBootloaderForWebDevice();
-            if (confirmed) {
-              await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
-            }
-          } catch (e) {
-            Log.log(
-              'FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ',
-              e
-            );
-            this.checkPromise?.reject(e);
+    let startPolling: () => void = () => undefined;
+    const pollForBootloader = async () => {
+      if (isFinished || isPromptingWebDevice || probeInFlight) return;
+      probeInFlight = true;
+      checkCount += 1;
+      Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+      if (isTouchOrProDevice && isFirstCheck) {
+        isFirstCheck = false;
+        Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
+        await wait(3000);
+      }
+
+      if (
+        checkCount > 4 &&
+        DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+        !this.payload.skipWebDevicePrompt &&
+        !hasPromptedWebDevice &&
+        !isPromptingWebDevice
+      ) {
+        clearPollingTimers();
+        isPromptingWebDevice = true;
+        try {
+          this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
+          const confirmed = await this._promptDeviceInBootloaderForWebDevice();
+          hasPromptedWebDevice = true;
+          if (confirmed) {
+            await checkForBootloader(false);
+          }
+          // WebUSB enumeration can still be empty immediately after the chooser
+          // resolves. Resume a fresh bounded polling window instead of leaving the
+          // deferred check pending forever after the original timers were paused.
+          if (!isFinished) {
+            startPolling();
           }
-          return;
+        } catch (e) {
+          isFinished = true;
+          clearPollingTimers();
+          Log.log(
+            'FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ',
+            e
+          );
+          this.checkPromise?.reject(e);
+        } finally {
+          isPromptingWebDevice = false;
+          probeInFlight = false;
         }
+        return;
+      }
 
-        if (isBleReconnect) {
-          if (bleProbeInFlight) return;
-          bleProbeInFlight = true;
-          try {
-            await this.device.deviceConnector?.acquire(
-              this.device.originalDescriptor.id,
-              null,
-              true,
-              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
-            );
-            // Bound each probe so a request the rebooting device never received
-            // frees the slot for the next tick instead of hanging into the
-            // 30s reboot budget.
-            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
-            if (this.device.isBootloader()) {
-              clearInterval(intervalTimer);
-              this.checkPromise?.resolve(true);
-            }
-          } catch (e) {
-            // ignore error because of device is not connected
-            Log.log('catch Bluetooth error when device is restarting: ', e);
-          } finally {
-            bleProbeInFlight = false;
+      if (isBleReconnect) {
+        try {
+          await this.device.deviceConnector?.acquire(
+            this.device.originalDescriptor.id,
+            null,
+            true,
+            this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
+          );
+          // Bound each probe so a request the rebooting device never received
+          // frees the slot for the next tick instead of hanging into the
+          // 30s reboot budget.
+          await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
+          if (this.device.isBootloader()) {
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.resolve(true);
           }
-        } else {
-          await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
+        } catch (e) {
+          // ignore error because of device is not connected
+          Log.log('catch Bluetooth error when device is restarting: ', e);
+        } finally {
+          probeInFlight = false;
+        }
+      } else {
+        try {
+          await checkForBootloader(true);
+        } finally {
+          probeInFlight = false;
         }
-      },
-      isBleReconnect ? 3000 : 2000
-    );
-
-    // check goto bootloader mode timeout and throw error
-    timeoutTimer = setTimeout(() => {
-      if (this.checkPromise) {
-        clearInterval(intervalTimer);
-        this.checkPromise.reject(new Error());
       }
-    }, 30000);
+    };
+
+    startPolling = () => {
+      if (isFinished) return;
+      clearPollingTimers();
+      intervalTimer = setInterval(
+        () => {
+          pollForBootloader().catch(error => {
+            if (isFinished) return;
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.reject(error);
+          });
+        },
+        isBleReconnect ? 3000 : 2000
+      );
+      // Each automatic polling phase is bounded. Time spent in the browser's
+      // permission chooser is intentionally excluded from this deadline.
+      timeoutTimer = setTimeout(() => {
+        if (!isFinished && this.checkPromise) {
+          isFinished = true;
+          clearPollingTimers();
+          this.checkPromise.reject(new Error());
+        }
+      }, 30000);
+    };
+
+    startPolling();
   }
 
   private async _checkDeviceInBootloaderMode(

package/src/api/FirmwareUpdateV3.ts

@@ -609,29 +609,40 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       try {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
         const timeoutMs = 3000;
-        const featuresRes = await Promise.race<TypedResponseMessage<'Features'>>([
-          typedCall('GetFeatures', 'Features', {}),
-          new Promise<never>((_, reject) => {
-            setTimeout(
-              () =>
-                reject(
-                  ERRORS.TypedError(
-                    HardwareErrorCode.CallMethodNotResponse,
-                    'GetFeatures timeout',
-                    { method: 'GetFeatures', timeoutMs }
-                  )
-                ),
-              timeoutMs
-            );
-          }),
-        ]);
+        const isBrowserWebUsb = DataManager.isBrowserWebUsb(DataManager.getSettings('env'));
+        const getFeaturesPromise = isBrowserWebUsb
+          ? typedCall('GetFeatures', 'Features', {}, { timeoutMs })
+          : typedCall('GetFeatures', 'Features', {});
+        // WebUSB owns timeout cleanup so a reboot cannot leave a pending transfer blocking reconnect.
+        const featuresRes = isBrowserWebUsb
+          ? await getFeaturesPromise
+          : await Promise.race<TypedResponseMessage<'Features'>>([
+              getFeaturesPromise,
+              new Promise<never>((_, reject) => {
+                setTimeout(
+                  () =>
+                    reject(
+                      ERRORS.TypedError(
+                        HardwareErrorCode.CallMethodNotResponse,
+                        'GetFeatures timeout',
+                        { method: 'GetFeatures', timeoutMs }
+                      )
+                    ),
+                  timeoutMs
+                );
+              }),
+            ]);
         getFeaturesTimeoutCount = 0;
         const features = buildProtocolV1FeaturesPayload(featuresRes.message, this.device.features);
         const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
         const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
         const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
-        // Treat update as complete once firmware version becomes non-zero
-        if (firmwareVersion !== '0.0.0') {
+        // Browser WebUSB may read updater Features before the final reboot. Do not let cached
+        // pre-update versions promote a current 0.0.0 response to install completion.
+        const completionFirmwareVersion = isBrowserWebUsb
+          ? getDeviceFirmwareVersion(featuresRes.message).join('.')
+          : firmwareVersion;
+        if (completionFirmwareVersion !== '0.0.0') {
           this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
           DevicePool.resetState();
           return {
@@ -640,7 +651,6 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             firmwareVersion,
           };
         }
-        // Still in update mode; continue polling (e.g., iOS may return firmwareVersion 0.0.0 during switches)
         await wait(1000);
       } catch (error) {
         Log.log('getFeatures error', error);