libervia-web: libervia/web/pages/calls/_browser/__init_

comparison libervia/web/pages/calls/_browser/init.py @ 1616:6bfeb9f0fb84

browser (calls): conferences implementation: - Handle A/V conferences calls creation/joining by entering a conference room JID in the search box. - Group call box has been improved and is used both for group calls (small number of participants) and A/V conferences (larger number of participants). - Fullscreen button for group call is working. - Avatar/user nickname are shown in group call on peer user, as an overlay on video stream. - Use `user` metadata when present to display the right user avatar/name when receiving a stream from SFU (i.e. A/V conference). - Peer user have a new 3 dots menu with a `pin` item to (un)pin it (i.e. display it on full container with on top). - Updated webrtc to handle unidirectional streams correctly and to adapt to A/V conference specification. rel 448

author	Goffi <goffi@goffi.org>
date	Wed, 07 Aug 2024 00:01:57 +0200
parents	4a9679369856
children

comparison

equal deleted inserted replaced

-:97ea776df74c
+:6bfeb9f0fb84
 from template import Template
 from webrtc import WebRTC
 log.warning = log.warn
 profile = window.profile or ""
+own_jid = JID(window.own_jid)
 bridge = Bridge()
 GATHER_TIMEOUT = 10000
 ALLOWED_STATUSES = (
 None,
 "dialing",
 local_video_elt=document["local_video"],
 remote_video_elt=document["remote_video"]
 )
 # mapping of file sending
 self.files_webrtc: list[dict] = []
-# WebRTC instances used for group calls.
 self.mode = "search"
 self._status = None
 self._callee: JID|None = None
 self._group_call_room: JID|None = None
 self._group_call_peers: dict = {}
+self.is_conference = False
 self.contacts_elt = document["contacts"]
 self.search_container_elt = document["search_container"]
 self.call_container_elt = document["call_container"]
 self.group_call_container_elt = document["group_call_container"]
 self.call_box_elt = document["call_box"]
 # other buttons
 document["full_screen_btn"].bind("click", lambda __: self.toggle_fullscreen())
 document["exit_full_screen_btn"].bind(
 "click", lambda __: self.toggle_fullscreen()
+)
+document["group_full_screen_btn"].bind(
+"click",
+lambda __: self.toggle_fullscreen(group=True)
+)
+document["group_exit_full_screen_btn"].bind(
+"click",
+lambda __: self.toggle_fullscreen(group=True)
 )
 document["mute_audio_btn"].bind("click", self.toggle_audio_mute)
 document["mute_video_btn"].bind("click", self.toggle_video_mute)
 self.share_desktop_col_elt = document["share_desktop_column"]
 if hasattr(window.navigator.mediaDevices, "getDisplayMedia"):
 aio.run(self.on_group_call_proposal(action_data, action_id))
 elif type_ != "call":
 return
 elif MUJI_PREFIX in action_data.get("from_jid", ""):
 aio.run(self.on_group_call_join(action_data, action_id))
+elif self.is_conference and action_data["from_jid"] == self._callee:
+aio.run(self.on_conference_call_join(action_data, action_id))
 else:
 aio.run(self.on_action_new(action_data, action_id))
 def get_human_size(self, size: int|float) -> str:
 """Return size in human-friendly size using SI units"""
 if peer_jid.bare != self._group_call_room:
 log.warning(
 f"Refusing group call join as were are not expecting any from this room.\n"
 f"{peer_jid.bare=} {self._group_call_room=}"
 )
+return
 log.info(f"{peer_jid} joined the group call.")
 group_video_grid_elt = document["group_video_grid"]
 await cache.fill_identities([peer_jid])
 group_peer_elt = self.group_peer_tpl.get_elt({
 "entity": str(peer_jid),
-# "identities": cache.identities,
+"identities": cache.identities,
 })
+for pin_item in group_peer_elt.select('.action_pin'):
+pin_item.bind('click', self.toggle_pin)
 group_video_grid_elt <= group_peer_elt
 peer_video_stream_elt = group_peer_elt.select_one(".peer_video_stream")
 assert peer_video_stream_elt is not None
 webrtc = WebRTC(
 remote_video_elt=peer_video_stream_elt
 )
 "element": group_peer_elt,
 "sid": sid
 }
 log.debug(f"Call SID: {sid}")
+await bridge.action_launch(action_id, json.dumps({"cancelled": False}))
+async def on_conference_call_join(self, action_data: dict, action_id: str) -> None:
+log.debug(f"on_conference_call_join {action_data=}")
+peer_jid = JID(action_data["from_jid"])
+try:
+user_jid = JID(action_data["metadata"]["user"])
+except KeyError:
+user_jid = peer_jid
+log.info(f"{user_jid} joined the conference call.")
+group_video_grid_elt = document["group_video_grid"]
+await cache.fill_identities([str(user_jid)])
+group_peer_elt = self.group_peer_tpl.get_elt({
+"entity": str(user_jid),
+"identities": cache.identities,
+})
+for pin_item in group_peer_elt.select('.action_pin'):
+pin_item.bind('click', self.toggle_pin)
+group_video_grid_elt <= group_peer_elt
+peer_video_stream_elt = group_peer_elt.select_one(".peer_video_stream")
+assert peer_video_stream_elt is not None
+log.debug(f"starting webrtc for {peer_jid} on {peer_video_stream_elt}")
+webrtc = WebRTC(
+remote_video_elt=peer_video_stream_elt
+)
+sid = webrtc.sid = action_data["session_id"]
+self._group_call_peers[peer_jid] = {
+"webrtc": webrtc,
+"element": group_peer_elt,
+"sid": sid
+}
+log.debug(f"Somebody joined conference call. SID: {sid}")
 await bridge.action_launch(action_id, json.dumps({"cancelled": False}))
 async def on_action_new(self, action_data: dict, action_id: str) -> None:
 peer_jid = JID(action_data["from_jid"]).bare
 )
 return
 if role == "initiator":
 await webrtc.accept_call(session_id, sdp, profile)
 elif role == "responder":
-await webrtc.answer_call(session_id, sdp, profile)
+await webrtc.answer_call(
+session_id, sdp, profile, conference=self.is_conference
+)
 else:
 dialog.notification.show(
 f"Invalid role received during setup: {setup_data}", level="error"
 )
 return
 entity_jid = JID(entity_jid_s)
 log.info(f"Calling {entity_jid_s}.")
 await cache.fill_identities([entity_jid])
 group_peer_elt = self.group_peer_tpl.get_elt({
 "entity": str(entity_jid),
-# "identities": cache.identities,
+"identities": cache.identities,
 })
+for pin_item in group_peer_elt.select('.action_pin'):
+pin_item.bind('click', self.toggle_pin)
 group_video_grid_elt <= group_peer_elt
 peer_video_stream_elt = group_peer_elt.select_one(".peer_video_stream")
 assert peer_video_stream_elt is not None
 webrtc = WebRTC(
 remote_video_elt=peer_video_stream_elt,
 def on_reset_cb(self) -> None:
 """Call when webRTC connection is reset, we reset buttons statuses"""
 document["full_screen_btn"].classList.remove("is-hidden")
 document["exit_full_screen_btn"].classList.add("is-hidden")
+document["group_full_screen_btn"].classList.remove("is-hidden")
+document["group_exit_full_screen_btn"].classList.add("is-hidden")
 for btn_elt in document["mute_audio_btn"], document["mute_video_btn"]:
 btn_elt.classList.remove(INACTIVE_CLASS, MUTED_CLASS, "is-warning")
 btn_elt.classList.add("is-success")
 async def make_call(
 )
 return
 self._callee = callee_jid
 await cache.fill_identities([callee_jid])
+self.is_conference = False
+try:
+disco_identities = cache.identities[callee_jid]["identities"]
+except KeyError:
+pass
+else:
+for disco_identity in disco_identities:
+if (
+disco_identity.get("category") == "conference"
+and disco_identity.get("type") == "audio-video"
+):
+self.is_conference = True
+log.info(f"{callee_jid} is an A/V Conference room.")
 self.status = "dialing"
 self.set_avatar(callee_jid)
-self.switch_mode("call")
+self.switch_mode("group_call" if self.is_conference else "call" )
 if remote:
 await self.webrtc.start_remote_control(
 callee_jid, audio, video
 )
 else:
-await self.webrtc.make_call(callee_jid, audio, video)
+if self.is_conference:
+direction = "sendonly"
+group_video_grid_elt = document["group_video_grid"]
+await cache.fill_identities([str(own_jid.bare)])
+group_peer_elt = self.group_peer_tpl.get_elt({
+"entity": str(own_jid.bare),
+"identities": cache.identities,
+})
+for pin_item in group_peer_elt.select('.action_pin'):
+pin_item.bind('click', self.toggle_pin)
+group_video_grid_elt <= group_peer_elt
+peer_video_stream_elt = group_peer_elt.select_one(".peer_video_stream")
+assert peer_video_stream_elt is not None
+self.webrtc.local_video_elt = peer_video_stream_elt
+else:
+direction = "sendrecv"
+self.webrtc.local_video_elt = document["local_video"]
+await self.webrtc.make_call(
+callee_jid,
+audio,
+video,
+direction
+)
 async def make_group_call(
 self,
 ) -> None:
 """Start a group call.
 for elt_id in to_hide:
 document[elt_id].parent.classList.add("is-hidden")
 for elt_id in to_show:
 document[elt_id].parent.classList.remove("is-hidden")
-def toggle_fullscreen(self, fullscreen: bool | None = None):
+def toggle_fullscreen(self, fullscreen: bool | None = None, group=False):
 """Toggle fullscreen mode for video elements.
 @param fullscreen: if set, determine the fullscreen state; otherwise,
 the fullscreen mode will be toggled.
 """
 if fullscreen is None:
 fullscreen = document.fullscreenElement is NULL
+log.debug(f"toggle_fullscreen {fullscreen=} {group=}")
+full_screen_cls = "full_screen_btn"
+exit_full_screen_cls = "exit_full_screen_btn"
+if group:
+full_screen_cls = f"group_{full_screen_cls}"
+exit_full_screen_cls = f"group_{exit_full_screen_cls}"
+parent_elt = self.group_call_container_elt
+else:
+parent_elt = self.call_box_elt
 try:
 if fullscreen:
 if document.fullscreenElement is NULL:
-self.call_box_elt.requestFullscreen()
+parent_elt.requestFullscreen()
-document["full_screen_btn"].classList.add("is-hidden")
+document[full_screen_cls].classList.add("is-hidden")
-document["exit_full_screen_btn"].classList.remove("is-hidden")
+document[exit_full_screen_cls].classList.remove("is-hidden")
 else:
 if document.fullscreenElement is not NULL:
 document.exitFullscreen()
-document["full_screen_btn"].classList.remove("is-hidden")
+document[full_screen_cls].classList.remove("is-hidden")
-document["exit_full_screen_btn"].classList.add("is-hidden")
+document[exit_full_screen_cls].classList.add("is-hidden")
 except Exception as e:
 dialog.notification.show(
 f"An error occurred while toggling fullscreen: {e}", level="error"
 )
+def toggle_pin(self, event):
+peer_container = event.target.closest('.peer_video_container')
+is_pinned = peer_container.dataset.pinned == 'true'
+# Unpin all peers
+for container in self.group_call_container_elt.select('.peer_video_container'):
+container.dataset.pinned = 'false'
+container.classList.remove('is-12')
+container.classList.add('is-3-widescreen', 'is-4-desktop', 'is-6-tablet')
+if not is_pinned:
+# Pin the selected peer
+peer_container.dataset.pinned = 'true'
+peer_container.classList.remove('is-3-widescreen', 'is-4-desktop', 'is-6-tablet')
+peer_container.classList.add('is-12')
+# Rearrange the grid
+grid = document['group_video_grid']
+pinned = [peer for peer in grid.children if peer.dataset.pinned == 'true']
+unpinned = [peer for peer in grid.children if peer.dataset.pinned != 'true']
+grid.clear()
+for peer in pinned + unpinned:
+grid <= peer
 def toggle_audio_mute(self, evt):
 is_muted = self.webrtc.toggle_audio_mute()
 btn_elt = evt.currentTarget
 if is_muted:

Mercurial > libervia-web

comparison libervia/web/pages/calls/_browser/__init__.py @ 1616:6bfeb9f0fb84

comparison libervia/web/pages/calls/_browser/init.py @ 1616:6bfeb9f0fb84