• Docs /
• RTC /
• Audio and Video SDK /
• Web /
• Client /

CloudHub JSSDK

• Overview
• CloudHubRTC
• CloudHubRTCObject
• Client
• ClientEvent
• ClientLiveTranscoding
• ClientChannelMediaRelayConfig
• Stream
• StreamEvent
• DeviceManager
• constant

• The Client interface provides major functions for a voice/video call, such as joining a channel and publishing a stream.
• The Client object is created by the createClient method and represents the local client.

Base

init

Initializes a Client Object

This method initializes the client object.

init(appId: string, options?:object, onSuccess?: function, onFailure?: function): void

// example:
client.init(appId, {}, function() {
  console.log("client initialized");
}, function(err) {
  console.log("client init failed", err);
});

renewToken

Renews the Token

This method renews your token.

If the Token mechanism is enabled, the token used after a while will be invalid. Trigger Client.on(‘token-privilege-will-expire’) When the callback is called to reagent, then the method updates token, otherwise the SDK cannot establish a connection with the server.

renewToken(token:string, onSuccess?:function, onFailure?:function): void

// example:
client.renewToken(<token>,  function(){
  console.info("renewToken success");
}, function(errflag){
  console.error("renewToken fail", errflag);
});

Note： Token is generated by a combination of authkey, secretkey, channel, userid, and expiretime, so make sure that the newly generated token uses the authkey, secretkey, channel, and userid unchanged.

event

off

Unbinds Events

This method removes the events attached by the Client.on() method.

off(eventType: string, listener: function): void

// example:
client.on("stream-published", function processStreamPublished(evt) {
  console.log("Stream Published");
  evt.stream.play("divId");
  client.off("stream-published", processStreamPublished);
}

on

Make event binding.

For more information about the events that currently support binding and the role of the events Client event documentation

on(eventType: string, listener: function): void

// example:
client.on('first-audio-frame-decode', function (evt) {
  // The callback of the first frame of the remote audio has been decoded.
  // This callback is triggered when the local subscription to the remote stream is successful and the first frame of audio decoding is completed. 
  console.log('first-audio-frame-decode', evt);
})

offAll

Unbind all events under Type.

offAll(eventType: string): void

// example:
client.offAll("stream-network-quality");

channel

setChannelConfig

Set channel configuration, you can modify the ‘coding mode’ and ‘channel usage scene’ before entering the channel

client.setChannelConfig({
    codec: 'vp8',
    mode: 'live',
});

joinChannel

Join cloudHubRTC channels.

This method allows users to join the CloudHubRTC channel. When the method is successfully called to join the channel, it is triggered locally Client.on(“signal-connected”) and Client.on(“signal-connection-state-change”) Callback.

In a communication scenario, the remote side is triggered Client.on(“peer-join”) Callback

In a live scenario, the user role that joins the channel is the anchor and the remote end is triggered Client.on(“peer-join”) Callback, if it is the audience, the far end does not trigger Client.on(“peer-join”) Callback.

joinChannel(token: string | null, channelId: string, uid: string | null, options?: object, onSuccess?: function, onFailure?: function): void

// example:
client.joinChannel(<token>, "1024", "userid", {}, function(uid) {
  console.log("client" + uid + "joined channel");
  // Create a local stream
  //……
}, function(err) {
  console.error("client join failed", err);
  // Error handling
});

Note:

• Locally triggered when joining a channel is successful Client.on(“signal-connected”) Call back, see for details Client event documentation。
• When the signaling channel connection is successful (locally triggered Client.on(“signal-connected”) Callback).The signaling channel may be disconnected due to network reasons, the SDK automatically reconnects, and the reconnection is successful and triggered locally Client.on(“signal-connected”)Callback.
• Do not engage in any communication behavior during the signaling channel disconnect（pubMsg、delMsg）.It is recommended that the interface appear floating layer, do not let the user on the interface until the signaling channel connection is restored.

leaveChannel

Leave the CloudHubRTC channel.

When the method is called to leave the channel, it is triggered locally Client.on(“signal-connection-state-change”) Callback.

In a communication scenario, the remote side is triggered Client.on(“peer-leave”) Callback.

In a live scenario, the user role that leaves the channel is the anchor and the remote end is triggered Client.on(“peer-leave”) Callback, if the audience is far from the distal end Client.on(“peer-leave”) Callback.

leaveChannel(): void

// example:
client.leaveChannel()

Audio and video

publish

Publish the local audio and video stream.

This method is issued to the server.

After issuing audio and video streams, the local will trigger Client.on(“stream-published”) Torch; distal trigger Client.on(“stream-added”) Callback.

In the live broadcast scene, if the user’s role is the audience (audience)，Automatically switch into an anchor when calling Publish(host) Role, Local trigger Client.on(“client-role-changed”) Tune, distal trigger Client.on(“peer-join”).

publish(stream: Stream, options?:object, onFailure?: function): void

// example:
client.publish(stream, {}, function(err) {
  console.log(err);
  // Code logic to handle release failures
})

Note:

• SDK has an automatic re-release policy. Once triggered, it is triggered. Client.on(“stream-reconnect-start”) and Client.on(“stream-reconnect-end”)， For details, please see Client event documentation 的 stream-reconnect-start 和 stream-reconnect-end。
• Redistribution may be caused by the following reasons:
  • “PUB_ACK_FAILED”: Release ACK failure, general is in release process connection lost [note: this failure SDK automatically republish ]
  • “PUB_TIMEOUT”: Publish timeout [Note: SDK will automatically republish].
  • “PUB_CONNECTION_FAILED”: Media transfer channel establishment failed after publishing [Note: SDK will automatically republish].
  • “PUB_CONNECTION_INSTABILITY”: The stream has been successfully published, but the media transfer channel is unstable and needs to be forced to republish [Note: the SDK will automatically republish].
  • “PUB_CONNECTION_ICE_DISCONNECTED”: The stream has been successfully published, but the media transfer channel is disconnected [Note: the SDK will automatically republish].
  • “PUB_APP_HIDDEN_CATON”: After successful publishing, the APP lags because it is re-displayed after hiding the APP (pressing the Home button) [SDK will automatically re-publish].
  • “PUB_UNDEFINED_FAIL”: Undefined publish failed [Note: SDK will automatically re-publish].
  • “PUB_SDK_FORCE_RECONN”: Switching devices / switching resolutions because the browser version is too low requires a forced republish [Note: the SDK will automatically republish].
• The sdk auto-release will first unpublish the stream and then republish it, so if the stream is republished after it has already been successfully published the remote will trigger the Client.on(“stream-removed”) callback, the local will trigger the Client.on(“stream-unpublished”) Callback. if the republishing succeeds locally it will trigger the Client.on(“stream-published”) callback, the remote end will trigger the Client.on(“stream-added”) Callback.
• The SDK release has a comment of “SDK will automatically republish”, it will be automatically released after failure, if you don’t want to call unpublish anymore.
• It is recommended to call the unpublish method when the failure reason is “PUBLISH_STREAM_LIMIT”.
• Because of the SDK re-release mechanism, Client.on(“stream-removed”), Client.on(“stream-unpublished”), Client.on(“stream-published”), Client.on(“stream- added”) It may be triggered multiple times. After successful publishing, the re-publishing is successful for simple reasons. For example, the client (“stream-unpublished”) will be triggered locally and Client.(“stream-published”) will be started after the client starts, and the remote will trigger Client.on(“stream -unpublished”) -removed") Trigger Client.on(“stream- added”) after the start.

subscribe

Subscribe to remote audio and video streams.

This method receives remote audio and video streams from the server.

After subscribing to the remote audio and video stream, the Client.on(“stream-subscribed”) callback will be triggered locally. If the subscription stream contains audio, it will also trigger Client.on(“first-audio-frame-decode”) callback; if the subscription stream contains video, it will also trigger Client.on(“first-video-frame-decode”) Callback.

subscribe(stream: Stream, options?:object, onFailure?: function): void

// example:
client.subscribe(stream, {}, function(err) {
    console.error("stream subscribe failed", err);
    // Code logic to handle subscription failures
})

Note:

• The SDK has an automatic re-subscription strategy. Once the automatic re-subscription is triggered, Client.on(“stream-reconnect-start”) and Client.on(“stream-reconnect-end”) will be triggered. For details, please see “Client Event Document “ stream-reconnect-start and stream-reconnect-end.

• Re-subscription may be triggered by the following reasons:

  • “SUB_ACK_FAILED”: ACK subscription failed, usually due to disconnection during the subscription process [Note: SDK will automatically re-subscribe].
  • “SUB_TIMEOUT”: Subscription timeout [Note: SDK will automatically re-subscribe].
  • “SUB_CONNECTION_FAILED”: Media transmission channel establishment failed after subscribing [Note: SDK will automatically resubscribe].
  • “SUB_CONNECTION_INSTABILITY”: The stream has been subscribed successfully, but the media transmission channel is unstable, and it needs to be forced to resubscribe [Note: SDK will automatically resubscribe].
  • “SUB_CONNECTION_ICE_DISCONNECTED”: The stream has been subscribed successfully, but the media transmission channel is disconnected [Note: SDK will automatically resubscribe].
  • “SUB_APP_HIDDEN_CATON”: After the subscription is successful, the app is hidden (for example, press the Home button) and then the app is redisplayed, causing a freeze [Note: SDK will automatically re-subscribe].
  • “SUB_UNDEFINED_FAIL”: Undefined subscription failed [Note: SDK will automatically resubscribe].

• The automatic re-subscription of SDK will first unsubscribe this stream, and the Client.on(“stream-unsubscribed”) callback will be triggered locally, and then subscribe. If the re-subscription is successful, the Client.on(“stream-subscribed”) callback will be triggered locally. If the subscription stream contains audio, it will also trigger Client.on(“first-audio-frame-decode”) callback; if the subscription stream contains video, it will also trigger Client.on(“first-video-frame-decode”) Callback.

• There is a comment marked “SDK will automatically resubscribe”, the SDK will automatically resubscribe after failure, if you don’t want to subscribe, please call the unsubscribe method.

• Because of the SDK re-subscription mechanism, Client.on(“stream-unsubscribed”) and Client.on(“stream-subscribed”) may be triggered multiple times. For example, after the subscription is successful, the client will be triggered if the re-subscription is successful due to link reasons. on(“stream-unsubscribed”) and Client.on(“stream-subscribed”).

unpublish

Unpublish local audio and video streams.

This method cancels the release of local audio and video streams. After unpublishing the audio and video stream, the remote site will trigger the Client.on(“stream-removed”) callback, and the local site will trigger the Client.on(“stream-unpublished”) callback.

In the live broadcast scenario, if the user’s role is the host, after calling unpublish, if there is no local stream release, it will automatically switch to the audience role, and the local will trigger Client.on(“client-role-changed”) Callback, the remote end will trigger Client.on(“peer-leave”).

unpublish(stream: Stream, options?:object, onSuccess?: function, onFailure?: function): void

// example:
client.unpublish(stream, {}, function(){
  console.log("unpublish success");
  }, function(err) {
    console.log(err);
    //……
})

unsubscribe

Unsubscribe the remote audio and video stream.

unsubscribe(stream: Stream, options?:object, onSuccess?: function, onFailure?: function): void

// example:
client.unsubscribe(stream, {}, function(){
console.log("unsubscribe success");
}, function(err) {
    console.log(err);
    //……
})

getRemoteAudioStats

Obtain audio statistics of the remote subscribed stream.

getRemoteAudioStats(onCallback: function): void

// example:
client.getRemoteAudioStats((remoteAudioStatsMap) => {
  console.log("remoteAudioStatsMap", remoteAudioStatsMap);
});

enableAudioVolumeIndicator

Enable speaker volume alert.

This method allows the SDK to periodically return the volume reminder of the published/subscribed stream.

After enabling this method, the SDK will trigger the “stream-volume-indicator” callback to return the volume prompt every interval milliseconds, regardless of whether there is anyone speaking in the channel. Only return volume prompts whose stream Type is video (stream.getType() === “video”)

enableAudioVolumeIndicator(interval?:number): void

// example:
client.enableAudioVolumeIndicator(2000); // Triggers "volume-indicator" every two seconds retrace
client.on("stream-volume-indicator", function(evt){
    console.log("stream-volume-indicator", evt);
});

getLocalAudioStats

Obtain audio statistics of the locally published stream.

getLocalAudioStats(onCallback: function): void

//example:
client.getLocalAudioStats((localAudioStats) => {
  console.log("localAudioStats:", localAudioStats);
});

Note：

• Some statistics need to be counted after the stream-published event, which may take 0-3 seconds to return.
• Edge browser does not support.

getLocalVideoStats

getLocalVideoStats(onCallback: function): void

//example:
client.getLocalVideoStats((localVideoStats) => {
    console.log("localVideoStats:", localVideoStats);
});

Get the video statistics of the local publishing stream.

Note：

• Some statistics need to be counted after the stream-published event, which may take 0-3 seconds to return.
• Edge browser does not support.

getRemoteVideoStats

Method function: Obtain the video statistics data of the remote subscribed stream.

getRemoteVideoStats(onCallback: function): void
// example:
client.getRemoteVideoStats((remoteVideoStatsMap) => {
  console.log("remoteVideoStatsMap", remoteVideoStatsMap);
});

Note:

• Statistical data needs to be counted after the stream-subscribed event, and it may take 0-3 seconds to return.
• Edge browser does not support.

enableMultiStream

Method function: Whether to enable multi-stream mode.

enableMultiStream(bEnable:boolean): void

// example:
client.enableMultiStream(true)

Note:

• Multi-stream mode means that multiple device streams can be released.

• When you need to enable the multi-stream mode, please call the enableMultiStream method to enable it before joiningChannel.

• The enableMultiStream method will be invalid after joinChannel is called.

• Does not support multi-stream mode and single-stream mode to switch within the channel.

• The mobile terminal does not support multi-stream mode, that is, multiple device streams cannot be published.

information

sendChatMsg

Method function: Send chat messages. Client.on(“recv-chat-msg”) callback will be triggered after receiving the chat message.

sendChatMsg(message:string, toId: string, extraData?:object): void

// example:
client.sendChatMsg("this is chat msg", CloudHubRTC.CONSTANTS.MSG_TO_ALLUSER, {"key1":"value1", "key2":"value2"});

Note:

• 1. When there are too many chat messages sent within 1 second, the chat messages may be discarded, generally 20-100 messages per second.
• 2. CloudHub will filter sensitive words for chat messages.

pubMsg

Send a signaling message. Client.on(“recv-pub-msg”) callback will be triggered after receiving “send signaling message”.

pubMsg(msgName: string, msgId:string, toId:string, data:object, save?:boolean,associatedMsgID?:string): void

//example:
client.pubMsg("msgname", "msgid", CloudHubRTC.CONSTANTS.MSG_TO_ALLUSER, {testdata: 1}, true);

Note: In the live broadcast scene, it is recommended that only some people (hosts or authorized viewers, etc.) be able to send pubMsg, and not everyone can actively send pubMsg [for example: a channel with 100,000 people and an audience of 99,000 people, then these people There should not be the ability to actively send pubMsg, but the anchor should be authorized to a certain audience, this audience can send pubMsg].

delMsg

Delete the signaling message. Client.on(“recv-del-msg”) callback will be triggered after receiving the “delete signaling message”.

delMsg(msgName: string, msgId:string, toId:string): void

// example:
client.delMsg("msgname", "msgid", CloudHubRTC.CONSTANTS.MSG_TO_ALLUSER);

Note: In the live broadcast scene, it is recommended that only some people (hosts or authorized viewers, etc.) be able to send delMsg, and not everyone can actively send delMsg [for example: a channel with 100,000 people and an audience of 99,000 people, then these people There should not be the ability to actively send delMsg, but the anchor should be authorized to a certain audience, this audience can send delMsg].

Signaling

getSignalConnectionState

getSignalConnectionState(): string

Obtain the connection status between the SDK and the signaling server. Calling this method will return the connection status between the SDK and the signaling server. There are 3 types of connection status between the SDK and the signaling server:

• DISCONNECTED: The connection is disconnected. This status indicates that the SDK is in any of the following stages:
• Call Client.joinChannel to join the initial stage of the channel
• The phase of leaving the channel after calling Client.leaveChannel
• CONNECTING: Connecting. It is in this state when calling Client.joinChannel or automatically reconnecting when the connection is interrupted.
• CONNECTED: Connected. This status indicates that the user has joined the channel and can publish or subscribe to media streams in the channel.

Note:

• When the status changes to DISCONNECTED, it is necessary to clear the data cached in the UI layer, such as stream list, user list, UI interface, channel closed connection, etc. [Note: This state is usually triggered when the user calls leaveChannel or is kicked out of the channel, and will truly disconnect from the server and will not reconnect]
• When a signal-reconnect event is received (ie: the state is CONNECTING), the data cached in the UI layer, such as stream list, user list, UI interface, etc., need to be cleared. [Note: This state generally means that the current network is disconnected from the server and will be reconnected, and the server can be reconnected when the network is restored]

Note:

• Statistical data needs to be counted after the stream-subscribed event, and it may take 0-3 seconds to return.
• Edge browser does not support.

User

evictUser

Kick the user out of the channel.

evictUser(uid:string, reason?:string): void
// example:
client.evictUser("uid", "reason");

setProperty

Change the user’s custom user attributes. This method changes the properties of a user and notifies the specified user in the channel of the property change. The specified user will receive the Client.on(“user-properties-update”) callback.

setProperty(uid: string, properties: object, toId?: string): void

// example:
client.setProperty("userid", {key1:value1}, CloudHubRTC.CONSTANTS.MSG_TO_ALLUSER);

Note:

• The setProperty interface is called in the live broadcast scene. If the changed person is an audience, the custom user property change will not be notified, that is, Client.on(“user-properties-update”) will not trigger the callback.
• Viewers are not recommended to call the setProperty interface in the live broadcast scene.

setClientRole

Set user roles.

This method is only applicable to live broadcast scenes.

In the live broadcast scenario, you can call this method to set the user role.

Before joining the channel, users can set their own roles through this method.

After joining the channel, the user can switch roles through this method:

• In the live broadcast scenario, call Client.setClientRole to switch the host to the audience, and all local streams will be automatically unpublished.
• In a live broadcast scenario, if the user’s role is the host, after calling unpublish, if there is no local stream release, it will automatically switch to the audience role, and the local will trigger Client.on(“client-role-changed” ) Callback, the remote end will trigger Client.on(“peer-leave”).
• In a live broadcast scenario, if the user’s role is an audience, it will automatically switch to the host role when publish is called. The local will trigger the Client.on(“client-role-changed”) callback, and the remote will Trigger Client.on(“peer-join”).

If you call this method to switch user roles after joining a channel, after the switch is successful, Client.on(“client-role-changed”) callback will be triggered locally; and Client.on(“peer-join”) or Client will be triggered remotely .on(“peer-leave”) callback.

setClientRole(role:string, onCallback?:function): void

// example:
client.setClientRole("host", function(errinfo) {
  if (!errinfo) {
    console.log("setClientRole success");
  } else {
    console.log("setClientRole error", errinfo);
  }
});

Note: This method cannot be used in communication scenarios (mode set to rtc). By default, all users are in the host role.

Recording

startServerRecord

Start server-side recording.

The recording function needs to be turned on by contacting cloudHub business personnel. If it is not turned on, it will not be possible to call this interface to record. Will trigger the Client.on(“server-record-state-change”) callback.

startServerRecord(config?:object): void
// example:
client.startServerRecord({});

Note: If you call startServerRecord twice (that is, call startServerRecord again without calling stopServerRecord), the first call will prevail.

stopServerRecord

Stop server-side recording.

Will trigger the Client.on(“server-record-state-change”) callback.

stopServerRecord(): void
// example:
client.stopServerRecord();

pauseServerRecord

Method function: Pause server-side recording.

Will trigger the Client.on(“server-record-state-change”) callback.

pauseServerRecord(): void

//  example:
client.pauseServerRecord();

resumeServerRecord

Resume server-side recording.

Will trigger the Client.on(“server-record-state-change”) callback.

resumeServerRecord(): void

//  example:
client.resumeServerRecord();

Push Stream

addPublishStreamUrl

Increase the bypass push address.

addPublishStreamUrl(url:string): void

//  example:
client.removePublishStreamUrl("xxxx");

removePublishStreamUrl

Delete the bypass streaming address.

removePublishStreamUrl(url:string): void

setLiveTranscoding

Set up live streaming and transcoding.

setLiveTranscoding(liveTranscoding:LiveTranscoding): void

//  example:
var liveTranscoding = {
    "width": 640,
    "height": 360,
    "videoBitrate": 400,
    "videoFramerate": 15,
    "audioSampleRate": 48000,
    "audioBitrate": 48,
    "audioChannels": 1,
    "audioCodecProfile": 0,
    "videoGop": 30,
    "videoCodecProfile": 100,
    "streamCount": 1,
    "backgroundColor": 0x000000,
    "transcodingStreams": [{
      "x": 0,
      "y": 0,
      "width": 640,
      "height": 360,
      "zOrder": 0,
      "uid": "123456",
      "type": "video",
      "sourceID": "default_source_id"
    }]
  };
client.setLiveTranscoding(liveTranscoding);

startChannelMediaRelay

Start cross-channel media stream forwarding.

startChannelMediaRelay(channelMediaRelayConfig:ChannelMediaRelayConfig): void

//  example:
var channelMediaRelayConfig = client.produceChannelMediaRelayConfig();
  channelMediaRelayConfig.setDestChannelInfo(
    "destChannelName",
    {
      uid: "Relay_myChannelName_Requester_myuid"
    }
  );
client.startChannelMediaRelay(channelMediaRelayConfig);

Note： For events related to the stream forwarding state, please see the event description of client.on(“channel-media-relay-state”)

updateChannelMediaRelay

Update cross-channel media stream forwarding.

updateChannelMediaRelay(channelMediaRelayConfig:ChannelMediaRelayConfig): void

// example:
channelMediaRelayConfig.setDestChannelInfo(
    "destChannelName2",
    {
        uid: "Relay_myChannelName_Requester_myuid"
    }
);
client.updateChannelMediaRelay(channelMediaRelayConfig);

Note: For events related to the stream forwarding state, please see the event description of client.on(“channel-media-relay-state”)

stopChannelMediaRelay

Method effect: Stop the cross-channel media stream forwarding.

stopChannelMediaRelay(): void

// example:
client.stopChannelMediaRelay();

Note: For events related to the stream forwarding state, please see the event description of client.on(“channel-media-relay-state”)

produceChannelMediaRelayConfig

Production cross-channel media forwarding configuration examples. For details about ChannelMediaRelayConfig, see ChannelMediaRelayConfig

produceChannelMediaRelayConfig(): void

// example:
var channelMediaRelayConfig = client.produceChannelMediaRelayConfig();