@stormstreaming/stormstreamer 0.9.2-beta.3 → 0.9.3-beta.0

package/dist/types/network/AbstractSocket.d.ts

@@ -1,26 +1,120 @@
+/**
+ * Base for all classes that use WebSocksts
+ */
 import { ConnectionState } from "../playback/enum/ConnectionState";
 import { Logger } from "../logger/Logger";
+/**
+ * Abstract socket connection
+ */
 export declare class AbstractSocket {
+    /**
+     * Connection timeout
+     * @protected
+     */
     protected readonly CONNECTION_TIMEOUT: number;
+    /**
+     * Logger for this class
+     * @private
+     */
     protected _logger: Logger;
+    /**
+     * WebSocket object
+     * @protected
+     */
     protected socket: WebSocket;
+    /**
+     * Current WebSocket URL (with protocol and port)
+     * @protected
+     */
     protected socketURL: string;
+    /**
+     * Whenever it is binary data or not
+     * @protected
+     */
     protected isBinary: boolean;
+    /**
+     * Current state of the connection
+     * @private
+     */
     protected _connectionState: ConnectionState;
+    /**
+     * Number of messages that arrived
+     * @private
+     */
     protected _messageCount: number;
+    /**
+     * Connection timeout for the player
+     * @protected
+     */
     protected _connectionTimeout: any;
+    /**
+     * Was disconnected by user?
+     * @protected
+     */
     protected _disconnectedByUser: boolean;
+    /**
+     * Whenever we're connected to a server or not
+     * @private
+     */
     protected _isConnected: boolean;
+    /**
+     * Counts connections
+     * @protected
+     */
     protected _sequenceNumber: number;
+    /**
+     * Creates and starts new socket connection
+     *
+     * @param socketURL
+     * @private
+     */
     startConnection(): void;
+    /**
+     * Method is called once connection with the server is established
+     * @param event
+     */
     protected onSocketOpen(event: Event): void;
+    /**
+     * Method is called once connection with the server is closed (
+     *
+     * @param event
+     */
     protected onSocketClose(event: CloseEvent): void;
+    /**
+     * Method is called whenever a new message from socket arrives
+     * @private
+     */
     protected onSocketMessage(event: MessageEvent): void;
+    /**
+     * Method is called whenever an error on socket occures
+     *
+     * @param event
+     * @private
+     */
     protected onSocketError(event: Event): void;
     protected onError(error: string): void;
+    /**
+     * Sends data via socket
+     * @param data
+     */
     sendData(data: any): void;
+    /**
+     * Returns player state e.g. NOT_INITIALIZED, STARTED, CONNECTED, ENDED
+     */
     getConnectionState(): ConnectionState;
+    /**
+     * Rozłacza z serwerem
+     */
     disconnect(byUser?: boolean): void;
+    /**
+     * Destroys connection
+     *
+     * @protected
+     */
     protected destroy(): void;
+    /**
+     * Returns currenly used socketURL
+     * @protected
+     */
     getSocketURL(): string;
 }

package/dist/types/network/NetworkController.d.ts

@@ -1,12 +1,39 @@
 import { WowzaConnection } from "./WowzaConnection";
 import { Logger } from "../logger/Logger";
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Main class for managing socket connections (only one per instance) and parsing packets.
+ */
 export declare class NetworkController {
+    /**
+     * Reference to the main class
+     * @private
+     */
     private readonly _main;
+    /**
+     * Object containing WebSocket Connection (only one is needed)
+     * @private
+     */
     private _connection;
+    /**
+     * Reference to the player logger
+     * @private
+     */
     protected _logger: Logger;
+    /**
+     * Current streamKey
+     * @private
+     */
     private _currentStreamKey;
+    /**
+     * Last state
+     * @private
+     */
     private _lastState;
+    /**
+     * Constructor
+     * @param main reference to the main class
+     */
     constructor(main: StormStreamer);
     initialize(): void;
     start(): void;
@@ -15,6 +42,12 @@ export declare class NetworkController {
     private onServerDisconnect;
     onMessage: (event: MessageEvent) => void;
     sendMessage(message: String): void;
+    /**
+     * Returns current SocketConnection object
+     */
     getConnection(): WowzaConnection;
+    /**
+     * Returns streamKey that is currently being used
+     */
     getCurrentStreamKey(): string;
 }

package/dist/types/network/WowzaConnection.d.ts

@@ -2,21 +2,84 @@ import { AbstractSocket } from "./AbstractSocket";
 import { StormServerItem } from "../model/StormServerItem";
 import { NetworkController } from "./NetworkController";
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Main class for communicating with Storm Streaming Server
+ */
 export declare class WowzaConnection extends AbstractSocket {
+    /**
+     * Reference to the main class
+     * @private
+     */
     private readonly _main;
+    /**
+     * Reference to the NetworkController object
+     * @private
+     */
     private readonly _networkController;
+    /**
+     * Current server connection data
+     * @private
+     */
     private _currServer;
+    /**
+     * How long (in seconds) will it take to reconnect to a server after a failure
+     * @private
+     */
     private _reconnectTimer;
+    /**
+     * Constructor
+     * @param main
+     * @constructor
+     */
     constructor(main: StormStreamer, networkController: NetworkController);
     initialize(): void;
+    /**
+     * On server connection opened;
+     * @param event
+     * @protected
+     */
     protected onSocketOpen(event: Event): void;
+    /**
+     * On server connection error
+     * @param event
+     * @protected
+     */
     protected onSocketError(event: Event): void;
+    /**
+     * On server connection closed
+     * @param event
+     * @protected
+     */
     protected onSocketClose(event: CloseEvent): void;
+    /**
+     * Method is called whenever a new message from socket arrives
+     * @private
+     */
     protected onSocketMessage(event: MessageEvent): void;
+    /**
+     * Creates new URL for WebSockets based on serverItem object
+     * @param serverItem
+     * @private
+     */
     private createURL;
+    /**
+     * Initiates reconnection procedure
+     * @private
+     */
     private initiateReconnect;
+    /**
+     * Picks new server from this list of available ones
+     * @param serverList
+     * @private
+     */
     private pickServerFromList;
+    /**
+     * Returns true/false depending if a connection with a server is active
+     */
     isConnectionActive(): boolean;
     getCurrentServer(): StormServerItem | null;
+    /**
+     * Destroys object and clean-ups everything that is needed
+     */
     destroy(): void;
 }

package/dist/types/network/WowzaStatusConnection.d.ts

@@ -1,19 +1,73 @@
 import { AbstractSocket } from "./AbstractSocket";
 import { StormServerItem } from "../model/StormServerItem";
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Main class for communicating with Storm Streaming Server
+ */
 export declare class WowzaStatusConnection extends AbstractSocket {
+    /**
+     * Reference to the main class
+     * @private
+     */
     private readonly _main;
+    /**
+     * Current server connection data
+     * @private
+     */
     private _currServer;
+    /**
+     * How long (in seconds) will it take to reconnect to a server after a failure
+     * @private
+     */
     private _reconnectTimer;
+    /**
+     * Constructor
+     * @param main
+     * @constructor
+     */
     constructor(main: StormStreamer, server: StormServerItem);
     initialize(): void;
+    /**
+     * On server connection opened;
+     * @param event
+     * @protected
+     */
     protected onSocketOpen(event: Event): void;
+    /**
+     * On server connection error
+     * @param event
+     * @protected
+     */
     protected onSocketError(event: Event): void;
+    /**
+     * On server connection closed
+     * @param event
+     * @protected
+     */
     protected onSocketClose(event: CloseEvent): void;
+    /**
+     * Method is called whenever a new message from socket arrives
+     * @private
+     */
     protected onSocketMessage(event: MessageEvent): void;
+    /**
+     * Initiates reconnection procedure
+     * @private
+     */
     private initiateReconnect;
+    /**
+     * Creates new URL for WebSockets based on serverItem object
+     * @param serverItem
+     * @private
+     */
     private createURL;
+    /**
+     * Returns true/false depending if a connection with a server is active
+     */
     isConnectionActive(): boolean;
     getCurrentServer(): StormServerItem | null;
+    /**
+     * Destroys object and clean-ups everything that is needed
+     */
     destroy(): void;
 }

package/dist/types/playback/CooldownMonitor.d.ts

@@ -1,9 +1,26 @@
+/**
+ * Simple cooldown mechanism
+ */
 export declare class CooldownMonitor {
     private cooldownDuration;
     private lastCooldownTime;
+    /**
+     * Constructs a new instance of CooldownMonitor.
+     * @param cooldownDuration The cooldown duration in seconds.
+     */
     constructor(cooldownDuration?: number);
+    /**
+     * Triggers the cooldown, setting the last cooldown time to the current timestamp.
+     */
     triggerCooldown(): void;
     setCooldownDuration(newTime: number): void;
+    /**
+     * Checks if the cooldown is still in effect.
+     * @returns true if within cooldown period, otherwise false.
+     */
     isCooling(): boolean;
+    /**
+     * Resets the cooldown by setting the last cooldown time to zero.
+     */
     reset(): void;
 }

package/dist/types/playback/StreamerController.d.ts

@@ -4,80 +4,329 @@ import { InputDevice } from "./model/InputDevice";
 import { PublishState } from "./enum/PublishState";
 import { InputDevicesState } from "./enum/InputDevicesState";
 import { DeviceState } from "./enum/DeviceState";
+/**
+ * This class (instance) is responsible to controlling video playback. It's the central point of the whole project, where
+ * all components are being managed.
+ */
 export declare class StreamerController {
+    /**
+     * Reference to the main class
+     * @private
+     */
     private readonly _main;
+    /**
+     * Reference to the player logger
+     * @private
+     */
     protected _logger: Logger;
+    /**
+     * Whenever current window is active or not
+     * @private
+     */
     private _isWindowActive;
+    /**
+     * WebRTC Connection with Wowza Server
+     * @private
+     */
     private _peerConnection;
+    /**
+     * Status connection
+     * @private
+     */
     private _statusConnection;
+    /**
+     * Default configuration for ICE-Servers
+     * @private
+     */
     private _peerConnectionConfig;
+    /**
+     * MungeSDP for injecting values into WebRTC Description
+     * @private
+     */
     private _mungeSDP;
+    /**
+     * Currently selected camera (if ay)
+     * @private
+     */
     private _selectedCamera;
+    /**
+     * Currently selected microphone (if ay)
+     * @private
+     */
     private _selectedMicrophone;
+    /**
+     * Whenever microphone is currenly muted
+     * @private
+     */
     private _isMicrophoneMuted;
+    /**
+     * Desired microphone state that should be applied when stream becomes available
+     * @private
+     */
     private _pendingMicrophoneState;
+    /**
+     * List of all available camera devices found on user device
+     * @private
+     */
     private _cameraList;
+    /**
+     * List of all available microphone devices found on user device
+     * @private
+     */
     private _microphoneList;
+    /**
+     * The stream itself;
+     * @private
+     */
     private _stream;
+    /**
+     * Sound meter device
+     * @private
+     */
     private _soundMeter;
+    /**
+     * Whenever we have cheched for permissions
+     * @private
+     */
     private _permissionChecked;
+    /**
+     * A default set of permissions
+     * @private
+     */
     private _constraints;
+    /**
+     * Restart timer
+     * @private
+     */
     private _restartTimer;
+    /**
+     * Current count for restart, _restartTimerMaxCount is the max number
+     * @private
+     */
     private _restartTimerCount;
+    /**
+     * max
+     * @private
+     */
     private _restartTimerMaxCount;
+    /**
+     * Current streamer state
+     * @protected
+     */
     protected _publishState: PublishState;
     protected _publishTime: number;
+    /**
+     * General state for streamer
+     * @protected
+     */
     protected _inputDeviceState: InputDevicesState;
+    /**
+     * Current Camera state
+     * @protected
+     */
     protected _cameraState: DeviceState;
+    /**
+     * Current Microphone state
+     * @protected
+     */
     protected _microphoneState: DeviceState;
     protected _publishTimer: number;
     private _currentOrientation;
     private _statusTimer;
     private _debug;
+    private _fullStreamName;
+    /**
+     * Constructor - requires properly configured config object
+     * @param config
+     */
     constructor(main: StormStreamer);
+    /**
+     * Initializes the PlaybackController by setting up event listeners and device handling
+     * This method orchestrates the initialization process by first checking device availability
+     * and permissions, then setting up necessary event listeners and configurations
+     * @private
+     */
     private initialize;
+    /**
+     * Sets up core event listeners for the controller
+     * @private
+     */
     private setupEventListeners;
+    /**
+     * Initializes media devices by checking permissions and setting up initial device lists
+     * @private
+     */
     private initializeDevices;
+    /**
+     * Handles device state changes and initiates publishing if appropriate
+     * @private
+     */
     private onDeviceStateChange;
+    /**
+     * Initializes the media stream if a camera or microphone is selected
+     * @private
+     */
     private initializeStream;
     private setupPermissionListeners;
     private handlePermissionChange;
+    /**
+     * Handles successful camera stream initialization
+     */
     private onCameraStreamSuccess;
+    /**
+     * Initializes WebRTC connection
+     */
     private initializeWebRTC;
+    /**
+     * Modified publish method to handle both camera and WebRTC
+     *
+     * @param streamKey - klucz streamu
+     * @returns {boolean} - true jeśli udało się rozpocząć publikowanie
+     */
     publish(streamKey: string): boolean;
     unpublish(): void;
+    /**
+     * This method
+     * @private
+     */
     private setupOrientationListener;
+    /**
+     * This method is responsible for handing orientation changes for mobile devices
+     */
     private handleOrientationChange;
+    /**
+     * Error on trying to grab video stream (it usually means that browser does not support WebRTC streaming)
+     *
+     * @param error
+     */
     onUserMediaError(error: any): Promise<void>;
+    /**
+     * This method is used for checking individual access to output devices
+     * @private
+     */
     private checkIndividualDeviceAccess;
+    /**
+     * This method handles basic SDP/ICE-Candidate exchange with a Wowza Server
+     *
+     * @param data
+     */
     onSocketMessage(data: any): void;
+    /**
+     * Recives events related to peerConnection (change of state)
+     *
+     * @param event event with its data
+     * @param thisRef reference to player classonConnectionStateChange
+     * @private
+     */
     private onConnectionStateChange;
     private onServerDisconnect;
+    /**
+     * Method for handling a situation when a given streamKey is already in use.
+     */
     private onStreamKeyTaken;
+    /**
+     * Returns list od devices (cameras, microphones) available for user's device
+     */
     grabDevices(): Promise<void>;
+    /**
+     * Selects camera based on camera device ID;
+     * @param cameraID
+     */
     selectCamera(cameraID: string): void;
+    /**
+     * Method tries to select (change) microphone based on its system ID
+     * @param micID
+     */
     selectMicrophone(micID: string): Promise<void>;
+    /**
+     * This method tries to start a camera.
+     *
+     * @private
+     */
     private startCamera;
+    /**
+     * Updates WebRTC connection with new stream
+     */
     private updateWebRTCStream;
+    /**
+     * Modified closeStream to handle both camera and WebRTC completely
+     */
     private closeStream;
+    /**
+     * This method selects a camera based on previous uses or saved IDs
+     *
+     * @private
+     */
     private pickCamera;
+    /**
+     * This method selects a microphone based on previous uses or saved IDs
+     *
+     * @private
+     */
     private pickMicrophone;
+    /**
+     * Cleans all saved cameras and microphones IDs.
+     */
     clearSavedDevices(): void;
+    /**
+     * Messes up camera's and microphone's id (for testing only)
+     */
     messSavedDevices(): void;
+    /**
+     * Handles microphone muting state
+     * @param microphoneState true to unmute, false to mute
+     */
     muteMicrophone(shouldMute: boolean): void;
+    /**
+     * Applies the microphone state to the actual stream tracks
+     *
+     * @param enabled true to enable tracks, false to disable
+     * @private
+     */
     private applyMicrophoneState;
+    /**
+     * This methods is a final check whenever we're ready to publish a stream
+     *
+     * @param requireVideo - whenever video track is required
+     * @param requireAudio - whenever audio track is required
+     * @returns {boolean} true if stream is ready for publishing
+     */
     isStreamReady(requireVideo?: boolean, requireAudio?: boolean): boolean;
+    /**
+     * Method fires once a connection with wowza is established. It's the main connection where we exchange
+     * ice-candidates and SDP. We'll start setting up peer connections.
+     */
     private onServerConnect;
+    /**
+     * Method fires once a status connection is established. We'll set an interval for monitoring stream status.
+     */
     private onStatusServerConnect;
     private requestStatusData;
+    /**
+     * If for some reason the status connection is disconnected we have to clean the interval
+     */
     private onStatusServerDisconnect;
+    /**
+     * This event fires whenever "STREAM_STATUS_RESPONSE" packet form status connection reports stream status along some stream data. This gives
+     * us an insight into whenever our stream is ok (works) or not.
+     * @param event
+     */
     private onStreamStatsUpdate;
     private closeWebRTCConnection;
     private onDescriptionError;
     private onDescriptionSuccess;
     private onIceCandidate;
+    /**
+     * Methods handles visibility change events
+     */
     private visibilityChange;
+    /**
+     * Reacts to browser changing visibility of the document (or blur)
+     */
     private onWindowBlur;
+    /**
+     * Reacts to browser changing visibility of the document (or focus)
+     */
     private onWindowFocus;
     createStatusConnection(): void;
     isMicrophoneMuted(): boolean;
@@ -94,9 +343,26 @@ export declare class StreamerController {
     getCameraList(): InputDevice[];
     getMicrophoneList(): InputDevice[];
     getPublishState(): PublishState;
+    /**
+     * Method used to stop camera from streaming
+     * @private
+     */
     private stopCameraStream;
+    /**
+     * Method stops streaming for all streams
+     * @private
+     */
     private forceStopAllStreams;
+    /**
+     * Stops all streaming operations and cleans up resources
+     */
     stop(): void;
+    /**
+     * Reinitializes the streaming setup
+     */
     start(): Promise<void>;
+    /**
+     * Method used for destroying everything (one-time use)
+     */
     destroy(): void;
 }