android_media/

player.rs

use {
    super::{constants::*, load_class},
    jni::{
        JNIEnv,
        errors::Error as JniError,
        objects::{GlobalRef, JObject, JString},
    },
    std::{
        collections::HashMap,
        error::Error,
        fmt::{Display, Formatter, Result as FmtResult},
        mem::transmute,
        sync::{
            LazyLock, Mutex, PoisonError,
            atomic::{AtomicI16, Ordering},
        },
    },
    tokio::sync::oneshot::{Sender, channel, error::RecvError},
    tracing::error,
};

#[derive(Debug)]
pub enum PlayerError {
    Jni(JniError),
    Poison(String),
    Recv(RecvError),
    Write(String),
}

impl Display for PlayerError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "PlayerError: ")?;
        match self {
            Self::Jni(e) => Display::fmt(e, f),
            Self::Poison(msg) => write!(f, "PoisonError: {}", msg),
            Self::Recv(e) => Display::fmt(e, f),
            Self::Write(msg) => write!(f, "WriteError: {}", msg),
        }
    }
}

impl Error for PlayerError {}

impl From<JniError> for PlayerError {
    fn from(value: JniError) -> Self {
        Self::Jni(value)
    }
}

impl From<RecvError> for PlayerError {
    fn from(value: RecvError) -> Self {
        Self::Recv(value)
    }
}

impl<T> From<PoisonError<T>> for PlayerError {
    fn from(value: PoisonError<T>) -> Self {
        Self::Poison(value.to_string())
    }
}

type PlayerResult<T> = Result<T, PlayerError>;

/// Player write task callbacks
static PLAYER_WRITE_CALLBACKS: LazyLock<Mutex<HashMap<i16, Sender<PlayerResult<()>>>>> =
    LazyLock::new(|| Mutex::new(Default::default()));

/// Rust wrapper for Android audio player
pub struct AudioPlayer {
    /// JNI environment
    env: JNIEnv<'static>,
    /// Java object instance
    this: GlobalRef,
    /// Sample rate (Hz)
    sample_rate: i32,
    /// Audio channel count
    channel_count: i32,
    /// Audio encoding format
    audio_format: i32,
    /// Playback mode
    mode: i32,
}

//noinspection SpellCheckingInspection
#[allow(dead_code)]
impl AudioPlayer {
    /// Create a new AudioPlayer instance
    ///
    /// # Arguments
    /// * `env` - JNI environment
    /// * `context` - GlobalRef to context object (used to get the correct ClassLoader)
    /// * `sample_rate` - Sample rate (e.g., 16000, 44100, 48000)
    /// * `channel_config` - Channel configuration (use ChannelOutConfig constants)
    /// * `audio_format` - Audio encoding format (use AudioEncoding constants)
    /// * `mode` - Playback mode (use PlayerMode constants)
    ///
    /// # Returns
    /// Returns initialized AudioPlayer instance
    ///
    /// # Examples
    ///
    /// See the README.md for complete usage examples.
    pub fn new(
        mut env: JNIEnv,
        context: &GlobalRef,
        sample_rate: i32,
        channel_config: i32,
        audio_format: i32,
        mode: i32,
    ) -> PlayerResult<Self> {
        // Load Player class using ClassLoader
        let player_class = load_class(&mut env, context, "rust.android.Player")?;

        // Create Player Java object
        let player_obj = env.new_object(
            &player_class,
            "(IIII)V",
            &[
                sample_rate.into(),
                channel_config.into(),
                audio_format.into(),
                mode.into(),
            ],
        )?;
        let this = env.new_global_ref(player_obj)?;

        // Initialize audio player
        env.call_method(
            &this,
            "init",
            "(IIII)V",
            &[
                sample_rate.into(),
                channel_config.into(),
                audio_format.into(),
                mode.into(),
            ],
        )?;

        unsafe {
            Ok(Self {
                env: transmute(env),
                this,
                sample_rate,
                channel_count: if channel_config == ChannelOutConfig::Mono.value() {
                    1
                } else {
                    2
                },
                audio_format,
                mode,
            })
        }
    }

    fn get_env(&self) -> JNIEnv<'_> {
        unsafe { self.env.unsafe_clone() }
    }

    /// Start playback
    pub fn play(&self) -> PlayerResult<()> {
        self.get_env().call_method(&self.this, "play", "()V", &[])?;
        Ok(())
    }

    /// Stop playback
    pub fn stop(&self) -> PlayerResult<()> {
        self.get_env().call_method(&self.this, "stop", "()V", &[])?;

        Ok(())
    }

    /// Pause playback
    pub fn pause(&self) -> PlayerResult<()> {
        self.get_env()
            .call_method(&self.this, "pause", "()V", &[])?;
        Ok(())
    }

    /// Flush buffer
    pub fn flush(&self) -> PlayerResult<()> {
        self.get_env()
            .call_method(&self.this, "flush", "()V", &[])?;

        Ok(())
    }

    /// Release resources
    pub fn release(&self) -> PlayerResult<()> {
        self.get_env()
            .call_method(&self.this, "release", "()V", &[])?;

        Ok(())
    }

    /// Write audio data asynchronously
    ///
    /// # Arguments
    /// * `audio_data` - Audio data (raw PCM data)
    ///
    /// # Returns
    /// * `Result<(), PlayerError>` - Returns () on success, error on failure
    ///
    /// # Examples
    ///
    /// See the README.md for complete usage examples.
    pub async fn write(&self, audio_data: &[u8]) -> PlayerResult<()> {
        static ID: AtomicI16 = AtomicI16::new(0);
        let task_id = ID.fetch_add(1, Ordering::AcqRel);
        let (tx, rx) = channel();

        {
            let mut lock = PLAYER_WRITE_CALLBACKS.lock()?;
            lock.insert(task_id, tx);
        }

        // Create byte array
        {
            let jbyte_array = self.env.byte_array_from_slice(audio_data)?;

            // Call Java layer's write method
            self.get_env()
                .call_method(
                    &self.this,
                    "performWrite",
                    "(S[B)V",
                    &[task_id.into(), (&jbyte_array).into()],
                )?
                .v()?;
        }

        rx.await?
    }

    /// Get sample rate
    pub fn get_sample_rate(&self) -> i32 {
        self.sample_rate
    }

    /// Get channel count
    pub fn get_channel_count(&self) -> i32 {
        self.channel_count
    }

    /// Get audio format
    pub fn get_audio_format(&self) -> i32 {
        self.audio_format
    }

    /// Get playback mode
    pub fn get_mode(&self) -> i32 {
        self.mode
    }

    /// Get buffer size
    pub fn get_buffer_size(&self) -> PlayerResult<i32> {
        Ok(self
            .get_env()
            .call_method(&self.this, "getBufferSize", "()I", &[])?
            .i()?)
    }
}

unsafe impl Send for AudioPlayer {}
unsafe impl Sync for AudioPlayer {}

impl Drop for AudioPlayer {
    fn drop(&mut self) {
        if let Err(e) = self.release() {
            error!(?e, "Dropping error.");
        }
    }
}

//noinspection SpellCheckingInspection
/// Player write success callback
///
/// This function is called by the Java layer after audio data is successfully written
///
/// # Arguments
/// * `env` - JNI environment
/// * `_this` - Java object
/// * `task_id` - Task ID
#[allow(non_snake_case)]
#[unsafe(no_mangle)]
extern "C" fn Java_rust_android_Player_onWriteSuccess(_env: JNIEnv, _this: JObject, task_id: i16) {
    let Ok(mut lock) = PLAYER_WRITE_CALLBACKS.lock() else {
        return;
    };
    let Some(tx) = lock.remove(&task_id) else {
        return;
    };
    drop(lock);

    let _ = tx.send(Ok(()));
}

//noinspection SpellCheckingInspection
/// Player write failure callback
///
/// This function is called by the Java layer after audio data write fails
///
/// # Arguments
/// * `env` - JNI environment
/// * `_this` - Java object
/// * `task_id` - Task ID
/// * `error_message` - Error message (string)
#[allow(non_snake_case)]
#[unsafe(no_mangle)]
extern "C" fn Java_rust_android_Player_onWriteFailure(
    mut env: JNIEnv,
    _this: JObject,
    task_id: i16,
    error_message: JString,
) {
    let Ok(mut lock) = PLAYER_WRITE_CALLBACKS.lock() else {
        return;
    };
    let Some(tx) = lock.remove(&task_id) else {
        return;
    };

    let error_msg = match env.get_string(&error_message) {
        Ok(msg) => msg.to_string_lossy().to_string(),
        Err(e) => format!("Parsing error failed: {}", e),
    };

    if let Err(e) = tx.send(Err(PlayerError::Write(format!(
        "Player write failed: {}",
        error_msg
    )))) {
        error!(?e, "Sending error failed.");
    }
}