@stormstreaming/stormstreamer 0.9.0-beta.0 → 0.9.0-beta.11

package/dist/types/index.esm.d.ts

@@ -2,6 +2,8 @@ import { StormStreamer } from "./StormStreamer";
 import { StreamerConfig } from "./types/StreamerConfig";
 export { StormStreamer } from "./StormStreamer";
 export { PublishState } from "./playback/enum/PublishState";
+export { StreamerState } from "./playback/enum/StreamerState";
+export { DeviceState } from "./playback/enum/DeviceState";
 export type { StreamerConfig } from "./types/StreamerConfig";
 export type { StormStreamerListener } from "./events/StormStreamerListener";
 export type { StormStreamerEvent } from "./events/StormStreamerEvent";

package/dist/types/index.umd.d.ts

@@ -2,6 +2,8 @@ import { StormStreamer } from "./StormStreamer";
 import { StreamerConfig } from "./types/StreamerConfig";
 export { StormStreamer } from "./StormStreamer";
 export { PublishState } from "./playback/enum/PublishState";
+export { StreamerState } from "./playback/enum/StreamerState";
+export { DeviceState } from "./playback/enum/DeviceState";
 export type { StreamerConfig } from "./types/StreamerConfig";
 export type { StormStreamerListener } from "./events/StormStreamerListener";
 export type { StormStreamerEvent } from "./events/StormStreamerEvent";

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

@@ -0,0 +1,18 @@
+import { AbstractSocket } from "./AbstractSocket";
+import { StormServerItem } from "../model/StormServerItem";
+import { StormStreamer } from "../StormStreamer";
+export declare class WowzaStatusConnection extends AbstractSocket {
+    private readonly _main;
+    private readonly _networkController;
+    private _currServer;
+    constructor(main: StormStreamer, server: StormServerItem);
+    initialize(): void;
+    protected onSocketOpen(event: Event): void;
+    protected onSocketError(event: Event): void;
+    protected onSocketClose(event: CloseEvent): void;
+    protected onSocketMessage(event: MessageEvent): void;
+    private createURL;
+    isConnectionActive(): boolean;
+    getCurrentServer(): StormServerItem | null;
+    destroy(): void;
+}

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

@@ -1,54 +1,90 @@
 import { Logger } from "../logger/Logger";
-import { IPlayer } from "./player/IPlayer";
 import { StormStreamer } from "../StormStreamer";
 import { InputDevice } from "./model/InputDevice";
 import { PublishState } from "./enum/PublishState";
+import { StreamerState } from "./enum/StreamerState";
+import { DeviceState } from "./enum/DeviceState";
 export declare class PlaybackController {
     private readonly _main;
     protected _logger: Logger;
-    private _selectedPlayer;
     private _isWindowActive;
     private _peerConnection;
+    private _statusConnection;
     private _peerConnectionConfig;
     private _mungeSDP;
     private _selectedCamera;
     private _selectedMicrophone;
     private _isMicrophoneMuted;
+    private _pendingMicrophoneState;
     private _cameraList;
     private _microphoneList;
     private _stream;
     private _soundMeter;
+    private _permissionChecked;
     private _constraints;
+    private _restartTimer;
+    private _restartTimerCount;
+    private _restartTimerMaxCount;
     protected _publishState: PublishState;
+    protected _inputDeviceState: StreamerState;
+    protected _cameraState: DeviceState;
+    protected _microphoneState: DeviceState;
+    protected _publishTimer: number;
+    private _currentOrientation;
     constructor(main: StormStreamer);
     initialize(): void;
-    private startWebRTC;
-    publish(streamKey: string): void;
+    private initializeDevices;
+    requestPermissions(): Promise<boolean>;
+    private setupPermissionListeners;
+    private handlePermissionChange;
+    private onCameraStreamSuccess;
+    private initializeWebRTC;
+    publish(streamKey: string): boolean;
     unpublish(): void;
-    private onUserMediaSuccess;
-    onUserMediaError(error: any): void;
+    private setupOrientationListener;
+    private handleOrientationChange;
+    onUserMediaError(error: any): Promise<void>;
+    private checkIndividualDeviceAccess;
     onSocketMessage(data: any): void;
     private onConnectionStateChange;
     private onServerDisconnect;
-    grabDevices(): void;
+    private onStreamKeyTaken;
+    grabDevices(): Promise<void>;
     selectCamera(cameraID: string): void;
-    selectMicrophone(micID: string): void;
+    selectMicrophone(micID: string): Promise<void>;
+    private startCamera;
+    private updateWebRTCStream;
+    private closeStream;
     private pickCamera;
     private pickMicrophone;
-    muteMicrophone(microphoneState: boolean): void;
+    clearSavedDevices(): void;
+    messSavedDevices(): void;
+    muteMicrophone(shouldMute: boolean): void;
+    private applyMicrophoneState;
+    isStreamReady(requireVideo?: boolean, requireAudio?: boolean): boolean;
     private onServerConnect;
+    private closeWebRTCConnection;
     private onDescriptionError;
     private onDescriptionSuccess;
     private onIceCandidate;
-    private closeStream;
     private visibilityChange;
     private onWindowBlur;
     private onWindowFocus;
+    createStatusConnection(): void;
+    isMicrophoneMuted(): boolean;
     getCurrentCamera(): InputDevice | null;
     getCurrentMicrophone(): InputDevice | null;
     setPublishState(newState: PublishState): void;
+    setInputDeviceState(newState: StreamerState): void;
+    getInputDeviceState(): StreamerState;
+    setCameraState(newState: DeviceState): void;
+    getCamerState(): DeviceState;
+    setMicrophoneState(newState: DeviceState): void;
+    getMicrophoneState(): DeviceState;
     getCameraList(): InputDevice[];
     getMicrophoneList(): InputDevice[];
-    getPlayer(): IPlayer | null;
+    getPublishState(): PublishState;
+    private stopCameraStream;
+    private forceStopAllStreams;
     destroy(): void;
 }

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

@@ -1,17 +1,17 @@
 import { StormStreamer } from "../StormStreamer";
 export declare class SoundMeter {
-    private _main;
-    private _stream;
+    private readonly _main;
+    private _audioContext;
+    private _analyser;
+    private _microphone;
+    private _lastEventTime;
+    private readonly THROTTLE_INTERVAL;
+    private _isMonitoring;
     private _instant;
     private _slow;
-    private clip;
-    private audioContext;
-    private script;
-    private microphone;
-    private processor;
     constructor(main: StormStreamer);
     attach(stream: MediaStream): void;
     detach(): void;
     private clear;
-    onAudioProcess(event: any): void;
+    private startMonitoring;
 }

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

@@ -0,0 +1,6 @@
+export declare enum DeviceState {
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    ENABLED = "ENABLED",
+    ACCESS_DENIED = "ACCESS_DENIED",
+    NOT_FOUND = "NOT_FOUND"
+}

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

@@ -3,6 +3,7 @@ export declare enum PublishState {
     INITIALIZED = "INITIALIZED",
     CONNECTING = "CONNECTING",
     PUBLISHED = "PUBLISHED",
+    PUBLISHED2 = "PUBLISHED2",
     UNPUBLISHED = "UNPUBLISHED",
     STOPPED = "STOPPED",
     UNKNOWN = "UNKNOWN",

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

@@ -0,0 +1,8 @@
+export declare enum StreamerState {
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    INITIALIZED = "INITIALIZED",
+    READY = "READY",
+    UPDATING = "UPDATING",
+    INVALID = "INVALID",
+    UNKNOWN = "UNKNOWN"
+}

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

@@ -18,15 +18,18 @@ export declare class StageController {
     private _main;
     protected _logger: Logger;
     private _resizeObserver;
+    private _isResizing;
     private _autoResizeEnabled;
+    private _parentOriginalOverflow;
     constructor(main: StormStreamer);
     initialize(): void;
-    private onFullScreenChange;
     attachToParent(container: string | HTMLElement): boolean;
     detachFromParent(): boolean;
-    onResize: () => void;
+    handleResize(): void;
+    private calculateNewDimensions;
     private resizeVideoContainer;
     private scaleVideo;
+    private onFullScreenChange;
     enterFullScreen(): void;
     exitFullScreen(): void;
     isFullScreenMode(): boolean;

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

@@ -6,5 +6,6 @@ export declare class StorageManager {
     private logger;
     constructor(main: StormStreamer);
     saveField(name: string, value: string): void;
+    removeField(name: string): void;
     getField(name: string): string | null;
 }

package/dist/types/types/SettingsConfig.d.ts

@@ -7,7 +7,9 @@ export type SettingsConfig = {
     autoStart?: boolean;
     restartOnFocus?: boolean;
     restartOnError?: boolean;
+    cancelPublishOnError?: boolean;
     reconnectTime?: number;
+    preselectDevices?: boolean;
     video?: VideoConfig;
     audio?: AudioConfig;
     storage?: StorageConfig;