libervia-backend: libervia/backend/plugins/plugin_xep_0167/__init_

comparison libervia/backend/plugins/plugin_xep_0167/init.py @ 4240:79c8a70e1813

backend, frontend: prepare remote control: This is a series of changes necessary to prepare the implementation of remote control feature: - XEP-0166: add a `priority` attribute to `ApplicationData`: this is needed when several applications are working in a same session, to know which one must be handled first. Will be used to make Remote Control have precedence over Call content. - XEP-0166: `_call_plugins` is now async and is not used with `DeferredList` anymore: the benefit to have methods called in parallels is very low, and it cause a lot of trouble as we can't predict order. Methods are now called sequentially so workflow can be predicted. - XEP-0167: fix `senders` XMPP attribute <=> SDP mapping - XEP-0234: preflight acceptance key is now `pre-accepted` instead of `file-accepted`, so the same key can be used with other jingle applications. - XEP-0167, XEP-0343: move some method to XEP-0167 - XEP-0353: use new `priority` feature to call preflight methods of applications according to it. - frontend (webrtc): refactor the sources/sink handling with a more flexible mechanism based on Pydantic models. It is now possible to have has many Data Channel as necessary, to have them in addition to A/V streams, to specify manually GStreamer sources and sinks, etc. - frontend (webrtc): rework of the pipeline to reduce latency. - frontend: new `portal_desktop` method. Screenshare portal handling has been moved there, and RemoteDesktop portal has been added. - frontend (webrtc): fix `extract_ufrag_pwd` method. rel 436

author	Goffi <goffi@goffi.org>
date	Sat, 11 May 2024 13:52:41 +0200
parents	e11b13418ba6
children	a7d4007a8fa5

comparison

equal deleted inserted replaced

-:a38559e6d6e2
+:79c8a70e1813
 "unhold",
 "mute",
 "unmute",
 "ringing",
 )
+ANSWER_SDP_SENT_KEY = "answer_sdp_sent"
 class XEP_0167(BaseApplicationHandler):
+namespace = NS_JINGLE_RTP
 def __init__(self, host):
 log.info(f'Plugin "{PLUGIN_INFO[C.PI_NAME]}" initialization')
 self.host = host
 # FIXME: to be removed once host is accessible from global var
 mapping.host = host
 def parse_call_data(self, call_data: dict) -> dict:
 """Parse ``call_data`` and return corresponding contents end metadata"""
 metadata = call_data.get("metadata") or {}
 if "sdp" in call_data:
-sdp_data = mapping.parse_sdp(call_data["sdp"])
+sdp_data = mapping.parse_sdp(call_data["sdp"], self._j.ROLE_INITIATOR)
 to_delete = set()
 for media, data in sdp_data.items():
 if media not in ("audio", "video", "application"):
 continue
 to_delete.add(media)
 del sdp_data[media]
 metadata.update(sdp_data.get("metadata", {}))
 return metadata
-async def call_start(
+def get_contents(self, call_data: dict, metadata: dict) -> list[dict]:
-self,
+"""Generate call related contents.
-client: SatXMPPEntity,
-peer_jid: jid.JID,
+@param call_data: Call data after being parsed by [parse_call_data]
-call_data: dict,
+@param metadata: Metadata as returned by [parse_call_data]
-) -> str:
+@return: List of contents to be used with [jingle.initiate].
-"""Initiate a call session with the given peer.
-@param peer_jid: JID of the peer to initiate a call session with.
-@param call_data: Dictionary containing data for the call. Must include SDP information.
-The dict can have the following keys:
-- sdp (str): SDP data for the call.
-- metadata (dict): Additional metadata for the call (optional).
-Each media type ("audio" and "video") in the SDP should have:
-- application_data (dict): Data about the media.
-- fingerprint (str): Security fingerprint data (optional).
-- id (str): Identifier for the media (optional).
-- ice-candidates: ICE candidates for media transport.
-- And other transport specific data.
-@return: Session ID (SID) for the initiated call session.
-@raises exceptions.DataError: If media data is invalid or duplicate content name
-(mid) is found.
 """
-sid = str(uuid.uuid4())
-metadata = self.parse_call_data(call_data)
 contents = []
 seen_names = set()
 for media, media_data in call_data.items():
 if media not in ("audio", "video"):
 continue
 content = {
 "app_ns": NS_JINGLE_RTP,
-"senders": "both",
+"senders": media_data["senders"],
 "transport_type": self._j.TRANSPORT_DATAGRAM,
 "app_kwargs": {"media": media, "media_data": media_data},
 "transport_data": {
 "local_ice_data": {
 "ufrag": metadata["ice-ufrag"],
 raise exceptions.DataError(
 f"Content name (mid) seen multiple times: {name}"
 )
 content["name"] = name
 contents.append(content)
+return contents
+async def call_start(
+self,
+client: SatXMPPEntity,
+peer_jid: jid.JID,
+call_data: dict,
+) -> str:
+"""Initiate a call session with the given peer.
+@param peer_jid: JID of the peer to initiate a call session with.
+@param call_data: Dictionary containing data for the call. Must include SDP information.
+The dict can have the following keys:
+- sdp (str): SDP data for the call.
+- metadata (dict): Additional metadata for the call (optional).
+Each media type ("audio" and "video") in the SDP should have:
+- application_data (dict): Data about the media.
+- fingerprint (str): Security fingerprint data (optional).
+- id (str): Identifier for the media (optional).
+- ice-candidates: ICE candidates for media transport.
+- And other transport specific data.
+@return: Session ID (SID) for the initiated call session.
+@raises exceptions.DataError: If media data is invalid or duplicate content name
+(mid) is found.
+"""
+metadata = self.parse_call_data(call_data)
+contents = self.get_contents(call_data, metadata)
 if not contents:
 raise exceptions.DataError("no valid media data found: {call_data}")
 call_type = (
 C.META_SUBTYPE_CALL_VIDEO if "video" in call_data
 else C.META_SUBTYPE_CALL_AUDIO
 )
-defer.ensureDeferred(
+sid = await self._j.initiate(
-self._j.initiate(
 client,
 peer_jid,
 contents,
-sid=sid,
 call_type=call_type,
 metadata=metadata,
 peer_metadata={},
 )
-)
 return sid
 def _call_answer_sdp(self, session_id: str, answer_sdp: str, profile: str) -> None:
 client = self.host.get_client(profile)
 session = self._j.get_session(client, session_id)
 resp_data = await dialog_d
 accepted = not resp_data.get("cancelled", False)
 if accepted:
-session["call_accepted"] = True
+session["pre_accepted"] = True
 return accepted
 async def jingle_preflight(
 self, client: SatXMPPEntity, session: dict, description_elt: domish.Element
 @param description_elt: The description element. It's parent attribute is used to
 determine check siblings to see if it's an audio only or audio/video call.
 @raises exceptions.CancelError: If the user doesn't accept the incoming call.
 """
-if session.get("call_accepted", False):
+if session.get("pre_accepted", False):
 # the call is already accepted, nothing to do
 return
 parent_elt = description_elt.parent
 assert parent_elt is not None
 # we request confirmation only for the first content, all others are
 # automatically accepted. In practice, that means that the call confirmation
 # is requested only once for audio and video contents.
 return True
-if not session.get("call_accepted", False):
+if not session.get("pre_accepted", False):
 if any(
 c["desc_elt"].getAttribute("media") == "video"
 for c in session["contents"].values()
 ):
 call_type = session["call_type"] = C.META_SUBTYPE_CALL_VIDEO
 client.profile,
 )
 answer_sdp = await answer_sdp_d
-parsed_answer = mapping.parse_sdp(answer_sdp)
+parsed_answer = mapping.parse_sdp(answer_sdp, session["role"])
 session["metadata"].update(parsed_answer["metadata"])
-for media in ("audio", "video"):
+self.propagate_data(session, parsed_answer)
+return True
+def propagate_data(self, session: dict, parsed_answer: dict) -> None:
+"""Propagate local SDP data to other contents"""
+for media in ("audio", "video", "application"):
 for content in session["contents"].values():
-if content["desc_elt"].getAttribute("media") == media:
+try:
-media_data = parsed_answer[media]
 application_data = content["application_data"]
-application_data["local_data"] = media_data["application_data"]
+content_media = application_data["media"]
-transport_data = content["transport_data"]
+except KeyError:
-local_ice_data = media_data["transport_data"]
+pass
-transport_data["local_ice_data"] = local_ice_data
+else:
+if content_media == media:
-return True
+media_data = parsed_answer[media]
+application_data["local_data"] = media_data["application_data"]
+transport_data = content["transport_data"]
+local_ice_data = media_data["transport_data"]
+transport_data["local_ice_data"] = local_ice_data
+def send_answer_sdp(self, client: SatXMPPEntity, session: dict) -> None:
+"""Send answer SDP to frontend"""
+if not session.get(ANSWER_SDP_SENT_KEY, False):
+# we only send the signal once, as it means that the whole session is
+# accepted
+answer_sdp = mapping.generate_sdp_from_session(session)
+self.host.bridge.call_setup(
+session["id"],
+data_format.serialise(
+{
+"role": session["role"],
+"sdp": answer_sdp,
+}
+),
+client.profile,
+)
+session[ANSWER_SDP_SENT_KEY] = True
 async def jingle_handler(self, client, action, session, content_name, desc_elt):
 content_data = session["contents"][content_name]
 application_data = content_data["application_data"]
 if action == self._j.A_PREPARE_CONFIRMATION:
 elif action == self._j.A_ACCEPTED_ACK:
 pass
 elif action == self._j.A_PREPARE_INITIATOR:
 application_data["peer_data"] = mapping.parse_description(desc_elt)
 elif action == self._j.A_SESSION_ACCEPT:
-if content_name == next(iter(session["contents"])):
+pass # self.send_answer_sdp(client, session)
-# we only send the signal for first content, as it means that the whole
-# session is accepted
-answer_sdp = mapping.generate_sdp_from_session(session)
-self.host.bridge.call_setup(
-session["id"],
-data_format.serialise(
-{
-"role": session["role"],
-"sdp": answer_sdp,
-}
-),
-client.profile,
-)
 else:
 log.warning(f"FIXME: unmanaged action {action}")
 self.host.trigger.point(
 "XEP-0167_jingle_handler",

Mercurial > libervia-backend

comparison libervia/backend/plugins/plugin_xep_0167/__init__.py @ 4240:79c8a70e1813

comparison libervia/backend/plugins/plugin_xep_0167/init.py @ 4240:79c8a70e1813