fix(qconnect): register renderer role during connect bootstrap

cx

crates/qconnect-app/src/app.rs

@@ -147,6 +147,13 @@ where
         Ok(action_uuid)
     }
 
+    pub async fn send_renderer_report_command(
+        &self,
+        report: RendererReport,
+    ) -> Result<(), QconnectAppError> {
+        self.send_renderer_report(report).await
+    }
+
     pub async fn handle_transport_event(
         &self,
         event: TransportEvent,

crates/qconnect-app/src/lib.rs

@@ -19,5 +19,5 @@ pub use qconnect_core::{
     evaluate_remote_queue_admission, resolve_handoff_intent, AdmissionDecision, HandoffIntent,
     QConnectQueueState, QConnectRendererState, RendererCommand, TrackOrigin,
 };
-pub use qconnect_protocol::QueueCommandType;
+pub use qconnect_protocol::{QueueCommandType, RendererReport, RendererReportType};
 pub use state::QconnectRuntimeState;

crates/qconnect-protocol/src/mapper.rs

@@ -390,6 +390,19 @@ fn map_queue_command(command: &QueueCommand) -> Result<QConnectMessage, Protocol
 
 fn map_renderer_report(report: &RendererReport) -> Result<QConnectMessage, ProtocolError> {
     match report.report_type {
+        RendererReportType::RndrSrvrJoinSession => Ok(QConnectMessage {
+            message_type: Some(QConnectMessageType::MessageTypeRndrSrvrJoinSession as i32),
+            rndr_srvr_join_session: Some(JoinSessionMessage {
+                session_uuid: optional_uuid_bytes(&report.payload, &["session_uuid", "sessionUuid"])?,
+                device_info: parse_device_info(&report.payload)?,
+            }),
+            ..Default::default()
+        }),
+        RendererReportType::RndrSrvrDeviceInfoUpdated => Ok(QConnectMessage {
+            message_type: Some(QConnectMessageType::MessageTypeRndrSrvrDeviceInfoUpdated as i32),
+            rndr_srvr_device_info_updated: parse_device_info(&report.payload)?,
+            ..Default::default()
+        }),
         RendererReportType::RndrSrvrStateUpdated => {
             let queue_version = optional_queue_version(&report.payload, "queue_version")?
                 .unwrap_or(report.queue_version_ref);

crates/qconnect-protocol/src/queue_command_proto.rs

@@ -702,6 +702,10 @@ pub struct QConnectMessages {
 pub struct QConnectMessage {
     #[prost(int32, optional, tag = "1")]
     pub message_type: Option<i32>,
+    #[prost(message, optional, tag = "21")]
+    pub rndr_srvr_join_session: Option<JoinSessionMessage>,
+    #[prost(message, optional, tag = "22")]
+    pub rndr_srvr_device_info_updated: Option<DeviceInfoMessage>,
     #[prost(message, optional, tag = "23")]
     pub rndr_srvr_state_updated: Option<RendererStateUpdatedMessage>,
     #[prost(message, optional, tag = "25")]

crates/qconnect-protocol/src/renderer.rs

@@ -42,6 +42,8 @@ impl RendererServerCommand {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum RendererReportType {
+    RndrSrvrJoinSession,
+    RndrSrvrDeviceInfoUpdated,
     RndrSrvrStateUpdated,
     RndrSrvrVolumeChanged,
     RndrSrvrVolumeMuted,
@@ -52,6 +54,8 @@ pub enum RendererReportType {
 impl RendererReportType {
     pub const fn as_message_type(self) -> &'static str {
         match self {
+            Self::RndrSrvrJoinSession => "MESSAGE_TYPE_RNDR_SRVR_JOIN_SESSION",
+            Self::RndrSrvrDeviceInfoUpdated => "MESSAGE_TYPE_RNDR_SRVR_DEVICE_INFO_UPDATED",
             Self::RndrSrvrStateUpdated => "MESSAGE_TYPE_RNDR_SRVR_STATE_UPDATED",
             Self::RndrSrvrVolumeChanged => "MESSAGE_TYPE_RNDR_SRVR_VOLUME_CHANGED",
             Self::RndrSrvrVolumeMuted => "MESSAGE_TYPE_RNDR_SRVR_VOLUME_MUTED",

src-tauri/src/qconnect_service.rs

@@ -4,7 +4,7 @@ use async_trait::async_trait;
 use qconnect_app::{
     evaluate_remote_queue_admission, resolve_handoff_intent, HandoffIntent, QConnectQueueState,
     QConnectRendererState, QconnectApp, QconnectAppEvent, QconnectEventSink, QueueCommandType,
-    RendererCommand, TrackOrigin,
+    RendererCommand, RendererReport, RendererReportType, TrackOrigin,
 };
 use qconnect_transport_ws::{NativeWsTransport, WsTransportConfig};
 use serde::{Deserialize, Serialize};
@@ -538,9 +538,27 @@ fn normalize_volume_to_fraction(volume: i32) -> f32 {
 async fn bootstrap_remote_presence(
     app: &Arc<QconnectApp<NativeWsTransport, TauriQconnectEventSink>>,
 ) -> Result<(), String> {
+    let device_info = default_qconnect_device_info();
+    let queue_version_ref = app.queue_state_snapshot().await.version;
+
+    let renderer_join_payload = serde_json::to_value(QconnectJoinSessionRequest {
+        session_uuid: None,
+        device_info: Some(device_info.clone()),
+    })
+    .map_err(|err| format!("serialize renderer join_session bootstrap payload: {err}"))?;
+    let renderer_join_report = RendererReport::new(
+        RendererReportType::RndrSrvrJoinSession,
+        Uuid::new_v4().to_string(),
+        queue_version_ref,
+        renderer_join_payload,
+    );
+    app.send_renderer_report_command(renderer_join_report)
+        .await
+        .map_err(|err| format!("send bootstrap rndr_srvr_join_session failed: {err}"))?;
+
     let join_payload = serde_json::to_value(QconnectJoinSessionRequest {
         session_uuid: None,
-        device_info: Some(default_qconnect_device_info()),
+        device_info: Some(device_info),
     })
     .map_err(|err| format!("serialize join_session bootstrap payload: {err}"))?;
 
@@ -556,16 +574,6 @@ async fn bootstrap_remote_presence(
     // queue reducer correlation. Drop pending slot so queue operations are not blocked for 10s.
     clear_pending_if_matches(app, &join_action_uuid).await;
 
-    let ask_queue_command = app
-        .build_queue_command(
-            QueueCommandType::CtrlSrvrAskForQueueState,
-            Value::Object(Default::default()),
-        )
-        .await;
-    app.send_queue_command(ask_queue_command)
-        .await
-        .map_err(|err| format!("send bootstrap ask_for_queue_state failed: {err}"))?;
-
     Ok(())
 }