Fix VolumeProvider: add logging, metadata, and system volume observer fallback

- Added MediaMetadata to MediaSession so system treats it as real session
- Added MediaSession.Callback for media button events
- Added logging to VolumeProvider onSetVolumeTo/onAdjustVolume callbacks
- Added ContentObserver fallback on Settings.System.CONTENT_URI: if
  Android 12+ bug prevents VolumeProvider callbacks from firing, we
  detect STREAM_MUSIC volume changes and map them to app volume
- Volume observer maps system vol (0..maxVol) to app vol (0..100)
  and emits volume_change events for JS slider sync

Co-Authored-By: Raymond <20248577+javaarchive@users.noreply.github.com>

Author: devin-ai-integration[bot]

app/android/app/src/main/kotlin/com/audiostream/AudioStreamService.kt

@@ -7,19 +7,24 @@ import android.app.Service
 import android.content.Context
 import android.content.Intent
 import android.content.pm.ServiceInfo
+import android.database.ContentObserver
 import android.media.AudioAttributes
 import android.media.AudioFormat
 import android.media.AudioManager
 import android.media.AudioPlaybackCaptureConfiguration
 import android.media.AudioRecord
+import android.media.MediaMetadata
 import android.media.VolumeProvider
 import android.media.projection.MediaProjection
 import android.media.projection.MediaProjectionManager
 import android.media.session.MediaSession
 import android.media.session.PlaybackState
 import android.net.wifi.WifiManager
+import android.os.Handler
 import android.os.IBinder
+import android.os.Looper
 import android.os.PowerManager
+import android.provider.Settings
 import java.net.DatagramPacket
 import java.net.DatagramSocket
 import java.net.InetAddress
@@ -45,13 +50,11 @@ class AudioStreamService : Service() {
         const val EXTRA_LOG_SCALING = "logScaling"
         const val EXTRA_MUTE_LOCAL = "muteLocal"
 
-        // Airwire protocol signature bytes
         const val SIGNATURE_BYTE_1: Byte = 13
         const val SIGNATURE_BYTE_2: Byte = 37
         const val SIGNATURE_SIZE = 2
         const val PACKET_ID_SIZE = 8
 
-        // Static instance so AudioCaptureModule can call updateVolume
         @Volatile
         var instance: AudioStreamService? = null
             private set
@@ -69,26 +72,30 @@ class AudioStreamService : Service() {
     @Volatile var currentGain: Float = 1.0f
     @Volatile var currentLogScaling: Boolean = false
 
-    // Locks
     private var wakeLock: PowerManager.WakeLock? = null
     private var wifiLock: WifiManager.WifiLock? = null
 
-    // Mute
     private var audioManager: AudioManager? = null
     private var savedVolume: Int = -1
     private var didMute = false
 
-    // MediaSession
     private var mediaSession: MediaSession? = null
     private var volumeProvider: VolumeProvider? = null
 
+    // Fallback: watch system volume changes in case VolumeProvider callbacks
+    // are not fired (known Android 12+ issue)
+    private var volumeObserver: ContentObserver? = null
+    private var lastObservedSystemVol: Int = -1
+    private var systemMaxVol: Int = 15
+
     override fun onBind(intent: Intent?): IBinder? = null
 
     override fun onCreate() {
         super.onCreate()
         instance = this
         createNotificationChannel()
         audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        systemMaxVol = audioManager?.getStreamMaxVolume(AudioManager.STREAM_MUSIC) ?: 15
         log("info", "[Service] onCreate")
     }
 
@@ -128,7 +135,6 @@ class AudioStreamService : Service() {
             return START_NOT_STICKY
         }
 
-        // Set up MediaSession before startForeground so the notification can reference it
         setupMediaSession(volume, logScaling)
 
         try {
@@ -165,6 +171,9 @@ class AudioStreamService : Service() {
             muteLocalAudio()
         }
 
+        // Start fallback volume observer
+        startVolumeObserver(volume)
+
         startStreaming(host, port, sampleRate, channels, frameSize, packetPacing, repeatPackets, verboseLogging, volume, logScaling)
 
         return START_NOT_STICKY
@@ -224,20 +233,47 @@ class AudioStreamService : Service() {
     private fun setupMediaSession(initialVolume: Int, logScaling: Boolean) {
         try {
             mediaSession = MediaSession(this, "AirwireStreamer").apply {
+                // Set metadata so the system treats this as a real media session
+                setMetadata(
+                    MediaMetadata.Builder()
+                        .putString(MediaMetadata.METADATA_KEY_TITLE, "Airwire Streamer")
+                        .putString(MediaMetadata.METADATA_KEY_ARTIST, "Streaming audio")
+                        .putLong(MediaMetadata.METADATA_KEY_DURATION, -1L)
+                        .build()
+                )
+
                 setPlaybackState(
                     PlaybackState.Builder()
                         .setState(PlaybackState.STATE_PLAYING, 0, 1.0f)
-                        .setActions(PlaybackState.ACTION_PLAY or PlaybackState.ACTION_STOP)
+                        .setActions(
+                            PlaybackState.ACTION_PLAY or
+                            PlaybackState.ACTION_STOP or
+                            PlaybackState.ACTION_PAUSE
+                        )
                         .build()
                 )
 
+                // Set a callback for media button events
+                setCallback(object : MediaSession.Callback() {
+                    override fun onPlay() {
+                        log("info", "[MediaSession] onPlay callback")
+                    }
+                    override fun onStop() {
+                        log("info", "[MediaSession] onStop callback")
+                    }
+                    override fun onPause() {
+                        log("info", "[MediaSession] onPause callback")
+                    }
+                }, Handler(Looper.getMainLooper()))
+
                 val vp = object : VolumeProvider(
                     VOLUME_CONTROL_ABSOLUTE,
                     100,
                     initialVolume.coerceIn(0, 100)
                 ) {
                     override fun onSetVolumeTo(volume: Int) {
                         val clamped = volume.coerceIn(0, 100)
+                        log("info", "[VolumeProvider] onSetVolumeTo: $clamped")
                         setCurrentVolume(clamped)
                         applyVolume(clamped, currentLogScaling)
                         AudioStreamEventEmitter.emit("volume_change", clamped.toString())
@@ -252,6 +288,7 @@ class AudioStreamService : Service() {
                             AudioManager.ADJUST_UNMUTE -> current
                             else -> current
                         }
+                        log("info", "[VolumeProvider] onAdjustVolume: direction=$direction, $current->$newVol")
                         setCurrentVolume(newVol)
                         applyVolume(newVol, currentLogScaling)
                         AudioStreamEventEmitter.emit("volume_change", newVol.toString())
@@ -267,7 +304,42 @@ class AudioStreamService : Service() {
         }
     }
 
-    /** Called from AudioCaptureModule.updateVolume or from MediaSession VolumeProvider */
+    /**
+     * Fallback: If VolumeProvider callbacks don't fire (Android 12+ bug),
+     * observe system STREAM_MUSIC volume changes and map them to our gain.
+     * When the user drags the system "cast" slider, on broken Android versions
+     * it changes STREAM_MUSIC directly instead of calling VolumeProvider.
+     */
+    private fun startVolumeObserver(initialAppVolume: Int) {
+        val am = audioManager ?: return
+        lastObservedSystemVol = am.getStreamVolume(AudioManager.STREAM_MUSIC)
+
+        val handler = Handler(Looper.getMainLooper())
+        volumeObserver = object : ContentObserver(handler) {
+            override fun onChange(selfChange: Boolean) {
+                val newSysVol = am.getStreamVolume(AudioManager.STREAM_MUSIC)
+                if (newSysVol != lastObservedSystemVol) {
+                    val delta = newSysVol - lastObservedSystemVol
+                    lastObservedSystemVol = newSysVol
+
+                    // Map system volume (0..systemMaxVol) to app volume (0..100)
+                    val appVol = ((newSysVol.toFloat() / systemMaxVol.toFloat()) * 100).toInt().coerceIn(0, 100)
+                    log("info", "[VolumeObserver] System vol changed: $newSysVol/$systemMaxVol -> appVol=$appVol (delta=$delta)")
+                    applyVolume(appVol, currentLogScaling)
+                    syncMediaSessionVolume(appVol)
+                    AudioStreamEventEmitter.emit("volume_change", appVol.toString())
+                }
+            }
+        }
+
+        contentResolver.registerContentObserver(
+            Settings.System.CONTENT_URI,
+            true,
+            volumeObserver!!
+        )
+        log("info", "[Service] Volume observer registered (sysVol=$lastObservedSystemVol/$systemMaxVol)")
+    }
+
     fun applyVolume(volume: Int, logScaling: Boolean) {
         val clamped = volume.coerceIn(0, 100)
         currentLogScaling = logScaling
@@ -279,7 +351,6 @@ class AudioStreamService : Service() {
         }
     }
 
-    /** Called from AudioCaptureModule to sync MediaSession's volume display */
     fun syncMediaSessionVolume(volume: Int) {
         volumeProvider?.setCurrentVolume(volume.coerceIn(0, 100))
     }
@@ -303,7 +374,6 @@ class AudioStreamService : Service() {
             .setSmallIcon(android.R.drawable.ic_media_play)
             .setOngoing(true)
 
-        // Attach MediaSession token so system volume UI routes here
         val session = mediaSession
         if (session != null) {
             builder.setStyle(
@@ -399,7 +469,6 @@ class AudioStreamService : Service() {
         val recState = audioRecord?.recordingState
         log("info", "[Stream] AudioRecord recordingState=$recState (3=recording)")
 
-        // Set initial gain
         applyVolume(volume, logScaling)
         log("info", "[Stream] Initial volume=$volume%, logScaling=$logScaling, gain=$currentGain")
 
@@ -429,7 +498,6 @@ class AudioStreamService : Service() {
                 }
                 if (shortsRead == 0) continue
 
-                // Read the volatile gain (may be updated by slider or MediaSession at any time)
                 val gain = currentGain
                 if (gain < 1.0f) {
                     for (s in 0 until shortsRead) {
@@ -514,6 +582,12 @@ class AudioStreamService : Service() {
         mediaSession = null
         volumeProvider = null
 
+        // Unregister volume observer
+        try {
+            volumeObserver?.let { contentResolver.unregisterContentObserver(it) }
+        } catch (_: Exception) {}
+        volumeObserver = null
+
         restoreLocalAudio()
 
         try {