@mcesystems/adb-kit 1.0.92 → 1.0.94

package/dist/index.js

@@ -30217,12 +30217,12 @@ __export(index_exports, {
   USB_DEBUGGING_EVENT_AUTHORIZED: () => USB_DEBUGGING_EVENT_AUTHORIZED,
   USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW: () => USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW,
   USB_DEBUGGING_EVENT_OFF: () => USB_DEBUGGING_EVENT_OFF,
+  UsbDebuggingEventEmitter: () => UsbDebuggingEventEmitter,
   readAll: () => readAll
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/logic/adbDeviceKit.ts
-var import_node_events = require("node:events");
 var adbkit = __toESM(require_dist());
 
 // ../tool-debug/dist/index.mjs
@@ -31358,9 +31358,21 @@ function portNumbers(from, to) {
 }
 
 // src/types/usbDebugging.ts
+var import_node_events = __toESM(require("node:events"));
 var USB_DEBUGGING_EVENT_OFF = "usbDebuggingOff";
 var USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW = "usbDebuggingNeedsAlwaysAllow";
 var USB_DEBUGGING_EVENT_AUTHORIZED = "usbDebuggingAuthorized";
+var UsbDebuggingEventEmitter = class extends import_node_events.default {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+};
 
 // src/utils/adbPath.ts
 var import_node_fs = require("node:fs");
@@ -31546,96 +31558,46 @@ var AdbDeviceKit = class {
   matchesDeviceId(device) {
     return device.id === this.deviceId || device.id.endsWith(this.deviceId);
   }
-  waitForUsbDebugging(timeout2 = 12e4, _numberOfAllowedAttempts = 5) {
-    const events = new import_node_events.EventEmitter();
-    const promise = (async () => {
-      const device = (await this.client.listDevices()).find((device2) => device2.id === this.deviceId);
-      logDetail(`Device: ${device?.id} (${device?.type})`);
-      if (device?.type === "device") {
-        logDetail("USB debugging is already enabled");
-        return true;
-      }
-      const trackingClient = this.createTrackingClient();
-      const tracker = await trackingClient.trackDevices();
-      if (device?.type === "unauthorized") {
+  async trackUsbDebuggingStatus(eventEmitter) {
+    const device = (await this.client.listDevices()).find(
+      (device2) => device2.id === this.deviceId
+    );
+    logDetail(`Device: ${device?.id} (${device?.type})`);
+    if (device?.type === "device") {
+      logDetail("USB debugging is already enabled");
+      eventEmitter.emit(USB_DEBUGGING_EVENT_AUTHORIZED, { deviceId: this.deviceId });
+      return () => {
+      };
+    }
+    if (device?.type === "unauthorized") {
+      logDetail("Device needs 'Always allow' authorization");
+      eventEmitter.emit(USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW, { deviceId: this.deviceId });
+    } else {
+      logDetail("Device is not authorized");
+      eventEmitter.emit(USB_DEBUGGING_EVENT_OFF, { deviceId: this.deviceId });
+    }
+    const trackingClient = this.createTrackingClient();
+    const tracker = await trackingClient.trackDevices();
+    tracker.on("remove", (_) => {
+      logError("Device removed from tracker");
+      eventEmitter.emit(USB_DEBUGGING_EVENT_OFF, { deviceId: this.deviceId });
+    });
+    tracker.on("change", (device2) => {
+      if (!this.matchesDeviceId(device2)) return;
+      if (device2.type === "unauthorized") {
         logDetail("Device needs 'Always allow' authorization");
-        events.emit(USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW);
-      } else {
-        events.emit(USB_DEBUGGING_EVENT_OFF);
-      }
-      let settled = false;
-      return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-          logError("Timeout waiting for USB debugging");
-          settle({ type: "reject", err: new Error("Timeout waiting for USB debugging") });
-        }, timeout2);
-        const cleanupTrackingClient = () => {
-          try {
-            tracker.end();
-          } catch {
-          }
-          trackingClient.on("error", () => {
-          });
-        };
-        const settle = (result) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timeoutId);
-          cleanupTrackingClient();
-          if (result.type === "resolve") {
-            resolve(result.value);
-          } else {
-            logError(result.err.message);
-            reject(result.err);
-          }
-        };
-        const handleAddOrChange = (device2) => {
-          if (!this.matchesDeviceId(device2)) return;
-          if (device2.type === "unauthorized") {
-            logDetail("Device needs 'Always allow' authorization");
-            events.emit(USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW);
-            return;
-          }
-          if (device2.type === "device") {
-            logDetail("Device authorized");
-            events.emit(USB_DEBUGGING_EVENT_AUTHORIZED);
-            settle({ type: "resolve", value: true });
-          }
-        };
-        trackingClient.on("error", (err) => {
-          if (isConnectionErrorMessage(err)) {
-            logDetail(`Tracking client connection closed: ${err.message}`);
-            settle({ type: "resolve", value: false });
-          } else {
-            logError(`Tracking client error: ${err.message}`);
-            settle({ type: "reject", err });
-          }
-        });
-        tracker.on("error", (err) => {
-          if (isConnectionErrorMessage(err)) {
-            logDetail(`Tracker connection closed: ${err.message}`);
-            settle({ type: "resolve", value: false });
-          } else {
-            logError(`Tracker error: ${err.message}`);
-            settle({ type: "reject", err });
-          }
-        });
-        tracker.on("end", () => {
-          logDetail("Device tracking ended");
-          settle({ type: "resolve", value: false });
-        });
-        tracker.on("remove", (_) => {
-          logError("Device removed from tracker");
-          settle({
-            type: "reject",
-            err: new Error("Device removed while waiting for USB debugging")
-          });
-        });
-        tracker.on("add", handleAddOrChange);
-        tracker.on("change", handleAddOrChange);
-      });
-    })();
-    return { promise, events };
+        eventEmitter.emit(USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW, { deviceId: this.deviceId });
+      }
+      if (device2.type === "device") {
+        logDetail("Device authorized");
+        eventEmitter.emit(USB_DEBUGGING_EVENT_AUTHORIZED, { deviceId: this.deviceId });
+      }
+      if (!device2.type) {
+        logDetail("Device removed from tracker");
+        eventEmitter.emit(USB_DEBUGGING_EVENT_OFF, { deviceId: this.deviceId });
+      }
+    });
+    return () => tracker.end();
   }
   async startPortForward(serviceName) {
     if (this.devicePort) {
@@ -31668,6 +31630,7 @@ var readAll = import_adbkit.default.util.readAll;
   USB_DEBUGGING_EVENT_AUTHORIZED,
   USB_DEBUGGING_EVENT_NEEDS_ALWAYS_ALLOW,
   USB_DEBUGGING_EVENT_OFF,
+  UsbDebuggingEventEmitter,
   readAll
 });
 //# sourceMappingURL=index.js.map