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

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;
@@ -88,15 +337,32 @@ export declare class StreamerController {
     setInputDeviceState(newState: InputDevicesState): void;
     getInputDeviceState(): InputDevicesState;
     setCameraState(newState: DeviceState): void;
-    getCamerState(): DeviceState;
+    getCameraState(): DeviceState;
     setMicrophoneState(newState: DeviceState): void;
     getMicrophoneState(): DeviceState;
     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;
 }

package/dist/types/playback/enum/ConnectionState.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Different connection states
+ */
 export declare enum ConnectionState {
     NOT_INITIALIZED = 0,
     STARTED = 1,

package/dist/types/playback/player/AbstractPlayer.d.ts

@@ -1,11 +1,34 @@
 import { StreamerController } from "../StreamerController";
 import { Logger } from "../../logger/Logger";
 import { StormStreamer } from "../../StormStreamer";
+/**
+ * Abstract Player Class, gathers common fields and methods
+ */
 export declare class AbstractPlayer {
+    /**
+     * Reference to the main class
+     * @protected
+     */
     protected _main: StormStreamer;
+    /**
+     * Reference to the playback controller
+     * @protected
+     */
     protected _playbackController: StreamerController;
+    /**
+     * Reference to the player logger
+     * @protected
+     */
     protected _logger: Logger;
+    /**
+     * Reference to the VideoElement
+     * @protected
+     */
     protected _videoObject: HTMLVideoElement;
+    /**
+     * Numer of received data packets
+     * @protected
+     */
     protected _dataPacketCount: number;
     getPlaybackRate(): number;
 }

package/dist/types/playback/task/IPlaybackTask.d.ts

@@ -1,4 +1,7 @@
 import { TaskType } from "../enum/TaskType";
+/**
+ * Interface for all configs within the player
+ */
 export interface IPlaybackTask {
     getType(): TaskType;
 }

package/dist/types/stage/ScreenElement.d.ts

@@ -1,19 +1,73 @@
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Class controls the VideoElement itself
+ */
 export declare class ScreenElement {
+    /**
+     * Decides whenever logs are being generated by this class
+     * @private
+     */
     private readonly LOG_ACTIVITY;
+    /**
+     * Reference to the main class
+     * @private
+     */
     private _main;
+    /**
+     * Current volume level
+     * @private
+     */
     private _volume;
+    /**
+     * Whenever video is muted
+     * @private
+     */
     private _isMuted;
+    /**
+     * Whenever video is muted by a browser
+     * @private
+     */
     private _isMutedByBrowser;
+    /**
+     * Video Element itself
+     * @private
+     */
     private _videoElement;
+    /**
+     * Reference to the main logger
+     * @private
+     */
     private _logger;
     constructor(main: StormStreamer);
+    /**
+     * Initializes and pre-configures main video object
+     */
     initialize(): void;
+    /**
+     * Called whenever browser stops playback
+     */
     private onForceMute;
+    /**
+     * Sets new volume for playback. It'll also try to store value in a browser memory
+     * @param value
+     */
     setVolume(value: number): void;
     getVolume(): number;
+    /**
+     * Allows to apply mute to a video element
+     * @param isMuted
+     */
     setMuted(isMuted: boolean): void;
+    /**
+     * Returns true/false whenever video is muted or not
+     */
     getIfMuted(): boolean;
+    /**
+     * Dispatches event informing about volume chan
+     */
     dispatchVolumeEvent(): void;
+    /**
+     * Return VideoElement
+     */
     getVideoElement(): HTMLVideoElement;
 }

package/dist/types/stage/StageController.d.ts

@@ -2,32 +2,118 @@ import { Logger } from "../logger/Logger";
 import { ScalingType } from "../config/enum/ScalingType";
 import { ScreenElement } from "./ScreenElement";
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Class controls all visual elements of the player
+ */
 export declare class StageController {
+    /**
+     * Decides whenever logs are being generated by this class
+     * @private
+     */
     private static readonly LOG_ACTIVITY;
+    /**
+     * Video object itself (reference to object on document)
+     */
     private _screenElement;
+    /**
+     * Container that holds video object itself
+     * @private
+     */
     private _videoContainer;
+    /**
+     * Parent container for the player
+     * @private
+     */
     private _parentElement;
+    /**
+     * Video width
+     * @private
+     */
     private _containerWidth;
+    /**
+     * Temp container width
+     * @private
+     */
     private _tempContainerWidth;
+    /**
+     * Video height
+     * @private
+     */
     private _containerHeight;
+    /**
+     * Temp container height
+     * @private
+     */
     private _tempContainerHeight;
+    /**
+     * Video width (initally 0, after "onmetadata" event is updated to match the real one
+     * @private
+     */
     private _videoWidth;
+    /**
+     * Video width (initally 0, after "onmetadata" event is updated to match the real one
+     * @private
+     */
     private _videoHeight;
+    /**
+     * Current scaling type
+     * @private
+     */
     private _scalingMode;
+    /**
+     * If in fullscreen mode
+     * @private
+     */
     private isInFullScreenMode;
+    /**
+     * Reference to the main class
+     * @private
+     */
     private _main;
+    /**
+     * Reference to the player logger
+     * @private
+     */
     protected _logger: Logger;
+    /**
+     * Watches for changes in the parent container
+     * @private
+     */
     private _resizeObserver;
+    /**
+     * Whenever we are resizing atm.
+     * @private
+     */
     private _isResizing;
+    /**
+     * Deco
+     * @private
+     */
     private _autoResizeEnabled;
+    /**
+     * Parameter holds original overflow style
+     * @private
+     */
     private _parentOriginalOverflow;
     private _debug;
     constructor(main: StormStreamer);
     initialize(): void;
+    /**
+     * Method attaches element to a parent container
+     *
+     * @param container
+     */
     attachToParent(container: string | HTMLElement): boolean;
+    /**
+     * Detaches the library from a parent container
+     */
     detachFromParent(): boolean;
     handleResize(): void;
     private calculateNewDimensions;
+    /**
+     * Method resizes video container
+     * @private
+     */
     private resizeVideoContainer;
     private scaleVideo;
     private onFullScreenChange;

package/dist/types/statistics/StatsController.d.ts

@@ -1,7 +1,15 @@
 import { StormStreamer } from "../StormStreamer";
 import { Logger } from "../logger/Logger";
 export declare class StatsController {
+    /**
+     * Reference to the main class
+     * @private
+     */
     private readonly _main;
+    /**
+     * Reference to the player logger
+     * @private
+     */
     protected _logger: Logger;
     private _publishVideoWidth;
     private _publishVideoHeight;

package/dist/types/storage/StorageManager.d.ts

@@ -1,11 +1,48 @@
 import { StormStreamer } from "../StormStreamer";
+/**
+ * Saves and retrieve data from localStorage.
+ */
 export declare class StorageManager {
+    /**
+     * Decides whenever logs are being generated by this class
+     * @private
+     */
     private readonly LOG_ACTIVITY;
+    /**
+     * Whenever saving cookies is enabled at all
+     * @private
+     */
     private isEnabled;
+    /**
+     * Prefix for multiple instances
+     * @private
+     */
     private prefix;
+    /**
+     * Reference to the main logger
+     * @private
+     */
     private logger;
+    /**
+     * Constructor
+     * @param main
+     * @param prefix
+     */
     constructor(main: StormStreamer);
+    /**
+     * Saves data a a cookie
+     * @param name name of a field
+     * @param value value of a field
+     */
     saveField(name: string, value: string): void;
+    /**
+     * Removes a field from localStorage
+     * @param name the name of the field to remove
+     */
     removeField(name: string): void;
+    /**
+     * Retrieves field from cookie
+     * @param name cookie name
+     */
     getField(name: string): string | null;
 }

package/dist/types/utilities/DomUtilities.d.ts

@@ -1,4 +1,11 @@
+/**
+ * Class responsible for operations on numbers
+ */
 export declare class DomUtilities {
+    /**
+     * Calculates element dimensions including margins
+     * @param element
+     */
     static calculateDimensionsWithMargins(element: HTMLElement): {
         width: number;
         height: number;

package/dist/types/utilities/NumberUtilities.d.ts

@@ -1,4 +1,11 @@
+/**
+ * Class responsible for operations on numbers
+ */
 export declare class NumberUtilities {
+    /**
+     * Adds leading "zero" before the number and returns it as a string. Example: "1" -> "01"
+     * @param number
+     */
     static addLeadingZero(number: number): string;
     static isNear(currentBuffer: number, target: number, targetMargin: number): boolean;
     static generateUniqueString(length: number): string;