android-emulator-webrtc 1.0.18 → 2.0.1

package/dist/components/emulator/net/logcat.js

@@ -9,8 +9,6 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _events = require("events");
-require("../../../proto/emulator_controller_pb");
-var _emulator_web_client = require("../../../proto/emulator_web_client");
 /*
  * Copyright 2019 The Android Open Source Project
  *
@@ -29,7 +27,7 @@ var _emulator_web_client = require("../../../proto/emulator_web_client");
 /**
  * Observe the logcat stream from the emulator.
  *
- * Streaming is done by either polling the emulator endpoint or making a streaming call.
+ * Streaming is done by polling the emulator REST endpoint.
  *
  * It will send out the following events:
  *
@@ -46,10 +44,10 @@ var Logcat = /*#__PURE__*/(0, _createClass2["default"])(
  * - `unauthorized()` a function that gets called when a 401 was received.
  *
  * @constructor
- * @param {object} uriOrEmulator
- * @param {object} auth
+ * @param {string} logcatUrl Full REST URL to the logcat endpoint.
+ * @param {object} auth Authentication helper.
  */
-function Logcat(uriOrEmulator, auth) {
+function Logcat(logcatUrl, auth) {
   var _this = this;
   (0, _classCallCheck2["default"])(this, Logcat);
   /**
@@ -78,9 +76,6 @@ function Logcat(uriOrEmulator, auth) {
    * @memberof Logcat
    */
   (0, _defineProperty2["default"])(this, "stop", function () {
-    if (_this.stream) {
-      _this.stream.cancel();
-    }
     if (_this.timerID) {
       clearInterval(_this.timerID);
       _this.timerID = null;
@@ -89,70 +84,58 @@ function Logcat(uriOrEmulator, auth) {
   });
   (0, _defineProperty2["default"])(this, "pollStream", function () {
     var self = _this;
-    /* eslint-disable */
-    var request = new proto.android.emulation.control.LogMessage();
-    request.setStart(_this.offset);
-    _this.emulator.getLogcat(request, {}, function (err, response) {
-      if (err) {
-        _this.stop();
+    var url = new URL(_this.logcatUrl);
+    url.searchParams.append("start", _this.offset);
+    var headers = {
+      "Accept": "application/json"
+    };
+    if (_this.auth && _this.auth.authHeader) {
+      Object.assign(headers, _this.auth.authHeader());
+    }
+    fetch(url.toString(), {
+      headers: headers
+    }).then(function (res) {
+      if (res.status === 401 && _this.auth && _this.auth.unauthorized) {
+        _this.auth.unauthorized();
       }
-      if (response) {
-        var nextOffset = response.getNext();
-        if (nextOffset > self.offset) {
-          self.offset = response.getNext();
-          self.events.emit("data", response.getContents());
-        }
+      if (!res.ok) {
+        throw new Error("HTTP error " + res.status);
       }
-    });
-  });
-  // Uses streaming, this really locks up the ui, so best not to use for now.
-  (0, _defineProperty2["default"])(this, "stream", function () {
-    var self = _this;
-    /* eslint-disable */
-    var request = new proto.android.emulation.control.LogMessage();
-    request.setStart(_this.offset);
-    _this.stream = _this.emulator.streamLogcat(request);
-    _this.stream.on("data", function (response) {
-      self.offset = response.getNext();
-      var contents = response.getContents();
-      self.events.emit("data", contents);
-    });
-    _this.stream.on("error", function (error) {
-      if (error.code = 1) {
-        // Ignore we got cancelled.
+      return res.json();
+    }).then(function (response) {
+      var nextOffset = response.next;
+      if (nextOffset > self.offset) {
+        self.offset = nextOffset;
+        self.events.emit("data", response.contents);
       }
+    })["catch"](function (err) {
+      console.error("Logcat error:", err);
+      _this.stop();
     });
   });
   /**
    * Requests the logcat stream, invoking the callback when a log line arrives.
    *
-   * *Note:* Streaming can cause serious UI delays, so best not to use it.
-   *
    * @param  {Callback} fnNotify when a new log line arrives.
-   * @param  {number} refreshRate polling interval, or 0 if you wish to use streaming.
+   * @param  {number} refreshRate polling interval. Must be > 0.
    * @memberof Logcat
    */
   (0, _defineProperty2["default"])(this, "start", function (fnNotify) {
     var refreshRate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
     if (fnNotify) _this.on("data", fnNotify);
     _this.refreshRate = refreshRate;
-    if (_this.refreshRate > 0) {
-      _this.timerID = setInterval(function () {
-        return _this.pollStream();
-      }, _this.refreshRate);
-    } else {
-      _this.stream();
+    if (_this.refreshRate <= 0) {
+      console.warn("Streaming logcat is no longer supported. Falling back to 1000ms polling.");
+      _this.refreshRate = 1000;
     }
+    _this.timerID = setInterval(function () {
+      return _this.pollStream();
+    }, _this.refreshRate);
     _this.events.emit("start");
   });
-  if (uriOrEmulator instanceof _emulator_web_client.EmulatorControllerService) {
-    this.emulator = uriOrEmulator;
-  } else {
-    this.emulator = new _emulator_web_client.EmulatorControllerService(uriOrEmulator, auth);
-  }
+  this.logcatUrl = logcatUrl;
+  this.auth = auth;
   this.offset = 0;
-  this.lastline = "";
-  this.stream = null;
   this.events = new _events.EventEmitter();
   this.refreshRate = 1000;
   this.timerID = null;

package/dist/components/emulator/net/logger.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Configures and exports a loglevel logger instance scoped to
+ * the 'android-emulator-webrtc' package.
+ */
+import log from "loglevel";
+declare const logger: log.Logger;
+export default logger;

package/dist/components/emulator/net/logger.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _loglevel = _interopRequireDefault(require("loglevel"));
+/**
+ * @fileoverview Configures and exports a loglevel logger instance scoped to
+ * the 'android-emulator-webrtc' package.
+ */
+
+// Create a logger specific to the emulator package
+var logger = _loglevel["default"].getLogger("android-emulator-webrtc");
+
+// Default to "info" level so that verbose signaling (debug) is hidden by default,
+// but warnings and errors are still printed.
+logger.setDefaultLevel("info");
+var _default = exports["default"] = logger;

package/dist/components/emulator/net/ws_jsep_protocol_driver.d.ts

@@ -0,0 +1,213 @@
+export interface WsJsepConfig {
+    enableLogging?: boolean;
+    onError?: (error: Error | Event) => void;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
+    reconnectBackoffFactor?: number;
+    [key: string]: any;
+}
+export interface StreamCallbacks {
+    onConnected?: (track: MediaStreamTrack) => void;
+    onDisconnected?: (driver: WsJsepProtocol) => void;
+}
+export interface EmulatorController {
+    sendMouse?(msg: any): void;
+    sendKey?(msg: any): void;
+    sendTouch?(msg: any): void;
+}
+export interface JsepSignal {
+    start?: RTCConfiguration;
+    type?: "offer" | "answer";
+    sdp?: RTCSessionDescriptionInit | string;
+    candidate?: RTCIceCandidateInit | string;
+    bye?: boolean;
+}
+/**
+ * A JSEP protocol driver that uses WebSockets for signaling.
+ *
+ * @export
+ * @class WsJsepProtocol
+ */
+export default class WsJsepProtocol {
+    wsUrl: string;
+    emulator: EmulatorController | null;
+    config: WsJsepConfig;
+    onError?: (error: Error | Event) => void;
+    maxReconnectAttempts: number;
+    reconnectDelay: number;
+    reconnectBackoffFactor: number;
+    connected: boolean;
+    event_forwarders: Record<string, RTCDataChannel>;
+    peerConnection: RTCPeerConnection | null;
+    ws: WebSocket | null;
+    pendingCandidates: (RTCIceCandidateInit | string)[];
+    remoteDescriptionSet: boolean;
+    signalQueue: JsepSignal[];
+    isProcessingSignal: boolean;
+    onConnected: ((track: MediaStreamTrack) => void) | null;
+    onDisconnected: ((driver: WsJsepProtocol) => void) | null;
+    reconnectAttempts: number;
+    reconnectTimeoutId: any | null;
+    /**
+     * Creates an instance of WsJsepProtocol.
+     *
+     * @param wsUrl The WebSocket JSEP signaling URL.
+     * @param emulator Fallback emulator controller for sending events when WebRTC is unavailable.
+     * @param config Configuration options.
+     */
+    constructor(wsUrl: string, emulator?: EmulatorController | null, config?: WsJsepConfig);
+    /**
+     * Establishes the WebSocket connection and starts the signaling process.
+     * Cleans up any existing connection beforehand.
+     *
+     * @param callbacks Callbacks for stream lifecycle events.
+     */
+    startStream: (callbacks?: StreamCallbacks) => void;
+    /**
+     * Internal method to establish WebSocket connection.
+     *
+     * @private
+     */
+    _connect: () => void;
+    /**
+     * Queues a reconnection attempt with exponential backoff.
+     *
+     * @private
+     */
+    _queueReconnect: () => void;
+    /**
+     * Internal handler for incoming WebSocket messages. Parses the signal
+     * and queues it for sequential processing.
+     *
+     * @private
+     * @param event The WebSocket message event.
+     */
+    _handleWsMessage: (event: MessageEvent) => void;
+    /**
+     * Sequentially processes JSEP signals from the queue.
+     *
+     * @private
+     */
+    _processSignalQueue: () => Promise<void>;
+    /**
+     * Handles WebSocket connection close events.
+     *
+     * @private
+     * @param event The WebSocket close event.
+     */
+    _handleWsClose: (event: CloseEvent) => void;
+    /**
+     * Handles WebSocket error events.
+     *
+     * @private
+     * @param error The WebSocket error event.
+     */
+    _handleWsError: (error: Event) => void;
+    /**
+     * Processes a single JSEP signal (e.g., start, offer, answer, candidate, bye).
+     *
+     * @private
+     * @param signal The JSEP signaling message.
+     */
+    _handleSignal: (signal: JsepSignal) => Promise<void>;
+    /**
+     * Initializes the RTCPeerConnection and local data channels based on the start configuration.
+     *
+     * @private
+     * @param config The signaling start configuration.
+     */
+    _handleStart: (config: RTCConfiguration) => Promise<void>;
+    /**
+     * Handles incoming media track events from the RTCPeerConnection.
+     *
+     * @private
+     * @param e The track event.
+     */
+    _handlePeerConnectionTrack: (e: RTCTrackEvent) => void;
+    /**
+     * Handles ICE candidate generation from the local RTCPeerConnection.
+     *
+     * @private
+     * @param e The ICE candidate event.
+     */
+    _handlePeerIceCandidate: (e: RTCPeerConnectionIceEvent) => void;
+    /**
+     * Monitors connection state changes on the RTCPeerConnection to trigger disconnection.
+     *
+     * @private
+     * @param e The state change event.
+     */
+    _handlePeerConnectionStateChange: (e: Event) => void;
+    /**
+     * Registers a data channel for event forwarding.
+     *
+     * @private
+     * @param channel The data channel.
+     */
+    _setupDataChannel: (channel: RTCDataChannel) => void;
+    /**
+     * Handles remote data channel creation.
+     *
+     * @private
+     * @param e The data channel event.
+     */
+    _handleDataChannel: (e: RTCDataChannelEvent) => void;
+    /**
+     * Processes a remote SDP offer or answer, applying it to the RTCPeerConnection.
+     *
+     * @private
+     * @param sdp The session description.
+     */
+    _handleSDP: (sdp: RTCSessionDescriptionInit) => Promise<void>;
+    /**
+     * Adds a remote ICE candidate to the RTCPeerConnection.
+     *
+     * @private
+     * @param candidate The ICE candidate object or string.
+     */
+    _addIceCandidate: (candidate: RTCIceCandidateInit | string) => void;
+    /**
+     * Handles an incoming remote ICE candidate, queueing it if the remote description is not yet set.
+     *
+     * @private
+     * @param candidate The remote ICE candidate.
+     */
+    _handleCandidate: (candidate: RTCIceCandidateInit | string) => void;
+    /**
+     * Handles the 'bye' signal from the remote side, triggering disconnection.
+     *
+     * @private
+     */
+    _handleBye: () => void;
+    /**
+     * Serializes and sends a JSEP JSON message over the WebSocket.
+     *
+     * @private
+     * @param jsonObject The JSON payload.
+     */
+    _sendJsep: (jsonObject: JsepSignal) => void;
+    /**
+     * Sends a control message (mouse, keyboard, touch) over either the corresponding
+     * WebRTC DataChannel or via the fallback emulator controller.
+     *
+     * @param label The channel label ("mouse", "keyboard", "touch").
+     * @param msg The protobuf message instance.
+     */
+    send: (label: string, msg: any) => void;
+    /**
+     * Cleans up the current connection's WebSocket and PeerConnection state,
+     * but does not mark the driver as permanently disconnected or trigger
+     * the onDisconnected callback. Used during reconnection.
+     *
+     * @private
+     */
+    _disconnectState: () => void;
+    /**
+     * Disconnects both the WebSocket signaling connection and the WebRTC PeerConnection.
+     */
+    disconnect: () => void;
+    /**
+     * Fully cleans up signaling and WebRTC state.
+     */
+    cleanup: () => void;
+}