Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This release improves early invite logic for audio and video calls, updates dependencies, fixes ICE candidate handling during renegotiation, and enhances typing support. It makes several internal changes and bug fixes to improve the stability of the SDK.
]]>Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This release improves the websocket connection and stability significantly.
It also focuses on microphone controls, participant management, and Call Fabric SDK enhancements.
Key additions include new microphone control features (auto gain, echo cancellation, noise suppression),
the ability to mute/unmute all participants simultaneously, and improved Call Fabric SDK functionality with
fromFabricAddressId parameter support and configurable default media parameters. Additionally, this release
fixes critical issues with push notifications, improves WebSocket reconnection handling, and resolves
various type interface inconsistencies for a more stable development experience.
Added support for microphone control features including auto gain, echo cancellation, and noise suppression.
New FabricMemberContract controls:
member.auto_gainmember.echo_cancellationmember.noise_suppressionNew function support:
await FabricRoomSession.setAudioFlags({
autoGain: false,
echoCancellation: false,
noiseSuppression: false,
});
Added support for muting and unmuting audio and video for all participants in both audio-only and video calls.
// Mute all members' audio
await FabricRoomSession.audioMute({ memberId: "all" });
// Unmute all members' audio
await FabricRoomSession.audioUnmute({ memberId: "all" });
// Mute all members' video
await FabricRoomSession.videoMute({ memberId: "all" });
// Unmute all members' video
await FabricRoomSession.videoUnmute({ memberId: "all" });
fromFabricAddressId parameterAdded the ability to pass fromFabricAddressId when dialing.
const call = await SignalWireClient.dial({
// ... other parameters
to: "...",
fromFabricAddressId: "valid_subscriber_id", // Optional
// ... other parameters
});
Added support for configuring default media parameters during call setup.
await call.dial({
applyLocalVideoOverlay: false, // Should the SDK apply local video overlay? Default: true
applyMemberOverlay: true, // Should the SDK apply member video overlays? Default: true
stopCameraWhileMuted: true, // Should the SDK stop the camera when muted? Default: true
stopMicrophoneWhileMuted: true, // Should the SDK stop the mic when muted? Default: true
mirrorLocalVideoOverlay: false, // Should the SDK mirror the local video overlay? Default: true
});
Added an optional handlePushNotification method to allow developers to receive push notifications without being online via websocket.
SignalWireContract.handlePushNotification(params: HandlePushNotificationParams)
Previously, receiving push notifications required calling SignalWireContract.online() which automatically made you online on websocket as well.
If user is online from both websocket and push notification simultaneously, the call would hang up because the server couldn't
distinguish that both notification endpoints belonged to the same device.
Fixed raise hand call and member capability issues.
Exposed pagination interfaces for better type safety:
PaginatedResponsePaginatedResultImproved WebSocket reconnections and re-subscription to voice call topics after socket reconnects.
Fixed type interfaces for getMessages and getMembers methods.
Future updates will adhere to Semantic Versioning. This means you can upgrade with confidence knowing that new versions will not break your code from minor updates.
This release of the Realtime API SDK includes bug fixes and improvements. Further, dependencies have been updated to ensure stability.
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This release introduces Call Fabric and Video SDK enhancements, including new APIs for room management, media renegotiation, member overlays, chat messaging, user hand raising, and more. In the Call Fabric interface, several types and interfaces have been refined or added for better clarity, and default call behavior is now audio-only for a more optimized initial setup. Additionally, we've introduced convenient methods for sorting addresses, reattaching calls, and handling conversations. Numerous fixes address type inconsistencies, event handling, and memory leaks, ensuring a more stable and efficient development experience.
New lock and unlock methods on FabricRoomSession to restrict and restore entry to a specific room.
await call.lock()
await call.unlock()
Allows you to move a member to a specific position within the room layout.
await roomSession.setPositions({ positions: { self: "standard-2" }})
Expose overlays on top of video elements for each member to display additional member information or custom UI for the Call Fabric and Video SDK.
Call Fabric SDK now supports raising and lowering the participant's hand.
await roomSession.setRaisedHand({ raised: true })
await roomSession.setRaisedHand({ raised: false })
New chat methods to handle sending and receiving chat messages within a room or call context.
const messages = await client.chat.getMessages({ addressId: 'id' })
const sub = await client.chat.subscribe({ addressId: 'id', onMessage: console.log })
await client.chat.sendMessage({ addressId: 'id', text: 'hello' })
A new reattach method has been introduced for the Call Fabric client to reattach a call without starting from scratch.
const call = await client.reattach({
to: `/public/${roomName}`,
rootElement: document.getElementById('rootElement'),
})
The FabricRoomSession object now provides direct access to the current room layout.
const call = await client.dial({ ... })
await call.start()
call.currentLayout;
You can now use sort parameters when fetching addresses on the server side for more organized data retrieval.
const response = await client.address.getAddresses({
type: 'room',
sortBy: 'name',
sortOrder: 'desc',
pageSize: 3,
})
Added a userVariables parameter to both DialOption and SignalWireClientParams to send additional metadata.
const call = await SignalWire({
...params,
userVariables: { name: 'Jane Doe', email: 'john.doe@gmail.com' },
})
// Or
const call = await client.dial({
...params,
userVariables: { name: 'Jane Doe', email: 'john.doe@gmail.com' },
})
Dynamically set or change the audio/video direction (sendonly, recvonly, sendrecv, inactive) and apply new MediaTrackConstraints during an active session.
await updateMedia({
audio: {
enable: true,
direction: 'send' | 'sendrecv',
constraints?: MediaTrackConstraints
},
video: {
enable: false,
direction: 'none' | 'receive'
}
})
await setVideoDirection('send' | 'sendrecv' | 'none' | 'receive')
await setAudioDirection('send' | 'sendrecv' | 'none' | 'receive')
Screen sharing is now baked into the Call Fabric SDK for simpler real-time collaboration.
const screenShare = await call
.startScreenShare({
audio: true,
video: true,
...opts,
})
.catch((error) => {
console.error('ScreenShare Error', error)
})
await screenShare.hangup()
Seamlessly join existing conversations in the CF SDK.
await client.conversation.join({
addressId: id,
})
New name parameter to client.address.getAddress for retrieving addresses using their name.
const addressByName = await client.address.getAddress({ name: "john doe" })
Call Fabric SDK no longer tries to automatically reauthenticate, giving you full control over session auth flow.
The onRefreshToken is no longer available for the CF SDK that performed the implicit re-authentication.
With the new changes, the application needs to call the updateToken function to perform the explicit re-authentication.
await client.updateToken('newToken');
Dialing a Call Fabric room (e.g. client.dial()) defaults to audio-only unless otherwise specified.
const call = await client.dial({address: `/public/${roomName}`}) // now defaults to audio-only
const call = await client.dial({address: `/public/${roomName}?channel=video`}) // use channel parameter to explicitly request video
client.dialUser-defined parameters (e.g., audio, video, negotiateAudio, negotiateVideo) now override or get higher priority than the channel specified in the resource address when dialing a call with client.dial.
Call.startScreenShare() now throws an error if the user denies screen sharing permission.
The InternalVideoLayoutLayer interface type is now publicly exposed.
Browser SDKs can now leverage a more specialized enumerateDevicesByKind method for microphone, camera, and more.
import { enumerateDevicesByKind } from '@signalwire/js'
const devices = await enumerateDevicesByKind('videoinput') // "videoinput", "audioinput" or "audiooutput"
Types for FabricRoomSession are now exported for easier type-checking and integration.
The CF SDK ConversationContract now exposes the addressId for more direct resource referencing
You can set the audio/video negotiation parameters to better control media usage while dialing a call.
const call = await client.dial({
address: `/public/room`,
negotiateAudio: true,
negotiateVideo: false,
})
New properties were added to ConversationMessage, GetAddressResponse, and GetSubscriberInfoResponse interfaces for expanded functionality.
CF SDK allows unsubscribing from conversation updates, giving you more fine-grained control over event listening.
const { unsubscribe } = await client.conversation.subscribe(() => { /* ... */ })
unsubscribe();
Clear separation of types for each SDK to reduce confusion and potential collisions. The Video SDK and the Call Fabric SDK are now distinct types.
For example, FabricRoomSession and VideoRoomSession are now distinct types which both derive from BaseRoomSession.
ConversationMessageEventParams.type is now string instead of MessageTypeConversationContract has been addedVideoLayout and other layout related types fixedgetAddress method now returns a normalized responseaudio_muted and video_muted state for Call will now reflect the actual stateConversationChatMessagesSubscribeParams and ConversationChatMessagesSubscribeResultUpgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This release brings significant enhancements and new features to the SignalWireClient, focusing on improved video handling, expanded API capabilities, and better user management:
buildVideoElement function to easily create and manage video elements for calls and rooms.These updates collectively aim to provide a more flexible, powerful, and user-friendly experience for developers using the SignalWireClient.
userVariables param added when dialing a Fabric callconst client = await SignalWire({
host: ...
token: ...,
})
const call = await client.dial({
...params,
rootElement: document.getElementById('rootElement'),
userVariables: {
"name": "John Doe",
"email": "johndoe@signalwire.com",
//...
"fullBrowserVersion": "125.0.0.0",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
}
})
buildVideoElement function that creates and optionally injects a video DOM element for a given Call or Room object.const call = await client.dial({
// ...
})
await call.start();
const { element, unsubscribe } = await buildVideoElement({
room: call,
})
const container = document.getElementById('container');
container.appendChild(element)
Or, to also implicitly inject the video DOM element into your chosen container:
const { element, unsubscribe } = await buildVideoElement({
room: call,
rootElement: document.getElementById('container'),
})
getAddress method added to the address namespace in SignalWireClient which returns the details about a particular address idclient.address.getAddress({id: <address_id_to_fetch_details>})
getConversations, getConversationMessages, createConversationMessage methods added to the conversation namespace in SignalWireClientconst conversations = await client.conversation.getConversations()
const conversationMessages = await client.conversation.getConversationMessages({ addressId: '...' })
// Subscribe to updates
client.conversation.subscribeToUpdates((newConversation) => {
console.log('>> newConversation', newConversation)
})
SignalWireClient.getSubscriberInfo method returns the info about the current subscriberconst subscriber = await client.getSubscriberInfo()
online and offline methods added to SignalWireClient to register/unregister the WebRTC endpointawait client.online()
//or
await client.offline()
sendMessage and getMessages methods added to the conversation namespaceconst result = await client.conversation.getConversations();
const convo = result.data.filter(c => c.id == <address_id>)[0];
convo.sendMessage({
text: 'hello world~',
})
await convo.getMessages()
conversation and the address namespaceawait client.conversation.getConversations({ pageSize: 10 });
await client.conversation.getMessages({ pageSize: 10 });
await client.conversation.getConversationMessages({ pageSize: 10 });
const addressData = await client.address.getAddresses({
type: 'room',
displayName: 'john doe',
pageSize: 10
})
rootElement container (breaking)// register invitation callback for push notification only
client.online({pushNotification: __incomingCallNotification})
// register invitation callback for both push notification and websocket
client.online({all: __incomingCallNotification})
//accept call using the invite notification
function __incomingCallNotification(invite){
const call = await invite.accept(document.getElementById('rootElement'))
}
SignalWireClient.dial and CallInvite.accept methods now accept an optional rootElement parameter to specify where to put the video streaminvite.accept(document.getElementById('rootElement'))
const call = await client.dial({
// ...
rootElement: document.getElementById('rootElement')
});
member.joined event now emitted for all members in a call.joined eventconst call = await client.dial({
to: "/public/some_resource",
video: false, // boolean | MediaTrackConstraints
audio: true, // boolean | MediaTrackConstraints
})
When upgrading to this version from a previous version, please be aware that there may be breaking changes. Please check out our Upgrading to RELAY v4 Guide for more information.
Future updates will adhere to Semantic Versioning. This means you can upgrade with confidence knowing that new versions will not break your version from minor updates.
This marks the release of SignalWires new RELAY Realtime-api v4 SDK. This SDK strives to model the SDK after the concept of PUC (Programmable Unified Communications.) The v4 SDK will include all the namespaces that were originally included in the v3 SDK:
VoiceMessagingChatVideoPubSubTaskSetting Up a Single Client in v4:
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" });
// Access voice functionalities through the unified client
const voiceClient = client.voice;
const messagingClient = client.messaging;
RELAY v4 introduces a new approach, offering more granular control over applications by allowing
listening to events not only on the Call and RoomSession but also on particular sessions through a new method/parameter called listen.
Examples of some sessions that can be directly listened to are: Collects, Recordings, Playback, Detects, etc.
You can now listen to when this particular session has: Started, Updated, Failed, Ended, and some other session-specific events.
Example:
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" })
const voiceClient = client.voice;
// Setup a Voice Client and listen for incoming calls
await voiceClient.listen({
topics: ["office"],
onCallReceived: async (call) => {
call.answer();
console.log("Call received", call.id);
// Start a call collect session
await call.collect({
digits: {
max: 4,
digitTimeout: 10,
terminators: "#"
},
partialResults: true,
sendStartOfInput: true,
listen: {
onStarted: () => {
console.log("Collect started");
},
onInputStarted: (collect) => {
console.log("Collect input started:", collect.result);
},
onUpdated: (collect) => {
console.log("Collect updated:", collect.result);
},
onFailed: (collect) => {
console.log("Collect failed:", collect.result);
},
onEnded: async (collect) => {
console.log("Collect ended:", collect.result);
// Play back the digits collected
await call.playTTS({ text: `You entered ${collect.digits}` });
call.hangup()
}
}
}).onStarted();
}
});
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" })
await client.voice.listen({
topics: ["office"],
onCallReceived: (call) => {
call.answer();
call.playTTS({ text: "Hello world" });
}
});
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here"})
let messageClient = client.messaging;
await messageClient.listen({
topics: ["office"],
async onMessageReceived(message) {
console.log("Received message", message);
const response = await messageClient.send({
from: message.to,
to: message.from,
body: "Hello World!"
});
console.log("Sent message", await response);
}
})
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" })
const chatClient = client.chat;
await chatClient.listen({
channels: ["channel1"],
onMemberJoined: async (member) => {
let members = await chatClient.getMembers({
channel: member.channel
});
let chatMessage = `Hello ${member.id}!
There are ${members.members.length} members in this channel.
The members are: ${members.members.map(m => m.id).join(", ")}`
await chatClient.publish({
channel: member.channel,
content: chatMessage
})
}
});
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" })
const videoClient = client.video;
await videoClient.listen({
onRoomStarted: async (room) => {
console.log("Room started", room.displayName);
},
onRoomEnded: async (room) => {
console.log("Room ended", room.displayName);
},
});
import { SignalWire} from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here" })
const pubSubClient = client.pubSub;
await pubSubClient.listen({
channels: ["welcome"],
onMessageReceived: (message) => {
console.log("Received message:", message);
}
});
import { SignalWire } from "@signalwire/realtime-api";
const client = await SignalWire({ project: "ProjectID Here", token: "Token Here"})
const taskClient = client.task
await taskClient.listen({
topics: ['office'],
onTaskReceived: (payload) => {
console.log('Received task', payload)
}
});
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
sendDigits, which enables users to transmit DTMF (Dual-Tone Multi-Frequency) tones within a RoomSession. This enhancement allows for the sending of specific tone signals, akin to those produced by telephone key presses, directly within the video session environment. room.sendDigits('1')
hand-raise API is a new feature added to Video SDKs for both real-time and browser-based applications. It introduces a visual cue around a participant's video when they 'raise their hand', enhancing interaction in virtual meetings. This API lets participants indicate their wish to speak without interrupting the session. Key features include the ability for participants to raise or lower their hands, and for moderators to prioritize those who have raised their hands, thereby improving the management and structure of participation in online group sessions.// `room` is an instance of a RoomSession
// 'member' is an instance of RoomSessionMember
// Raise hand (browser only)
await room.setRaisedHand()
// Lower hand (browser only)
await room.setRaisedHand({ raised: false })
// Raise hand for a specific member
await room.setRaisedHand({ memberId: '...' })
// Lower hand for a specific member
await room.setRaisedHand({ raised: false, memberId: '...' })
// Enable/disable handraise prioritization
await room.setPrioritizeHandraise(true)
// Raise or lower this member's hand.
await member.setRaisedHand()
// check if a member's hand is raised
console.log(member.handraised)
CallCollect.ended() only when state is NOT collecting and final is either undefined or true, and result.type is a valid END_STATEUpgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
lock and unlock on RoomSessions. This will allow the locking of the RoomSession
which will prevent new members from being able to join. Additionally, room previews are stopped
and replaced with a locked image. The RoomSession can be unlocked through the unlock method.const roomSession = new SignalWire.Video.RoomSession({
token: "<YourRoomToken>",
rootElement: document.getElementById("myVideoElement"),
});
// Short example that locks the room when a member joins and unlocks it when they leave.
roomSession.on("member.joined", (e) => {
roomSession.lock();
});
roomSession.on("member.leave", (e) => {
roomSession.unlock();
});
nodeId. Optional parameter for dialSip and dialPhone that allows you to direct your calls through a specified node. This can help with efficient geolocation routing.try {
const call = await client.dialSip({
from: "sip:xxx@yyy.zz",
to: "sip:ppp@qqq.rr",
timeout: 30,
nodeId: "NODE ID HERE"
});
} catch (e) {
console.log("Call not answered.");
}
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
lock and unlock on RoomSessions. This will allow the locking of the RoomSession which will prevent new members from being able to join. Additionally, room previews are stopped and replaced with a locked image. The RoomSession can be unlocked through the unlock method.const roomSession = new SignalWire.Video.RoomSession({
token: "<YourRoomToken>",
rootElement: document.getElementById("myVideoElement"),
});
// Short example that locks the room when a member joins and unlocks it when they leave.
roomSession.on("member.joined", (e) => {
roomSession.lock();
});
roomSession.on("member.leave", (e) => {
roomSession.unlock();
});
member.updated events to emit them properly.Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This new release of version 3.11 of the Realtime SDK introduces improvements and new additions to Voice and Video.
CallRecordingconst recording = await call.recordingAudio({ direction: "both"});
...
await recording.pause();
const recording = await call.recordingAudio({ direction: "both"});
...
await recording.resume();
detectInterruptions AdditionThis allows the application to restart message delivery to the answering machine when speech activity is detected after the detector is in a READY state.
// Start the detector
const detector = await call.amd({ detectInterruptions: true})
topicNow context or contexts will have a valid alias of topic or topics.
import { Voice } from "@signalwire/realtime-api";
const client = new Voice.Client({
project: "<project-id>",
token: "<api-token>",
topics: ["office"],
});
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
This small release of version 3.10 of the Realtime SDK introduces a new method for Voice calls and fixes a Voice bug.
We have added the call.pass() method to pass an incoming call to another RELAY consumer. 6a35f0a3
This will allow a consumer to decline incoming calls without ending the call and redirect the call to another RELAY client.
client.on("call.received", async (call) => {
await call.pass();
});
setPayload method on the CallTap instance. a7426731Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
SignalWire client. 65b0eea5 This will allow users to access Call Fabric to create calls outside of a namespace as they currently do with a Voice.Client or Video.Client.onRefreshToken to update an access token. b44bd6fb This is a method on the SignalWire client mentioned above.client = await SignalWire({
host: document.getElementById('host').value,
token: document.getElementById('token').value,
rootElement: document.getElementById('rootElement'),
onRefreshToken: async () => {
// Fetch the new token and update the client
const newToken = await fetch('/foo')
await client.updateToken(newToken)
},
})
When the access token is expiring, onRefreshToken will be called to fetch and set a new token without interruption to the client's operation.
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
callStateUrl and callStateEvents parameters on dial and connect Voice Call methods. 4e1116b6Call states you may specify with callStateEvents include created, ringing, answered, ending, and ended.
If callStateUrl and callStateEvents parameters are included when creating or connecting a call:
const call = await client.dialPhone({
to: '+123456',
from: '+19876',
timeout: 30,
callStateUrl: 'http://mydomain.com/hook',
callStateEvents: ['ended', 'answered']
})
the RELAY system will make a request to the specified webhook with the following payload:
"params": {
"event_type": "calling.call.state",
"event_channel": "signalwire_...",
"timestamp": 123457.1234,
"space_id": "<UUID>",
"project_id": "<UUID>",
"params": {
"node_id": "<UUID>",
"call_id": "<UUID>",
"tag": "<ID>",
"device": {
"type": "phone",
"params": {
"from_number": "+15551231234",
"to_number": "+15553214321"
}
},
"parent": {
"node_id": "<UUID>",
"call_id": "<UUID>",
"device_type": "phone"
},
"peer": {
"node_id": "<UUID>",
"call_id": "<UUID>"
},
"call_state": "ended",
"start_time": <time in ms>,
"answer_time": <time in ms>,
"end_time": <time in ms>,
"created_by": "dial"
}
}
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
e8141c0eWe have added updated and disconnected events for microphone, camera, and speaker devices. When listening for microphone update events with
const roomSession = new Video.RoomSession({
host: YOUR_HOST,
token: YOUR_TOKEN,
...
})
roomSession.on('microphone.updated', (payload) => {
console.debug('>> microphone.updated', payload)
});
roomSession.on('microphone.disconnected', (payload) => {
console.debug('>> microphone.disconnected', payload)
});
you will receive the following event payload if a microphone is updated:
{
previous: {
label: 'microphone array',
deviceId: '35e85417-09cf-4b07-8f21-d3c16809e5a8'
},
current: {
label: 'headset',
deviceId: '4a829c9f-812c-49d7-b272-e3077213c55e'
},
}
If the microphone is then disconnected, you will receive the following event:
{
label: 'headset',
deviceId: '4a829c9f-812c-49d7-b272-e3077213c55e'
}
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Version 3.20 of the JavaScript SDK includes a small new feature for Video: local video stream mirroring.
We have exposed the property localOverlay on a Video RoomSession object. The method setMirrored on this new property allows a user to mirror their local video overlay. 2e58a76b
await roomSession.localOverlay.setMirrored(true);
The mirrored local stream is sent to the SignalWire Multipoint Control Unit (MCU), muxed into a single unified stream, and visible to all participants.
You can also unset mirroring with
await roomSession.localOverlay.setMirrored(false);
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Today's JavaScript SDK release includes an improvement for Video and a small fix.
setLocalStream has been added to the Video RoomSession object to update the local media stream. aaa07479const canvas = document.createElement("canvas");
// Interact with the canvas
const stream = canvas.captureStream(25); // 25 FPS
await roomSession.setLocalStream(stream);
See the technical reference for additional examples.
f3711f17Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Version 3.9 of the RELAY Realtime SDK includes a couple of improvements for Voice calls.
Enhanced speech recognition is now available for speech collection. Prompt and Collect methods use a speech configuration object to specify how to collect speech. The new optional key model enables enhanced speech recognition at an added cost with any of three possible values: enhanced, enhanced.phone_call, or enhanced.video. phone_call optimizes speech recognition for phone calls at an 8khz sample rate. video optimizes speech recognition for video calls at a 16khz sample rate. The value enhanced will automatically detect whether to optimize with the phone call or video setting. 4e8e5b0d
const collect = await call.collect({
speech: {
endSilenceTimeout: 1,
speechTimeout: 60,
model: "enhanced",
hints: ["one", "two", "three", "four", "five"]
},
});
const result = await collect.ended();
See our Voice pricing page for pricing information on advanced features.
The parameter maxPricePerMinute has been added to call.dial and call.connect methods to allow users to set a maximum price limit for a call to be created. If the rate for the call is greater than this value, the call will not be created. aa31e1a0
try {
const call = await client.dialPhone({
from: "+YYYYYYYYYY",
to: "+XXXXXXXXXX",
timeout: 30,
maxPricePerMinute: 0.0075,
});
} catch (e) {
console.log("Call not completed.");
}
The cost of a call can vary by rate center and call features. In the example above, if the call charge is greater than $0.0075, the call is not created, and a 30010 error will be returned with the message, "MaxPricePerMinute was exceeded. This call's cost is XX."
]]>Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Version 3.8 of the RELAY Realtime SDK is out now and introduces a new feature for Video: Interactive Live Streaming. Here are the highlights.
Interactive Live Streaming is a Video product that provides a flexible middle ground between RTMP streaming and a Video conference. RTMP streaming allows a user to stream their audio and video to a passive audience, while a video conference allows all users to transmit and receive audio and video. Interactive Live Streaming allows users to experience either state or switch between them in one Video room depending on their role.
member or audienceTo join a Video Room with member abilities to send and receive audio and video or audience permissions
to only receive audio and video, you must generate a Room Token with the appropriate parameters.
try {
let token = await axios.post(
apiurl + "/room_tokens",
{
user_name: user_name,
room_name: room_name,
join_as: "audience",
},
{ auth }
);
console.log(token.data.token);
return res.json({ token: token.data.token });
} catch (e) {
console.log(e);
return res.sendStatus(500);
}
curl -L -X POST "https://$SPACE_URL/api/video/room_tokens" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-u "$PROJECT_ID:$API_TOKEN" \
--data-raw '{
"room_name": "my_room",
"user_name": "John Smith",
"join_as": "audience"
}'
To change the interactivity mode of a participant, the methods promote() and demote()
have been added to the RoomSession object. bc56cc4
promote requires the audience participant's ID, and you may choose to set specific Video Room permissions.
await roomSession.promote({
memberId: "de550c0c-3fac-4efd-b06f-b5b8614b8966",
mediaAllowed: "all",
permissions: [
"room.self.audio_mute",
"room.self.audio_unmute",
"room.self.video_mute",
"room.self.video_unmute",
"room.list_available_layouts",
],
});
Optional parameters on promote include meta, joinAudioMuted and joinVideoMuted.
bc56cc4
See the promote technical reference
for a full list of parameters.
demote removes the participant's ability to send audio and video.
Technical reference
await roomSession.demote({
memberId: "de550c0c-3fac-4efd-b06f-b5b8614b8966",
mediaAllowed: "all",
});
The room.audience_count event is available on the RoomSession object to track the audience count.
It is triggered periodically as audience participants join and leave the room session.
fb83b89
Upgrading is straightforward with our release process, which adheres to Semantic Versioning. Minor versions are guaranteed to not have breaking changes, so you can upgrade with confidence.
Version 3.19 of the JavaScript SDK introduces a new feature for Video: Interactive Live Streaming. Here are the highlights.
Interactive Live Streaming is a Video product that provides a flexible middle ground between RTMP streaming and a Video conference. RTMP streaming allows users to stream their audio and video to a passive audience, while a video conference allows all users to transmit and receive audio and video. Interactive Live Streaming allows users to experience either state or switch between them in one Video room, depending on their role.
member or audienceAs always, the JavaScript SDK join() method will join a Video room. Whether a user joins as member
or audience depends on the room token passed. In the API, The join_as() parameter has been added to the
Video Room Token request to give users member or audience permissions. A member will transmit and receive
audio and video. An audience participant will only receive audio and video.
baf34a8
curl -L -X POST "https://$SPACE_URL/api/video/room_tokens" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-u "$PROJECT_ID:$API_TOKEN" \
--data-raw '{
"room_name": "my_room",
"user_name": "John Smith",
"join_as": "audience"
}'
import * as SignalWire from '@signalwire/js'
const roomSession = new SignalWire.Video.RoomSession({
token: "<YourRoomToken>",
rootElement: document.getElementById("yourVideoElement"),
});
roomSession.join();
The new property interactivityMode is available on the RoomSession object to read the local member's current
interactivity mode (member or audience).
6c4d4b3
To change the interactivity mode of a participant, the methods promote() and demote()
have been added to the RoomSession object.
bc56cc4
promote requires the audience participant's ID, and you may choose to set specific Video Room permissions.
await roomSession.promote({
memberId: "de550c0c-3fac-4efd-b06f-b5b8614b8966",
mediaAllowed: "all",
permissions: [
"room.self.audio_mute",
"room.self.audio_unmute",
"room.self.video_mute",
"room.self.video_unmute",
"room.list_available_layouts",
],
});
Optional parameters on promote include meta, joinAudioMuted, and joinVideoMuted.
bc56cc4
See the promote technical reference
for a complete list of parameters.
demote removes the participant's ability to send audio and video.
Technical reference
await roomSession.demote({
memberId: "de550c0c-3fac-4efd-b06f-b5b8614b8966",
mediaAllowed: "all",
});
member.promoted member.demoted and room.audience_count events are available on the
RoomSession object to track members and audience changes.
fb83b89