complete basics for macos

Author: wgibbs-rs

build.rs

@@ -29,8 +29,7 @@ fn main() {
     if !status.success() {
         panic!("Swift compilation failed");
     }
-
-    // Tell cargo to link the library
+    
     println!("cargo:rustc-link-search=native={}", out_dir);
     println!("cargo:rustc-link-lib=static=swiftlib");
 

examples/basic.rs

@@ -0,0 +1,11 @@
+
+
+use system_media::MediaSession;
+
+fn main() {
+    println!("Now Playing session started");
+    println!("Keeping process alive... Press Ctrl+C to exit");
+    let mut session = MediaSession::new();
+    session.set_title("Hello!");
+    session.start();
+}

examples/tmp.rs

@@ -1,28 +1,146 @@
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(not(any(
+    target_os = "macos"
+)))]
+mod null;
 
+pub trait MediaBackend {
+    fn set_title(&self, title: &str);
+    fn set_artist(&self, artist: &str);
+    fn set_album(&self, album: &str);
+    fn set_genre(&self, genre: &str);
+    fn set_media_type(&self, media_type: MediaType);
+    fn set_playback_duration(&self, duration: f64);
+    fn set_elapsed_duration(&self, duration: f64);
+    fn set_playback_rate(&self, rate: f64);
+    fn start_session(&self);
+    fn stop_session(&self);
+}
+
+// Defines the type of media being presented
+#[derive(Clone, Copy, PartialEq)]
+pub enum MediaType {
+    Audio,
+    Video
+}
 
-#[unsafe(no_mangle)]
-pub extern "C" fn rust_hello() {
-    println!("Hello from Rust!");
+pub struct Metadata {
+    title: String,
+    artist: String,
+    album: String,
+    genre: String,
+    media_type: MediaType,
+    duration: f64,
+    playback_rate: f64,
 }
 
-unsafe extern "C" {
-    fn hello_world();
+pub struct MediaSession {
+    backend: Box<dyn MediaBackend>,
+    metadata: Metadata,
 }
 
+impl MediaSession {
 
+    pub fn new() -> Self {
+        #[cfg(target_os = "macos")]
+        let backend = Box::new(macos::NowPlayingBackend::new());
 
-use std::thread;
-use std::time::Duration;
+        #[cfg(not(any(
+            target_os = "macos"
+        )))]
+        let backend = Box::new(null::NullBackend::new());
 
-pub fn call_swift() {
-    unsafe {
-        hello_world();
+        Self {
+            backend,
+            metadata: Metadata {
+                title: "".to_string(),
+                artist: "".to_string(),
+                album: "".to_string(),
+                genre: "".to_string(),
+                media_type: MediaType::Audio,
+                duration: 0.0f64,
+                playback_rate: 0.0f64,
+            },
+        }
     }
 
-    thread::sleep(Duration::from_secs(10));
-}
+    pub fn set_title(&mut self, title: &str) {
+        self.metadata.title = title.to_string();
+        self.backend.set_title(title);
+    }
+
+    pub fn title(&self) -> &str {
+        &self.metadata.title
+    }
+
+    pub fn set_artist(&mut self, artist: &str) {
+        self.metadata.artist = artist.to_string();
+        self.backend.set_artist(artist);
+    }
+    
+    pub fn artist(&self) -> &str {
+        &self.metadata.artist
+    }
+    
+    pub fn set_album(&mut self, album: &str) {
+        self.metadata.album = album.to_string();
+        self.backend.set_album(album);
+    }
+    
+    pub fn album(&self) -> &str {
+        &self.metadata.album
+    }
+    
+    pub fn set_genre(&mut self, genre: &str) {
+        self.metadata.genre = genre.to_string();
+        self.backend.set_album(genre);
+    }
+    
+    pub fn genre(&self) -> &str {
+        &self.metadata.genre
+    }
+    
+    pub fn set_media_type(&mut self, media_type: MediaType) {
+        self.metadata.media_type = media_type;
+        self.backend.set_media_type(media_type);
+    }
+    
+    pub fn media_type(&self) -> MediaType {
+        self.metadata.media_type
+    }
+    
+    pub fn set_playback_duration(&mut self, duration: f64) {
+        self.metadata.duration = duration;
+        self.backend.set_playback_duration(duration);
+    }
+    
+    pub fn duration(&self) -> f64 {
+        self.metadata.duration
+    }
+    
+    pub fn set_elapsed_duration(&self, duration: f64) {
+        self.backend.set_elapsed_duration(duration);
+    }
+    
+    pub fn set_playback_rate(&mut self, rate: f64) {
+        self.metadata.playback_rate = rate;
+        self.backend.set_playback_rate(rate);
+    }
+    
+    pub fn playback_rate(&self) -> f64 {
+        self.metadata.playback_rate
+    }
 
+    pub fn start(&self) {
+        self.backend.start_session();
+    }
+    
+    pub fn stop(&self) {
+        self.backend.stop_session();
+    }
 
+}
 
 
 #[cfg(test)]

src/lib.rs

@@ -0,0 +1,100 @@
+use std::ffi::CString;
+use crate::{MediaBackend, MediaType};
+// Swift functions called by Rust
+unsafe extern "C" {
+    fn swift_set_metadata_title(title: *mut i8);
+    fn swift_set_metadata_artist(artist: *mut i8);
+    fn swift_set_metadata_album(album: *mut i8);
+    fn swift_set_metadata_genre(genre: *mut i8);
+    fn swift_set_metadata_media_type(id: i64);
+    fn swift_set_playback_duration(seconds: f64);
+    fn swift_set_elapsed_duration(seconds: f64);
+    fn swift_set_playback_rate(rate: f64);
+    fn swift_start_session();
+}
+
+// Rust functions called by Swift
+// TODO: Add hooks for SystemMedia events.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rust_resume_playback_command() { }
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rust_pause_playback_command() { }
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rust_next_track_playback_command() { }
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rust_previous_track_playback_command() { }
+
+fn str_to_raw(s: &str) -> *mut i8 {
+    let c_string = CString::new(s).expect("CString::new() failed. ");
+    c_string.into_raw()
+}
+
+pub struct NowPlayingBackend;
+
+impl NowPlayingBackend {
+    pub fn new() -> Self { Self }
+}
+
+impl MediaBackend for NowPlayingBackend {
+    fn set_title(&self, title: &str) {
+        unsafe {
+            swift_set_metadata_title(str_to_raw(title));
+        }
+    }
+
+    fn set_artist(&self, artist: &str) {
+        unsafe {
+            swift_set_metadata_artist(str_to_raw(artist));
+        }
+    }
+
+    fn set_album(&self, album: &str) {
+        unsafe {
+            swift_set_metadata_album(str_to_raw(album));
+        }
+    }
+
+    fn set_genre(&self, genre: &str) {
+        unsafe {
+            swift_set_metadata_genre(str_to_raw(genre));
+        }
+    }
+
+    fn set_media_type(&self, media_type: MediaType) {
+        unsafe {
+            if media_type == MediaType::Audio {
+                swift_set_metadata_media_type(0);
+            } else {
+                swift_set_metadata_media_type(1);
+            }
+        }
+    }
+
+    fn set_playback_duration(&self, duration: f64) {
+        unsafe {
+            swift_set_playback_duration(duration);
+        }
+    }
+
+    fn set_elapsed_duration(&self, duration: f64) {
+        unsafe {
+            swift_set_elapsed_duration(duration);
+        }
+    }
+    
+    fn set_playback_rate(&self, rate: f64) {
+        unsafe {
+            swift_set_playback_rate(rate);
+        }
+    }
+
+    fn start_session(&self) {
+        unsafe {
+            swift_start_session();
+        }
+    }
+
+    fn stop_session(&self) {
+        println!("How do we stop a session?");
+    }
+}