Search Results for

    Show / Hide Table of Contents

    Mute and Unmute Other Participants

    In a SIP call or a regular conference, anyone can mute or unmute themselves or others locally. If a client requires the ability to mute or unmute a participant globally in a channel so that no one can see and hear the person, they must have appropriate permissions assigned. To grant a client the permissions, see Grant Client Permissions.

    To mute or unmute audio or video in a channel:

    1. Turn on or off the audio or video in the following channel configurations:

      • For all connections: channelConfig
      • For all connections belonging to a specific user: channelUserConfig
      • For all connections belonging to a specific user and device: channelDeviceConfig
      • For all connections belonging to a specific user, device, and client: channelClientConfig
      • For a specific connection belonging to a specific user, device, and client: channelConnectionConfig
    2. Pass the configurations to the following methods of the channel:

      • For all connections: update
      • For all connections belonging to a specific user: updateUser
      • For all connections belonging to a specific user and device: updateDevice
      • For all connections belonging to a specific user, device, and client: updateClient
      • For a specific connection belonging to a specific user, device, and client: udpateConnection
    Note

    About the code examples on this page:

    • For .NET MAUI and Unity, use the C# code.
    • For macOS, use the iOS code.
    • CSharp
    • Android
    • iOS
    • JavaScript
    public Future<object> ToggleAudioMuted(bool audioMuted)
    {
        var channelConfig = new ChannelConfig();
        channelConfig.AudioMuted = audioMuted;
        return _Channel.Update(channelConfig);
    }
    
    public Future<object> ToggleVideoMuted(bool videoMuted)
    {
        var channelConfig = new ChannelConfig();
        channelConfig.VideoMuted = videoMuted;
        return _Channel.Update(channelConfig);
    }
    
    public Future<object> ToggleUserAudioMuted(string userId, bool audioMuted)
    {
        var channelUserConfig = new ChannelUserConfig();
        channelUserConfig.AudioMuted = audioMuted;
        return _Channel.UpdateUser(userId, channelUserConfig);
    }
    
    public Future<object> ToggleUserVideoMuted(string userId, bool videoMuted)
    {
        var channelUserConfig = new ChannelUserConfig();
        channelUserConfig.VideoMuted = videoMuted;
        return _Channel.UpdateUser(userId, channelUserConfig);
    }
    
    public Future<object> ToggleDeviceAudioMuted(string userId, string deviceId, bool audioMuted)
    {
        var channelDeviceConfig = new ChannelDeviceConfig();
        channelDeviceConfig.AudioMuted = audioMuted;
        return _Channel.UpdateDevice(userId, deviceId, channelDeviceConfig);
    }
    
    public Future<object> ToggleDeviceVideoMuted(string userId, string deviceId, bool videoMuted)
    {
        var channelDeviceConfig = new ChannelDeviceConfig();
        channelDeviceConfig.VideoMuted = videoMuted;
        return _Channel.UpdateDevice(userId, deviceId, channelDeviceConfig);
    }
    
    public Future<object> ToggleClientAudioMuted(string userId, string deviceId, string clientId, bool audioMuted)
    {
        var channelClientConfig = new ChannelClientConfig();
        channelClientConfig.AudioMuted = audioMuted;
        return _Channel.UpdateClient(userId, deviceId, clientId, channelClientConfig);
    }
    
    public Future<object> ToggleClientVideoMuted(string userId, string deviceId, string clientId, bool videoMuted)
    {
        var channelClientConfig = new ChannelClientConfig();
        channelClientConfig.VideoMuted = videoMuted;
        return _Channel.UpdateClient(userId, deviceId, clientId, channelClientConfig);
    }
    
    public Future<object> ToggleConnectionAudioMuted(string userId, string deviceId, string clientId, string connectionId, bool audioMuted)
    {
        var channelConnectionConfig = new ChannelConnectionConfig();
        channelConnectionConfig.AudioMuted = audioMuted;
        return _Channel.UpdateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
    }
    
    public Future<object> ToggleConnectionVideoMuted(string userId, string deviceId, string clientId, string connectionId, bool videoMuted)
    {
        var channelConnectionConfig = new ChannelConnectionConfig();
        channelConnectionConfig.VideoMuted = videoMuted;
        return _Channel.UpdateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
    }
    

    See also:

    • update
    • updateUser
    • updateDevice
    • updateClient
    • updateConnection
    public Future<Object> setAudioMuted(NullableBoolean audioMuted) {
        ChannelConfig channelConfig = new ChannelConfig();
        channelConfig.setAudioMuted(audioMuted);
        return this.channel.update(channelConfig);
    }
    
    public Future<Object> setVideoMuted(NullableBoolean videoMuted) {
        ChannelConfig channelConfig = new ChannelConfig();
        channelConfig.setVideoMuted(videoMuted);
        return this.channel.update(channelConfig);
    }
    
    public Future<Object> setUserAudioMuted(String userId, NullableBoolean audioMuted) {
        ChannelUserConfig channelUserConfig = new ChannelUserConfig();
        channelUserConfig.setAudioMuted(audioMuted);
        return this.channel.updateUser(userId, channelUserConfig);
    }
    
    public Future<Object> setUserVideoMuted(String userId, NullableBoolean videoMuted) {
        ChannelUserConfig channelUserConfig = new ChannelUserConfig();
        channelUserConfig.setVideoMuted(videoMuted);
        return this.channel.updateUser(userId, channelUserConfig);
    }
    
    public Future<Object> setDeviceAudioMuted(String userId, String deviceId, NullableBoolean audioMuted) {
        ChannelDeviceConfig channelDeviceConfig = new ChannelDeviceConfig();
        channelDeviceConfig.setAudioMuted(audioMuted);
        return this.channel.updateDevice(userId, deviceId, channelDeviceConfig);
    }
    
    public Future<Object> setDeviceVideoMuted(String userId, String deviceId, NullableBoolean videoMuted) {
        ChannelDeviceConfig channelDeviceConfig = new ChannelDeviceConfig();
        channelDeviceConfig.setVideoMuted(videoMuted);
        return this.channel.updateDevice(userId, deviceId, channelDeviceConfig);
    }
    
    public Future<Object> setClientAudioMuted(String userId, String deviceId, String clientId, NullableBoolean audioMuted) {
        ChannelClientConfig channelClientConfig = new ChannelClientConfig();
        channelClientConfig.setAudioMuted(audioMuted);
        return this.channel.updateClient(userId, deviceId, clientId, channelClientConfig);
    }
    
    public Future<Object> setClientVideoMuted(String userId, String deviceId, String clientId, NullableBoolean videoMuted) {
        ChannelClientConfig channelClientConfig = new ChannelClientConfig();
        channelClientConfig.setVideoMuted(videoMuted);
        return this.channel.updateClient(userId, deviceId, clientId, channelClientConfig);
    }
    
    public Future<Object> setConnectionAudioMuted(String userId, String deviceId, String clientId, String connectionId, NullableBoolean audioMuted) {
        ChannelConnectionConfig channelConnectionConfig = new ChannelConnectionConfig();
        channelConnectionConfig.setAudioMuted(audioMuted);
        return this.channel.updateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
    }
    
    public Future<Object> setConnectionVideoMuted(String userId, String deviceId, String clientId, String connectionId, NullableBoolean videoMuted) {
        ChannelConnectionConfig channelConnectionConfig = new ChannelConnectionConfig();
        channelConnectionConfig.setVideoMuted(videoMuted);
        return this.channel.updateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
    }
    

    See also:

    • update
    • updateUser
    • updateDevice
    • updateClient
    • updateConnection
    func setAudioMuted(audioMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelConfig = FMLiveSwitchChannelConfig()
        channelConfig?.setAudioMuted(audioMuted)
        return _channel?.update(withNewConfig: channelConfig)
    }
    
    func setVideoMuted(videoMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelConfig = FMLiveSwitchChannelConfig()
        channelConfig?.setVideoMuted(videoMuted)
        return _channel?.update(withNewConfig: channelConfig)
    }
    
    func setUserAudioMuted(userId: String, audioMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelUserConfig = FMLiveSwitchChannelUserConfig()
        channelUserConfig?.setAudioMuted(audioMuted)
        return _channel?.updateUser(withUserId: userId, newConfig: channelUserConfig)
    }
    
    func setUserVideoMuted(userId: String, videoMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelUserConfig = FMLiveSwitchChannelUserConfig()
        channelUserConfig?.setVideoMuted(videoMuted)
        return _channel?.updateUser(withUserId: userId, newConfig: channelUserConfig)
    }
    
    func setDeviceAudioMuted(userId: String, deviceId: String, audioMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelDeviceConfig = FMLiveSwitchChannelDeviceConfig()
        channelDeviceConfig?.setAudioMuted(audioMuted)
        return _channel?.updateDevice(withUserId: userId, deviceId: deviceId, newConfig: channelDeviceConfig)
    }
    
    func setDeviceVideoMuted(userId: String, deviceId: String, videoMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelDeviceConfig = FMLiveSwitchChannelDeviceConfig()
        channelDeviceConfig?.setVideoMuted(videoMuted)
        return _channel?.updateDevice(withUserId: userId, deviceId: deviceId, newConfig: channelDeviceConfig)
    }
    
    func setClientAudioMuted(userId: String, deviceId: String, clientId: String, audioMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelClientConfig = FMLiveSwitchChannelClientConfig()
        channelClientConfig?.setAudioMuted(audioMuted)
        return _channel?.updateClient(withUserId: userId, deviceId: deviceId, clientId: clientId, newConfig: channelClientConfig)
    }
    
    func setClientVideoMuted(userId: String, deviceId: String, clientId: String, videoMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelClientConfig = FMLiveSwitchChannelClientConfig()
        channelClientConfig?.setVideoMuted(videoMuted)
        return _channel?.updateClient(withUserId: userId, deviceId: deviceId, clientId: clientId, newConfig: channelClientConfig)
    }
    
    func setConnectionAudioMuted(userId: String, deviceId: String, clientId: String, connectionId: String, audioMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelConnectionConfig = FMLiveSwitchChannelConnectionConfig()
        channelConnectionConfig?.setAudioMuted(audioMuted)
        return _channel?.updateConnection(withUserId: userId, deviceId: deviceId, clientId: clientId, connectionId: connectionId, newConfig: channelConnectionConfig)
    }
    
    func setConnectionVideoMuted(userId: String, deviceId: String, clientId: String, connectionId: String, videoMuted: FMLiveSwitchNullableBool) -> FMLiveSwitchFuture? {
        let channelConnectionConfig = FMLiveSwitchChannelConnectionConfig()
        channelConnectionConfig?.setVideoMuted(videoMuted)
        return _channel?.updateConnection(withUserId: userId, deviceId: deviceId, clientId: clientId, connectionId: connectionId, newConfig: channelConnectionConfig)
    }
    

    See also:

    • update
    • updateUser
    • updateDevice
    • updateClient
    • updateConnection
    setAudioMuted(audioMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelConfig = new liveswitch.ChannelConfig();
            channelConfig.setAudioMuted(audioMuted);
            yield this.channel.update(channelConfig);
        });
    }
    setVideoMuted(videoMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelConfig = new liveswitch.ChannelConfig();
            channelConfig.setVideoMuted(videoMuted);
            yield this.channel.update(channelConfig);
        });
    }
    setUserAudioMuted(userId, audioMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelUserConfig = new liveswitch.ChannelUserConfig();
            channelUserConfig.setAudioMuted(audioMuted);
            yield this.channel.updateUser(userId, channelUserConfig);
        });
    }
    setUserVideoMuted(userId, videoMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelUserConfig = new liveswitch.ChannelUserConfig();
            channelUserConfig.setVideoMuted(videoMuted);
            yield this.channel.updateUser(userId, channelUserConfig);
        });
    }
    setDeviceAudioMuted(userId, deviceId, audioMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelDeviceConfig = new liveswitch.ChannelDeviceConfig();
            channelDeviceConfig.setAudioMuted(audioMuted);
            yield this.channel.updateDevice(userId, deviceId, channelDeviceConfig);
        });
    }
    setDeviceVideoMuted(userId, deviceId, videoMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelDeviceConfig = new liveswitch.ChannelDeviceConfig();
            channelDeviceConfig.setVideoMuted(videoMuted);
            yield this.channel.updateDevice(userId, deviceId, channelDeviceConfig);
        });
    }
    setClientAudioMuted(userId, deviceId, clientId, audioMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelClientConfig = new liveswitch.ChannelClientConfig();
            channelClientConfig.setAudioMuted(audioMuted);
            yield this.channel.updateClient(userId, deviceId, clientId, channelClientConfig);
        });
    }
    setClientVideoMuted(userId, deviceId, clientId, videoMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelClientConfig = new liveswitch.ChannelClientConfig();
            channelClientConfig.setVideoMuted(videoMuted);
            yield this.channel.updateClient(userId, deviceId, clientId, channelClientConfig);
        });
    }
    setConnectionAudioMuted(userId, deviceId, clientId, connectionId, audioMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelConnectionConfig = new liveswitch.ChannelConnectionConfig();
            channelConnectionConfig.setAudioMuted(audioMuted);
            yield this.channel.updateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
        });
    }
    setConnectionVideoMuted(userId, deviceId, clientId, connectionId, videoMuted) {
        return __awaiter(this, void 0, void 0, function* () {
            let channelConnectionConfig = new liveswitch.ChannelConnectionConfig();
            channelConnectionConfig.setVideoMuted(videoMuted);
            yield this.channel.updateConnection(userId, deviceId, clientId, connectionId, channelConnectionConfig);
        });
    }
    

    See also:

    • update
    • updateUser
    • updateDevice
    • updateClient
    • updateConnection
    In This Article
    Back to top Copyright © LiveSwitch Inc. All Rights Reserved.Documentation for LiveSwitch Version 1.24.5