refactor(client): ♻️ Move platform to alvr_system_info; rename video decoder

Cargo.toml

@@ -21,6 +21,7 @@ alvr_server_core = { path = "alvr/server_core"}
 alvr_server_io = { path = "alvr/server_io" }
 alvr_session = { path = "alvr/session" }
 alvr_sockets = { path = "alvr/sockets" }
+alvr_system_info = { path = "alvr/system_info" }
 
 [profile.release]
 debug = "limited"

alvr/client_core/Cargo.toml

@@ -20,6 +20,7 @@ alvr_common.workspace = true
 alvr_packets.workspace = true
 alvr_session.workspace = true
 alvr_sockets.workspace = true
+alvr_system_info.workspace = true
 
 app_dirs2 = "2"
 bincode = "1"

alvr/client_core/src/c_api.rs

@@ -1,7 +1,8 @@
 use crate::{
-    decoder::{self, DecoderConfig, DecoderSource},
     graphics::{GraphicsContext, LobbyRenderer, RenderViewInput, StreamRenderer},
-    storage, ClientCapabilities, ClientCoreContext, ClientCoreEvent,
+    storage,
+    video_decoder::{self, VideoDecoderConfig, VideoDecoderSource},
+    ClientCapabilities, ClientCoreContext, ClientCoreEvent,
 };
 use alvr_common::{
     anyhow::Result,
@@ -255,7 +256,7 @@ pub extern "C" fn alvr_protocol_id(protocol_buffer: *mut c_char) -> u64 {
 #[cfg(target_os = "android")]
 #[no_mangle]
 pub unsafe extern "C" fn alvr_try_get_permission(permission: *const c_char) {
-    crate::platform::try_get_permission(CStr::from_ptr(permission).to_str().unwrap());
+    alvr_system_info::try_get_permission(CStr::from_ptr(permission).to_str().unwrap());
 }
 
 /// NB: for android, `context` must be thread safe.
@@ -823,7 +824,7 @@ pub unsafe extern "C" fn alvr_render_stream_opengl(
 
 // Decoder-related interface
 
-static DECODER_SOURCE: OptLazy<DecoderSource> = alvr_common::lazy_mut_none();
+static DECODER_SOURCE: OptLazy<VideoDecoderSource> = alvr_common::lazy_mut_none();
 
 #[repr(u8)]
 pub enum AlvrMediacodecPropType {
@@ -863,7 +864,7 @@ pub struct AlvrDecoderConfig {
 /// alvr_initialize() must be called before alvr_create_decoder
 #[no_mangle]
 pub extern "C" fn alvr_create_decoder(config: AlvrDecoderConfig) {
-    let config = DecoderConfig {
+    let config = VideoDecoderConfig {
         codec: match config.codec {
             AlvrCodec::H264 => CodecType::H264,
             AlvrCodec::Hevc => CodecType::Hevc,
@@ -909,7 +910,7 @@ pub extern "C" fn alvr_create_decoder(config: AlvrDecoderConfig) {
     };
 
     let (mut sink, source) =
-        decoder::create_decoder(config, |maybe_timestamp: Result<Duration>| {
+        video_decoder::create_decoder(config, |maybe_timestamp: Result<Duration>| {
             if let Some(context) = &*CLIENT_CORE_CONTEXT.lock() {
                 match maybe_timestamp {
                     Ok(timestamp) => context.report_frame_decoded(timestamp),

alvr/client_core/src/connection.rs

@@ -2,7 +2,6 @@
 
 use crate::{
     logging_backend::{LogMirrorData, LOG_CHANNEL_SENDER},
-    platform,
     sockets::AnnouncerSocket,
     statistics::StatisticsManager,
     storage::Config,
@@ -75,7 +74,7 @@ fn set_hud_message(event_queue: &Mutex<VecDeque<ClientCoreEvent>>, message: &str
         "ALVR v{}\nhostname: {}\nIP: {}\n\n{message}",
         *ALVR_VERSION,
         Config::load().hostname,
-        platform::local_ip(),
+        alvr_system_info::local_ip(),
     );
 
     event_queue
@@ -167,7 +166,7 @@ fn connection_pipeline(
     proto_control_socket
         .send(&ClientConnectionResult::ConnectionAccepted {
             client_protocol_id: alvr_common::protocol_id_u64(),
-            display_name: platform::platform().to_string(),
+            display_name: alvr_system_info::platform().to_string(),
             server_ip,
             streaming_capabilities: Some(
                 alvr_packets::encode_video_streaming_capabilities(&VideoStreamingCapabilities {
@@ -438,7 +437,7 @@ fn connection_pipeline(
 
                 #[cfg(target_os = "android")]
                 if Instant::now() > battery_deadline {
-                    let (gauge_value, is_plugged) = platform::get_battery_status();
+                    let (gauge_value, is_plugged) = alvr_system_info::get_battery_status();
                     if let Some(sender) = &mut *ctx.control_sender.lock() {
                         sender
                             .send(&ClientControlPacket::Battery(crate::BatteryInfo {

alvr/client_core/src/lib.rs

@@ -8,16 +8,15 @@
 mod c_api;
 mod connection;
 mod logging_backend;
-mod platform;
 mod sockets;
 mod statistics;
 mod storage;
 
 #[cfg(target_os = "android")]
 mod audio;
 
-pub mod decoder;
 pub mod graphics;
+pub mod video_decoder;
 
 use alvr_common::{
     dbg_client_core, error,
@@ -32,7 +31,6 @@ use alvr_packets::{
 };
 use alvr_session::CodecType;
 use connection::ConnectionContext;
-use serde::{Deserialize, Serialize};
 use std::{
     collections::{HashSet, VecDeque},
     sync::Arc,
@@ -41,17 +39,9 @@ use std::{
 };
 use storage::Config;
 
+pub use alvr_system_info::Platform;
 pub use logging_backend::init_logging;
-pub use platform::Platform;
 
-#[cfg(target_os = "android")]
-pub use platform::try_get_permission;
-
-pub fn platform() -> Platform {
-    platform::platform()
-}
-
-#[derive(Serialize, Deserialize)]
 pub enum ClientCoreEvent {
     UpdateHudMessage(String),
     StreamingStarted(Box<StreamConfig>),
@@ -104,8 +94,8 @@ impl ClientCoreContext {
         #[cfg(target_os = "android")]
         {
             dbg_client_core!("Getting permissions");
-            platform::try_get_permission(platform::MICROPHONE_PERMISSION);
-            platform::set_wifi_lock(true);
+            alvr_system_info::try_get_permission(alvr_system_info::MICROPHONE_PERMISSION);
+            alvr_system_info::set_wifi_lock(true);
         }
 
         let lifecycle_state = Arc::new(RwLock::new(LifecycleState::Idle));
@@ -402,7 +392,7 @@ impl Drop for ClientCoreContext {
         }
 
         #[cfg(target_os = "android")]
-        platform::set_wifi_lock(false);
+        alvr_system_info::set_wifi_lock(false);
     }
 }
 

alvr/client_core/src/sockets.rs

@@ -1,4 +1,3 @@
-use crate::platform;
 use alvr_common::anyhow::{bail, Result};
 use mdns_sd::{ServiceDaemon, ServiceInfo};
 
@@ -18,7 +17,7 @@ impl AnnouncerSocket {
     }
 
     pub fn announce(&self) -> Result<()> {
-        let local_ip = platform::local_ip();
+        let local_ip = alvr_system_info::local_ip();
         if local_ip.is_unspecified() {
             bail!("IP is unspecified");
         }

alvr/client_core/src/platform/android/decoder.rs → alvr/client_core/src/video_decoder/android.rs

@@ -1,3 +1,4 @@
+use super::VideoDecoderConfig;
 use alvr_common::{
     anyhow::{anyhow, bail, Context, Result},
     error, info,
@@ -25,8 +26,6 @@ use std::{
     time::Duration,
 };
 
-use crate::decoder::DecoderConfig;
-
 struct FakeThreadSafe<T>(T);
 unsafe impl<T> Send for FakeThreadSafe<T> {}
 unsafe impl<T> Sync for FakeThreadSafe<T> {}
@@ -90,7 +89,7 @@ pub struct VideoDecoderSource {
     running: Arc<RelaxedAtomic>,
     dequeue_thread: Option<JoinHandle<()>>,
     image_queue: Arc<Mutex<VecDeque<QueuedImage>>>,
-    config: DecoderConfig,
+    config: VideoDecoderConfig,
     buffering_running_average: f32,
 }
 
@@ -191,7 +190,7 @@ fn decoder_attempt_setup(
 // Since we leak the ImageReader, and we pass frame_result_callback to it which contains a reference
 // to ClientCoreContext, to avoid circular references we need to use a Weak reference.
 fn decoder_lifecycle(
-    config: DecoderConfig,
+    config: VideoDecoderConfig,
     csd_0: Vec<u8>,
     frame_result_callback: Weak<impl Fn(Result<Duration>) + Send + Sync + 'static>,
     running: Arc<RelaxedAtomic>,
@@ -334,7 +333,7 @@ fn decoder_lifecycle(
 
 // Create a sink/source pair
 pub fn video_decoder_split(
-    config: DecoderConfig,
+    config: VideoDecoderConfig,
     csd_0: Vec<u8>,
     frame_result_callback: impl Fn(Result<Duration>) + Send + Sync + 'static,
 ) -> Result<(VideoDecoderSink, VideoDecoderSource)> {

alvr/client_core/src/decoder.rs → alvr/client_core/src/video_decoder/mod.rs

@@ -1,9 +1,12 @@
+#[cfg(target_os = "android")]
+mod android;
+
 use alvr_common::anyhow::Result;
 use alvr_session::{CodecType, MediacodecDataType};
 use std::time::Duration;
 
 #[derive(Clone, Default, PartialEq)]
-pub struct DecoderConfig {
+pub struct VideoDecoderConfig {
     pub codec: CodecType,
     pub force_software_decoder: bool,
     pub max_buffering_frames: f32,
@@ -12,12 +15,12 @@ pub struct DecoderConfig {
     pub config_buffer: Vec<u8>,
 }
 
-pub struct DecoderSink {
+pub struct VideoDecoderSink {
     #[cfg(target_os = "android")]
-    inner: crate::platform::VideoDecoderSink,
+    inner: android::VideoDecoderSink,
 }
 
-impl DecoderSink {
+impl VideoDecoderSink {
     // returns true if frame has been successfully enqueued
     #[allow(unused_variables)]
     pub fn push_nal(&mut self, timestamp: Duration, nal: &[u8]) -> bool {
@@ -30,12 +33,12 @@ impl DecoderSink {
     }
 }
 
-pub struct DecoderSource {
+pub struct VideoDecoderSource {
     #[cfg(target_os = "android")]
-    inner: crate::platform::VideoDecoderSource,
+    inner: android::VideoDecoderSource,
 }
 
-impl DecoderSource {
+impl VideoDecoderSource {
     /// If a frame is available, return the timestamp and the AHardwareBuffer.
     pub fn get_frame(&mut self) -> Option<(Duration, *mut std::ffi::c_void)> {
         #[cfg(target_os = "android")]
@@ -50,20 +53,23 @@ impl DecoderSource {
 // report_frame_decoded: (target_timestamp: Duration) -> ()
 #[allow(unused_variables)]
 pub fn create_decoder(
-    config: DecoderConfig,
+    config: VideoDecoderConfig,
     report_frame_decoded: impl Fn(Result<Duration>) + Send + Sync + 'static,
-) -> (DecoderSink, DecoderSource) {
+) -> (VideoDecoderSink, VideoDecoderSource) {
     #[cfg(target_os = "android")]
     {
-        let (sink, source) = crate::platform::video_decoder_split(
+        let (sink, source) = android::video_decoder_split(
             config.clone(),
             config.config_buffer,
             report_frame_decoded,
         )
         .unwrap();
 
-        (DecoderSink { inner: sink }, DecoderSource { inner: source })
+        (
+            VideoDecoderSink { inner: sink },
+            VideoDecoderSource { inner: source },
+        )
     }
     #[cfg(not(target_os = "android"))]
-    (DecoderSink {}, DecoderSource {})
+    (VideoDecoderSink {}, VideoDecoderSource {})
 }

alvr/client_openxr/Cargo.toml

@@ -14,6 +14,7 @@ alvr_common.workspace = true
 alvr_client_core.workspace = true
 alvr_packets.workspace = true
 alvr_session.workspace = true
+alvr_system_info.workspace = true
 
 openxr = { git = "https://github.com/Ralith/openxrs", rev = "9270509d23dc774b43a8b7289e8adf69fcac6828" }
 

alvr/client_openxr/src/interaction.rs

@@ -65,14 +65,14 @@ pub fn initialize_interaction(
         if (config.combined_eye_gaze || config.eye_tracking_fb)
             && matches!(platform, Platform::QuestPro)
         {
-            alvr_client_core::try_get_permission("com.oculus.permission.EYE_TRACKING")
+            alvr_system_info::try_get_permission("com.oculus.permission.EYE_TRACKING")
         }
         if config.combined_eye_gaze && platform.is_pico() {
-            alvr_client_core::try_get_permission("com.picovr.permission.EYE_TRACKING")
+            alvr_system_info::try_get_permission("com.picovr.permission.EYE_TRACKING")
         }
         if config.face_tracking_fb && matches!(platform, Platform::QuestPro) {
-            alvr_client_core::try_get_permission("android.permission.RECORD_AUDIO");
-            alvr_client_core::try_get_permission("com.oculus.permission.FACE_TRACKING")
+            alvr_system_info::try_get_permission("android.permission.RECORD_AUDIO");
+            alvr_system_info::try_get_permission("com.oculus.permission.FACE_TRACKING")
         }
     }
 
@@ -82,7 +82,7 @@ pub fn initialize_interaction(
             && platform.is_quest()
             && platform != Platform::Quest1
         {
-            alvr_client_core::try_get_permission("com.oculus.permission.BODY_TRACKING")
+            alvr_system_info::try_get_permission("com.oculus.permission.BODY_TRACKING")
         }
     }
 

alvr/client_openxr/src/lib.rs

@@ -114,7 +114,7 @@ fn default_view() -> xr::View {
 pub fn entry_point() {
     alvr_client_core::init_logging();
 
-    let platform = alvr_client_core::platform();
+    let platform = alvr_system_info::platform();
 
     let loader_suffix = match platform {
         Platform::Quest1 => "_quest1",