fix(aaudio): use system mixer bursts for buffer capacity

Author: roderickvd

src/host/aaudio/java_interface/audio_manager.rs

@@ -1,6 +1,7 @@
 use super::{
     utils::{
-        get_context, get_property, get_system_service, with_attached, JNIEnv, JObject, JResult,
+        get_context, get_property, get_system_property, get_system_service, with_attached, JNIEnv,
+        JObject, JResult,
     },
     AudioManager, Context,
 };
@@ -13,6 +14,15 @@ impl AudioManager {
         with_attached(context, |env, context| get_frames_per_buffer(env, &context))
             .map_err(|error| error.to_string())
     }
+
+    /// Get the AAudio mixer burst count from system property
+    /// Returns the value from aaudio.mixer_bursts property, defaulting to 2
+    pub fn get_mixer_bursts() -> Result<i32, String> {
+        let context = get_context();
+
+        with_attached(context, |env, _context| get_mixer_bursts(env))
+            .map_err(|error| error.to_string())
+    }
 }
 
 fn get_frames_per_buffer<'j>(env: &mut JNIEnv<'j>, context: &JObject<'j>) -> JResult<i32> {
@@ -31,3 +41,14 @@ fn get_frames_per_buffer<'j>(env: &mut JNIEnv<'j>, context: &JObject<'j>) -> JRe
         .parse::<i32>()
         .map_err(|_| jni::errors::Error::JniCall(jni::errors::JniError::Unknown))
 }
+
+fn get_mixer_bursts<'j>(env: &mut JNIEnv<'j>) -> JResult<i32> {
+    let mixer_bursts = get_system_property(env, "aaudio.mixer_bursts", "2")?;
+
+    let mixer_bursts_string = String::from(env.get_string(&mixer_bursts)?);
+
+    // TODO: Use jni::errors::Error::ParseFailed instead of jni::errors::Error::JniCall once jni > v0.21.1 is released
+    mixer_bursts_string
+        .parse::<i32>()
+        .map_err(|_| jni::errors::Error::JniCall(jni::errors::JniError::Unknown))
+}

src/host/aaudio/java_interface/utils.rs

@@ -165,6 +165,26 @@ pub fn get_property<'j>(
     call_method_string_arg_ret_string(env, subject, "getProperty", name)
 }
 
+/// Read an Android system property
+pub fn get_system_property<'j>(
+    env: &mut JNIEnv<'j>,
+    name: &str,
+    default_value: &str,
+) -> JResult<JString<'j>> {
+    Ok(env
+        .call_static_method(
+            "android/os/SystemProperties",
+            "get",
+            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            &[
+                (&env.new_string(name)?).into(),
+                (&env.new_string(default_value)?).into(),
+            ],
+        )?
+        .l()?
+        .into())
+}
+
 pub fn get_devices<'j>(
     env: &mut JNIEnv<'j>,
     subject: &JObject<'j>,

src/host/aaudio/mod.rs

@@ -277,21 +277,35 @@ fn configure_for_device(
     };
     builder = builder.sample_rate(config.sample_rate.try_into().unwrap());
 
-    let size = match config.buffer_size {
+    match config.buffer_size {
         BufferSize::Default => {
-            // Use the optimal burst size from AudioManager:
-            // https://developer.android.com/ndk/guides/audio/audio-latency#buffer-size
-            match AudioManager::get_frames_per_buffer() {
-                Ok(size) if size > 0 => size as u32,
-                _ => 256,
-            }
-        }
-        BufferSize::Fixed(size) => size,
-    };
+            // Following the pattern from Oboe and Google's AAudio samples, we only set the buffer
+            // capacity and let AAudio choose the optimal callback size dynamically. See:
+            // - https://developer.android.com/ndk/reference/group/audio
+            // - https://developer.android.com/ndk/guides/audio/audio-latency#buffer-size
+            let burst = match AudioManager::get_frames_per_buffer() {
+                Ok(size) if size > 0 => size,
+                _ => 256, // default from Android docs
+            };
 
-    builder
-        .frames_per_data_callback(size as i32)
-        .buffer_capacity_in_frames((size * 2) as i32) // Double-buffering
+            // Determine the buffer capacity multiplier. This matches AOSP's
+            // AAudioServiceEndpointPlay buffer sizing strategy.
+            let mixer_bursts = match AudioManager::get_mixer_bursts() {
+                Ok(bursts) if bursts > 1 => bursts,
+                _ => 2, // double-buffering: default from AOSP
+            };
+
+            let capacity = burst * mixer_bursts;
+            builder.buffer_capacity_in_frames(capacity)
+        }
+        BufferSize::Fixed(size) => {
+            // For fixed sizes, the user explicitly wants control over the callback size,
+            // so we set both the callback size and capacity (with double-buffering).
+            builder
+                .frames_per_data_callback(size as i32)
+                .buffer_capacity_in_frames((size * 2) as i32)
+        }
+    }
 }
 
 fn build_input_stream<D, E>(