LiveKit Community

Hi <@U044LA1H9D3> have you tried passing empty string  to `room.switchActiveDevice` ?

e.g
`room.switchActiveDevice('audioinput', '')`

Note: You can also pass the deviceId which can be captured via `await Room.getLocalDevices('audioinput')` .
Ref: <https://github.com/livekit/client-sdk-js#device-management-apis>

Hello <@U041NNV5U8N>, yes i tried, on initial work perfectly but when you change the OS default mic. livekit doesnt effect it

Do you get the deviceId of "OS default mic" from `await Room.getLocalDevices('audioinput')` ?

image.png

See in my experience, when I call getLocalDevices, it provide the list, and from that list we can pick the deviceId and use switchActiveDevice to change it in real-time.

livekit,Room.getLocalDevices remove the default devices. so i implement own logic for getDevices and i tired pass the `default` or `''` but didnt switch the device

and your default device is a audiooutput. output works perfectly input not working real-time

That's interesting. As per internal implementation of getLocalDevices , it is also calling the `navigator.mediaDevices.enumerateDevices` at <https://github.com/livekit/client-sdk-js/blob/main/src/room/DeviceManager.ts#L36>, just adding the default at the top:
<https://github.com/livekit/client-sdk-js/blob/main/src/room/DeviceManager.ts#L68>

I think that's the bug, if we call the `Room.getLocalDevices` without any input params, it will keep the first one and remove the other defaults.

<@U044LA1H9D3> can you try calling the function `Room.getLocalDevices` without any input params and see if it's matching the response of `navigator.mediaDevices.enumerateDevices` .

hmm, one `default` deviceId is missing from `Room.getLocalDevices` .
cc: <@U01KZ61GV5Z>

ah, I see the problem, it's due to our filtering. Issue filed: <https://github.com/livekit/client-sdk-js/issues/483>

<@U03SN0JBTJT> Give try on the playground, <https://livekit.io/playground>
It's also on react.

thanks for response <@U041NNV5U8N>, I try :slightly_smiling_face:

Most probably you aren't clicking anywhere before the audio start playing. Without user's interaction from Chrome audio won't play. You will get notification  if you have any function subscribed with `AudioPlaybackStatusChanged`. You can read from here: <https://github.com/livekit/client-sdk-js#audio-playback>

Does roomAdmin grant them the ability to create the room by id?

Does roomJoin allow creation by room id?

I see that roomJoin = true will permit any token holder to re-create a room. Makes sense. I guess it's not too ergonomic for multi-tenancy situations where you have to control how many simultaneous rooms are permitted.

Either you:

1. Generate rooms and tokens on-demand, which is fine, but I'd like to generate, store and update them ahead of time.
2. Or, you generate tokens with canJoin === false, but the express service would have to toggle all of those tokens based on the tenant's usage of resources. 
Gonna go with option 1 for now with short expiration intervals, understanding refresh is automatic once a client has connected.

Ok, so the tokens are immutable. You can update ParticipantPermission and metadata, of course, but a token will get refreshed as its used.

Is it possible to invalidate a token or enforce permanent deletion of a room?

~So far I just see using RoomServiceClient to set max participants to 0.~

I'm concerned that a customer who brings public, unauthenticated users into a room will try to close the room, but clients will refresh the room. Because LK refreshes the tokens for 10-minute intervals, the customer (and I) would not have control other than to turn off publishing/subscribing/data transmission. But, from LK's perspective, the room would remain open, and it will still count against the metering I apply to the customer.

Docs say that a participant who has been removed will still be able to rejoin the room. Say I turn off can_subscribe, can_publish, and can_publish_data, will they still get access to room metadata updates?

Is it possible to prevent a kicked user from getting room metadata updates and data packets from other participants?

Other than to point all data packets at specific participants?

`roomAdmin` doesn't create the room. Rooms are created by either `createRoom` API or when participants join (`auto_create`). you can disable auto_create from the config.

refreshed tokens cannot be re-used once the participant is removed from the room. they are used *only* for reconnecting due to network disruptions.

Given your mention of local storage, I’m assuming you’re building a native app? You couldn’t easily record an entire room, but you could record your own camera/microphone. Clients don’t support this yet, but we’ve started to discuss how we could. :blush: 

Or are you talking simply talking about recording rooms and storing those recordings in a cloud bucket?

I was talking about replacing the cloud bucket with my pc storage.

Egress does livestream to youtube or twitch right? Isn't there a way to create a separate websocket server that receives data from egress and does the rest..

Yes, you can use egress to stream out raw tracks over a websocket. I believe it has to be the raw track type? cc <@U01UB0LHTTQ> 

I am getting this error when trying to stream to youtube, can you guide me what it is? or what am I doing wrong.

this is how I am starting the egress. It starts, but fails

what does your application look like? are you handling the binary frames that are being sent?

I don't think it'll work with <http://nats.io|nats.io>, or crossbar, both have their own websocket protocols

Yes, it didn't work with either of them. So what can it work with? What should I do to make it work?

<https://docs.livekit.io/server/egress/track/#stream-audio-to-websocket>

hello guys,
```_, err = roomClient.CreateRoom(context.Background(), &amp;livekit.CreateRoomRequest{
   Name:            req.MeetingID,
   Metadata:        string(b),
   EmptyTimeout:    uint32(req.MeetingDuration),
   MaxParticipants: 10000,
})```
EmptyTimeout params does not work.
my rooms will only stay 20s.

and in livekit rtc/room.go
```
   if elapsed &gt;= int64(timeout) {
      fmt.Println("elapsed, timeout", elapsed, timeout)
      r.Close()
   }
}```
timeout is 20s

hi, may I know what is the value you have in req.MeetingDuration?

Based on my understanding, you need to pass in the duration in seconds for example 300 if you want the room to remain active for 5 minutes when no one else is in the room.

<https://pkg.go.dev/github.com/livekit/protocol/livekit#CreateRoomRequest>

Yes, that will be the way. During create room you can also set max participants number. If you want to disable to create room automatically using access token then you'll have to disable auto create option from server side: <https://github.com/livekit/livekit/blob/b9894ab0140548807b44a0b1701df7cfbb00a3a1/config-sample.yaml#L121>

Okay so if I understand correctly, if I want to enforce a room size I have to disable auto_create and create the room from the Go SDK every time.

Does the livekit server not remember that last time a room with a certain ID was used it had a specific capacity?

By disabling auto_create option will prevent users to create room automatically by using join token only.

Using create room API you'll have full control on room features. You can read more from here: <https://docs.livekit.io/guides/server-api/#createroom>

mediastreamtrack.jpg

have you tried e.g.

```room.localParticipant.publishTrack(canvasStream.getVideoTracks()[0])```
Note: Above line should use after you received the `LivekitClient.RoomEvent.SignalConnected` event and code didn't fire
```room.localParticipant.setCameraEnabled(true);
room.localParticipant.setMicrophoneEnabled(true);```

Thank you, it works!
I did fire room.localParticipant.setMicrophoneEnabled(true); but it didn't cause any disruption or error. Though I am currently only testing it on 1 laptop with 2 browsers... I will keep that in mind. Thank you!

Make sure you are testing either from localhost or SSL enabled domain

Run connection tester: <https://livekit.io/connection-test> to make sure your livekit server is working correctly.

THnaks <@U02LCP104CQ>, the problem is on the livekit server, it blocks on the Establishing WebRTC connection

self-signed certificates will work or not ??

hey <@U04416C9ZLJ>, appreciate your patience. Hiroshi will respond when he has a moment.

<@U04416C9ZLJ> I didn't implement this part so I don't know the details but I'll try to figure it out. Please give me some time.

<@U01KZ0SCDKL> <@U02MAJLGN65> thank you guys :relaxed:

<@U01NZKTNE1H> can you take a look ? :pray:

hey <@U04416C9ZLJ>, what are you using to enable the screen share?

ah, for the example looks like it wasn't starting it properly, I've pushed a fix to the example

Thanks <@U01NZKTNE1H> , I am pulling the fix.

It’s certainly possible, but complex and more compute-intensive. You’d need to decompress, decode, process/modify, reencode, then recompress each stream you’re interested in. An easier path for the specific use case you mention is a client-side processor which grayscales the video frames before they’re transmitted to the SFU.

Unfortunately in the use case that I am solving, the clients do not do any processing on their side (cameras).
I am aware of the extra compute requirements per stream and we have figured out that it is acceptable for current stage.
Any pointers you can give where the decoding/processing/reencoding should happen?

cc <@U02CM28PB4Y> <@U01KZ61GV5Z> <@U02EU2ZPTQU>

<@U047MQGL0CV> I guess the camera is running LK client and directly talking to the LK server.

Given the processing that would be required. a different service might be the best option.

We have an upcoming RTMP-in based service that is designed to take RTMP input and bridge it to WebRTC and distribute the streams via LK server. Adding some processing pipelines to that service might be another option, but we will have to think through that. Do you have the option of using such a service?

You can also ingest via WebRTC with Pion, then have a server process that receives and processes the streams on your backend.

once processed, you can use our Go SDK to publish to LiveKit for distribution

<@U02CM28PB4Y> Yes, that would be an option.

<@U01KZ61GV5Z> That is also 1 option. I will investigate how to do it. Thanks!

Although I did find that W3C is working on MediaCapture spec that allows to transform media streams. See an example - <https://w3c.github.io/mediacapture-transform/#video-processing>

<@U047MQGL0CV> just saw a post you wrote on HN! Really cool stuff. :slightly_smiling_face: Is this what you were building when this thread started?
<https://news.ycombinator.com/item?id=34221287>

That is for `Dynacast` feature. If you don't want then can disable it. By default it's enabled.

Thank you for jumping in <@U02LCP104CQ>. This is probably not due to dynacast. This looks like a publisher or subscriber side mute.

<@U03T55WRVM3> If you see the `StreamAllocator` log line, it says `MUTED` . That's why the stream is `paused`. `MUTED` condition happens if either the publisher side mutes (camera is disabled) or subscriber disables the track.

Request the server to connect using adaptive_ Stream=0 can solve this problem, thanks

not currently. Opus is the only audio format that the server would negotiate

curious, what is your use case with g711?

The arm device will use the g711 wav codec, and the opus codec will consume a lot of cpu and memory using software codec on these devices.

I see, currently livekit doesn't support it, but we are open to it. Would you be interested in submitting a PR? it should be fairly straight forward to get the server to negotiate it.

There are still some stability problems of audio and video (h264+opus) that need time to deal with.

If the g711 audio is implemented, I will submit it to the platform integration.

I think g711 audio only requires declaring them in the <https://github.com/livekit/livekit/blob/master/pkg/rtc/mediaengine.go|mediaengine> and <https://github.com/livekit/livekit/blob/master/pkg/config/config.go#L248|supported codecs>

It looks great. The client also needs to modify the sdp. I need to verify it. Thanks:+1:

hi david,
that’s a good catch.
The current behaviour for this is certainly not perfect, so feel free to open an issue on github! We’ll want to find a way to make this behave more intuitively and from the first glance I’m leaning towards your first suggestion…

thanks for the feedback. Here's the issue <https://github.com/livekit/client-sdk-js/issues/486>

greetings this may have been asked but i'm new here
i have done the vm setup but i wondering if i can just run livkit on fargate/ecs and use livekit/livekit-server:latest straight out of dockerhub and not have to do all that docker on a VM as it's documented

you just need to build this <https://github.com/livekit/egress/blob/main/build/Dockerfile|dockerfile>

you can build it by running `mage build` <https://github.com/livekit/egress/blob/main/magefile.go#L64>

:wave:  cc <@U02EU2ZPTQU> who i think has played with this before

Figured this out.
Sad that this Slack only has a 90 day search history, but for anyone interested I found how Decentraland was doing this here, using a loopback stream: <https://github.com/decentraland/kernel/blob/72c45ac45a8f8bc0e9650538208fc0bf2e584219/packages/voice-chat-codec/liveKitVoiceHandler.ts>

would love to have the search history, but with almost 1400 folks in here, it’s pretty $$$$

i have a workaround i’m working on, stay tuned :slightly_smiling_face:

Yeah I love slack but think this is why most people use Discord now

I prefer discord but miss a few features from slack

As a product, i prefer Slack, but Discord is definitely more community friendly

hey <@U047ZTF8EHH>
I think you might be interested in a new experimental option that we’ve been testing. you can set `expWebaudioMix: true` in the room options in the latest js client version, which will pipe all audio through web audio. You can then add audio nodes on a track basis by calling `remoteAudioTrack.setWebAudioPlugins([myPannerNode])`.
These options are still marked as experimental and aren’t battle tested yet. would be great to hear your feedback whether this makes your life easier already.
In terms of spatial support, we aim to make this even easier for people in the future, so anything you are willing to share about your specific usecase would help us make decisions also with your usecase in mind :slightly_smiling_face:

Interesting. So currently you don't use Web Audio?

I'm not 100% sure why what i've got works but I had to initialize our listener with this:

```async init() {
  // code inspired by decentraland kernal repo
  // they also use livekit and to get proper positional audio it seems a loopback
  // stream is required, at least in chrome
  const listener = this.engine.audio.listener
  this.destination = listener.context.createMediaStreamDestination()
  this.destinationStream = window.navigator.userAgent.includes('Chrome')
    ? await startLoopback(this.destination.stream)
    : this.destination.stream
  this.audio = new Audio()
  this.audio.srcObject = this.destinationStream
  await this.driver.gesture
  this.audio.play()
}```
After doing that then the following way of connecting tracks works:

```const stream = track.mediaStream
this.source = listener.context.createMediaStreamSource(stream)
this.source.connect(this.isSpatial ? this.panner : this.gain)```

by default livekit uses standard html audio elements for audio output. with the option I mentioned you can change that and don’t have to worry about the loopback stuff.

sounds perfect, but since its not the docs, what are the chances this stays in the API and remains robust?

that’s a fair concern. the idea is definitely to keep this as part of the API,  we marked it experimental for now just in case the feedback from users who try it out would lead us to reconsider how that API is designed. For the sake of robustness it helps of course to have as many people as possible try it out early on :wink:
But I’m pretty sure the general functionality will become part of the client-sdk in the short to midterm future.

If you have it working now with the snippet you posted that’s great! Just in case you still want to try it out via our integrated path, an advantage might be that it would keep you from manually having to work around potential future browser quirks, as we’ll handle them within the package as they come up!

Great, thanks! I'll switch over to this and report back soon

I've got this working but wanted to make sure i'm using it as intended.

With `expWebAudioMix: true` as a Room option, I removed our loopback.
And for each RemoteAudioTrack we basically do this:

```track.setAudioContext(listener.context)
track.attach()
const node = this.isSpatial ? this.panner : this.gain
track.setWebAudioPlugins([node])```
To disconnect we call:

```track.disconnectWebAudio()
track.detach()```
Does this seem about right to you?

I couldn't find anything in your source code that would let me provide my own context so i'm feeling a bit iffy about using `track.setAudioContext` as I think it's a private api

that looks about right!
for disconnect it shouldn’t be required for you to call `disconnectWebAudio` yourself, this is handled within the `detach` function already.
the same is true for `attach`. but you’re raising a good point about not being able to set the audio context from outside via public APIs.
Two things that I’m thinking about:
1. would a custom audioContext be set once via room options (e.g. `expWebAudioMix: { audioContext: myCustomContext}` or is there the need to update the context programatically on demand via something like `room.setAudioContext` 
2. could there be cases where individual tracks would need a different audioContext to the “main” one? If so, we could make that API public 

For me personally a single Room({ audioContext }) option would work really well.

I don't *think* individual tracks would use a different context.

Basically we have a single context that represents the local player (listener)

We're using three.js so try to rely on their constructs as much as possible: <https://threejs.org/docs/#api/en/audio/AudioListener>

Although we introduced a DynamicAudio class that lets you switch between Audio (global) and PositionalAudio (spatial) on the fly without recreating the entire object

Hi there: Here are some examples of how to integrate spatial audio voice chat / positional voice chat with SFU. No LiveKit example included yet, but should help to integrate with LiveKit quite similar. <https://docs.atmoky.com/examples/voicechat/overview>

Which version of egress? All but the one released on Monday have an issue with cpu load computation that could explain this. Hard to tell if it's the issue though. A look at the individual metrics returned by each pod may help

This version could have that issue, depending on the environment where the pod runs. What does the cpu metric exported by the egress service say for all instances??

I’m using the custom metric livekit_egress_available there is another thread where I ask exactly how to use this with hpa in K8s

So far no workable solution has been given

Again, what do you get for the other exported metrics? livekit-node-cpu_load particularly

I will check I was particularly concerned with egress but let me get back to you

kubectl get --raw “/apis/custom.metrics.k8s.io/v1beta1/namespaces/default/pods/*/livekit_node_cpu_load” | jq .
{
 “kind”: “MetricValueList”,
 “apiVersion”: “<http://custom.metrics.k8s.io/v1beta1|custom.metrics.k8s.io/v1beta1>”,
 “metadata”: {},
 “items”: [
  {
   “describedObject”: {
    “kind”: “Pod”,
    “namespace”: “default”,
    “name”: “livekit-egress-766c4c54f-s9jtk”,
    “apiVersion”: “/v1"
   },
   “metricName”: “livekit_node_cpu_load”,
   “timestamp”: “2022-10-28T00:57:38Z”,
   “value”: “27m”,
   “selector”: null
  },
  {
   “describedObject”: {
    “kind”: “Pod”,
    “namespace”: “default”,
    “name”: “livekit-egress-766c4c54f-v2qvt”,
    “apiVersion”: “/v1"
   },
   “metricName”: “livekit_node_cpu_load”,
   “timestamp”: “2022-10-28T00:57:38Z”,
   “value”: “5m”,
   “selector”: null
  }
 ]
}

Anyway I may of solved my problem in another way. Thanks for the assistance

<https://github.com/livekit/client-sdk-js/blob/main/src/room/track/Track.ts#L309>

you can use track.source

I notice that `TrackPublishOptions`  has a `name`  field but it doesn't look like it syncs

This was way easier to add than agora btw

the error will be returned, err is being set in the previous line.

I also just merged this PR to remove named returns as there was a mix. Hopefully, this is easier to read - <https://github.com/livekit/livekit/pull/1124>

hey, confirmed it’s not working on my side either, we’ll investigate!

<@U03EH62ABHQ> can you try if <https://github.com/livekit/client-sdk-js/pull/494> solves it for you too ?

<@U02EU2ZPTQU> Sorry, but i don't know hot to implement it

Updating code in node_modules doesn't work

Everything else is fine, clients are all connected and working. Just the egress blows up.

This doesn't happen on desktop even with Safari, it just seems to be iOS (only tested safari on iOS)

Are you running this on your local dev machine?

<@U01KZ0SCDKL> Also i want to stream to chromecast device. Is it possible?

Anil, this will get you started:
<https://docs.livekit.io/getting-started/server-setup/|https://docs.livekit.io/getting-started/server-setup/>

For streaming to Chromecast, I’m not sure. Maybe <@U01NZKTNE1H> or <@U02MAJLGN65> know?

theoretically yes? if we're talking about doing it yourself, looks like a huge lift since you need to encode the video for hls/dash and serve it off a webserver from your device. I don't have any experience with it personally though

Hey Jonathan, sometimes things slip through the cracks given how busy the team is. It’s absolutely nothing personal. I don’t want you to feel like you’re not asking appropriate questions, or something like that.

Maybe <@U01UB0LHTTQ> or <@U02BBTRGF98> can help with this one?

If you want to keep a minimum of 2 available, you can use `sum(livekit_egress_available) &gt; 1` instead of an average

Thanks @dc and @dsa. I’ve seen that comment in the docs. I tried to set this up with my metrics query to Prometheus but ends up returning no values. I also noticed I can set up a custom metric as part of the helm chart. I tried putting that statement there. That also did not work. Where should this be put?

Is the metric getting scraped by Prometheus and returning a 0 value, or is it not being scraped and returning no result?

With the Boolean expression I get no value can be picked up from the hpa. But doing a kubectl —raw I can see the metric is there but has no values

To get it to work I had a query like this sum(livekit_egress_available) by (&lt;&lt;.Group&gt;&gt;)

Got it, so the raw metric has values, but not when you’re comparing it

That makes sense if you have no pods available

But I have 2 pods available in my cluster

do you know what version of kubernetes you’re running?

I also want to check, are you deploying egress with the helm chart?

I’m using the helm chart you guys provided 

so I think what you’re seeing is correct. the metric value you see in the HPA is the result of dividing the query by the number of pods. so 1 shows that there is 1 available for each of your 2 pods.

Ok cool. So now if the number goes down how do I use that to scale?

Knowing that the scale algorithm is current/target=scaling 

right… the number should be going up. if the number is under the target, it’ll scale down. if its above the target, it’ll scale up

I did as an example if I have 2 pods the current will be 1 and if I have a target of 1 to scale pods I need would need livekit_egress_available to go to 2. From the formula 2/1= 1 so scale up but actuall it goes to 500m/1 if one is in use so no scaling is initiated. It seemed to me I need the inverse or livekit_egress_inuse at least to work how I understand it

I’d suggest switching over to the CPU based scaler instead until I can get some clarity on how best to use the custom scaler

Ok thanks I hope at least it’s clear what I’m talking about now

yes, what you said makes sense! thanks for bringing this up!

if you’re using the average I think you can use `1-livekit_egress_available` so it starts at 0 and goes up

this will still be percentage based, if you want a constant number you’d need something like `{total_instances} - sum(livekit_egress_available)`

I’m not too familiar with k8s/hpa, so I’m not sure what the difference is

There are 2 parts. The query from prometheus that determines the current part of the formula and the target number is given in the hpa object (yaml config file for pod autoscaling)

seems like that would be the prometheus query then

Yes let me see if that works. PromQL is not my forte either

No dice :disappointed:. Seems Prometheus doesn’t allow me to do that. Back to no values given for the metric

<@U01UB0LHTTQ>: Seems I just can’t get the query to work with the regular prometheus-adaptor and altering values in the helm chart

I used keda having just discovered it and it takes the prometheus query directly

Note that I still think it should be livekit_egress_inuse as I ended up doing a query like this to get things to scale as expected

(sum(kube_pod_labels{pod=~“^.*livekit-egress.*“}) - sum(livekit_egress_available))/sum(kube_pod_labels{pod=~“^.*livekit-egress.*“})

Sorry for all the noise seems my prometheus-adaptor foo is weak

Thanks for the updates! Sounds like it works with KEDA and not prometheus-adapter? And you’re now using a query to subtract available from total number of ingress pods.

Yes the value needs to be inverted to work how I would expect in k8s

Awesome. Makes sense! I wonder why Prometheus-adapter didn’t work for you 

Not sure. I left an issue on the github hopefully I’ll get a response. But at least for now I have a solution

Maybe it doesn’t support full promql, but that’s just a guess

Glad you figured it out! We’ll have to update our docs

I think an example of the yaml or helm values used would help alot. The example gives the logic you would need but not how to implement in k8s objects and PromQL

Hey <@U02BBTRGF98> <@U01UB0LHTTQ>: Another update I found out the correct syntax for the prometheus-adaptor should look something like this

  - seriesQuery: ‘livekit_egress_available{namespace!=“”,pod!=“”}’
    resources:
      overrides:
        namespace: {resource: “namespace”}
        pod: {resource: “pod”}
        service: {resource: “service”}
    name:
       matches: “^(.*)_egress_available”
       as: “${1}_recorders_inuse”
    metricsQuery: ‘(sum(kube_pod_labels{pod=~“^.*livekit-egress.*“}) by (&lt;&lt;.GroupBy&gt;&gt;) - sum(livekit_egress_available) by (&lt;&lt;.GroupBy&gt;&gt;))/sum(kube_pod_labels{pod=~“^.*livekit-egress.*“}) by (&lt;&lt;.GroupBy&gt;&gt;)’

that's generally not a good idea. TCP will not give you consistent latency in poor networks due to head of line blocking. You will likely get stuttering video.

you are welcome to try it by setting
```rtc:
  force_tcp: true```

You can use egress: <https://docs.livekit.io/server/egress/|https://docs.livekit.io/server/egress/>

at what point are you calling room.connect? are you registering the event handlers before or after the call to room.connect?

I register handlers before calling room.connect

```const room = new Room()
new LocalState(room)
room.connect(url, token)```

thanks, what you'll want to do is, is to listen to `RoomEvent.Connected` instead of `SignalConnected`

Seems to work! Thanks <@U02EU2ZPTQU>

So SignalConnected means only that I can start calling LocalParticipant.publishTrack, right?

you can use this <https://docs.livekit.io/client-sdk-js/classes/Room.html#switchActiveDevice>

however it’s only supported on chromium based browsers as of now

Uh okay nice, I should have read it better but I assumed it was only for the mic/cam.
Let me look at the implementation, I didn't see the `setSinkId`  being referenced anywhere

and is there a way to retrieve the currently set `audiooutput`?

&gt; <https://docs.livekit.io/client-sdk-js/classes/Room.html#switchActiveDevice|Room.html#switchActiveDevice>
works like a charm

As far as I am aware, there’s currently no way to retrieve the currently set `audioutput`

<@U02EU2ZPTQU> thanks for the feedback, I'll create a Feature Request on Github... Do you want me to create a PR for it or would you rather handle it yourself? (It's not super urgent for me)

I’ll have to check what impact the change would have in different scenarios also depending on which level calls it, so I guess I’ll take a stab at it myself. Thanks for offering!

Here's the issue <https://github.com/livekit/client-sdk-js/issues/497>

ah, sorry got confused with the threads, for this issue feel free to open a PR! I was thinking about the mute thing

okay, which of the approaches do you prefer <@U02EU2ZPTQU>?

you mean between `getActiveDevice` and `getActiveAudioDevice` ?

Do you have any idea how you would want to determine `active` ? would this return `undefined` if no publication of that kind was present? or the default device? :thinking_face:

Hmm good question. I'd start with something like this
```getActiveAudioOutputDevice() {
    // throw exception if setSinkId isn't supported
    const deviceId = this.options.audioOutput.deviceId;
    if(deviceId)
        return deviceId;
    //else either return `undefined` here or go on to:
    //check if we have the permission to access the mic (needed to list the available output devices)
    //if not -&gt; return undefined?
    //if yes -&gt; list available output devices, find 'default' device and translate to the correct device ID
}```

If we go for `getActiveDevice` For the Inputs, I think it should return `undefined` if we don't have any active publication

so for `localTracks` there is already a `getDeviceId` function that handles this. so maybe limiting it to the audioOutput would make sense

Here's a first draft.
Let me know what you think <@U02EU2ZPTQU>
<https://github.com/livekit/client-sdk-js/pull/500>

hi <@U046B0LNLD7>,
thanks for the PR! I think this looks good, just thinking it might make sense to use the `empty string` instead of `undefined` as that seems to be the correct way for “default” device according to the spec: <https://w3c.github.io/mediacapture-output/#attributes>