LiveSwitch SDK Capabilities

WebRTC in general is very secure and LiveSwitch follows the WebRTC spec. We take extra precautions over and above the industry standard to ensure that your private communications are kept safe with LiveSwitch Security. Select the region or country where your app is deployed.

See how AMA XpertEye™ uses LiveSwitch Video and Security to power leading industrial organizations and healthcare professionals with real-time visibility and insights:

AMA_logo_nomargin

All our product’s media pipelines are flexibly designed to allow you to add additional end-to-end encryption that satisfies your industry’s requirements. Keep customer data safe with the highest levels of security including SSL, TLS, DTLS, with 256 bit encryption. All connections use secure X.509 certificates. ls-capabilities-security-DTLS

Encryption

Encryption is a mandatory part of Web Real-Time Communication (WebRTC) and is enforced on all aspects of establishing and maintaining a connection. It makes it effectively impossible for someone to gain access to the contents of a communication stream because all media streams are securely encrypted through standardized and time-tested encryption protocols. Only those applications with the secret encryption key are able to decode the streams.

The best practice for this is to use perfect forward secrecy (PFS) ciphers in a DTLS (Datagram Transport Layer Security) handshake to securely exchange key data (this is the method LiveSwitch uses). For audio and video, key data can then be used to generate AES (Advanced Encryption Standard) keys which are in turn used by SRTP (Secure Real-time Transport Protocol) to encrypt and decrypt the media. This acronym-rich stack of technologies translates to extremely secure connections that are impossible to break with current technology. Both WebRTC and ORTC mandate this particular stack, which is backwards-compatible and interoperable with VoIP systems.

With LiveSwitch Security you get full control of information flow (deploy on-prem):

LiveSwitch is a North America based company → unlocks opportunities for companies who don’t want risk of data flowing through other countries
Industry regulations
Country compliance / regulations (GDPR)
Corporate security concerns

What else you need to know about LiveSwitch Security:

Browser Protection

No more Plug-ins
Fast Security Patches
Automatic Updates

Flexible Media Pipeline Access - 5 really important points:

[1.Capture Source] → [2.Pre-Process] → [Send] → [3.Server] → [Receive] → [4.Post-Process] → [5.Render Sink]

Our media provides a set of defaults. So if you use LiveSwitch SDK and a browser, you get access to basically a webcam and microphones as the input sources. And then on the render side, you get access to a speaker and a display, right? You see it on your screen and you can hear somebody's voice coming out. The other side: those are the defaults we ship. But our customers like to do interesting things, and what the media pipeline access lets you do is manipulate that media.

ls-core-product-flexible-media-pipeline-customization-diagram

1. Capture Source

We have standard configurations like connecting a camera or a mic but then we give people the flexibility to plug any source in. For instance: a Microsoft Hololens. You could do a doorbell ring. You could do a camera attached inside the cockpit of a fighter plane. This is LiveSwitch Flexible Media Pipeline.

2. Pre-process

This comes right after the source. For example: blurring backgrounds. So you're intercepting the video feed, detecting the body form within that feed, and then blurring out the background and that's what gets put on the network and sent out.

3. Server

One common scenario is people want transcripts or live closed captioning. So we've put a component that sits in the sever and listens to the audio flow. We grab the audio and push it to Microsoft's cognitive services—which analyzes it and turns it into text. Then we turn around and pump that information back into the conference call (or whatever kind of call it is) so that the information can then be used to display some sort of closed captioning. But there's some sort of manipulation happening on the server specifically.

4. Post-process/Pre-Render

This is before you render the video feed or audio feed and you want to do some sort of processing to it. A good example of this: oftentimes if you're doing something pre-render you're also doing something pre-send/pre-process.

Here's an example that does this: there is an AI project out there that will take a video feed, grab the face out of it, blow that face up that it takes up the vast majority of the screen real estate, so that the face is high-def even if the rest of the image is not, but, of course, it blows it up and the image comes through all distorted—metadata is sent with that feed—so that on the received side, that image can then be squished back to normal. But because it was large when it was encoded—when you squish it back to normal—it's higher resolution than the rest of the image. However, you have to pass information through. So there's a step that happens on the send side. And then there's a step that happens on the receive side to basically undo what happened on the send side. The result is: as you end up with much higher quality looking people and a video feed. Without that interception step before render there is no mechanism for you to do that. And then the last step is actually the render itself and a very common scenario for that one is if you just want to render to a file.

5. Render Sink

Rendered video/file or recording.

      
        Copied
      
      
      
        // Create a client to interact with the server

        var client = new Client("https://cloud.livewitch.io", "my-app-id", "my-user-id", "my-device-id");

        var claims = new[] { new ChannelClaim("my-channel-id") };



        // Securely generate a registration token

        var token = GenerateToken(client, claims);



        // Register the client with the server

        var channels = await client.Register(token);



        // Open an MCU (or SFU or peer) connection to send/receive data

        var connection = channels[0].CreateMcu/Sfu/PeerConnection(...);
        
      
      
      
        // Create a client to interact with the server

        const client = new fm.liveswitch.Client("https://cloud.liveswitch.io", "my-app-id", "my-user-id", "my-device-id");

        const claims = [ new fm.liveswitch.ChannelClaim("my-channel-id") ];



        // Securely generate a registration token

        const token = generateToken(client, claims);



        // Register the client with the server

        const channels = await client.register(token);



        // Open an MCU (or SFU or peer) connection to send/receive data

        const connection = channels[0].createMcu/Sfu/PeerConnection(...);
        
      
      
      
        import fm.liveswitch.*;



        // Create a client to interact with the server

        Client client = new Client("https://cloud.livewitch.io", "my-app-id", "my-user-id", "my-device-id");

        ChannelClaim[] claims = new ChannelClaim[] { new ChannelClaim("my-channel-id") };



        // Securely generate a registration token

        Token token = GenerateToken(client, claims);



        // Register the client with the server

        Channel[] channels = await(client.Register(token));



        // Open an MCU (or SFU or peer) connection to send/receive data

        ManagedConnection connection = channels[0].CreateMcu/Sfu/PeerConnection(...);
        
      
      
      
        // Create a client to interact with the server

        let client = FMLiveSwitchClient.init(gatewayUrl: "https://cloud.livewitch.io", applicationId: "my-app-id", userId: "my-user-id", deviceId: "my-device-id");

        let claims: NSMutableArray = [];

        claims.add(FMLiveSwitchChannelClaim.init(id: "my-channel-id"));



        // Securely generate a registration token

        let token = self.generateToken(withClient: client, withClaims: claims);



        // Register the client with the server

        let channels = try await client.register(withToken: token);



        // Open an MCU (or SFU or peer) connection to send/receive data

        let connection = channels[0].createMcu/Sfu/PeerConnection(...);