Possibly screensharing fix for windows where they get deafened when screensharing with audio

server/src/websocket/handler.ts

@@ -8,18 +8,24 @@ interface WsMessage {
   type: string;
 }
 
+function normalizeDisplayName(value: unknown, fallback = 'User'): string {
+  const normalized = typeof value === 'string' ? value.trim() : '';
+
+  return normalized || fallback;
+}
+
 /** Sends the current user list for a given server to a single connected user. */
 function sendServerUsers(user: ConnectedUser, serverId: string): void {
   const users = Array.from(connectedUsers.values())
     .filter(cu => cu.serverIds.has(serverId) && cu.oderId !== user.oderId)
-    .map(cu => ({ oderId: cu.oderId, displayName: cu.displayName ?? 'Anonymous' }));
+    .map(cu => ({ oderId: cu.oderId, displayName: normalizeDisplayName(cu.displayName) }));
 
   user.ws.send(JSON.stringify({ type: 'server_users', serverId, users }));
 }
 
 function handleIdentify(user: ConnectedUser, message: WsMessage, connectionId: string): void {
   user.oderId = String(message['oderId'] || connectionId);
-  user.displayName = String(message['displayName'] || 'Anonymous');
+  user.displayName = normalizeDisplayName(message['displayName'], normalizeDisplayName(user.displayName));
   connectedUsers.set(connectionId, user);
   console.log(`User identified: ${user.displayName} (${user.oderId})`);
 }
@@ -47,7 +53,7 @@ async function handleJoinServer(user: ConnectedUser, message: WsMessage, connect
   user.serverIds.add(sid);
   user.viewedServerId = sid;
   connectedUsers.set(connectionId, user);
-  console.log(`User ${user.displayName ?? 'Anonymous'} (${user.oderId}) joined server ${sid} (new=${isNew})`);
+  console.log(`User ${normalizeDisplayName(user.displayName)} (${user.oderId}) joined server ${sid} (new=${isNew})`);
 
   sendServerUsers(user, sid);
 
@@ -55,7 +61,7 @@ async function handleJoinServer(user: ConnectedUser, message: WsMessage, connect
     broadcastToServer(sid, {
       type: 'user_joined',
       oderId: user.oderId,
-      displayName: user.displayName ?? 'Anonymous',
+      displayName: normalizeDisplayName(user.displayName),
       serverId: sid
     }, user.oderId);
   }
@@ -66,7 +72,7 @@ function handleViewServer(user: ConnectedUser, message: WsMessage, connectionId:
 
   user.viewedServerId = viewSid;
   connectedUsers.set(connectionId, user);
-  console.log(`User ${user.displayName ?? 'Anonymous'} (${user.oderId}) viewing server ${viewSid}`);
+  console.log(`User ${normalizeDisplayName(user.displayName)} (${user.oderId}) viewing server ${viewSid}`);
 
   sendServerUsers(user, viewSid);
 }
@@ -87,7 +93,7 @@ function handleLeaveServer(user: ConnectedUser, message: WsMessage, connectionId
   broadcastToServer(leaveSid, {
     type: 'user_left',
     oderId: user.oderId,
-    displayName: user.displayName ?? 'Anonymous',
+    displayName: normalizeDisplayName(user.displayName),
     serverId: leaveSid,
     serverIds: Array.from(user.serverIds)
   }, user.oderId);

src/app/core/services/webrtc.service.ts

@@ -825,13 +825,15 @@ export class WebRTCService implements OnDestroy {
    * @param displayName - The user's display name.
    */
   identify(oderId: string, displayName: string, signalUrl?: string): void {
+    const normalizedDisplayName = displayName.trim() || DEFAULT_DISPLAY_NAME;
+
     this.lastIdentifyCredentials = { oderId,
-      displayName };
+      displayName: normalizedDisplayName };
 
     const identifyMessage = {
       type: SIGNALING_TYPE_IDENTIFY,
       oderId,
-      displayName
+      displayName: normalizedDisplayName
     };
 
     if (signalUrl) {
@@ -839,7 +841,15 @@ export class WebRTCService implements OnDestroy {
       return;
     }
 
-    this.sendRawMessage(identifyMessage);
+    const connectedManagers = this.getConnectedSignalingManagers();
+
+    if (connectedManagers.length === 0) {
+      return;
+    }
+
+    for (const { manager } of connectedManagers) {
+      manager.sendRawMessage(identifyMessage);
+    }
   }
 
   /**

src/app/core/services/webrtc/screen-share-platforms/desktop-electron-screen-share.capture.ts

@@ -27,8 +27,14 @@ export class DesktopElectronScreenShareCapture {
     return !!this.dependencies.getElectronApi()?.getSources && !this.isLinuxElectron();
   }
 
-  shouldSuppressRemotePlaybackDuringShare(includeSystemAudio: boolean): boolean {
+  shouldSuppressRemotePlaybackDuringShare(
-    return includeSystemAudio && this.isWindowsElectron();
+    includeSystemAudio: boolean,
+    usingElectronDesktopCapture: boolean
+  ): boolean {
+    // Chromium display-media capture can use own-audio suppression on modern
+    // builds. The Electron desktop-capturer fallback cannot, so keep the old
+    // Windows mute behavior only for that fallback path.
+    return includeSystemAudio && usingElectronDesktopCapture && this.isWindowsElectron();
   }
 
   async startCapture(

src/app/core/services/webrtc/screen-share.manager.ts

@@ -340,7 +340,10 @@ export class ScreenShareManager {
       includeSystemAudio: this.isScreenActive ? includeSystemAudio : false,
       stream: this.isScreenActive ? this.activeScreenStream : null,
       suppressRemotePlayback: this.isScreenActive
-        && this.desktopElectronScreenShareCapture.shouldSuppressRemotePlaybackDuringShare(includeSystemAudio),
+        && this.desktopElectronScreenShareCapture.shouldSuppressRemotePlaybackDuringShare(
+          includeSystemAudio,
+          captureMethod === 'electron-desktop'
+        ),
       forceDefaultRemotePlaybackOutput: this.isScreenActive
         && includeSystemAudio
         && captureMethod === 'linux-electron'

src/app/features/room/rooms-side-panel/rooms-side-panel.component.html

@@ -261,11 +261,11 @@
       }
 
       <!-- Other Online Users -->
-      @if (onlineUsersFiltered().length > 0) {
+      @if (onlineRoomUsers().length > 0) {
         <div class="mb-4">
-          <h4 class="text-xs uppercase tracking-wide text-muted-foreground font-medium mb-2 px-1">Online - {{ onlineUsersFiltered().length }}</h4>
+          <h4 class="text-xs uppercase tracking-wide text-muted-foreground font-medium mb-2 px-1">Online - {{ onlineRoomUsers().length }}</h4>
           <div class="space-y-1">
-            @for (user of onlineUsersFiltered(); track user.id) {
+            @for (user of onlineRoomUsers(); track user.id) {
               <div
                 class="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-secondary/40 group/user"
                 (contextmenu)="openUserContextMenu($event, user)"
@@ -354,7 +354,7 @@
       }
 
       <!-- No other users message -->
-      @if (onlineUsersFiltered().length === 0 && offlineRoomMembers().length === 0) {
+      @if (onlineRoomUsers().length === 0 && offlineRoomMembers().length === 0) {
         <div class="text-center py-4 text-muted-foreground">
           <p class="text-sm">No other users in this server</p>
         </div>

src/app/features/room/rooms-side-panel/rooms-side-panel.component.ts

@@ -104,15 +104,30 @@ export class RoomsSidePanelComponent {
   textChannels = this.store.selectSignal(selectTextChannels);
   voiceChannels = this.store.selectSignal(selectVoiceChannels);
   roomMembers = computed(() => this.currentRoom()?.members ?? []);
-  offlineRoomMembers = computed(() => {
+  roomMemberIdentifiers = computed(() => {
-    const current = this.currentUser();
+    const identifiers = new Set<string>();
-    const onlineIds = new Set(this.onlineUsers().map((user) => user.oderId || user.id));
 
-    if (current) {
+    for (const member of this.roomMembers()) {
-      onlineIds.add(current.oderId || current.id);
+      this.addIdentifiers(identifiers, member);
     }
 
-    return this.roomMembers().filter((member) => !onlineIds.has(this.roomMemberKey(member)));
+    return identifiers;
+  });
+  onlineRoomUsers = computed(() => {
+    const memberIdentifiers = this.roomMemberIdentifiers();
+
+    return this.onlineUsers().filter((user) => !this.isCurrentUserIdentity(user) && this.matchesIdentifiers(memberIdentifiers, user));
+  });
+  offlineRoomMembers = computed(() => {
+    const onlineIdentifiers = new Set<string>();
+
+    for (const user of this.onlineRoomUsers()) {
+      this.addIdentifiers(onlineIdentifiers, user);
+    }
+
+    this.addIdentifiers(onlineIdentifiers, this.currentUser());
+
+    return this.roomMembers().filter((member) => !this.matchesIdentifiers(onlineIdentifiers, member));
   });
   knownUserCount = computed(() => {
     const memberIds = new Set(
@@ -151,18 +166,36 @@ export class RoomsSidePanelComponent {
   volumeMenuPeerId = signal('');
   volumeMenuDisplayName = signal('');
 
-  onlineUsersFiltered() {
-    const current = this.currentUser();
-    const currentId = current?.id;
-    const currentOderId = current?.oderId;
-
-    return this.onlineUsers().filter((user) => user.id !== currentId && user.oderId !== currentOderId);
-  }
-
   private roomMemberKey(member: RoomMember): string {
     return member.oderId || member.id;
   }
 
+  private addIdentifiers(identifiers: Set<string>, entity: { id?: string; oderId?: string } | null | undefined): void {
+    if (!entity)
+      return;
+
+    if (entity.id) {
+      identifiers.add(entity.id);
+    }
+
+    if (entity.oderId) {
+      identifiers.add(entity.oderId);
+    }
+  }
+
+  private matchesIdentifiers(identifiers: Set<string>, entity: { id?: string; oderId?: string }): boolean {
+    return !!((entity.id && identifiers.has(entity.id)) || (entity.oderId && identifiers.has(entity.oderId)));
+  }
+
+  private isCurrentUserIdentity(entity: { id?: string; oderId?: string }): boolean {
+    const current = this.currentUser();
+
+    return !!current && (
+      (typeof entity.id === 'string' && entity.id === current.id)
+      || (typeof entity.oderId === 'string' && entity.oderId === current.oderId)
+    );
+  }
+
   canManageChannels(): boolean {
     const room = this.currentRoom();
     const user = this.currentUser();

src/app/store/rooms/rooms.effects.ts

@@ -60,7 +60,7 @@ function buildSignalingUser(
   data: { oderId: string; displayName?: string },
   extras: Record<string, unknown> = {}
 ) {
-  const displayName = data.displayName || 'User';
+  const displayName = data.displayName?.trim() || 'User';
 
   return {
     oderId: data.oderId,
@@ -98,6 +98,16 @@ function isWrongServer(
   return !!(msgServerId && viewedServerId && msgServerId !== viewedServerId);
 }
 
+function resolveUserDisplayName(user: Pick<User, 'displayName' | 'username'> | null | undefined): string {
+  const displayName = user?.displayName?.trim();
+
+  if (displayName) {
+    return displayName;
+  }
+
+  return user?.username?.trim() || 'User';
+}
+
 interface RoomPresenceSignalingMessage {
   type: string;
   reason?: string;
@@ -1379,7 +1389,7 @@ export class RoomsEffects {
       sourceUrl: room.sourceUrl
     });
     const oderId = resolvedOderId || user?.oderId || this.webrtc.peerId();
-    const displayName = user?.displayName || 'Anonymous';
+    const displayName = resolveUserDisplayName(user);
     const sameSignalRooms = this.getRoomsForSignalingUrl(this.includeRoom(savedRooms, room), wsUrl);
     const backgroundRooms = sameSignalRooms.filter((candidate) => candidate.id !== room.id);
     const joinCurrentEndpointRooms = () => {

src/app/store/users/users.effects.ts

@@ -438,6 +438,25 @@ export class UsersEffects {
     { dispatch: false }
   );
 
+    /** Keep signaling identity aligned with the current profile to avoid stale fallback names. */
+    syncSignalingIdentity$ = createEffect(
+      () =>
+        this.actions$.pipe(
+          ofType(
+            UsersActions.setCurrentUser,
+            UsersActions.loadCurrentUserSuccess
+          ),
+          withLatestFrom(this.store.select(selectCurrentUser)),
+          tap(([, user]) => {
+            if (!user)
+              return;
+
+            this.webrtc.identify(user.oderId || user.id, this.resolveDisplayName(user));
+          })
+        ),
+      { dispatch: false }
+    );
+
   private resolveRoom(roomId: string | undefined, currentRoom: Room | null, savedRooms: Room[]): Room | null {
     if (!roomId)
       return currentRoom;
@@ -448,6 +467,16 @@ export class UsersEffects {
     return savedRooms.find((room) => room.id === roomId) ?? null;
   }
 
+  private resolveDisplayName(user: Pick<User, 'displayName' | 'username'>): string {
+    const displayName = user.displayName?.trim();
+
+    if (displayName) {
+      return displayName;
+    }
+
+    return user.username?.trim() || 'User';
+  }
+
   private toSourceSelector(room: Room): { sourceId?: string; sourceUrl?: string } {
     return {
       sourceId: room.sourceId,