ngx-agora
Version:
Angular wrapper for Agora RTC client (https://www.agora.io/en/)
4,839 lines • 190 kB
JavaScript
import { Injectable, Inject, ɵɵdefineInjectable, ɵɵinject, Component, NgModule } from '@angular/core';
import * as agoraSDK from 'agora-rtc-sdk';
/**
* @fileoverview added by tsickle
* Generated from: lib/ngx-agora.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Provides access to the Agora web API, including the AgoraRTC and Client objects.
*/
var NgxAgoraService = /** @class */ (function () {
function NgxAgoraService(config) {
this.config = config;
/**
* All audio devices collected from the AgoraRTC `getDevices()` method.
* @see [getDevices()](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
*
*/
this.audioDevices = [];
/**
* All video devices collected from the AgoraRTC `getDevices()` method.
* @see [getDevices()](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
*/
this.videoDevices = [];
/**
* Instance reference to the `static` AgoraRTC library object.
*/
this.AgoraRTC = NgxAgoraService.AgoraRTC;
if (!this.checkSystemRequirements()) {
this.AgoraRTC.Logger.error('Web RTC is not supported in this browser');
}
else {
this.collectDevices();
}
}
/**
* Checks the Web Browser Compatibility
*
* This method checks the compatibility between the Web SDK and the current web browser.
* Use this method before calling createClient to check the compatibility between the system and the web browser.
*
* - true: The Web SDK is compatible with the current web browser.
* - false: The Web SDK is not compatible with the current web browser.
*
* @remark
* Agora has yet to conduct comprehensive tests on Chromium kernel browsers, such as QQ and 360.
* Agora will gradually achieve compatibility on most mainstream browsers in subsequent versions of the Web SDK.
*/
/**
* Checks the Web Browser Compatibility
*
* This method checks the compatibility between the Web SDK and the current web browser.
* Use this method before calling createClient to check the compatibility between the system and the web browser.
*
* - true: The Web SDK is compatible with the current web browser.
* - false: The Web SDK is not compatible with the current web browser.
*
* \@remark
* Agora has yet to conduct comprehensive tests on Chromium kernel browsers, such as QQ and 360.
* Agora will gradually achieve compatibility on most mainstream browsers in subsequent versions of the Web SDK.
* @return {?}
*/
NgxAgoraService.prototype.checkSystemRequirements = /**
* Checks the Web Browser Compatibility
*
* This method checks the compatibility between the Web SDK and the current web browser.
* Use this method before calling createClient to check the compatibility between the system and the web browser.
*
* - true: The Web SDK is compatible with the current web browser.
* - false: The Web SDK is not compatible with the current web browser.
*
* \@remark
* Agora has yet to conduct comprehensive tests on Chromium kernel browsers, such as QQ and 360.
* Agora will gradually achieve compatibility on most mainstream browsers in subsequent versions of the Web SDK.
* @return {?}
*/
function () {
return this.AgoraRTC.checkSystemRequirements();
};
/**
* Creates a Client object.
*
* This method creates and returns a client object. You can only call this method once each call session.
*
* @param config
* Defines the property of the client, see
* [ClientConfig](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html) for details.
* @param [autoInitializing=true] Ngx-agora by default automatically initializes the client with the provided `AppID` after it is created.
* Set this property to `false` to disable this functionality, if you are going to call `init()` separately
* (after creating the client only).
* @param [onSuccess] The callback when the method succeeds.
* @param [onFailure] The callback when the method fails.
*
* @example
* AgoraRTC.createClient(config);
*/
/**
* Creates a Client object.
*
* This method creates and returns a client object. You can only call this method once each call session.
*
* \@example
* AgoraRTC.createClient(config);
* @param {?} config
* Defines the property of the client, see
* [ClientConfig](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html) for details.
* @param {?=} autoInitializing
* @param {?=} onSuccess
* @param {?=} onFailure
* @return {?}
*/
NgxAgoraService.prototype.createClient = /**
* Creates a Client object.
*
* This method creates and returns a client object. You can only call this method once each call session.
*
* \@example
* AgoraRTC.createClient(config);
* @param {?} config
* Defines the property of the client, see
* [ClientConfig](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html) for details.
* @param {?=} autoInitializing
* @param {?=} onSuccess
* @param {?=} onFailure
* @return {?}
*/
function (config, autoInitializing, onSuccess, onFailure) {
if (autoInitializing === void 0) { autoInitializing = true; }
this.client = this.AgoraRTC.createClient(config);
if (autoInitializing) {
this.init(this.config.AppID, onSuccess, onFailure);
}
return this.client;
};
/**
* This method creates and returns a stream object.
*
* @example
* AgoraRTC.createStream(spec)
*
* @param spec Defines the properties of the stream
* @see [StreamSpec](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html) for details.
*/
/**
* This method creates and returns a stream object.
*
* \@example
* AgoraRTC.createStream(spec)
*
* @see [StreamSpec](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html) for details.
* @param {?} spec Defines the properties of the stream
* @return {?}
*/
NgxAgoraService.prototype.createStream = /**
* This method creates and returns a stream object.
*
* \@example
* AgoraRTC.createStream(spec)
*
* @see [StreamSpec](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html) for details.
* @param {?} spec Defines the properties of the stream
* @return {?}
*/
function (spec) {
if (!spec.microphoneId && this.audioDevices && this.audioDevices.length) {
/** @type {?} */
var defaultMic = this.audioDevices[0].deviceId;
spec.microphoneId = defaultMic;
}
if (!spec.cameraId && this.videoDevices && this.videoDevices.length) {
/** @type {?} */
var defaultCamera = this.videoDevices[0].deviceId;
spec.cameraId = spec.cameraId || defaultCamera;
}
return this.AgoraRTC.createStream(spec);
};
/**
* Initializes the Client object.
*
* @param appId Pass in the App ID for your project.
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* To get your App ID,
* @see [Get an App ID](https://docs.agora.io/en/Video/web_prepare?platform=Web#create-an-agora-account-and-get-an-app-id).
* @param [onSuccess] The callback when the method succeeds.
* @param [onFailure] The callback when the method fails.
*
* @example
* this.ngxAgoraService.client.init(appId, () => {
* console.log("client initialized");
* // Join a channel
* //……
* }, error => {
* console.log("client init failed ", err);
* // Error handling
* });
*/
/**
* Initializes the Client object.
*
* @see [Get an App ID](https://docs.agora.io/en/Video/web_prepare?platform=Web#create-an-agora-account-and-get-an-app-id).
* \@example
* this.ngxAgoraService.client.init(appId, () => {
* console.log("client initialized");
* // Join a channel
* //……
* }, error => {
* console.log("client init failed ", err);
* // Error handling
* });
* @param {?} appId Pass in the App ID for your project.
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* To get your App ID,
* @param {?=} onSuccess
* @param {?=} onFailure
* @return {?}
*/
NgxAgoraService.prototype.init = /**
* Initializes the Client object.
*
* @see [Get an App ID](https://docs.agora.io/en/Video/web_prepare?platform=Web#create-an-agora-account-and-get-an-app-id).
* \@example
* this.ngxAgoraService.client.init(appId, () => {
* console.log("client initialized");
* // Join a channel
* //……
* }, error => {
* console.log("client init failed ", err);
* // Error handling
* });
* @param {?} appId Pass in the App ID for your project.
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* To get your App ID,
* @param {?=} onSuccess
* @param {?=} onFailure
* @return {?}
*/
function (appId, onSuccess, onFailure) {
this.client.init(appId, onSuccess, onFailure);
};
/**
* Attempts to automatically collect audio and video devices from the AgoraRTC `getDevices()` method.
*/
/**
* Attempts to automatically collect audio and video devices from the AgoraRTC `getDevices()` method.
* @private
* @return {?}
*/
NgxAgoraService.prototype.collectDevices = /**
* Attempts to automatically collect audio and video devices from the AgoraRTC `getDevices()` method.
* @private
* @return {?}
*/
function () {
var _this = this;
this.AgoraRTC.getDevices((/**
* @param {?} devices
* @return {?}
*/
function (devices) {
/** @type {?} */
var audioDevices = devices.filter((/**
* @param {?} device
* @return {?}
*/
function (device) {
return device.kind === 'audioinput' && device.deviceId !== 'default';
}));
/** @type {?} */
var videoDevices = devices.filter((/**
* @param {?} device
* @return {?}
*/
function (device) {
return device.kind === 'videoinput' && device.deviceId !== 'default';
}));
_this.audioDevices = audioDevices;
_this.videoDevices = videoDevices;
}));
};
NgxAgoraService.AgoraRTC = agoraSDK;
NgxAgoraService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
NgxAgoraService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Inject, args: ['config',] }] }
]; };
/** @nocollapse */ NgxAgoraService.ngInjectableDef = ɵɵdefineInjectable({ factory: function NgxAgoraService_Factory() { return new NgxAgoraService(ɵɵinject("config")); }, token: NgxAgoraService, providedIn: "root" });
return NgxAgoraService;
}());
if (false) {
/**
* @type {?}
* @private
*/
NgxAgoraService.AgoraRTC;
/**
* The local Agora.io Client object.
* @see [Web Client](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html)
* @type {?}
*/
NgxAgoraService.prototype.client;
/**
* All audio devices collected from the AgoraRTC `getDevices()` method.
* @see [getDevices()](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
*
* @type {?}
*/
NgxAgoraService.prototype.audioDevices;
/**
* All video devices collected from the AgoraRTC `getDevices()` method.
* @see [getDevices()](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
* @type {?}
*/
NgxAgoraService.prototype.videoDevices;
/**
* Instance reference to the `static` AgoraRTC library object.
* @type {?}
*/
NgxAgoraService.prototype.AgoraRTC;
/**
* @type {?}
* @private
*/
NgxAgoraService.prototype.config;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/ngx-agora.component.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var NgxAgoraComponent = /** @class */ (function () {
function NgxAgoraComponent() {
}
/**
* @return {?}
*/
NgxAgoraComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
};
NgxAgoraComponent.decorators = [
{ type: Component, args: [{
selector: 'lib-ngx-agora',
template: "\n <p>\n ngx-agora works!\n </p>\n "
}] }
];
/** @nocollapse */
NgxAgoraComponent.ctorParameters = function () { return []; };
return NgxAgoraComponent;
}());
/**
* @fileoverview added by tsickle
* Generated from: lib/ngx-agora.module.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var NgxAgoraModule = /** @class */ (function () {
function NgxAgoraModule() {
}
/**
* @param {?} config
* @return {?}
*/
NgxAgoraModule.forRoot = /**
* @param {?} config
* @return {?}
*/
function (config) {
return {
ngModule: NgxAgoraModule,
providers: [NgxAgoraService, { provide: 'config', useValue: config }]
};
};
NgxAgoraModule.decorators = [
{ type: NgModule, args: [{
declarations: [NgxAgoraComponent],
exports: [NgxAgoraComponent]
},] }
];
return NgxAgoraModule;
}());
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/agora-client.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The Client object returned by the [createClient](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createclient)
* method provides access to much of the core AgoraRTC functionality.
*
* @see [Web Client](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html)
* @record
*/
function AgoraClient() { }
if (false) {
/**
* Injects an Online Media Stream to a Live Broadcast
*
* If this method is called successfully, the server pulls the voice or video stream and
* injects it into a live channel. This is applicable to scenarios where all of the audience members
* in the channel can watch a live show and interact with each other.
*
*
* This method call triggers the following callbacks:
*
* - On the local client:
* - `Client.on("streamInjectedStatus")`, with the state of injecting the online stream.
* - `Client.on("stream-added")` and `Client.on("peer-online")` (uid: 666), if the online media stream is injected into the channel.
*
* - On the remote client:
* - `Client.on("stream-added")` and `Client.on("peer-online")` (uid: 666), if the online media stream is injected into the channel.
*
* \@remarks
* You can only inject one online media stream into the same channel at the same time.
* Ensure that you [enable the RTMP Converter service](https://docs.agora.io/en/Video/cdn_streaming_web#prerequisites)
* before using this function.
*
* \@param url URL address of the live streaming.
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* Valid protocols are RTMP, HLS, and HTTP-FLV.
*
* - Supported FLV audio codec type: AAC.
* - Supported FLV video codec type: H.264 (AVC).
*
* \@param config Configuration of the inject stream, see
* [InjectStreamConfig](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.injectstreamconfig.html) for details.
*
* @see [Inject an Online Media Stream](https://docs.agora.io/en/Interactive%20Broadcast/inject_stream_web?platform=Web) for details.
* @type {?}
*/
AgoraClient.prototype.addInjectStreamUrl;
/**
* Configures the CDN Live Streaming
*
* @deprecated Agora recommends using the following methods instead:
* - [startLiveStreaming](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startlivestreaming)
* - [setLiveTranscoding](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setlivetranscoding)
* - [stopLiveStreaming](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#stoplivestreaming)
* \@description
* This method configures the CDN live streaming before joining a channel.
* Call [configPublisher](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#configpublisher) before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
* \@example
* client.configPublisher({
* width: 360,
* height: 640,
* framerate: 30,
* bitrate: 500,
* publishUrl: "rtmp://xxx/xxx/"
* });
* @type {?}
*/
AgoraClient.prototype.configPublisher;
/**
* Disables dual streams.
*
* \@example
* client.disableDualStream(() => {
* console.log("Disable dual stream success!")
* }, err => {
* console.log(err)
* })
* @type {?}
*/
AgoraClient.prototype.disableDualStream;
/**
* Enables the SDK to report the active remote users who are speaking and their volume regularly.
*
* If this method is enabled, the SDK will return the volumes every two seconds, regardless of whether there are active speakers.
*
* \@remark
* If you have multiple web pages running the Web SDK, this function might not work.
*
* \@example
* client.enableAudioVolumeIndicator(); // Triggers the "volume-indicator" callback event every two seconds.
* client.on("volume-indicator", evt => {
* evt.attr.forEach((volume, index) => {
* console.log(`#${index} UID ${volume.uid} Level ${volume.level}`);
* });
* });
* @type {?}
*/
AgoraClient.prototype.enableAudioVolumeIndicator;
/**
* Enables the dual-stream mode on the publisher side.
*
* Dual streams are a hybrid of a high-video stream and a low-video stream:
* - High-video stream: high bitrate, high resolution
* - Low-video stream: low bitrate, low resolution
*
* \@example
* client.enableDualStream(() => {
* console.log("Enable dual stream success!")
* }, err => {
* console,log(err)
* })
*
* \@remark
* This method does not apply to the following scenarios:
* - The stream is created by defining the audioSource and videoSource properties.
* - Audio-only mode (audio: true, video: false)
* - Safari browser on iOS
* - Screen-sharing scenario
* @type {?}
*/
AgoraClient.prototype.enableDualStream;
/**
* Enumerates the available video input devices, such as cameras.
*
* If this method succeeds, the SDK returns a list of video input devices in an array of MediaDeviceInfo objects.
* @type {?}
*/
AgoraClient.prototype.getCameras;
/**
* This method returns the state of the connection between the SDK and Agora's edge server.
*
* \@description
* The connection state:
* - DISCONNECTED: The SDK is disconnected from Agora's edge server.
* This is the initial state before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
* The SDK also enters this state after the app calls
* [Client.leave](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#leave).
* - CONNECTING: The SDK is connecting to Agora's edge server. The SDK enters this state when
* calling [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join)
* or reconnecting to Agora's edge server automatically after the connection is lost.
* - CONNECTED: The SDK is connected to Agora's edge server and joins a channel. You can now publish or
* subscribe to a stream in the channel.
* - DISCONNECTING: The SDK is disconnecting from Agora's edge server. The SDK enters this state when calling
* [Client.leave](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#leave).
* @type {?}
*/
AgoraClient.prototype.getConnectionState;
/**
* Retrieves the Audio Statistics of the Local Stream
*
* This method retrieves the audio statistics of the published stream,
* including audio codec type, sampling rate, bitrate, and so on.
*
* \@description
* - Some of the statistics are calculated after the stream-published event, which may take at most 3 seconds.
* - This method supports the Chrome browser only.
* \@example
* client.getLocalAudioStats((localAudioStats) => {
* Object.keys(localAudioStats).forEach(uid => {
* console.log(`Audio CodecType from ${uid}: ${localAudioStats[uid].CodecType}`);
* console.log(`Audio MuteState from ${uid}: ${localAudioStats[uid].MuteState}`);
* console.log(`Audio RecordingLevel from ${uid}: ${localAudioStats[uid].RecordingLevel}`);
* console.log(`Audio SamplingRate from ${uid}: ${localAudioStats[uid].SamplingRate}`);
* console.log(`Audio SendBitrate from ${uid}: ${localAudioStats[uid].SendBitrate}`);
* console.log(`Audio SendLevel from ${uid}: ${localAudioStats[uid].SendLevel}`);
* })
* });
* @type {?}
*/
AgoraClient.prototype.getLocalAudioStats;
/**
* Retrieves the Video Statistics of the Local Stream
*
* This method retrieves the video statistics of the published stream, including video resolution, bitrate, frame rate, and so on.
*
* \@description
* Some of the statistics are calculated after the stream-published event, which may take at most 3 seconds.
* This method supports the Chrome browser only.
* @type {?}
*/
AgoraClient.prototype.getLocalVideoStats;
/**
* Gets the Statistics of the System Network
* @deprecated from v2.5.1, use getTransportStats instead.
*
* This method gets the statistics of the browser's local network.
* Currently only the network type information is provided, see NetworkType.
*
* \@description
* Chrome 61+ is required for this function, and the compatibility is not guaranteed. See Network Information API for details.
* @type {?}
*/
AgoraClient.prototype.getNetworkStats;
/**
* Enumerates Audio Output Devices
*
* This method enumerates the available audio output devices, such as speakers.
* If this method succeeds, the SDK returns a list of audio output devices in an array of
* [MediaDeviceInfo](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.mediadeviceinfo.html) objects.
* @type {?}
*/
AgoraClient.prototype.getPlayoutDevices;
/**
* Enumerates Audio Input Devices
*
* This method enumerates the available audio input devices, such as microphones.
* If this method succeeds, the SDK returns a list of audio input devices in an array of MediaDeviceInfo objects.
* @type {?}
*/
AgoraClient.prototype.getRecordingDevices;
/**
* Retrieves the Audio Statistics of the Remote Stream
* This method retrieves the audio statistics of the remote stream, including audio codec type, packet loss rate, bitrate, and so on.
*
* \@description
* The statistics are calculated after the `stream-subscribed` event, which may take at most 3 seconds.
* This method supports the Chrome browser only.
* @type {?}
*/
AgoraClient.prototype.getRemoteAudioStats;
/**
* Retrieves the Video Statistics of the Remote Stream
* This method retrieves the video statistics of the remote stream, including packet loss rate, video bitrate, frame rate, and so on.
*
* \@description
* The statistics are calculated after the `stream-subscribed` event, which may take at most 3 seconds.
* This method supports the Chrome browser only.
* @type {?}
*/
AgoraClient.prototype.getRemoteVideoStats;
/**
* Gets the Statistics of the Session
* This method gets the statistics of the session connection.
*
* \@description
* This method should be called after joining the channel, and it may take at most 3 seconds to retrieve the statistics.
* This method supports the Chrome browser only.
* @type {?}
*/
AgoraClient.prototype.getSessionStats;
/**
* Gets the Statistics of the System
*
* This method gets the statistics of the system.
*
* Currently only the battery level information is provided.
* @see [BatteryLevel](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.systemstats.html#batterylevel).
*
* \@description
* This feature is experimental.
* @see [Battery Status API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API) for browser compatibility.
* @type {?}
*/
AgoraClient.prototype.getSystemStats;
/**
* Gets the Statistics of the Transmission
* This method gets the statistics of the transmission quality to Agora service.
*
* \@description
* Calculation of the statistics may take at most 3 seconds.
* This method supports the Chrome browser only.
* @type {?}
*/
AgoraClient.prototype.getTransportStats;
/**
* Initializes the Client object.
*
* \@param appId Pass in the App ID for your project.
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* To get your App ID,
* @see [Get an App ID](https://docs.agora.io/en/Video/web_prepare?platform=Web#create-an-agora-account-and-get-an-app-id).
* \@param [onSuccess] The callback when the method succeeds.
* \@param [onFailure] The callback when the method fails.
*
* \@example
* client.init(appId, () => {
* console.log("client initialized");
* // Join a channel
* //……
* }, err => {
* console.log("client init failed ", err);
* // Error handling
* });
* @type {?}
*/
AgoraClient.prototype.init;
/**
* Joins an AgoraRTC Channel
* This method joins an AgoraRTC channel.
*
* \@description
* All users in the same channel should have the same type (number or string) of uid.
* - If you use a number as the user ID, it should be a 32-bit unsigned integer with a value ranging from 0 to (232-1).
* - If you use a string as the user ID, the maximum length is 255 characters.
*
* \@param tokenOrKey
* - Low security requirements: Pass null as the parameter value.
* - High security requirements: Pass the string of the Token or Channel Key as the parameter value. See Use Security Keys for details.
* \@param channel
* A string that provides a unique channel name for the Agora session. The length must be within 64 bytes. Supported character scopes:
* - 26 lowercase English letters a-z
* - 26 uppercase English letters A-Z
* - 10 numbers 0-9
* - Space
* - "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "\@", "[", "]", "^", "_", "{", "}", "|", "~", ","
* \@param uid The user ID, an integer or a string, ASCII characters only. Ensure this ID is unique.
* If you set the uid to null, the server assigns one and returns it in the onSuccess callback.
* \@param [onSuccess] The callback when the method succeeds. The server returns the uid which represents the identity of the user.
* \@param [onFailure] The callback when the method fails.
* \@example
* client.join(<token>, "1024", null, uid => {
* console.log("client" + uid + "joined channel");
* // Create a local stream
* //……
* }, err => {
* console.error("client join failed ", err);
* // Error handling
* });
*
* @type {?}
*/
AgoraClient.prototype.join;
/**
* Leaves an AgoraRTC Channel
*
* This method enables a user to leave a channel.
*
* \@param [onSuccess] The callback when the method succeeds.
* \@param [onFailure] The callback when the method fails.
* \@example
* client.leave(_ => {
* console.log("client leaves channel");
* //……
* }, err => {
* console.log("client leave failed ", err);
* //error handling
* });
* @type {?}
*/
AgoraClient.prototype.leave;
/**
* This method removes the events attached by the Client.on() method.
*
* \@example
* client.on("stream-published", function processStreamPublished(evt) {
* console.log("Stream Published");
* evt.stream.play("divId");
* client.off("stream-published", processStreamPublished);
* })
* @type {?}
*/
AgoraClient.prototype.off;
/**
* Occurs when an Agora.io event connected to the local client is received from the SDK.
*
* @see [On](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#on)
* for all variations of this core function.
* @type {?}
*/
AgoraClient.prototype.on;
/**
* Publishes a Local Stream
* This method publishes a local stream to the SD-RTN.
*
* \@description
* In a live broadcast, whoever calls this API is the host.
*
* \@param stream Stream object, which represents the local stream.
* \@param [onFailure] The callback when the method fails.
* \@example
* client.publish(stream, err => {
* console.log(err);
* //……
* })
* @type {?}
*/
AgoraClient.prototype.publish;
/**
* Removes the Injected Stream
*
* This method removes the HTTP/HTTPS URL address (added by addInjectStreamUrl) from the live broadcast.
*
* \@param url URL address of the live streaming. ASCII characters only, and the string
* length must be greater that 0 and less than 256 bytes.
* @type {?}
*/
AgoraClient.prototype.removeInjectStreamUrl;
/**
* This method renews your channel key.
*
* Once the Channel Key schema is enabled, the key expires after a certain period of time.
* When the onFailure callback reports the error DYNAMIC_KEY_TIMEOUT, the application should renew the
* Channel Key by calling this method. Not doing so will result in SDK disconnecting with the server.
* @type {?}
*/
AgoraClient.prototype.renewChannelKey;
/**
* This method renews your token.
*
* Once the Token schema is enabled, the token expires after a certain period of time.
* In case of the `onTokenPrivilegeWillExpire` or `onTokenPrivilegeDidExpire` callback events, the application
* should renew the Token by calling this method. Not doing so will result in SDK disconnecting with the server.
*
* \@param token Specifies the renewed Token.
* @type {?}
*/
AgoraClient.prototype.renewToken;
/**
* Sets the role of the user.
*
* This method is applicable only to the live mode.
* Sets the role of the user such as a host or an audience (default), before joining a channel.
* This method can be used to switch the user role after the user joins a channel.
*
* In live mode ([mode](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#mode) is set as live):
* - Before joining the channel, you can call this method to set the role.
* - After joining the channel, you can call this method to switch the role:
* When you call [publish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#publish),
* the user role switches to host; when you call
* [unpublish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#unpublish),
* the user role switches to audience.
* After calling [publish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#publish),
* if you call this method and set the user role as audience,
* [unpublish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#unpublish) is called automatically.
*
* In communication mode
* ([mode](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#mode) set as `rtc`),
* this method does not take effect. All users are host by default.
*
* \@param role User role in a live broadcast:
* - "audience": Audience, the default role. An audience can only receive streams.
* - "host": Host. A host can both send and receive streams.
*
* \@example
* client.setClientRole('host', _ => {
* console.log("setHost success");
* }, e => {
* console.log("setHost failed", e);
* })
* @type {?}
*/
AgoraClient.prototype.setClientRole;
/**
* This method sets the encryption mode.
*
* \@description
* Ensure that you call this API before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
*
* \@param encryptionMode
* - aes-128-xts: Sets the encryption mode as AES128XTS.
* - aes-256-xts: Sets the encryption mode as AES256XTS.
* - aes-128-ecb: Sets the encryption mode as AES128ECB.
* @type {?}
*/
AgoraClient.prototype.setEncryptionMode;
/**
* This method enables the built-in encryption.
*
* \@description
* Ensure that you call this API before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
*
* \@param password
* - The encryption password. ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
AgoraClient.prototype.setEncryptionSecret;
/**
* This method sets the video layout and audio for CDN live.
*
* \@description
* Call [setLiveTranscoding](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setlivetranscoding)
* after [createStream](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createstream).
* For details, see [Push Streams to the CDN](https://docs.agora.io/en/Video/push_stream_web).
* @type {?}
*/
AgoraClient.prototype.setLiveTranscoding;
/**
* Sets the Low-video Stream Parameter
*
* If you enabled the dual-stream mode by calling
* [Client.enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream),
* use this method to set the low-video stream profile.
* If you do not set the low-video stream profile, the SDK will assign default values based on your stream video profile.
*
* \@description
* - As different web browsers have different restrictions on the video profile, the parameters you set
* may fail to take effect. The Firefox browser has a fixed frame rate of 30 fps, therefore the frame
* rate settings do not work on the Firefox browser.
* - Due to limitations of some devices and browsers, the resolution you set may fail to take effect and
* get adjusted by the browser. In this case, billings will be calculated based on the actual resolution.
* - Call [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join) before using this method.
* - Screen sharing supports the high-video stream only.
*
* @see [setLowStreamParameter](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setlowstreamparameter)
* @type {?}
*/
AgoraClient.prototype.setLowStreamParameter;
/**
* Deploys the Nginx Server
*
* Use this method to deploy the Nginx server.
*
* \@description
* Ensure that you call this API before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
* Proxy services by different service providers may result in slow performance if you are using the Firefox browser.
* Therefore, Agora recommends using the same service provider for the proxy services. If you use different service providers,
* Agora recommends not using the Firefox browser.
*
* \@param proxyServer Your Nginx server domain name. ASCII characters only, and the string length
* must be greater than 0 and less than 256 bytes.
* @type {?}
*/
AgoraClient.prototype.setProxyServer;
/**
* Sets the Remote Video-stream Type
* When a remote user sends dual streams, this method decides on which stream to receive on the subscriber side.
* If this method is not used, the subscriber receives the high-video stream.
*
* \@description
* As not all web browsers are compatible with dual streams, Agora does not recommend developers setting the
* resolution of the low-video stream.
*
* Some web browsers may not be fully compatible with dual streams:
* @see [Table](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setremotevideostreamtype)
*
* \@param stream The remote video stream object.
* \@param streamType Sets the remote video stream type. The following lists the video-stream types:
* - 0: High-bitrate, high-resolution video stream.
* - 1: Low-bitrate, low-resolution video stream.
*
* \@example
* switchStream = function (){
* if (highOrLow === 0) {
* highOrLow = 1
* console.log("Set to low");
* }
* else {
* highOrLow = 0
* console.log("Set to high");
* }
*
* client.setRemoteVideoStreamType(stream, highOrLow);
* }
* @type {?}
*/
AgoraClient.prototype.setRemoteVideoStreamType;
/**
* Use this method to set stream fallback option on the receiver.
*
* Under poor network conditions, the SDK can choose to subscribe to the low-video stream or only the audio stream.
*
* \@description
* This method can only be used when the publisher has enabled the dual-stream mode by
* [enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream).
*
* \@param stream The remote stream object.
* \@param fallbackType The fallback option:
* - 0: Disable the fallback.
* - 1: (Default) Automatically subscribe to the low-video stream under poor network.
* - 2: Under poor network, the SDK may subscribe to the low-video stream (of lower resolution and lower bitrate) first,
* but if the network still does not allow displaying the video, the SDK will receive audio only.
*
* \@example
* // The sender side, after publishing the high stream
* client.enableDualStream();
*
* // The receiver side, set the fallback option as 2
* client.setStreamFallbackOption(remoteStream, 2);
*
* @type {?}
*/
AgoraClient.prototype.setStreamFallbackOption;
/**
* Deploys the TURN Server.
*
* \@description
* Ensure that you call this API before
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
*
* @see [setTurnServer](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setturnserver)
* @type {?}
*/
AgoraClient.prototype.setTurnServer;
/**
* Starts relaying media streams across channels.
*
* After this method call, the SDK triggers the following callbacks:
*
* - Client.on(`"channel-media-relay-state"`), which reports the state and error code of the media stream relay.
* - If the media stream relay starts successfully, this callback returns `state` 2 and `code` 0.
* - If the media stream relay fails, this callback returns `state` 3. Refer to `code` for the error code and call this method again.
*
* - Client.on(`"channel-media-relay-event"`), which reports the events of the media stream relay.
* - If the media stream relay starts successfully, this callback returns `code` 4, reporting that the
* SDK starts relaying the media stream to the destination channel.
*
* \@remark
* - Contact sales-us＠agora.io to enable this function.
* - We do not support string user IDs in this API.
* - Call this method only after joining a channel.
* - In a live-broadcast channel, only a host can call this method.
* - To call this method again after it succeeds, you must call stopChannelMediaRelay to quit the current relay.
*
* \@since 3.0.0
* @type {?}
*/
AgoraClient.prototype.startChannelMediaRelay;
/**
* This method starts a live stream.
*
* \@description
* Call [startLiveStreaming](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startlivestreaming)
* after [createStream](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createstream).
*
* \@param url URL address for the live stream. ASCII characters only, and
* the string length must be greater than 0 and less than 256 bytes.
* \@param [enableTranscoding] Marks whether to enable live transcoding.
* If set as true, setLiveTranscoding must be called before this method.
*
* @see [Push Streams to the CDN](https://docs.agora.io/en/Video/push_stream_web).
* @type {?}
*/
AgoraClient.prototype.startLiveStreaming;
/**
* Enables Cloud Proxy.
*
* This method must be called before joining the channel or after leaving the channel.
*
* To use the cloud proxy service, some extra settings are needed, see
* [Use Cloud Proxy](https://docs.agora.io/en/Interactive%20Broadcast/cloud_proxy_web?platform=Web) for details.
* @type {?}
*/
AgoraClient.prototype.startProxyServer;
/**
* Stops the media stream relay. Once the relay stops, the user leaves all the destination channels.
*
* After this method call, the SDK triggers the `Client.on("channel-media-relay-state")` callback.
*
* - If the relay stops, the callback returns `state` 0.
* - If the relay fails to stop, the callback returns `state` 3 and `code` 2 or 8. The failure is usually due to poor network conditions.
* You can call [Client.leave](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#leave)
* to leave the channel and stop the relay.
*
* \@since 3.0.0
* \@example
* stopChannelMediaRelay: () => {
* client.stopChannelMediaRelay(e => {
* if(e) {
* utils.notification(`stopChannelMediaRelay failed: ${JSON.stringify(e)}`);
* } else {
* utils.notification(`stopChannelMediaRelay success`);
* }
* });
* }
*
* \@param callback The result of stopping the media stream relay.
* @type {?}
*/
AgoraClient.prototype.stopChannelMediaRelay;
/**
* This method stops and deletes the live streaming.
* When the live stream stops, the SDK triggers the `Client.on("liveStreamingStopped")` callback.
*
* \@param url URL address of the live streaming. ASCII characters only, and
* the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
AgoraClient.prototype.stopLiveStreaming;
/**
* Disables Cloud Proxy.
*
* This method must be called before joining the channel or after leaving the channel.
*
* This method disables all proxy settings, including those set by
* [setProxyServer](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setproxyserver) and
* [setTurnServer](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setturnserver).
* @type {?}
*/
AgoraClient.prototype.stopProxyServer;
/**
* This method enables a user to subscribe to a remote stream.
*
* After the user subscribes to a remote stream, the SDK triggers the `Client.on("stream-subscribed")` callback.
* If the remote stream contains an audio track, the SDK also triggers the `Client.on("first-audio-frame-decode")` callback;
* if the remote stream contains a video track, the SDK also triggers the `Client.on("first-video-frame-decode")` callback.
*
* \@example
* client.subscribe(stream, err => {
* console.error("stream subscribe failed", err);
* //……
* });
*
* Advanced
*
* This method can be called multiple times for a single remote stream,
* and enables you to switch between receiving/not receiving the video or audio data flexibly.
*
* \@example
* // Initially, subscribe to the stream and receive only the video data
* client.subscribe(stream, {video: true, audio: false});
*
* // After a while, switch to receiving only the audio data
* client.subscribe(stream, {video: false, audio: true});
*
* \@remarks
* - video and `audio` cannot be set as `false` at the same time. If you need to stop subscribing to the stream,
* call [Client.unsubscribe](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#unsubscribe) instead.
* - Safari does not support independent subscription. Set `options` as `null` for Safari,
* otherwise the `SAFARI_NOT_SUPPORTED_FOR_TRACK_SUBSCRIPTION` error occurs.
*
* \@param stream Stream object, which represents the remote stream.
* \@param [options] Sets whether to receive the video or audio data independently by the `video` and `audio` parameters.
* \@param [onFailure] The callback when the method fails. The following are common errors:
* - `"SAFARI_NOT_SUPPORTED_FOR_TRACK_SUBSCRIPTION"`: Safari does not support independent subscription.
* - `"INVALID_OPERATION"`: The user is not in the channel, possibly because the user has not
* joined the channel or the connection is interrupted.
* - `"SUBSCRIBE_STREAM_FAILED"`: The subscription fails, usually because the SDK has disconnected
* from the Agora server when subscribing to the stream.
* - `"PEERCONNECTION_FAILED"`: Fails to establish the media transport channel.
* @type {?}
*/
AgoraClient.prototype.subscribe;
/**
* Unpublishes the Local Stream.
*
* When the stream is unpublished, the `Client.on("stream-removed")` callback is triggered on the remote client.
*
* \@param stream Stream object, which represents the local stream.
*
* \@example
* client.unpublish(stream, err => {
* console.log(err);
* //……
* })
*
* \@remarks
* In a live broadcast, the user role of a host switches to audience after unpublishing, and
* the `Client.on("peer-leave")` callback is triggered on the remote client.
* @type {?}
*/
AgoraClient.prototype.unpublish;
/**
* Unsubscribes from a Remote Stream.
*
* \@param stream Stream object, which represents the remote stream.
*
* \@example
* client.unsubscribe(stream, err => {
* console.log(err);
* //……
* })
*
* @type {?}
*/
AgoraClient.prototype.unsubscribe;
/**
* Updates the channels for media stream relay.
*
* After the channel media relay starts, if you want to relay the media stream to more channels,
* or leave the current relay channel, you can call this method.
*
* After this method call, the SDK triggers the `Client.on("channel-media-relay-event")` callback.
* - If the update succeeds, the callback returns `code` 7.
* - If the update fails, the callback returns `code` 8, and the SDK also triggers the
* `Client.on("channel-media-relay-state")` callback with `state` 3. In this case, the media relay state is reset, and you need to call
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* again to restart the relay.
*
* \@remarks
* - Call this method after
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay).
* - You can add a maximum of four destination channels to a relay.
*
* \@example
* client.updateChannelMediaRelay(channelMediaConfig, e => {
* if (e) {
* utils.notification(`updateChannelMediaRelay failed: ${JSON.stringify(e)}`);
* } else {
* utils.notification(`updateChannelMediaRelay success`);
* }
* });
*
* \@since 3.0.0
* @type {?}
*/
AgoraClient.prototype.updateChannelMediaRelay;
/** @type {?|undefined} */
AgoraClient.prototype.aesMode;
/** @type {?|undefined} */
AgoraClient.prototype.aespassword;
/** @type {?|undefined} */
AgoraClient.prototype.gatewayClient;
/** @type {?|undefined} */
AgoraClient.prototype.highStream;
/** @type {?|undefined} */
AgoraClient.prototype.highStreamState;
/** @type {?|undefined} */
AgoraClient.prototype.isDualStream;
/** @type {?|undefined} */
AgoraClient.prototype.key;
/** @type {?|undefined} */
AgoraClient.prototype.lowStream;
/** @type {?|undefined} */
AgoraClient.prototype.lowStreamParameter;
/** @type {?|undefined} */
AgoraClient.prototype.lowStreamState;
/** @type {?|undefined} */
AgoraClient.prototype.proxyServer;
/** @type {?|undefined} */
AgoraClient.prototype.turnServer;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/agora-config.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function AgoraConfig() { }
if (false) {
/** @type {?} */
AgoraConfig.prototype.AppID;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/agora-rtc.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* AgoraRTC is the entry point for all the methods that can be called in Agora Web SDK.
*
* You can use the AgoraRTC methods to create
* [Client](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html) and
* [Stream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html) objects.
* Other methods of the AgoraRTC object check for system requirements and set up error logging.
* @record
*/
function AgoraRTC() { }
if (false) {
/**
* Checks the Web Browser Compatibility
*
* This method checks the compatibility between the Web SDK and the current web browser.
* Use this method before calling createClient to check the compatibility between the system and the web browser.
*
* - true: The Web SDK is compatible with the current web browser.
* - false: The Web SDK is not compatible with the current web browser.
*
* \@remark
* Agora has yet to conduct comprehensive tests on Chromium kernel browsers, such as QQ and 360.
* Agora will gradually achieve compatibility on most mainstream browsers in subsequent versions of the Web SDK.
* @type {?}
*/
AgoraRTC.prototype.checkSystemRequirements;
/**
* Creates a Client Object
*
* This method creates and returns a client object. You can only call this method once each call session.
*
* \@param config
* Defines the property of the client, see
* [ClientConfig](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html) for details.
*
* \@example
* AgoraRTC.createClient(config);
* @type {?}
*/
AgoraRTC.prototype.createClient;
/**
* This method creates and returns a stream object.
*
* \@example
* AgoraRTC.createStream(spec)
*
* \@param spec Defines the properties of the stream
* @see [StreamSpec](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html) for details.
* @type {?}
*/
AgoraRTC.prototype.createStream;
/**
* This method enumerates the available media input and output devices, such as microphones, cameras, headsets, and so on.
*
* If this method succeeds, the SDK returns a list of media devices in an array of `MediaDeviceInfo` objects.
*
* \@example
* AgoraRTC.getDevices(devices => {
* const devCount = devices.length;
* const id = devices[0].deviceId;
* });
* @type {?}
*/
AgoraRTC.prototype.getDevices;
/**
* Gets the Sources for Screen-sharing
*
* To share the screen on Electron, call this method to get the screen sources.
* @see [Share the Screen](https://docs.agora.io/en/Video/screensharing_web?platform=Web#electron) for details.
*
* If this method succeeds, the SDK returns a list of screen sources in an array of
* [DesktopCapturerSource](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.desktopcapturersource.html) objects.
*
* \@example
* AgoraRTC.getScreenSources(function(err, sources) {
* console.log(sources)
* }
*
* @type {?}
*/
AgoraRTC.prototype.getScreenSources;
/**
* This method returns the codecs supported by both the Agora Web SDK and the web browser.
* The Agora Web SDK supports VP8 and H.264 for video, and OPUS for audio.
*
* This method supports all web browsers. For web browsers that do not support WebRTC or
* are not recognized, the returned codec list is empty.
*
* \@remark
* In the `.then(function(result){})` callback, `result` has the following properties:
* - `video`: array, the supported video codecs. The array might include `'H264'` and `'VP8'`, or be empty.
* - `audio`: array, the supported audio codecs. The array might include `'OPUS'`, or be empty.
*
* \@example
* // Gets the supported decoding formats as the receiver
* AgoraRTC.getSupportedCodec()
* .then(result => {
* console.log(`Supported video codec: ${result.video.join(',')}`);
* console.log(`Supported audio codec: ${result.audio.join(',')}`);
* });
*
* // Gets the supported encoding formats as the sender
* navigator.mediaDevices.getUserMedia({video: true, audio: true})
* .then(mediaStream => {
* return AgoraRTC.getSupportedCodec({stream: mediaStream});
* })
* .then(result => {
* console.log(`Supported video codec: ${result.video.join(',')}`);
* console.log(`Supported audio codec: ${result.audio.join(',')}`);
* });
* @type {?}
*/
AgoraRTC.prototype.getSupportedCodec;
/**
* Logs connection information and errors to the console during active periods of the Agora.io SDK.
* @type {?}
*/
AgoraRTC.prototype.Logger;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/audio-effect-options.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function AudioEffectOptions() { }
if (false) {
/**
* The number of playback loops (only supported on Chrome 65 and later).
*
* A positive integer. The value range is `[1,10000]`. The default value is 1.
* @type {?|undefined}
*/
AudioEffectOptions.prototype.cycle;
/**
* The URL of the online audio effect file.
*
* The URL must contain ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* Supported audio formats: MP3, AAC, and other audio formats depending on the browser.
* @type {?}
*/
AudioEffectOptions.prototype.filePath;
/**
* The ID of the specified audio effect.
*
* A positive integer. The value range is `[1,10000]`. Each audio effect has a unique ID.
* If the audio effect is preloaded into the memory through the
* [preloadEffect](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#preloadeffect)
* method, ensure that the soundId value is set to the same value as in
* [preloadEffect](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#preloadeffect).
* @type {?}
*/
AudioEffectOptions.prototype.soundId;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/audio-mixing-options.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Audio mixing settings.
* @record
*/
function AudioMixingOptions() { }
if (false) {
/**
* Whether or not to store the audio mixing file in the cache.
*
* - `true`: (default) store the audio mixing file in the cache to speed up mixing this file the next time.
* - `false`: do not store the audio mixing file in the cache to save RAM.
* @type {?|undefined}
*/
AudioMixingOptions.prototype.cacheResource;
/**
* Number of playback loops (only supports Chrome 65+)
* A positive integer. The value range is `[1,10000]`. The default value is `1`.
* @type {?|undefined}
*/
AudioMixingOptions.prototype.cycle;
/**
* Path of the online audio file to mix. ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* Supported audio formats: mp3, aac, and other audio formats depending on the browser.
* @type {?}
*/
AudioMixingOptions.prototype.filePath;
/**
* Whether the audio mixing file loops infinitely.
*
* - `true`: The audio mixing file loops infinitely. Do not use this option if cycle is specified.
* - `false`: (Default) Disables the infinite loops.
* @type {?|undefined}
*/
AudioMixingOptions.prototype.loop;
/**
* Sets the playback position (ms) of the audio mixing file. An integer, and the value range is `[0,100000000]`.
* If you need to play the file from the beginning, set this paramter to `0`.
* @type {?}
*/
AudioMixingOptions.prototype.playTime;
/**
* Whether the online audio file replaces the local audio stream.
* - `true`: The content of the online audio file replaces the audio stream from the microphone.
* - `false`: (Default) The online audio file is mixed with the audio stream from the microphone.
*
* \@remark
* Safari does not support this parameter.
* @type {?|undefined}
*/
AudioMixingOptions.prototype.replace;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/beauty-effect-options.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Image enhancement options.
* @record
*/
function BeautyEffectOptions() { }
if (false) {
/**
* The contrast level, used with the `lighteningLevel` parameter.
* - 0: Low contrast level.
* - 1: (Default) The original contrast level.
* - 2: High contrast level.
* @type {?|undefined}
*/
BeautyEffectOptions.prototype.lighteningContrastLevel;
/**
* The brightness level.
*
* The value ranges from 0.0 (original) to 1.0. The default value is 0.7.
* @type {?|undefined}
*/
BeautyEffectOptions.prototype.lighteningLevel;
/**
* The redness level.
*
* The value ranges from 0.0 (original) to 1.0. The default value is 0.1. This parameter adjusts the red saturation level.
* @type {?|undefined}
*/
BeautyEffectOptions.prototype.rednessLevel;
/**
* The sharpness level.
*
* The value ranges from 0.0 (original) to 1.0. The default value is 0.5. This parameter is usually used to remove blemishes.
* @type {?|undefined}
*/
BeautyEffectOptions.prototype.smoothnessLevel;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/channel-info.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function ChannelInfo() { }
if (false) {
/**
* The channel name.
* @type {?}
*/
ChannelInfo.prototype.channelName;
/**
* The unique ID to identify the relay stream in the destination channel.
* A 32-bit unsigned integer with a value ranging from 0 to (2^32-1).
* If you set it as `0`, the server assigns a random one. To avoid UID conflicts, this uid must be different
* from any other UIDs in the destination channel.
* @type {?}
*/
ChannelInfo.prototype.uid;
/**
* The token generated with the above `channelName` and `uid`. Do not set this parameter if you have not enabled token.
* @type {?}
*/
ChannelInfo.prototype.token;
}
/**
* @record
*/
function DestinationChannelInfo() { }
if (false) {
/**
* The unique ID to identify the relay stream in the destination channel.
* A 32-bit unsigned integer with a value ranging from 0 to (2^32-1).
* If you set it as `0`, the server assigns a random one. To avoid UID conflicts, this uid must be different
* from any other UIDs in the destination channel.
* @type {?}
*/
DestinationChannelInfo.prototype.uid;
}
/**
* @record
*/
function SourceChannelInfo() { }
if (false) {
/**
* The unique ID to identify the relay stream in the source channel.
* A 32-bit unsigned integer with a value ranging from 0 to (232-1).
* If you set it as `0`, the server assigns a random one. To avoid UID conflicts, this value must be different
* from the UID of the current host.
* @type {?}
*/
SourceChannelInfo.prototype.uid;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/channel-media-error.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Error information of the media stream relay.
*
* When errors occur in calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay),
* [updateChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay), or
* [stopChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#stopchannelmediarelay),
* the callback functions of these methods provide error details in this class.
*
* In this class, `code` is the error code and `message` is the error message.
*
* @see [the following table](https://docs.agora.io/en/Video/API%20Reference/web/classes/agorartc.channelmediaerror.html) for details.
* @record
*/
function ChannelMediaError() { }
if (false) {
/**
* The error code.
* @type {?}
*/
ChannelMediaError.prototype.code;
/**
* Additional information.
* @type {?}
*/
ChannelMediaError.prototype.data;
/**
* The error message.
* @type {?}
*/
ChannelMediaError.prototype.message;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/channel-media-relay-configuration.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Configurations of the media stream relay.
*
* \@description
* Use this interface to set the media stream relay when calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* or [updateChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay).
*
* \@since 3.0.0
* @record
*/
function ChannelMediaRelayConfiguration() { }
if (false) {
/**
* Removes the destination channel.
*
* \@example
* configuration.removeDestChannelInfo("cname")
* @type {?}
*/
ChannelMediaRelayConfiguration.prototype.removeDestChannelInfo;
/**
* Sets the information of the destination channel.
*
* To relay a media stream across multiple channels, call this method as many times (to a maximum of four).
*
* \@example
* var configuration = new AgoraRTC.ChannelMediaRelayConfiguration();
* configuration.setDestChannelInfo("cname", {
* channelName: "destChannel",
* uid: 123,
* token: "yourDestToken",
* })
*
* \@param channelName The name of the destination channel.
* Ensure that the value of this parameter is the same as the value of `channelName` in `destInfo`.
* \@param destInfo The information of the destination channel
*
* @type {?}
*/
ChannelMediaRelayConfiguration.prototype.setDestChannelInfo;
/**
* Sets the information of the source channel.
*
* \@example
* var configuration = new AgoraRTC.ChannelMediaRelayConfiguration();
* configuration.setSrcChannelInfo({
* channelName: "srcChannel",
* uid: 123,
* token: "yourSrcToken",
* })
* @type {?}
*/
ChannelMediaRelayConfiguration.prototype.setSrcChannelInfo;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/client-config.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A class defining the properties of the config parameter in the
* [createClient](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createclient) method.
*
* \@remark
* - Ensure that you do not leave mode and codec as empty.
* - Ensure that you set these properties before calling Client.join.
*
* Define [proxyServer](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#proxyserver) and
* [turnServer](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#turnserver)
* if you need to set a proxy server. For a tutorial on deploying the Proxy server on a Web client, see
* [Deploy the Enterprise Proxy](https://docs.agora.io/en/Video/proxy_web).
*
* Proxy services by different service providers may result in slow performance if you are using the Firefox browser.
* Therefore, Agora recommends using the same service provider for the proxy services.
* If you use different service providers, Agora recommends not using the Firefox browser.
*
* \@example
* import { ClientConfig } from 'ngx-agora';
*
* const config: ClientConfig = {
* mode: "live",
* codec: "vp8",
* proxyServer: "YOUR NGINX PROXY SERVER IP",
* turnServer: {
* turnServerURL: "YOUR TURNSERVER URL",
* username: "YOUR USERNAME",
* password: "YOUR PASSWORD",
* udpport: "THE UDP PORT YOU WANT TO ADD",
* tcpport: "THE TCP PORT YOU WANT TO ADD",
* forceturn: false
* }
* }
* this.ngxAgoraService.createClient(config);
* @record
*/
function ClientConfig() { }
if (false) {
/**
* The codec the Web browser uses for encoding and decoding.
* - `'vp8'`: Sets the browser to use VP8 for encoding and decoding.
* - `'h264'`: Sets the browser to use H264 for encoding and decoding.
*
* \@remark
* Set codec as "h264" as long as Safari is involved in the session.
* @type {?}
*/
ClientConfig.prototype.codec;
/**
* The channel profile.
*
* Agora Web SDK needs to know the application scenario to apply different optimization methods.
*
* Currently Agora Web SDK supports the following channel profiles:
* - "live": Sets the channel profile as live broadcast.
* Host and audience roles that can be set by calling the
* [Client.setClientRole](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setclientrole) method.
* The host sends and receives voice/video, while the audience can only receive voice/video.
* - "rtc": Sets the channel profile as communication. This is used in one-on-one calls or group calls,
* where all users in the channel can talk freely.
*
* \@remark
* If you need to communicate with Agora Native SDK, Agora recommends the following settings:
* - For Native SDK v2.3.2 and later:
* Set [mode](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#mode)
* as "rtc" or "live" if the Native SDK uses the communication channel profile.
* Set [mode](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#mode)
* as "live" if the Native SDK uses the live broadcast channel profile.
* - For Native SDK before v2.3.2, set mode as "live" regardless of which channel profile the Native SDK uses.
*
* If you set [mode](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.clientconfig.html#mode)
* as "rtc", the Agora Recording SDK is not supported.
* @type {?}
*/
ClientConfig.prototype.mode;
/**
* Your Nginx server domain name.
*
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* Enterprise users with a company firewall can use this property to pass signaling messages to the Agora SD-RTN through the Nginx Server.
* @type {?|undefined}
*/
ClientConfig.prototype.proxyServer;
/**
* TURN server settings.
*
* Enterprise users with a company firewall can use this property to pass audio and video data to the Agora SD-RTN through
* the TURN Server.
* @type {?|undefined}
*/
ClientConfig.prototype.turnServer;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/desktop-capturer-source.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* This interface contains information on the screen source
* @see [DesktopCapturerSource](https://electronjs.org/docs/api/structures/desktop-capturer-source).
* @record
*/
function DesktopCapturerSource() { }
if (false) {
/**
* ID of the screen source.
* @type {?}
*/
DesktopCapturerSource.prototype.id;
/**
* Name of the screen source.
* @type {?}
*/
DesktopCapturerSource.prototype.name;
/**
* Thumbnail of the screen source.
* @see [nativeImage](https://electronjs.org/docs/api/native-image#nativeimage) for supported types.
* @type {?}
*/
DesktopCapturerSource.prototype.thumbnail;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/inject-stream-config.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A class for configuring the imported live broadcast voice or video stream.
*
* \@example
* const injectStreamConfig = {
* width: 0,
* height: 0,
* videoGop: 30,
* videoFramerate: 15,
* videoBitrate: 400,
* audioSampleRate: 44100,
* audioChannels: 1,
* };
* @record
*/
function InjectStreamConfig() { }
if (false) {
/**
* Audio bitrate of the added stream to the broadcast.
* Positive integer. The default value is 48. The value range is [1, 10000].
*
* \@remark
* Agora recommends that you stay with the default value and not reset it at this point of time.
* @type {?|undefined}
*/
InjectStreamConfig.prototype.audioBitrate;
/**
* Audio channels to add into the broadcast.
* Positive integer. The default value is 1. The value range is [1, 2].
*
* \@remark
* Agora recommends that you stay with the default value and not reset it at this point of time.
* @type {?|undefined}
*/
InjectStreamConfig.prototype.audioChannels;
/**
* Audio sampling rate of the added stream to the broadcast.
* 32000: 32 kHz
* 44100: (Default) 44.1 kHz
* 48000: 48 kHz
*
* \@remark
* Agora recommends that you stay with the default value and not reset it at this point of time.
* @type {?|undefined}
*/
InjectStreamConfig.prototype.audioSampleRate;
/**
* Video bitrate of the added stream to the broadcast.
* Positive integer. The default value is 400 Kbps. The value range is [1, 10000].
*
* \@remark
* The setting of the video bitrate is closely linked to the resolution. If the video bitrate you set is beyond
* the reasonable range, the SDK will set it within the reasonable range instead.
* @type {?|undefined}
*/
InjectStreamConfig.prototype.videoBitrate;
/**
* Video frame rate of the added stream to the broadcast.
* Positive integer. The default value is 15 fps. The value range is [1, 10000].
* @type {?|undefined}
*/
InjectStreamConfig.prototype.videoFramerate;
/**
* Video GOP of the added stream to the broadcast.
* Positive integer. The default value is 30 frames. The value range is [1, 10000].
* @type {?|undefined}
*/
InjectStreamConfig.prototype.videoGop;
/**
* Width of the added stream to the broadcast.
* Integer, the default value is 0, which is the same width as the original stream. The value range is [0, 10000].
* @type {?|undefined}
*/
InjectStreamConfig.prototype.width;
/**
* Height of the added stream to the broadcast.
* Integer, the default value is 0, which is the same height as the original stream. The value range is [0, 10000].
* @type {?|undefined}
*/
InjectStreamConfig.prototype.height;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/live-transcoding.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function LiveTranscoding() { }
if (false) {
/**
* Bitrate of the CDN live audio output stream in Kbps.
* Positive integer. The default value is `48`, and the highest value is `128`.
* @type {?}
*/
LiveTranscoding.prototype.audioBitrate;
/**
* Agora’s self-defined audio channel type.
*
* Agora recommends choosing 1 or 2. Special players are required if you choose 3, 4 or 5:
* 1. (Default) Mono
* 2. Dual sound channels
* 3. Three sound channels
* 4. Four sound channels
* 5. Five sound channels
* @type {?}
*/
LiveTranscoding.prototype.audioChannels;
/**
* Audio sampling rate:
* - 32000: 32 kHz
* - 44100: (Default) 44.1 kHz
* - 48000: 48 kHz
* @type {?}
*/
LiveTranscoding.prototype.audioSampleRate;
/**
* The background color in RGB hex value.
*
* Value only, do not include a #. The default value is `0x000000`. The value range is `[0x000000, 0xffffff]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.backgroundColor;
/**
* Height of the video.
*
* Positive integer, the default value is 360. The value range is `[1, 10000]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.height;
/**
* - true: Low latency with unassured quality.
* - false: (Default）High latency with assured quality.
* @type {?|undefined}
*/
LiveTranscoding.prototype.lowLatency;
/**
* Manages the user layout configuration in the CDN live streaming.
*
* Agora supports a maximum of 17 transcoding users in a CDN streaming channel.
* @see [TranscodingUser](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.transcodinguser.html) for details.
* @type {?|undefined}
*/
LiveTranscoding.prototype.transcodingUsers;
/**
* Number of users; default value is 0. The maximum is 17.
* @type {?|undefined}
*/
LiveTranscoding.prototype.userCount;
/**
* Bitrate of the CDN live output video stream.
*
* Positive integer. The default value is 400 Kbps. The value range is `[1,1000000]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.videoBitrate;
/**
* Video codec profile type:
*
* - 66: Baseline video codec profile. Generally used in video calls on mobile phones.
* - 77: Main video codec profile.Generally used in mainstream electronics, such as MP4 players, portable video players, PSP, and iPads.
* - 100: (Default) High video codec profile.Generally used in high - resolution broadcasts or television.
* @type {?|undefined}
*/
LiveTranscoding.prototype.videoCodecProfile;
/**
* Frame rate of the output data stream set for CDN live.
*
* Positive integer. The default value is 15 fps. The value range is `[1, 10000]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.videoFramerate;
/**
* Video GOP in frames. The default value is 30 frames. The value range is `[1,10000]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.videoGop;
/**
* Width of the video.
*
* Positive integer, the default value is `640`. The value range is `[1, 10000]`.
* @type {?|undefined}
*/
LiveTranscoding.prototype.width;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/local-audio-stats-map.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A list of `LocalAudioStats` objects, one per uid.
* @record
*/
function LocalAudioStatsMap() { }
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/local-audio-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function LocalAudioStats() { }
if (false) {
/**
* Encoding type of the sent audio.
* @type {?|undefined}
*/
LocalAudioStats.prototype.CodecType;
/**
* Whether the audio is muted or not.
* @type {?|undefined}
*/
LocalAudioStats.prototype.MuteState;
/**
* Energy level of the captured audio.
* @type {?|undefined}
*/
LocalAudioStats.prototype.RecordingLevel;
/**
* Sampling rate, in kHz.
* @type {?|undefined}
*/
LocalAudioStats.prototype.SamplingRate;
/**
* Bitrate of the sent audio, in Kbps.
* @type {?|undefined}
*/
LocalAudioStats.prototype.SendBitrate;
/**
* Energy level of the sent audio.
* @type {?|undefined}
*/
LocalAudioStats.prototype.SendLevel;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/local-stream-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The connection statistics of the local stream.
* @record
*/
function LocalStreamStats() { }
if (false) {
/**
* Bytes of the sent audio.
* @type {?}
*/
LocalStreamStats.prototype.audioSendBytes;
/**
* Packets of the sent audio.
* @type {?}
*/
LocalStreamStats.prototype.audioSendPackets;
/**
* Number of lost packets of the sent audio.
*
* \@remark
* Safari and Firefox do not support this property.
* @type {?}
*/
LocalStreamStats.prototype.audioSendPacketsLost;
/**
* Bytes of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendBytes;
/**
* Frame rate of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendFrameRate;
/**
* Packets of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendPackets;
/**
* Number of lost packets of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendPacketsLost;
/**
* Resolution height of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendResolutionHeight;
/**
* Resolution width of the sent video.
* @type {?}
*/
LocalStreamStats.prototype.videoSendResolutionWidth;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/local-video-stats-map.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A list of `LocalVideoStats` objects, one per uid.
* @record
*/
function LocalVideoStatsMap() { }
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/local-video-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function LocalVideoStats() { }
if (false) {
/**
* Frame rate of the captured video, in fps.
* @type {?|undefined}
*/
LocalVideoStats.prototype.CaptureFrameRate;
/**
* Height (pixels) of the captured video.
* @type {?|undefined}
*/
LocalVideoStats.prototype.CaptureResolutionHeight;
/**
* Width (pixels) of the captured video.
* @type {?|undefined}
*/
LocalVideoStats.prototype.CaptureResolutionWidth;
/**
* Delay from capturing to encoding the local video, in ms.
* @type {?|undefined}
*/
LocalVideoStats.prototype.EncodeDelay;
/**
* Whether the video is muted or not.
* @type {?|undefined}
*/
LocalVideoStats.prototype.MuteState;
/**
* Bitrate of the sent video, in Kbps.
* @type {?|undefined}
*/
LocalVideoStats.prototype.SendBitrate;
/**
* Frame rate of the sent video, in fps.
* @type {?|undefined}
*/
LocalVideoStats.prototype.SendFrameRate;
/**
* Height of the sent video, in pixels.
* @type {?|undefined}
*/
LocalVideoStats.prototype.SendResolutionHeight;
/**
* Width of the sent video, in pixels.
* @type {?|undefined}
*/
LocalVideoStats.prototype.SendResolutionWidth;
/**
* Bitrate of the local video set in
* [setVideoProfile](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#setvideoprofile).
* @type {?|undefined}
*/
LocalVideoStats.prototype.TargetSendBitrate;
/**
* Total duration of the published video, in seconds.
* @type {?|undefined}
*/
LocalVideoStats.prototype.TotalDuration;
/**
* Total freeze time of the encoded video, in seconds.
* @type {?|undefined}
*/
LocalVideoStats.prototype.TotalFreezeTime;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/logger.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Provides methods to enable/disable log upload and set output log level.
* @record
*/
function Logger() { }
if (false) {
/**
* Outputs all logs.
* @type {?}
*/
Logger.prototype.DEBUG;
/**
* Outputs logs of the INFO, WARNING and ERROR levels.
* @type {?}
*/
Logger.prototype.INFO;
/**
* Outputs logs of the WARNING and ERROR levels.
* @type {?}
*/
Logger.prototype.WARNING;
/**
* Outputs logs of the ERROR level.
* @type {?}
*/
Logger.prototype.ERROR;
/**
* Outputs no logs.
* @type {?}
*/
Logger.prototype.NONE;
/** @type {?} */
Logger.prototype.debug;
/** @type {?} */
Logger.prototype.error;
/** @type {?} */
Logger.prototype.info;
/** @type {?} */
Logger.prototype.warning;
/**
* This method disables log upload.
*
* By default, the log-upload function is disabled. If you have used
* [enableLogUpload](https://docs.agora.io/en/Video/API%20Reference/web/modules/agorartc.logger.html#enablelogupload),
* call this method when you need to stop uploading the log.
*
* \@example
* AgoraRTC.Logger.disableLogUpload();
* @type {?}
*/
Logger.prototype.disableLogUpload;
/**
* Call this method to enable log upload to Agora’s server.
*
* The log-upload function is disabled by default, if you need to enable this function,
* please call this method before all the other methods.
*
* \@remark
* If the user fails to join the channel, the log information is not available on Agora’s server.
*
* \@example
* AgoraRTC.Logger.enableLogUpload();
* @type {?}
*/
Logger.prototype.enableLogUpload;
/**
* This method sets the output log level.
*
* The log level follows the sequence of NONE, ERROR, WARNING, INFO, and DEBUG.
* For example, if you set the log level as AgoraRTC.Logger.setLogLevel(AgoraRTC.Logger.INFO);,
* then you can see logs in levels INFO, ERROR, and WARNING.
* @type {?}
*/
Logger.prototype.setLogLevel;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/media-device-info.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* This interface contains information that describes a single media input or output device.
* The list of devices obtained by calling [AgoraRTC.getDevices](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
* is an array of MediaDeviceInfo objects, one per media device.
* @record
*/
function MediaDeviceInfo() { }
if (false) {
/**
* Unique ID of the device.
* @type {?}
*/
MediaDeviceInfo.prototype.deviceId;
/**
* Returns an enumerated value that is "videoinput", "audioinput" or "audiooutput".
* @type {?}
*/
MediaDeviceInfo.prototype.kind;
/**
* Returns a DOMString that is a label describing this device (for example "External USB Webcam").
*
* \@remark
* For security reasons, the label field is always blank unless an active media stream exists
* or the user has granted persistentpermission for media device access.
* @type {?}
*/
MediaDeviceInfo.prototype.label;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/media-stream-track.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* This interface represents a single media track within a stream, for example an audio track or a video track.
* @see [MediaStreamTrack](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) for details.
* @record
*/
function MediaStreamTrack() { }
if (false) {
/** @type {?} */
MediaStreamTrack.prototype.kind;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/media-stream.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The MediaStream interface represents a stream of media content.
*
* A stream consists of several tracks such as video or audio tracks. Each track is specified as an instance of
* [MediaStreamTrack](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.mediastreamtrack.html).
*
* @see [MediaStream](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream) for details.
* @record
*/
function MediaStream() { }
if (false) {
/**
* A Boolean value that returns true if the stream is active, or false otherwise.
* @see [active](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/active) for details.
* @type {?}
*/
MediaStream.prototype.active;
/**
* A [`DOMString`](https://developer.mozilla.org/en-US/docs/Web/API/DOMString) containing 36 characters
* denoting a universally unique identifier (UUID) for the object.
*
* @see [MediaStream.id](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/id) for details.
* @type {?}
*/
MediaStream.prototype.id;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/remote-audio-stats-map.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A list of RemoteAudioStats objects, one per uid.
* @record
*/
function RemoteAudioStatsMap() { }
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/remote-audio-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function RemoteAudioStats() { }
if (false) {
/**
* Decoding type of the received audio.
*
* - "1": Opus.
* - "2": AAC.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.CodecType;
/**
* End-to-end delay in ms.
*
* Delay from capturing to playing the audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.End2EndDelay;
/**
* Whether the audio is muted or not.
* - "1": Muted.
* - "0": Unmuted.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.MuteState;
/**
* Packet loss rate (%) of the remote audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.PacketLossRate;
/**
* Bitrate of the received audio, in Kbps.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.RecvBitrate;
/**
* Volume of the received audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.RecvLevel;
/**
* Total freeze time of the received audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.TotalFreezeTime;
/**
* Total playing duration of the received audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.TotalPlayDuration;
/**
* Transport delay in ms.
*
* Delay from sending to receiving the audio.
* @type {?|undefined}
*/
RemoteAudioStats.prototype.TransportDelay;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/remote-stream-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The connection statistics of the remote stream.
* @record
*/
function RemoteStreamStats() { }
if (false) {
/**
* Bytes of the received audio.
* @type {?}
*/
RemoteStreamStats.prototype.audioReceiveBytes;
/**
* Delay in receiving the audio (ms).
*
* Delay from sending to playing the audio, only supported by Chrome for now.
* @type {?}
*/
RemoteStreamStats.prototype.audioReceiveDelay;
/**
* Packets of the received audio.
* @type {?}
*/
RemoteStreamStats.prototype.audioReceivePackets;
/**
* Number of lost packets of the received audio.
* @type {?}
*/
RemoteStreamStats.prototype.audioReceivePacketsLost;
/**
* Delay from sending to receiving data.
* @type {?}
*/
RemoteStreamStats.prototype.endToEndDelay;
/**
* Bytes of the received video.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceiveBytes;
/**
* Decode frame rate after the video is received.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceiveDecodeFrameRate;
/**
* Delay in receiving the video (ms).
*
* Delay from sending to playing the video, only supported by Chrome for now.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceiveDelay;
/**
* Frame rate rof the received video.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceiveFrameRate;
/**
* Packets of the received video.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceivePackets;
/**
* Number of lost packets of the received video.
* @type {?}
*/
RemoteStreamStats.prototype.videoReceivePacketsLost;
/**
* Resolution height of the received video.
* @type {?|undefined}
*/
RemoteStreamStats.prototype.videoReceiveResolutionHeight;
/**
* Resolution width of the received video.
* @type {?|undefined}
*/
RemoteStreamStats.prototype.videoReceiveResolutionWidth;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/remote-video-stats-map.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A list of `RemoteVideoStats` objects, one per uid.
* @record
*/
function RemoteVideoStatsMap() { }
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/remote-video-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Video statistics of the remote stream.
* @record
*/
function RemoteVideoStats() { }
if (false) {
/**
* End-to-end delay in ms.
*
* Delay from capturing to playing the video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.End2EndDelay;
/**
* Whether the video is muted or not.
*
* - "1": Muted.
* - "0": Unmuted.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.MuteState;
/**
* Packet loss rate (%) of the remote video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.PacketLossRate;
/**
* Bitrate of the received video, in Kbps.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RecvBitrate;
/**
* Resolution height of the received video, in pixels.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RecvResolutionHeight;
/**
* Resolution width of the received video, in pixels.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RecvResolutionWidth;
/**
* Rendering frame rate of the decoded video, in fps.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RenderFrameRate;
/**
* Height (pixels) of the rendered video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RenderResolutionHeight;
/**
* Width (pixels) of the rendered video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.RenderResolutionWidth;
/**
* Total freeze time of the received video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.TotalFreezeTime;
/**
* Total playing duration of the received video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.TotalPlayDuration;
/**
* Transport delay in ms.
*
* Delay from sending to receiving the video.
* @type {?|undefined}
*/
RemoteVideoStats.prototype.TransportDelay;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/session-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function SessionStats() { }
if (false) {
/**
* Call duration in seconds, represented by an aggregate value.
* @type {?|undefined}
*/
SessionStats.prototype.Duration;
/**
* Total received bitrate of the stream, in Kbps, represented by an instantaneous value.
* @type {?|undefined}
*/
SessionStats.prototype.RecvBitrate;
/**
* Total number of bytes received, represented by an aggregate value.
* @type {?|undefined}
*/
SessionStats.prototype.RecvBytes;
/**
* Total sent bitrate of the stream, in Kbps, represented by an instantaneous value.
* @type {?|undefined}
*/
SessionStats.prototype.SendBitrate;
/**
* Total number of bytes sent, represented by an aggregate value.
* @type {?|undefined}
*/
SessionStats.prototype.SendBytes;
/**
* Number of users in the channel.
*
* rtc mode: The number of all users in the channel.
* live mode
* - If the local user is an audience: The number of hosts in the channel + 1.
* - If the user is a host: The number of hosts in the channel.
* @type {?|undefined}
*/
SessionStats.prototype.UserCount;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/stream-spec.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* A class defining the `spec` paramter in the
* [createStream](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createstream) method.
*
* * \@remark
* - Do not set `video` and `screen` as `true` at the same time.
* - To enable screen-sharing on the Firefox browser, ensure that the `screen` property is
* set to `true`, and the `mediaSource` property has been set to specify a certain sharing mode.
*
* # Create a Stream
*
* You have two options to create an audio/video stream:
*
* ## Set the audio, video, and screen properties
* const stream = AgoraRTC.createStream({
* streamID: uid,
* audio:true,
* video:true,
* screen:false
* });
*
*
* ## Set the audioSource and videoSource properties
*
* Compared with the first option, the
* [audioSource](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html#audiosource)
* and [videoSource](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html#videosource)
* properties can specify the audio and video tracks for the stream. Use this option if you need to process the audio
* and video before creating the stream.
*
* Use the `mediaStream` method to get the audio and video tracks from `MediaStreamTrack`, and then set `audioSource` and `videoSource`:
*
* navigator.mediaDevices.getUserMedia(
* {video: true, audio: true}
* ).then(function(mediaStream){
* var videoSource = mediaStream.getVideoTracks()[0];
* var audioSource = mediaStream.getAudioTracks()[0];
* // After processing videoSource and audioSource
* var localStream = AgoraRTC.createStream({
* video: true,
* audio: true,
* videoSource: videoSource,
* audioSource: audioSource
* });
* localStream.init(function(){
* client.publish(localStream, function(e){
* //...
* });
* });
* });
*
* \@remark
* - `MediaStreamTrack` refers to the `MediaStreamTrack` object supported by the browser.
* - Currently this option only supports the Chrome brower.
*
* @see [MediaStreamTrack API](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) for details.
*
*
* ### Enable Screen-sharing on the Chrome Web Browser
*
* const stream = AgoraRTC.createStream({
* streamID: uid,
* audio:false,
* video:false,
* screen:true,
* extensionId:"minllpmhdgpndnkomcoccfekfegnlikg"});
*
* ### Enable Screen-sharing on the Firefox Web Browser
*
* localStream = AgoraRTC.createStream({
* streamID: uid,
* audio: false,
* video: false,
* screen: true,
* mediaSource: "screen",
* });
*
* For a tutorial on screen-sharing on a website,
* @see [Share the Screen](https://docs.agora.io/en/Video/screensharing_web?platform=Web).
* @record
*/
function StreamSpec() { }
if (false) {
/**
* Whether this stream contains an audio track.
* @type {?}
*/
StreamSpec.prototype.audio;
/**
* Whether to enable audio processing.
*
* \@param [AEC] Whether to enable acoustic echo cancellation.
* The default value is `true` (enable). If you wish not to enable the acoustic echo cancellation, set AEC as `false`.
* \@param [AGC] Whether to enable audio gain control.
* The default value is true (enable). If you wish not to enable the audio gain control, set AGC as false.
* \@param [ANS] Whether to enable automatic noise suppression.
* The default value is true (enable). If you wish not to enable automatic noise suppression, set ANS as false.
*
* \@remark
* - Safari does not support this setting.
* - Noise suppression is always enabled on Firefox. Setting `ANS` as `false` does not take effect on Firefox.
* @type {?|undefined}
*/
StreamSpec.prototype.audioProcessing;
/**
* Specifies the audio source of the stream.
* @type {?|undefined}
*/
StreamSpec.prototype.audioSource;
/**
* The camera device ID retrieved from the [getDevices](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices)
* method.
*
* The retrieved ID is ASCII characters, and the string length is greater than 0 and less than 256 bytes.
*
* When the string length is 0, this property is ignored.
* @type {?|undefined}
*/
StreamSpec.prototype.cameraId;
/**
* The extension ID of the Chrome screen-sharing extension.
*
* ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* Set this property if you use the Chrome screen-sharing extension.
* @see [Chrome Extension for Screen Sharing](https://docs.agora.io/en/Video/chrome_screensharing_plugin?platform=Web) for details.
*
* \@remark
* Chrome 72 and later versions support screen sharing without the extension. You can leave extensionId as empty.
* If you set the `extensionId`, then you need to use the screen-sharing extension.
* @type {?|undefined}
*/
StreamSpec.prototype.extensionId;
/**
* Sets using the front or rear camera.
*
* You can set this parameter to use the front or rear camera on mobile devices:
* - `"user"`: The front camera
* - `"environment"`: The rear camera
* @type {?|undefined}
*/
StreamSpec.prototype.facingMode;
/**
* The screen-sharing mode on the Firefox browser.
*
* If you are using the Firefox browser, setting this property specifies the screen-sharing mode:
* - `"screen"`: (default) share the current screen
* - `"application"`: share all windows of an App
* - `"window"`: share a specified window of an App
*
* \@remark
* Firefox on Windows does not support the application mode.
*
* @see
* [Screen Sharing on Firefox](https://docs.agora.io/en/Video/screensharing_web?platform=Web#a-name-ff-a-screen-sharing-on-firefox)
* for details.
* @type {?|undefined}
*/
StreamSpec.prototype.mediaSource;
/**
* The microphone device ID retrieved from the
* [getDevices](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices) method.
*
* The retrieved ID is ASCII characters, and the string length is greater than 0 and less than 256 bytes.
*
* When the string length is 0, this property is ignored.
* @type {?|undefined}
*/
StreamSpec.prototype.microphoneId;
/**
* Marks whether to mirror the local video image of the publisher in the local preview.
*
* This setting does not take effect in screen-sharing streams.
* - `true`: (Default) Mirror the local video.
* - `false`: Do not mirror the local video.
*
* Agora recommends enabling this function when using the front camera, and disabling it when using the rear camera.
* @type {?|undefined}
*/
StreamSpec.prototype.mirror;
/**
* Whether this stream contains a screen-sharing track.
*
* @see [Share the Screen](https://docs.agora.io/en/Video/screensharing_web?platform=Web) for details.
* @type {?|undefined}
*/
StreamSpec.prototype.screen;
/**
* Marks whether to share the audio playback when sharing the screen.
*
* - `true`: Share the local audio playback when sharing the screen.
* - `false`: (Default) Do not share the local audio playback when sharing the screen.
*
* To share the local audio playback when sharing the screen, ensure that you set screen as `true`.
* We recommend also setting [audio](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html#audio)
* as false. If both `screenAudio` and `audio` are set as `true`, the stream only contains the local audio playback.
*
* \@remark
* - This function supports only Chrome 73 or later on Windows.
* - For the audio sharing to take effect, the user must check **Share audio** in the pop-up window when sharing the screen.
*
* \@since 3.0.0
* @type {?|undefined}
*/
StreamSpec.prototype.screenAudio;
/**
* The stream ID.
*
* Please set the stream ID as the user ID, which can be retrieved from the callback of
* [Client.join](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#join).
* @type {?|undefined}
*/
StreamSpec.prototype.streamID;
/**
* Whether this stream contains a video track.
* @type {?}
*/
StreamSpec.prototype.video;
/**
* Specifies the video source of the stream.
*
* \@remark
* If you use a video source created by the Canvas API, re-draw on the canvas every one second
* when the drawing is still to keep the video publishing.
* @type {?|undefined}
*/
StreamSpec.prototype.videoSource;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/stream-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function StreamStats() { }
if (false) {
/**
* Delay in accessing the SD-RTN (ms).
* @type {?}
*/
StreamStats.prototype.accessDelay;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/stream.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The Stream object created by the [createStream](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#createstream) method.
*
* A stream represents a published local or remote media stream object in a call session.
* All Stream methods can be called for both local and remote streams, except for
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init)
* that only applies to the local stream.
* @record
*/
function Stream() { }
if (false) {
/**
* This method adds the audio or video tracks into the stream.
*
* \@remark
* This method does not support Firefox and Safari.
* A Stream object can have only one audio track and one video track at most.
*
* \@param track The track can be retrieved from the `mediaStream` method.
*
* \@example
* const localStream = AgoraRTC.createStream({audio: true, video: false});
* localStream.addTrack(anotherStream.getVideoTrack());
*
* @type {?}
*/
Stream.prototype.addTrack;
/**
* Adjusts Audio Mixing Volume
*
* \@param level The volume of the mixing audio. The value ranges between 0 and 100 (default).
* @type {?}
*/
Stream.prototype.adjustAudioMixingVolume;
/**
* This method closes the video/audio stream.
*
* After calling this method, the camera and microphone authorizations are reset.
* @type {?}
*/
Stream.prototype.close;
/**
* @deprecated `v2.5.1`, use
* [muteAudio](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#muteaudio) instead.
*
* Disables the audio for a stream.
*
* This method disables the audio track in the stream.
* It works only when the audio flag is `true` in the stream.
* @type {?}
*/
Stream.prototype.disableAudio;
/**
* @deprecated `v2.5.1`, use
* [muteVideo](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#mutevideo) instead.
*
* Disables the video for a stream.
*
* This method disables the video track in the stream.
* It works only when the video flag is `true` in the stream.
* @type {?}
*/
Stream.prototype.disableVideo;
/**
* @deprecated `v2.5.1`, use
* [unmuteAudio](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#unmuteaudio) instead.
*
* Enabled the audio for a stream.
*
* This method enables the audio track in the stream.
* It works only when the audio flag is `true` in the stream.
*
* \@remark
* By default the audio track is enabled. If you call
* [disableAudio](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#disableaudio),
* call this method to enable audio.
* @type {?}
*/
Stream.prototype.enableAudio;
/**
* @deprecated `v2.5.1`, use
* [unmuteVideo](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#unmutevideo) instead.
*
* Enabled the video for a stream.
*
* This method enables the video track in the stream.
* It works only when the video flag is `true` in the stream.
*
* \@remark
* By default the video track is enabled. If you call
* [disabledVideo](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#disablevideo),
* call this method to enable audio.
* @type {?}
*/
Stream.prototype.enableVideo;
/**
* This method retrieves the current audio level.
*
* Call `setTimeout` or `setInterval` to retrieve the local or remote audio change.
*
* \@example
* setInterval(_ => {
* var audioLevel = stream.getAudioLevel();
* // Use audioLevel to render the UI
* }, 100)
*
* \@remark
* This method does not apply to streams that contain no audio data and may result in warnings.
*
* Due to browser policy changes, this method must be triggered by the user's gesture on the
* Chrome 70+ and Safari browser. See
* [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for details.
* @type {?}
*/
Stream.prototype.getAudioLevel;
/**
* Returns the current playback position of the audio mixing if successful.
* @type {?}
*/
Stream.prototype.getAudioMixingCurrentPosition;
/**
* Returns the audio mixing duration (ms) if successful.
* @type {?}
*/
Stream.prototype.getAudioMixingDuration;
/**
* This method retrieves the audio track in the stream and can be used together with
* [replaceTrack](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#replacetrack).
*
* If the stream contains an audio track, it will be returned in a `MediaStreamTrack` object.
* @type {?}
*/
Stream.prototype.getAudioTrack;
/**
* Gets the volume of the audio effects.
*
* \@example
* const volumes = stream.getEffectsVolume();
* volumes.forEach((soundId, volume) => {
* console.log("SoundId", soundId, "Volume", volume);
* });
*
* \@return Returns an array that contains `soundId` and `volume`. Each soundId has a corresponding `volume`.
* - `volume`: Volume of the audio effect. The value range is `[0,100]`.
* @type {?}
*/
Stream.prototype.getEffectsVolume;
/**
* This method retrieves the stream ID.
*
* \@example
* const id = stream.getId()
* @type {?}
*/
Stream.prototype.getId;
/**
* This method gets the connection statistics of the stream.
*
* \@remark
* It may take some time to get some of the statistics.
*
* \@example
* localStream.getStats(stats => {
* console.log(`Local Stream accessDelay: ${stats.accessDelay}`);
* console.log(`Local Stream audioSendBytes: ${stats.audioSendBytes}`);
* console.log(`Local Stream audioSendPackets: ${stats.audioSendPackets}`);
* console.log(`Local Stream audioSendPacketsLost: ${stats.audioSendPacketsLost}`);
* console.log(`Local Stream videoSendBytes: ${stats.videoSendBytes}`);
* console.log(`Local Stream videoSendFrameRate: ${stats.videoSendFrameRate}`);
* console.log(`Local Stream videoSendPackets: ${stats.videoSendPackets}`);
* console.log(`Local Stream videoSendPacketsLost: ${stats.videoSendPacketsLost}`);
* console.log(`Local Stream videoSendResolutionHeight: ${stats.videoSendResolutionHeight}`);
* console.log(`Local Stream videoSendResolutionWidth: ${stats.videoSendResolutionWidth}`);
* });
*
*
* remoteStream.getStats(stats => {
* console.log(`Remote Stream accessDelay: ${stats.accessDelay}`);
* console.log(`Remote Stream audioReceiveBytes: ${stats.audioReceiveBytes}`);
* console.log(`Remote Stream audioReceiveDelay: ${stats.audioReceiveDelay}`);
* console.log(`Remote Stream audioReceivePackets: ${stats.audioReceivePackets}`);
* console.log(`Remote Stream audioReceivePacketsLost: ${stats.audioReceivePacketsLost}`);
* console.log(`Remote Stream endToEndDelay: ${stats.endToEndDelay}`);
* console.log(`Remote Stream videoReceiveBytes: ${stats.videoReceiveBytes}`);
* console.log(`Remote Stream videoReceiveDecodeFrameRate: ${stats.videoReceiveDecodeFrameRate}`);
* console.log(`Remote Stream videoReceiveDelay: ${stats.videoReceiveDelay}`);
* console.log(`Remote Stream videoReceiveFrameRate: ${stats.videoReceiveFrameRate}`);
* console.log(`Remote Stream videoReceivePackets: ${stats.videoReceivePackets}`);
* console.log(`Remote Stream videoReceivePacketsLost: ${stats.videoReceivePacketsLost}`);
* console.log(`Remote Stream videoReceiveResolutionHeight: ${stats.videoReceiveResolutionHeight}`);
* console.log(`Remote Stream videoReceiveResolutionWidth: ${stats.videoReceiveResolutionWidth}`);
* });
*
* \@return Connection statistics of the stream.
* - If it is a publishing stream, then the stats is
* [LocalStreamStats](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.localstreamstats.html).
* - If it is a subscribing stream, then the stats is
* [RemoteStreamStats](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.remotestreamstats.html).
* @type {?}
*/
Stream.prototype.getStats;
/**
* This method retrieves the video track in the stream and can be used together with
* [replaceTrack](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#replacetrack).
*
* If the stream contains an audio track, it will be returned in a `MediaStreamTrack` object.
*
* @type {?}
*/
Stream.prototype.getVideoTrack;
/**
* This method retrieves the audio flag.
*
* \@return Audio flag of stream.
* - `true`: The stream contains audio data.
* -`false`: The stream does not contain audio data.
* @type {?}
*/
Stream.prototype.hasAudio;
/**
* This method retrieves the video flag.
*
* \@return Video flag of stream.
* - `true`: The stream contains video data.
* - `false`: The stream does not contain video data.
* @type {?}
*/
Stream.prototype.hasVideo;
/**
* This method initializes the local stream object.
*
* If this method fails
* @see [getUserMedia Exceptions](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#Exceptions)
* for error information.
*
* Some errors might be returned in the callback, for example: `{type: "error", msg: "NotAllowedError", info: "Permission denied"}`.
*
* The possible error information in the `msg` field includes:
*
* - NotAllowedError: User refuses to grant access to camera or audio resource.
* - MEDIA_OPTION_INVALID: The camera is occupied or the resolution is not supported (on browsers in early versions).
* - DEVICES_NOT_FOUND: No device is found.
* - NOT_SUPPORTED: The browser does not support using camera and microphone.
* - PERMISSION_DENIED: The device is disabled by the browser or the user has denied permission of using the device.
* - CONSTRAINT_NOT_SATISFIED: The settings are illegal (on browsers in early versions).
* - PluginNotInstalledProperly: A screen-sharing request is made with no plugin installed or with a
* wrong extensionId on the Chrome browser.
* - UNDEFINED: Undefined error.
*
* The `info` field shows the extra information for the error. If no more extra information, its value will be `null`.
*
* \@example
* init(_ => {
* console.log("local stream initialized");
* // publish the stream
* //……
* }, err => {
* console.error("local stream init failed ", err);
* //error handling
* });
* @type {?}
*/
Stream.prototype.init;
/**
* Returns whether the Stream is Playing
*
* - `true`: The stream is being rendered or playing on the page.
* - `false`: The stream is neither being rendered nor playing on the page.
* @type {?}
*/
Stream.prototype.isPlaying;
/**
* Disables the audio track in the stream.
*
* - For local streams, the SDK stops sending audio after you call this method.
* - For remote streams, the SDK still receives audio but stops playing it after you call this method.
*
* \@remark
* For local streams, it works only when the `audio` flag is `true` in the stream.
*
* \@return void ([Docs unclear](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#muteaudio))
* - `true`: Success.
* - `false`: Failure. Possible reasons include no audio, stream not initialized, and audio track already disabled.
* @type {?}
*/
Stream.prototype.muteAudio;
/**
* Disables the video track in the stream.
*
* - For local streams, the SDK stops sending video after you call this method.
* - For remote streams, the SDK still receives video but stops playing it after you call this method.
*
* \@remark
* For local streams, it works only when the video flag is true in the stream.
*
* \@return void ([Docs unclear](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#mutevideo))
* - `true`: Success.
* - `false`: Failure. Possible reasons include no video, stream not initialized, and video track already disabled.
* @type {?}
*/
Stream.prototype.muteVideo;
/**
* Occurs when an Agora.io event connected to the specific stream is received from the SDK.
*
* @see [On](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#on)
* for all variations of this core function.
* @type {?}
*/
Stream.prototype.on;
/**
* Pauses all audio effects.
*
* \@example
* stream.pauseAllEffects(err => {
* if (err) {
* console.error("Failed to pause effects, reason: ", err);
* } else {
* console.log("Effects are paused successfully");
* }
* });
* @type {?}
*/
Stream.prototype.pauseAllEffects;
/**
* Pauses audio mixing.
* @type {?}
*/
Stream.prototype.pauseAudioMixing;
/**
* Pauses a specified audio effect.
*
* \@example
* // When the audio effect 1 is playing
* stream.pauseEffect(1, err => {
* if (err) {
* console.error("Failed to pause Effect, reason: ", err);
* } else {
* console.log("Effect is paused successfully");
* }
* });
* @type {?}
*/
Stream.prototype.pauseEffect;
/**
* Plays the video or audio stream.
*
* \@remark
* Due to browser policy changes, this method must be triggered by the user's
* gesture on the Chrome 70+ and Safari browsers.
* @see [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for details.
*
* \@example
* stream.play("agora_remote", {fit: 'contain'}); // stream will be played in the element with the ID agora_remote
*
* \@param HTMLElementID
* Represents the HTML element ID. Digits and letters in the ASCII character set, “_”, “-", and ".".
* The string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
Stream.prototype.play;
/**
* Plays a specified audio effect.
*
* This method supports playing multiple audio effect files at the same time, and is different from
* [startAudioMixing](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#startaudiomixing).
* You can use this method to add specific audio effects for specific scenarios. For example, gaming.
*
* \@remark
* - Due to web browser autoplay policy changes, this method must be triggered by a user gesture on Chrome 70+ and Safari web
* browsers.
* @see [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for details.
*
* This method supports the following web browsers:
* - Safari 12 and later
* - Chrome 65 and later
* - Firefox 66 and later
* - Call this method when you are in a channel. Otherwise, it may cause issues.
*
* \@example
* stream.playEffect({
* soundId: 1,
* filePath: "biu.mp3"
* }, error => {
* if (error) {
* // Error handling
* return;
* }
* // Process after the method call succeeds
* });
*
* \@remark
* The callbacks of the audio effect methods all use the Node.js callback pattern.
* @type {?}
*/
Stream.prototype.playEffect;
/**
* Preloads a specified audio effect file into the memory.
*
* To ensure smooth communication, limit the size of the audio effect file.
*
* \@example
* stream.preloadEffect(1, "https://web-demos-static.agora.io/agora/smlt.flac", err => {
* if (err) {
* console.error("Failed to preload effect, reason: ", err);
* } else {
* console.log("Effect is preloaded successfully");
* }
* });
* @type {?}
*/
Stream.prototype.preloadEffect;
/**
* Removes the audio or video tracks from the stream.
*
* \@remark
* - If you need to change both the audio and video tracks, we recommend using the replaceTrack method instead.
* - This method does not support Firefox and Safari.
*
* \@example
* const localStream = AgoraRTC.createStream({ audio: true, video: true });
* localStream.removeTrack(localStream.getAudioTrack());
* @type {?}
*/
Stream.prototype.removeTrack;
/**
* Replaces the audio or video MediaStreamTrack in the local stream.
*
* After the local stream is published, you can use this method to switch the cameras, or switch
* between the microphone and the music player.
*
* The new track can be retrieved by getUserMedia, MediaElement.captureStream or other methods.
*
* The replaced track will be stopped.
*
* \@remark
* Supports Chrome 65+, Safari, and latest Firefox.
* - Firefox does not support switching audio tracks between different microphones.
* You can replace the audio track from the microphone with an audio file, or vice versa.
* - Replacing audio tracks from external audio devices may not be fully supported on Safari.
* - The subscriber will not be notified if the track gets replaced.
* - Agora recommends you use
* [switchDevice](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#switchdevice)
* to switch the media input devices.
*
* \@example
* // Suppose we have a localStream1
* localStream2 = AgoraRTC.createStream({ video: true, cameraId: "ABC" });
* localStream2.setVideoProfile('<same as localStream1>')
* localStream2.init(_ => {
* const newVideoTrack = localStream2.getVideoTrack();
* localStream1.replaceTrack(newVideoTrack);
* });
*
* @type {?}
*/
Stream.prototype.replaceTrack;
/**
* Resumes the Audio/Video Stream Playback.
* This method can be used when the playback fails after calling the
* [Stream.play](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#play) method.
* In most cases, the playback is stopped due to the browser policy.
*
* This method needs to be triggered by a user gesture.
*
* @see [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for more information.
* @type {?}
*/
Stream.prototype.resume;
/**
* Resumes playing all audio effects.
*
* \@example
* stream.resumeAllEffects(err => {
* if (err) {
* console.error("Failed to resume effects, reason: ", err);
* } else {
* console.log("Effects are resumed successfully");
* }
* });
* @type {?}
*/
Stream.prototype.resumeAllEffects;
/**
* Resumes audio mixing.
*
* When the audio mixing file playback resumes, the SDK triggers the `Stream.on("audioMixingPlayed")` callback on the local client.
* @type {?}
*/
Stream.prototype.resumeAudioMixing;
/**
* Resumes playing a specified audio effect.
*
* \@example
* // When the audio effect 1 is paused
* stream.resumeEffect(1, err => {
* if (err) {
* console.error("Failed to resume Effect, reason: ", err);
* } else {
* console.log("Effect is resumed successfully");
* }
* });
* @type {?}
*/
Stream.prototype.resumeEffect;
/**
* Sets the playback position of the audio mixing file to a different start position (by default plays from the beginning).
*
* \@param position
* The time (ms) to start playing the audio mixing file, an integer. The value range is `[0,100000000]`.
* @type {?}
*/
Stream.prototype.setAudioMixingPosition;
/**
* Sets the audio output device for the remote stream. You can use it to switch between the microphone and the speakerphone.
* It can be called either before or after the remote stream is played.
*
* \@remark
* Only Chrome 49+ supports this function.
*
* \@param deviceId The device ID can be retrieved from
* [getDevices](https://docs.agora.io/en/Video/API%20Reference/web/globals.html#getdevices), whose
* [kind](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.mediastreamtrack.html#kind) should be "audiooutput".
*
* The retrieved ID is ASCII characters, and the string length is greater than 0 and less than 256 bytes.
* @type {?}
*/
Stream.prototype.setAudioOutput;
/**
* This method sets the audio profile.
* It is optional and works only when called before
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init).
* The default value is `'music_standard'`.
*
* Due to the limitations of browsers, some browsers may not be fully compatible with the audio profile you set.
* - Firefox does not support setting the audio encoding rate.
* - Safari does not support stereo audio.
* - The latest version of Google Chrome does not support playing stereo audio, but supports sending a stereo audio stream.
*
* \@param profile The audio profile has the following options:
* - `'speech_low_quality'`: Sample rate 16 kHz, mono, encoding rate 24 Kbps.
* - `'speech_standard'`: Sample rate 32 kHz, mono, encoding rate 24 Kbps.
* - `'music_standard'`: Sample rate 48 kHz, mono, encoding rate 40 Kbps.
* - `'standard_stereo'`: Sample rate 48 kHz, stereo, encoding rate 64 Kbps.
* - `'high_quality'`: Sample rate 48 kHz, mono, encoding rate 128 Kbps.
* - `'high_quality_stereo'`: Sample rate 48 kHz, stereo, encoding rate 192 Kbps.
* @type {?}
*/
Stream.prototype.setAudioProfile;
/**
* Sets the volume for the remote stream.
* It can be called either before or after the remote stream is played.
*
* \@param volume Ranges from 0 (muted) to 100 (loudest).
* @type {?}
*/
Stream.prototype.setAudioVolume;
/**
* Enables/Disables image enhancement and sets the options.
*
*
* This method supports the following browsers:
* - Safari 12 or later
* - Chrome 65 or later
* - Firefox 70.0.1 or later
*
* \@remark
* - This function does not support mobile devices.
* - If the dual-stream mode is enabled
* ([enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream)),
* the image enhancement options apply only to the high-video stream.
* - If image enhancement is enabled, you must call this method to disable it before calling the following methods:
* - [leave](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#leave)
* - [stop](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#stop)
* - [removeTrack](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#removetrack)
* - [unpublish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#unpublish)
*
* - The image enhancement function involves real-time compute-intensive processing.
* Though it is based on hardware acceleration, the processing has high GPU and CPU overheads.
* For low-end devices, enabling image enhancement affects the system performance.
* When the video resolution is set as 360p, 720p or higher, and the frame rate is set as 30 fps or 15 fps,
* do not enable image enhancement.
*
* \@example
* stream.setBeautyEffectOptions(true, {
* lighteningContrastLevel: 1,
* lighteningLevel: 0.7,
* smoothnessLevel: 0.5,
* rednessLevel: 0.1
* });
*
* \@since 3.0.0
* @type {?}
*/
Stream.prototype.setBeautyEffectOptions;
/**
* Sets the volume of the audio effects.
*
* \@param volume
* Volume of the audio effect. The value range is [0,100].The default value is 100 (the original volume).
*
* \@example
* stream.setEffectsVolume(0, err => {
* if (err) {
* console.error("Failed to set effects volume, reason: ", err);
* } else {
* console.log("Effects volume is set successfully");
* }
* });
* @type {?}
*/
Stream.prototype.setEffectsVolume;
/**
* This method sets the profile of the screen in screen-sharing.
*
* @see [Table](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#setscreenprofile) for details.
*
* \@remark
* Due to limitations of some devices and browsers, the resolution you set may fail to take effect and get adjusted by the browser.
* In this case, billings will be calculated based on the actual resolution.
* @type {?}
*/
Stream.prototype.setScreenProfile;
/**
* Customizes the Video Encoder Configuration.
* You can use this method to customize the video resolution, frame rate, and bitrate of the local stream.
* This method can be called before or after
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init).
*
* \@remark
* - Do not call this method when publishing streams.
* - If you enable dual streams
* ([enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream)),
* we do not support increasing the video resolution in this method.
* This is a [known issue](https://bugs.chromium.org/p/chromium/issues/detail?id=768205) of Chromium.
* - On some iOS devices, when you update the video encoder configuration after
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init),
* black bars might appear around your video.
* - The actual resolution, frame rate, and bitrate depend on the device,
* see [MediaStreamTrack.applyConstraints()](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/applyConstraints)
* for more information.
* - This method works on Chrome 63 or later and is not fully functional on other browsers with the following issues:
* - The frame rate setting does not take effect on Safari 12 or earlier.
* - Safari 11 or earlier only supports specific resolutions.
* - Safari on iOS does not support low resolutions in H.264 codec.
*
* \@example
* stream.setVideoEncoderConfiguration({
* // Video resolution
* resolution: {
* width: 640,
* height: 480
* },
* // Video encoding frame rate. We recommend 15 fps. Do not set this to a value greater than 30.
* frameRate: {
* min: 15,
* max: 30
* },
* // Video encoding bitrate.
* bitrate: {
* min: 1000,
* max: 5000
* }
* });
* @type {?}
*/
Stream.prototype.setVideoEncoderConfiguration;
/**
* Sets the stream's video profile.
*
* This method sets the video encoding profile for the local stream. Each video encoding profile includes a set of parameters,
* such as the resolution,frame rate, and bitrate. The default value is `"480p_1"`.
*
* This method is optional and is usually called before
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init).
* From v2.7, you can also call this method after
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init)
* to change the video encoding profile.
*
* \@example
* setVideoProfile("480p");
*
* \@remark
* - Do not call this method when publishing streams.
* - If you enable dual streams
* ([enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream)),
* we do not support increasing the video resolution in this method. This is a
* [known issue](https://bugs.chromium.org/p/chromium/issues/detail?id=768205) of Chromium.
* - On some iOS devices, when you update the video profile after
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init),
* black bars might appear around your video.
* - Changing the video profile after
* [Stream.init](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#init) works only on
* Chrome 63 or later and Safari 11 or later.
*
* - Whether 1080 resolution or above can be supported depends on the device. If the device cannot support 1080p, the actual frame rate
* is lower than the one listed in the table. Agora optimizes the video on low-end devices.
* - The Safari browser does not support modifying the video frame rate (30 fps by default). If you set a frame rate other than 30 fps on
* Safari, the browser may change or reject your setting.
* - Due to limitations of some devices and browsers, the resolution you set may fail to take effect and get adjusted by the browser. In
* this case, billings are calculated based on the actual resolution.
* @type {?}
*/
Stream.prototype.setVideoProfile;
/**
* Sets the volume of a specified audio effect.
*
* \@param volume Volume of the audio effect. The value range is `[0,100]`.The default value is 100 (the original volume).
*
* \@example
* // When the audio effect 1 is loaded
* stream.setVolumeOfEffect(1, 50, err => {
* if (err) {
* console.error("Failed to set volume of Effect, reason: ", err);
* } else {
* console.log("Effect volume is set to", 50);
* }
* });
*
*
* @type {?}
*/
Stream.prototype.setVolumeOfEffect;
/**
* Starts Audio Mixing
* This method mixes the specified online audio file with the audio stream from the microphone; or, it
* replaces the microphone’s audio stream with the specified online audio file.
*
* You can specify the number of playback loops and play time duration.
*
* \@remark
* This method supports the following browsers:
* - Safari 12 and later
* - Chrome 65 and later
* - Firefox 66 and later
*
* \@remark
* - Call this method when you are in a channel, otherwise, it may cause issues.
* - Due to browser policy changes, this method must be triggered by the user's gesture on the Chrome 70+ and Safari browser.
* @see [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for details.
*
* \@example
* stream.startAudioMixing({
* filePath: 'example.mp3'
* }, error => {
* if (error) {
* // Error handling
* return;
* }
* // Processes after stream playing
* })
* @type {?}
*/
Stream.prototype.startAudioMixing;
/**
* Stops the Audio/Video Stream
*
* Call this method to stop playing the stream set by
* [Stream.play](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#play).
* @type {?}
*/
Stream.prototype.stop;
/**
* Stops playing all audio effects.
*
* \@example
* stream.stopAllEffects(err => {
* if (err) {
* console.error("Failed to stop effects, reason: ", err);
* } else {
* console.log("Effects are stopped successfully");
* }
* });
* @type {?}
*/
Stream.prototype.stopAllEffects;
/**
* Stops audio mixing.
*
* When the audio mixing file playback is stopped, the SDK triggers the `Stream.on("audioMixingFinished")` callback on the local client.
* @type {?}
*/
Stream.prototype.stopAudioMixing;
/**
* Stops playing a specified audio effect.
*
* \@example
* // When the audio effect 1 is playing
* stream.stopEffect(1, err => {
* if (err) {
* console.error("Failed to stop Effect, reason: ", err);
* } else {
* console.log("Effect is stopped successfully");
* }
* });
* @type {?}
*/
Stream.prototype.stopEffect;
/**
* Switches the media input device.
*
* This method switches between the media input devices:
* - Audio input devices, such as microphones.
* - Video input devices, such as cameras.
* If you call this method after [publish](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#publish),
* there is no need to re-publish the stream after switching the device.
*
* \@param deviceId Device ID, which can be retrieved from getDevices. The retrieved ID is ASCII characters,
* and the string length is greater than 0 and less than 256 bytes.
* \@remark
* This method does not support the following scenarios:
* - Dual-stream mode is enabled by
* [enableDualStream](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#enabledualstream).
* - The remote stream.
* - The stream is created by defining the
* [audioSource](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html#audiosource)
* and [videoSource](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.streamspec.html#videosource) properties.
* - The Firefox browser.
*
* \@remark
* This method might not take effect on some mobile devices.
* @type {?}
*/
Stream.prototype.switchDevice;
/**
* Releases a specified preloaded audio effect from the memory.
*
* \@example
* // When the audio effect 1 is loaded
* stream.unloadEffect(1, err => {
* if (err) {
* console.error("Failed to unload effect, reason: ", err);
* } else {
* console.log("Effect is unloaded successfully");
* }
* });
*
* @type {?}
*/
Stream.prototype.unloadEffect;
/**
* Enables the audio track in the stream.
*
* \@remark
* For local streams, it works only when the audio flag is `true` in the stream.
* By default the audio track is enabled. If you call
* [muteAudio](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#muteaudio),
* call this method to enable audio.
*
* \@return void ([Docs unclear](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#unmuteaudio))
* - `true`: Success.
* - `false`: Failure. Possible reasons include no audio, stream not initialized, and audio track already enabled.
* @type {?}
*/
Stream.prototype.unmuteAudio;
/**
* Enables the video track in the stream.
*
* \@remark
* For local streams, it works only when the video flag is true in the stream.
*
* By default the video track is enabled. If you call
* [muteVideo](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#mutevideo),
* call this method to enable video.
*
* \@return void ([Docs unclear](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#unmutevideo))
* - `true`: Success.
* - `false`: Failure. Possible reasons include no video, stream not initialized, and video track already enabled.
* @type {?}
*/
Stream.prototype.unmuteVideo;
/**
* Not mentioned in Agora.io official docs, may be inherited DOM function.
* @type {?}
*/
Stream.prototype.addEventListener;
/**
* Calculates whether the stream's audio is currently active.
*
* \@remark Refers to a snapshot of the stream's audio status and will return:
* - `true`: if the connected user's audio is not muted.
* - `false`: if the connected user's audio is muted.
* @type {?}
*/
Stream.prototype.isAudioOn;
/**
* Calculates whether the stream's video is currently active.
*
* \@remark Refers to a snapshot of the stream's video status and will return:
* - `true`: if the connected user's video is not muted.
* - `false`: if the connected user's video is muted.
* @type {?}
*/
Stream.prototype.isVideoOn;
/**
* Whether the stream currently has its audio enabled.
*
* @version 2.5.2 and below only
* @type {?|undefined}
*/
Stream.prototype.audioEnabled;
/**
* Whether the stream currently has its video enabled.
*
* @version 2.5.2 and below only
* @type {?|undefined}
*/
Stream.prototype.videoEnabled;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/subscribe-options.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Whether to receive the video or audio data independently by the video and audio parameters.
*
* \@remark
* `video` and `audio` cannot be set as `false` at the same time.
* If you need to stop subscribing to the stream, call
* [Client.unsubscribe](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#unsubscribe) instead.
* Safari does not support independent subscription. Set options as null for Safari, otherwise the
* `SAFARI_NOT_SUPPORTED_FOR_TRACK_SUBSCRIPTION` error occurs.
* @record
*/
function SubscribeOptions() { }
if (false) {
/**
* Whether to receive the audio data.
* - true: (Default) Receives the audio data.
* - false: Not receives the audio data.
* @type {?|undefined}
*/
SubscribeOptions.prototype.audio;
/**
* Whether to receive the video data.
* - true: (Default) Receives the video data.
* - false: Not receives the video data.
* @type {?|undefined}
*/
SubscribeOptions.prototype.video;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/system-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* System statistics.
* @record
*/
function SystemStats() { }
if (false) {
/**
* Battery level of the system (%).
* @type {?}
*/
SystemStats.prototype.BatteryLevel;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/transcoding-user.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function TranscodingUser() { }
if (false) {
/**
* Transparency of the video frame.
*
* The value ranges between 0.0 and 1.0:
* - 0.0: Completely transparent.
* - 1.0: (Default) Opaque.
* @type {?|undefined}
*/
TranscodingUser.prototype.alpha;
/**
* Height of the video.
*
* Integer only. The value range is `[0,10000]`, and the default value is `640`.
* @type {?|undefined}
*/
TranscodingUser.prototype.height;
/**
* User ID of the CDN live host.
* @type {?|undefined}
*/
TranscodingUser.prototype.uid;
/**
* Width of the video.
*
* Integer only. The value range is `[0,10000]`, and the default value is `360`.
* @type {?|undefined}
*/
TranscodingUser.prototype.width;
/**
* The position of the upper left end of the video on the horizontal axis.
*
* Integer only. The value range is `[0,10000]`, and the default value is `0`.
* @type {?|undefined}
*/
TranscodingUser.prototype.x;
/**
* The position of the upper left end of the video on the vertical axis.
*
* Integer only. The value range is `[0,10000]`, and the default value is `0`.
* @type {?|undefined}
*/
TranscodingUser.prototype.y;
/**
* Layer position of the video frame.
*
* Integer only. The value range is `[0,100]`.
*
* From v2.3.0, Agora SDK supports setting zOrder as 0.
* - 0: (Default) Lowest.
* - 100: Highest.
* @type {?|undefined}
*/
TranscodingUser.prototype.zOrder;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/transport-stats.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Statistics of the network connection.
* @record
*/
function TransportStats() { }
if (false) {
/**
* The network type.
* \@remark
* Chrome 61+ is required for this function, and the compatibility is not guaranteed.
* @see [Network Information API](https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API) for details.
* @type {?}
*/
TransportStats.prototype.NetworkType;
/**
* The estimated available bandwidth for sending the stream, in Kbps.
* @type {?}
*/
TransportStats.prototype.OutgoingAvailableBandwidth;
/**
* RTT (Round-Trip Time) between the SDK and the access node of the SD-RTN, in ms.
* @type {?}
*/
TransportStats.prototype.RTT;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/turn-server.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* TURN server settings.
*
* Enterprise users with a company firewall can use this property to pass audio and video data to the Agora SD-RTN through the TURN Server.
* @record
*/
function TurnServer() { }
if (false) {
/**
* Sets whether to force data transfer by TURN Server:
* - true: Force data transfer.
* - false: (default) Not to force data transfer.
* @type {?|undefined}
*/
TurnServer.prototype.forceTurn;
/**
* Your TURN Server password. ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
TurnServer.prototype.password;
/**
* The TCP port(s) you want add to TURN Server.
* Numeric characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?|undefined}
*/
TurnServer.prototype.tcpport;
/**
* Your TURN Server URL address. ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
TurnServer.prototype.turnServerURL;
/**
* The UDP port(s) you want to add to TURN Server.
* Numeric characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
TurnServer.prototype.udpport;
/**
* Your TURN Server username. ASCII characters only, and the string length must be greater than 0 and less than 256 bytes.
* @type {?}
*/
TurnServer.prototype.username;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/video-encoder-configuration.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* The video encoder configuration.
*
* This interface sets the video encoder configuration in
* [setVideoEncoderConfiguration](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.stream.html#setvideoencoderconfiguration).
*
* Depending on the OS, browser, and camera, the actual resolution, frame rate, and bitrate might be different from the set values.
*
* \@remark
* - Whether 1080 resolution or above can be supported depends on the device.
* If the device cannot support 1080p, the actual frame rate is lower than the one listed in the table.
* Agora optimizes the video on low-end devices.
* - With the update of web browsers, this table might not reflect all the supported profiles for each browser.
* The actual support is subject to the device and web browser version.
* - Some versions of some web browsers might not support all the video profiles listed in the table.
* In this case, we recommend you use the mainstream video profiles (the ones with the _1 suffix in the above table).
* - The Safari browser does not support modifying the video frame rate (30 fps by default).
* If you set a frame rate other than 30 fps on Safari, the browser may change or reject your setting.
* - Due to limitations of some devices and browsers, the resolution you set may fail to take effect and get adjusted by
* the browser. In this case, billings are calculated based on the actual resolution.
*
* @see [Video Profile Definition](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.videoencoderconfiguration.html)
* @record
*/
function VideoEncoderConfiguration() { }
if (false) {
/**
* The video bitrate (Kbps). The value range is [1,10000000].
*
* We recommend setting the bitrate between 100 Kbps and 5000 Kbps. You can refer to the table below and set your bitrate.
* @type {?|undefined}
*/
VideoEncoderConfiguration.prototype.bitrate;
/**
* The video frame rate (fps).
*
* The value range is [1, 10000]. We recommend setting the frame rate between 5 fps and 30 fps.
*
* \@remark
* - This parameter sets the local capturing video frame rate. The actual encoding frame rate depends on the device, system, and browser.
* - When the network conditions change, the browser adjusts the encoding frame rate automatically.
* @type {?|undefined}
*/
VideoEncoderConfiguration.prototype.frameRate;
/**
* Resolution of the video.
*
* We recommend using common resolutions, for example:
* - 480 x 360
* - 640 x 480
* - 960 x 720
* @type {?|undefined}
*/
VideoEncoderConfiguration.prototype.resolution;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/video-play-options.model.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Options for playing an Agora.io media stream.
* @record
*/
function VideoPlayOptions() { }
if (false) {
/**
* Video display mode:
* - `'cover'`: Uniformly scale the video until it fills the visible boundaries (cropped).
* One dimension of the video may have clipped contents. Refer to the cover option of object-fit in CSS.
* - `'contain'`: Uniformly scale the video until one of its dimension fits the boundary (zoomed to fit).
* Areas that are not filled due to the disparity in the aspect ratio will be filled with black.
* Refer to the contain option of object-fit in CSS.
*
* For local streams, by default the cover mode is used for video playing and the contain mode is used for screen sharing;
* for remote streams, by default the cover mode is used.
* @type {?|undefined}
*/
VideoPlayOptions.prototype.fit;
/**
* Sets whether to mute the playing stream.
*
* The `muted` flag can be used as a workaround for the browser's autoplay policy.
*
* On Chrome 70+ and Safari, a video stream with sound does not play until triggered by a user gesture.
* If you want to play the video anyway without a user gesture, you can set the muted flag to true, so that the video is
* automatically played without sound.
*
* @see [Autoplay Policy Changes](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes) for more information.
* @type {?|undefined}
*/
VideoPlayOptions.prototype.muted;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/data/models/index.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/channel-media-message.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {number} */
var ChannelMediaMessage = {
/** No error. */
'RELAY_OK': 0,
/** An error occurs in the server response. */
'SERVER_ERROR_RESPONSE': 1,
/** No server response. */
'SERVER_NO_RESPONSE': 2,
/** The SDK fails to access the service, probably due to limited resources of the server. */
'NO_RESOURCE_AVAILABLE': 3,
/** Fails to send the relay request. */
'FAILED_JOIN_SRC': 4,
/** Fails to accept the relay request. */
'FAILED_JOIN_DEST': 5,
/** The server fails to receive the media stream. */
'FAILED_PACKET_RECEIVED_FROM_SRC': 6,
/** The server fails to send the media stream. */
'FAILED_PACKET_SENT_TO_DEST': 7,
/**
* The SDK disconnects from the server and fails to reconnect to the server due to a poor network connection.
* In this case, the SDK resets the media stream relay state.
* You can try
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* to restart the media stream relay.
*/
'SERVER_CONNECTION_LOST': 8,
/** An internal error occurs in the server. */
'INTERNAL_ERROR': 9,
/** The token of the source channel has expired. */
'SRC_TOKEN_EXPIRED': 10,
/** The token of the destination channel has expired. */
'DEST_TOKEN_EXPIRED': 11,
/**
* The relay has already started. Possibly caused by calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* repeatedly, or calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* before
* [stopChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#stopchannelmediarelay)
* succeeds.
*/
'RELAY_ALREADY_START': 12,
/**
* The relay has not started. Possibly caused by calling
* [updateChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay)
* before
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* succeeds.
*/
'RELAY_NOT_START': 13,
};
ChannelMediaMessage[ChannelMediaMessage[
/** No error. */
'RELAY_OK']] =
/** No error. */
'RELAY_OK';
ChannelMediaMessage[ChannelMediaMessage[
/** An error occurs in the server response. */
'SERVER_ERROR_RESPONSE']] =
/** An error occurs in the server response. */
'SERVER_ERROR_RESPONSE';
ChannelMediaMessage[ChannelMediaMessage[
/** No server response. */
'SERVER_NO_RESPONSE']] =
/** No server response. */
'SERVER_NO_RESPONSE';
ChannelMediaMessage[ChannelMediaMessage[
/** The SDK fails to access the service, probably due to limited resources of the server. */
'NO_RESOURCE_AVAILABLE']] =
/** The SDK fails to access the service, probably due to limited resources of the server. */
'NO_RESOURCE_AVAILABLE';
ChannelMediaMessage[ChannelMediaMessage[
/** Fails to send the relay request. */
'FAILED_JOIN_SRC']] =
/** Fails to send the relay request. */
'FAILED_JOIN_SRC';
ChannelMediaMessage[ChannelMediaMessage[
/** Fails to accept the relay request. */
'FAILED_JOIN_DEST']] =
/** Fails to accept the relay request. */
'FAILED_JOIN_DEST';
ChannelMediaMessage[ChannelMediaMessage[
/** The server fails to receive the media stream. */
'FAILED_PACKET_RECEIVED_FROM_SRC']] =
/** The server fails to receive the media stream. */
'FAILED_PACKET_RECEIVED_FROM_SRC';
ChannelMediaMessage[ChannelMediaMessage[
/** The server fails to send the media stream. */
'FAILED_PACKET_SENT_TO_DEST']] =
/** The server fails to send the media stream. */
'FAILED_PACKET_SENT_TO_DEST';
ChannelMediaMessage[ChannelMediaMessage[
/**
* The SDK disconnects from the server and fails to reconnect to the server due to a poor network connection.
* In this case, the SDK resets the media stream relay state.
* You can try
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* to restart the media stream relay.
*/
'SERVER_CONNECTION_LOST']] =
/**
* The SDK disconnects from the server and fails to reconnect to the server due to a poor network connection.
* In this case, the SDK resets the media stream relay state.
* You can try
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* to restart the media stream relay.
*/
'SERVER_CONNECTION_LOST';
ChannelMediaMessage[ChannelMediaMessage[
/** An internal error occurs in the server. */
'INTERNAL_ERROR']] =
/** An internal error occurs in the server. */
'INTERNAL_ERROR';
ChannelMediaMessage[ChannelMediaMessage[
/** The token of the source channel has expired. */
'SRC_TOKEN_EXPIRED']] =
/** The token of the source channel has expired. */
'SRC_TOKEN_EXPIRED';
ChannelMediaMessage[ChannelMediaMessage[
/** The token of the destination channel has expired. */
'DEST_TOKEN_EXPIRED']] =
/** The token of the destination channel has expired. */
'DEST_TOKEN_EXPIRED';
ChannelMediaMessage[ChannelMediaMessage[
/**
* The relay has already started. Possibly caused by calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* repeatedly, or calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* before
* [stopChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#stopchannelmediarelay)
* succeeds.
*/
'RELAY_ALREADY_START']] =
/**
* The relay has already started. Possibly caused by calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* repeatedly, or calling
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* before
* [stopChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#stopchannelmediarelay)
* succeeds.
*/
'RELAY_ALREADY_START';
ChannelMediaMessage[ChannelMediaMessage[
/**
* The relay has not started. Possibly caused by calling
* [updateChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay)
* before
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* succeeds.
*/
'RELAY_NOT_START']] =
/**
* The relay has not started. Possibly caused by calling
* [updateChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay)
* before
* [startChannelMediaRelay](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* succeeds.
*/
'RELAY_NOT_START';
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/client-event.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var ClientEvent = {
/**
* Occurs when the first remote audio frame is decoded.
* The SDK triggers this callback when the local client successfully subscribes to a remote stream and decodes the first audio frame.
*
* @example
* client.on('first-audio-frame-decode', function (evt) {
* console.log('first-audio-frame-decode');
* console.log(evt.stream);
* })
*/
FirstAudioFrameDecoded: "first-audio-frame-decode",
/**
* Occurs when the first remote video frame is decoded.
* The SDK triggers this callback when the local client successfully subscribes to a remote stream and decodes the first video frame.
*
* @example
* client.on('first-video-frame-decode', function (evt) {
* console.log('first-video-frame-decode');
* console.log(evt.stream);
* })
*/
FirstVideoFrameDecoded: "first-video-frame-decode",
/**
* Occurs when the local stream is published.
*
* @example
* client.on("stream-published", function(evt) {
* console.log("local stream published");
* //……
* })
*/
LocalStreamPublished: "stream-published",
/**
* Occurs when the remote stream is added.
*
* @remark
* When the local user joins the channel, if other users are already in the channel,
* the SDK also reports to the app on the existing remote streams.
*
* @example
* client.on("stream-added", function(evt) {
* var stream = evt.stream;
* console.log("new stream added ", stream.getId());
* // Subscribe the stream.
* //……
* })
*/
RemoteStreamAdded: "stream-added",
/**
* Occurs when the remote stream is removed; for example, a peer user calls
* [Client.unpublish](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#unpublish).
*
* @example
* client.on("stream-removed", function(evt) {
* var stream = evt.stream;
* console.log("remote stream was removed", stream.getId());
* //……
* });
*/
RemoteStreamRemoved: "stream-removed",
/**
* Occurs when a user subscribes to a remote stream.
*
* @example
* client.on("stream-subscribed", function(evt) {
* var stream = evt.stream;
* console.log("new stream subscribed ", stream.getId());
* // Play the stream.
* //……
* })
*/
RemoteStreamSubscribed: "stream-subscribed",
/**
* Occurs when the peer user leaves the channel; for example, the peer user calls
* [Client.leave](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#leave).
*/
PeerLeave: "peer-leave",
/**
* Occurs when a remote user or host joins the channel.
* - Communication channel (rtc mode): This callback notifies the app that another user joins the channel.
* If other users are already in the channel, the SDK also reports to the app on the existing users.
* - Live-broadcast channel (live mode): This callback notifies the app that the host joins the channel.
* If other hosts are already in the channel, the SDK also reports to the app on the existing hosts.
* Agora recommends limiting the number of hosts to 17.
*/
PeerOnline: "peer-online",
/**
* Occurs when the peer user mutes the audio.
*
* @example
* client.on("mute-audio", function(evt) {
* var uid = evt.uid;
* console.log("mute audio:" + uid);
* //alert("mute audio:" + uid)
* });
*/
RemoteAudioMuted: "mute-audio",
/**
* Occurs when the peer user unmutes the audio.
*
* @example
* client.on("unmute-audio", function (evt) {
* var uid = evt.uid;
* console.log("unmute audio:" + uid);
* });
*/
RemoteAudioUnmuted: "unmute-audio",
/**
* Occurs when the peer user turns off the video.
*
* @example
* client.on("mute-video", function (evt) {
* var uid = evt.uid;
* console.log("mute video" + uid);
* //alert("mute video:" + uid);
* })
*/
RemoveVideoMuted: "mute-video",
/**
* Occurs when the peer user turns on the video.
*
* @example
* client.on("unmute-video", function (evt) {
* var uid = evt.uid;
* console.log("unmute video:" + uid);
* })
*/
RemoteVideoUnmuted: "unmute-video",
/**
* Occurs when encryption or decryption fails during publishing or subscribing to a stream.
* The failure is usually due to a wrong encryption password
* ([setEncryptionSecret](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#setencryptionsecret))
* or an incorrect encryption
* mode ([setEncryptionMode](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#setencryptionmode)).
*
* @since 3.0.0
*/
CryptError: "crypt-error",
/**
* This callback notifies the peer user that he/she is banned from the channel. Only the banned users receive this callback.
* Usually the reason is that the UID is banned (`K_UID_BANNED`(14)).
*
* @example
* client.on("client-banned", function (evt) {
* var uid = evt.uid;
* var attr = evt.attr;
* console.log(" user banned:" + uid + ", bantype:" + attr);
* alert(" user banned:" + uid + ", bantype:" + attr);
* });
*/
LocalClientBanned: "client-banned",
/** This callback notifies the application who is the active speaker in the channel. */
ActiveSpeaker: "active-speaker",
/**
* This callback notifies the application of all the speaking remote users and their volumes.
*
* It is disabled by default. You can enable this event by calling enableAudioVolumeIndicator.
* If enabled, it reports the volumes every two seconds regardless of whether there are users speaking.
*
* The volume is an integer ranging from 0 to 100. Usually a user with volume above five will be countedas a speaking user.
*/
VolumeIndicator: "volume-indicator",
/** Occurs when the live streaming starts. */
LiveStreamingStarted: "liveStreamingStarted",
/** Occurs when the live streaming fails. */
LiveStreamingFailed: "liveStreamingFailed",
/** Occurs when the live streaming stops. */
LiveStreamingStopped: "liveStreamingStopped",
/**
* Occurs when the live transcoding setting is updated.
*
* The SDK triggers this callback when the live transcoding setting is updated by calling the
* [setLiveTranscoding](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#setlivetranscoding) method.
*
* @remark
* The first call of the
* [setLiveTranscoding](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#setlivetranscoding)
* method does not trigger this callback.
*/
LiveTranscodingUpdated: "liveTranscodingUpdated",
/** Occurs when the injected online media stream's status is updated. */
StreamInjectedStatusUpdated: "streamInjectedStatus",
/**
* Occurs when the Token expires in 30 seconds.
*
* You should request a new Token from your server and call
* [Client.renewToken](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#renewtoken).
*/
TokenPrivelegeWillExpire: "onTokenPrivilegeWillExpire",
/**
* Occurs when the Token expires.
*
* You should request a new Token from your server and call
* [Client.renewToken](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#renewtoken).
*/
TokenPrivelegeExpired: "onTokenPrivilegeDidExpire",
/**
* Occurs when an error message is reported and requires error handling.
* For details, @see [Error Codes and Warning Codes](https://docs.agora.io/en/Video/the_error_web).
*/
Error: "error",
/**
* Occurs when the network type changes.
*
* @remark
* Chrome 61+ is required for this function, and the compatibility is not guaranteed.
*
* @see [Network Information API](https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API) for details.
*/
NetworkTypeChanged: "network-type-changed",
/**
* Occurs when an audio input device is added or removed.
*
* @example
* client.on("recording-device-changed", function(evt) {
* console.log("Recording Device Changed", evt.state, evt.device);
* });
*/
RecordingDeviceChanged: "recording-device-changed",
/**
* Occurs when an audio output device is added or removed.
* @remark
* Only supports Chrome 49+.
*/
AudioOutputDeviceChanged: "playout-device-changed",
/** Occurs when a camera is added or removed. */
CameraChanged: "camera-changed",
/**
* Occurs when the type of a video stream changes.
* It happens when a high-video stream changes to a low-video stream, or vice versa.
*
* The stream type (streamType):
* - 0: High-bitrate, high-resolution video stream.
* - 1: Low-bitrate, low-resolution video stream.
*/
StreamTypeChanged: "stream-type-changed",
/**
* Occurs when the network connection state changes.
*
* The connection between the SDK and Agora's edge server has the following states:
*
* - DISCONNECTED: The SDK is disconnected from Agora's edge server.
* This is the initial state before Client.join.
* The SDK also enters this state after the app calls Client.leave.
* - CONNECTING: The SDK is connecting to Agora's edge server. The SDK enters this state when calling Client.join or
* reconnecting to Agora's edge server automatically after the connection is lost.
* - CONNECTED: The SDK is connected to Agora's edge server and joins a channel. You can now publish or subscribe to a stream
* in the channel. If the connection is lost because, for example, the network is down or switched, the SDK triggers this callback
* and notifies the app that the state changes from CONNECTED to CONNECTING.
* - DISCONNECTING: The SDK is disconnecting from Agora's edge server. The SDK enters this state when calling Client.leave.
*/
ConnectionStateChanged: "connection-state-change",
/** Occurs when the SDK starts republishing or re-subscribing to a stream. */
StreamReconnectionStart: "stream-reconnect-start",
/** Occurs when the SDK finishes republishing or re-subscribing to a stream. */
StreamReconnectionEnd: "stream-reconnect-end",
/** Occurs when the user role switches in a live broadcast. For example, from a host to an audience or vice versa. */
ClientRoleChanged: "client-role-changed",
/**
* Reports the network quality of the local user once every two seconds.
*
* This callback reports on the uplink and downlink network conditions of the local user.
*
* @remark
* This is an experimental feature and the network quality rating is for reference only.
*/
NetworkQualityReported: "network-quality",
/**
* Occurs when the remote video stream falls back to an audio-only stream due to unreliable network
* conditions or switches back to the video after the network conditions improve.
*
* If you set `fallbackType` as 2 in
* [setStreamFallbackOption](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.client.html#setstreamfallbackoption),
* the SDK triggers this callback when the remote media stream falls back to audio only due to unreliable network conditions
* or switches back to the video after the network condition improves.
*
* @remark
* Once the remote media stream is switched to the low stream due to unreliable network conditions, you can monitor
* the stream switch between a high stream and low stream in the stream-type-changed callback.
*/
StreamFallback: "stream-fallback",
/**
* Occurs when a remote stream adds or removes a track.
*
* When a remote stream calls the [addTrack](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.stream.html#addtrack)
* or [removeTrack](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.stream.html#removetrack)
* method, the SDK triggers this callback.
*/
StreamUpdated: "stream-updated",
/**
* Reports exception events in the channel.
* Exceptions are not errors, but usually mean quality issues.
* This callback also reports recovery from an exception.
* Each exception event has a corresponding recovery event
* @see https://web-cdn.agora.io/docs-files/1547180053430 for details
*/
Exception: "exception",
/**
* Occurs when a remote user of the Native SDK calls `enableLocalVideo(true)` to enable video capture.
*
* @since 3.0.0
*/
RemoteVideoCaptureEnabled: "enable-local-video",
/**
* Occurs when a remote user of the Native SDK calls `enableLocalVideo(false)` to disable video capture.
*
* @since 3.0.0
*/
RemoteVideoCaptureDisabled: "disable-local-video",
/**
* Reports events during the media stream relay.
*
* Parameters
* - evt: `object`
* - code: `number`
* The event code for media stream relay.
* - 0: The user disconnects from the server due to a poor network connection.
* - 1: The user is connected to the server.
* - 2: The user joins the source channel.
* - 3: The user joins the destination channel.
* - 4: The SDK starts relaying the media stream to the destination channel.
* - 5: The server receives the video stream from the source channel.
* - 6: The server receives the audio stream from the source channel.
* - 7: The destination channel is updated.
*/
MediaStreamEventRelayed: "channel-media-relay-event",
/**
* Occurs when the state of the media stream relay changes.
*
* @since 3.0.0
* @description
* The SDK reports the state and error code of the current media relay in this callback.
*
* Parameters
* - evt: `object`
* - code: `number`
* The error code.
* - 0: No error.
* - 1: An error occurs in the server response.
* - 2: No server response.
* - 3: The SDK fails to access the service, probably due to limited resources of the server.
* - 4: Fails to send the relay request.
* - 5: Fails to accept the relay request.
* - 6: The server fails to receive the media stream.
* - 7: The server fails to send the media stream.
* - 8: The SDK disconnects from the server and fails to reconnect to the server due to a poor network connection.
* In this case, the SDK resets the relay state. You can try
* [startChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* to restart the media stream relay.
* - 9: An internal error occurs in the server.
* - 10: The token of the source channel has expired.
* - 11: The token of the destination channel has expired.
* - 12: The relay has already started. Possibly caused by calling
* [startChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* repeatedly, or calling
* [startChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* before
* [stopChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#stopchannelmediarelay)
* succeeds.
* - 13: The relay has not started. Possibly caused by calling
* [updateChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#updatechannelmediarelay)
* before
* [startChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* succeeds.
*
* - state: `number`
* The state code.
* - 0: The SDK is initializing.
* - 1: The SDK tries to relay the media stream to the destination channel.
* - 2: The SDK successfully relays the media stream to the destination channel.
* - 3: An error occurs. See `code` for the error code. In case of an error, the SDK resets the media stream relay state,
* and you need to call
* [startChannelMediaRelay](https://docs.agora.io/en/Voice/API%20Reference/web/interfaces/agorartc.client.html#startchannelmediarelay)
* to restart the relay.
*/
MediaStreamRelayStateChanged: "channel-media-relay-state",
};
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/codec-type.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var CodecType = {
Opus: "1",
AAC: "2",
};
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/log-level.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {number} */
var LogLevel = {
/** Outputs all logs. */
Debug: 0,
/** Outputs logs of the INFO, WARNING and ERROR levels. */
Info: 1,
/** Outputs logs of the WARNING and ERROR levels. */
Warning: 2,
/** Outputs logs of the ERROR level. */
Error: 3,
/** Outputs no logs. */
None: 4,
};
LogLevel[LogLevel.Debug] = 'Debug';
LogLevel[LogLevel.Info] = 'Info';
LogLevel[LogLevel.Warning] = 'Warning';
LogLevel[LogLevel.Error] = 'Error';
LogLevel[LogLevel.None] = 'None';
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/mute-state.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var MuteState = {
Unmuted: "0",
Muted: "1",
};
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/stream-event.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var StreamEvent = {
/** Occurs when the user gives access to the camera and microphone. */
MediaAccessAllowed: "accessAllowed",
/** Occurs when the user denies access to the camera and microphone. */
MediaAccessDenied: "accessDenied",
/** Occurs when screen-sharing stops. */
ScreenSharingStopped: "stopScreenSharing",
/**
* Occurs when the video track no longer provides data to the stream.
*
* Possible reasons include device removal and deauthorization.
*
* @see [MediaStreamTrack.onended](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/onended).
*/
VideoTrackEnded: "videoTrackEnded",
/**
* Occurs when the audio track no longer provides data to the stream.
*
* Possible reasons include device removal and deauthorization.
*
* @see [MediaStreamTrack.onended](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/onended).
*/
AudioTrackEnded: "audioTrackEnded",
/**
* Occurs when the audio mixing stream playback starts/resumes.
*
* @remark
* This callback is triggered when the audio mixing stream is loaded and starts playing,
* or when the paused audio mixing stream resumes playing.
*/
AudioMixingPlayed: "audioMixingPlayed",
/** Occurs when the last audio mixing stream playback finishes. */
AudioMixingFinished: "audioMixingFinished",
/**
* Occurs when the stream playback status changes.
*
* On Windows, frequent DOM manipulations might cause the browser to pause the Chrome player.
* To avoid this, you can listen for this event and call the
* [Stream.resume](https://docs.agora.io/en/Video/API%20Reference/web/interfaces/agorartc.stream.html#resume)
* method to resume the playback.
*
* This callback has the following properties.
*
* - isErrorState: Whether or not the playback fails.
* - true: The playback fails.
* - false: The playback is normal.
*
* - mediaType: The player type.
* - "audio": Audio player.
* - "video": Video player.
*
* - status: The playback status.
* - "play": Playing.
* - "aborted": The player is removed before the stream is played successfully.
* - "paused": The player is stopped.
*
* - reason: The reason why the playback status changes. Usually, this value is the event that triggers the status change.
* Possible values include the following:
* - "playing": The playback starts.
* See [HTMLMediaElement: playing event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/playing_event).
* - "stalled": The failure might be caused by the browser policy.
* See [stalled event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/stalled_event).
* - "pause": The stream playback might be paused by the user.
* See [pause event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause_event).
* - "suspend": The failure might be caused by the browser policy.
* See [suspend event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/suspend_event).
* - "canplay": Some browsers automatically stop the playback when the playback window is not displayed on the screen.
* See [canplay event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/canplay_event).
* - "timer": The playback failure is caused by an unknown reason and captured by the internal timer.
*
* @example
* stream.on("player-status-change", function(evt) {
* if (evt.isErrorState && evt.status === "paused") {
* console.error(`Stream is paused unexpectedly. Trying to resume...`);
* stream.resume().then(function() {
* console.log(`Stream is resumed successfully`);
* }).catch(function(e) {
* console.error(`Failed to resume stream. Error ${e.name} Reason ${e.message}`);
* });
* }
* });
*/
StreamPlaybackStatusChanged: "player-status-change",
};
/**
* @fileoverview added by tsickle
* Generated from: lib/data/enums/index.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/audio-profile.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/connection-state.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/screen-profile.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/sound-id.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/video-profile.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/volume.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: lib/data/types/index.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: public-api.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* Generated from: ngx-agora.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
export { ChannelMediaMessage, ClientEvent, CodecType, LogLevel, MuteState, NgxAgoraModule, NgxAgoraService, StreamEvent, NgxAgoraComponent as ɵb };
//# sourceMappingURL=ngx-agora.js.map