react-native-media-notification 0.2.0

package/android/src/main/java/com/mediacontrols/MediaControlsModule.kt

@@ -0,0 +1,188 @@
+package com.mediacontrols
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = MediaControlsModule.NAME)
+@UnstableApi
+class MediaControlsModule(reactContext: ReactApplicationContext) :
+  NativeMediaControlsSpec(reactContext) {
+
+  private var mediaService: MediaControlsService? = null
+  private var serviceBound = false
+  private var serviceInitialized = false // Flag to track if service has been initialized
+
+  private val serviceConnection = object : ServiceConnection {
+    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+      val binder = service as? MediaControlsService.LocalBinder
+      mediaService = binder?.getService()
+      serviceBound = true
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+      mediaService = null
+      serviceBound = false
+    }
+  }
+
+  init {
+    // Set react context for the service, but don't start it yet
+    MediaControlsService.reactContext = reactContext
+    MediaControlsService.player = MediaControlsPlayer(reactContext, this)
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  override fun setControlEnabled(name: String, enabled: Boolean) {
+    val control = Controls.fromString(name) ?: throw IllegalArgumentException("Invalid control name: $name")
+    MediaControlsService.player?.setControlEnabled(control, enabled)
+  }
+
+  @ReactMethod
+  override fun updateMetadata(metadata: ReadableMap, promise: Promise) {
+    try {
+      // Start service on first updateMetadata call
+      ensureServiceStarted()
+
+      val trackMetadata = MediaTrackMetadata(
+        title = metadata.getString("title") ?: "",
+        artist = metadata.getString("artist") ?: "",
+        album = metadata.getString("album"),
+        duration = if (metadata.hasKey("duration")) metadata.getDouble("duration") else null,
+        artwork = metadata.getString("artwork"),
+        position = if (metadata.hasKey("position")) metadata.getDouble("position") else null,
+        isPlaying = if (metadata.hasKey("isPlaying")) metadata.getBoolean("isPlaying") else null,
+        shuffleMode = if (metadata.hasKey("shuffle")) metadata.getBoolean("shuffle") else null,
+        repeatMode = if (metadata.hasKey("repeatMode")) metadata.getString("repeatMode") else null,
+      )
+
+      MediaControlsService.player?.updateMetadata(trackMetadata)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("UPDATE_METADATA_ERROR", "Failed to update metadata: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  override fun stopMediaNotification(promise: Promise) {
+    try {
+      stopMediaService()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("STOP_NOTIFICATION_ERROR", "Failed to stop notification: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  override fun enableAudioInterruption(enabled: Boolean, promise: Promise) {
+    try {
+      MediaControlsService.player?.setAudioInterruptionEnabled(enabled)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("AUDIO_INTERRUPTION_ERROR", "Failed to enable audio interruption: ${e.message}", e)
+    }
+  }
+
+  override fun enableBackgroundMode(enabled: Boolean) {
+    // NOOP on android
+  }
+
+  @ReactMethod
+  fun getControlsEnabled(promise: Promise) {
+    try {
+      ensureServiceStarted()
+      val player = MediaControlsService.player
+      val controls = Controls.entries.associate{ Pair(it.code, player?.isControlEnabled(it) ?: false) }
+
+      val result = Arguments.createMap()
+      controls.forEach { (key, value) ->
+        result.putBoolean(key, value)
+      }
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("GET_CONTROLS_ERROR", "Failed to get controls state: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  fun getCurrentPlayerState(promise: Promise) {
+    try {
+      ensureServiceStarted()
+      val player = MediaControlsService.player
+      val result = Arguments.createMap()
+
+      if (player != null) {
+        result.putBoolean("isPlaying", player.isPlaying)
+        result.putBoolean("playWhenReady", player.playWhenReady)
+        result.putInt("playbackState", player.playbackState)
+        result.putString("currentTitle", player.mediaMetadata.title?.toString() ?: "Unknown")
+      } else {
+        result.putBoolean("isPlaying", false)
+        result.putString("error", "Player not available")
+      }
+
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("GET_PLAYER_STATE_ERROR", "Failed to get player state: ${e.message}", e)
+    }
+  }
+
+  private fun ensureServiceStarted() {
+    if (!serviceInitialized) {
+      startMediaService()
+      serviceInitialized = true
+    }
+  }
+
+  fun sendEvent(eventName: Controls, position: Int?) {
+    val eventData = Arguments.createMap().apply {
+        putString("command", eventName.code)
+        position?.let {
+          putInt("seekPosition", it)
+        }
+    }
+    emitOnEvent(eventData)
+  }
+
+  private fun startMediaService() {
+    val intent = Intent(reactApplicationContext, MediaControlsService::class.java)
+    reactApplicationContext.startService(intent)
+    reactApplicationContext.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
+  }
+
+  private fun stopMediaService() {
+    mediaService?.stopNotificationAndService()
+
+    if (serviceBound) {
+      reactApplicationContext.unbindService(serviceConnection)
+      serviceBound = false
+    }
+
+    val intent = Intent(reactApplicationContext, MediaControlsService::class.java)
+    reactApplicationContext.stopService(intent)
+    serviceInitialized = false
+    mediaService = null
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    stopMediaService()
+  }
+
+  companion object {
+    const val NAME = "MediaControls"
+  }
+}

package/android/src/main/java/com/mediacontrols/MediaControlsPackage.kt

@@ -0,0 +1,36 @@
+package com.mediacontrols
+
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class MediaControlsPackage : BaseReactPackage() {
+    @UnstableApi
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == MediaControlsModule.NAME) {
+      MediaControlsModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+    @UnstableApi
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[MediaControlsModule.NAME] = ReactModuleInfo(
+        MediaControlsModule.NAME,
+        MediaControlsModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/mediacontrols/MediaControlsPlayer.kt

@@ -0,0 +1,321 @@
+package com.mediacontrols
+
+import android.os.Handler
+import android.os.Looper
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.common.SimpleBasePlayer
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.ListenableFuture
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import androidx.core.net.toUri
+import androidx.media3.session.CommandButton
+
+@UnstableApi
+class MediaControlsPlayer(
+    reactContext: ReactApplicationContext,
+    private val module: MediaControlsModule,
+) : SimpleBasePlayer(Looper.getMainLooper()) {
+
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private var currentState = State.Builder().build()
+
+    // Track metadata
+    private var currentMetadata: MediaTrackMetadata? = null
+
+    // Audio interruption
+    private var audioInterruptionEnabled = false
+
+    private var audioFocusListener = AudioFocusListener(reactContext, module, this)
+
+    // Control states
+    private val enabledControls = mutableMapOf<Controls, Boolean>()
+
+    override fun getState(): State = currentState
+
+    override fun handleSetPlayWhenReady(playWhenReady: Boolean): ListenableFuture<*> {
+        if (playWhenReady && audioInterruptionEnabled) {
+            audioFocusListener.requestAudioFocus()
+        }
+
+        updateState { builder ->
+            builder
+                .setPlayWhenReady(
+                    playWhenReady,
+                    Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST
+                )
+                .setContentPositionMs(currentState.contentPositionMsSupplier.get())
+        }
+
+        // Emit event to React Native
+        emitPlaybackStateChanged(playWhenReady)
+
+        return Futures.immediateFuture(null)
+    }
+
+    override fun handlePrepare(): ListenableFuture<*> {
+        updateState { builder ->
+            builder.setPlaybackState(Player.STATE_READY)
+        }
+        return Futures.immediateFuture(null)
+    }
+
+    override fun handleStop(): ListenableFuture<*> {
+        updateState { builder ->
+            builder.setPlayWhenReady(false, Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST)
+                .setPlaybackState(Player.STATE_IDLE)
+        }
+
+        module.sendEvent(Controls.STOP, null)
+        return Futures.immediateFuture(null)
+    }
+
+    override fun handleSeek(
+        mediaItemIndex: Int,
+        positionMs: Long,
+        seekCommand: Int
+    ): ListenableFuture<*> {
+        updateState { builder ->
+            builder.setCurrentMediaItemIndex(mediaItemIndex)
+                .setContentPositionMs(positionMs)
+        }
+
+        // Handle different seek commands
+        when (seekCommand) {
+            Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM -> {
+                module.sendEvent(Controls.NEXT, null)
+            }
+            Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM -> {
+                module.sendEvent(Controls.PREVIOUS, null)
+            }
+            Player.COMMAND_SEEK_FORWARD -> {
+                val positionSeconds = (positionMs / 1000).toInt()
+                module.sendEvent(Controls.SEEK_FORWARD, positionSeconds)
+            }
+            Player.COMMAND_SEEK_BACK -> {
+                val positionSeconds = (positionMs / 1000).toInt()
+                module.sendEvent(Controls.SEEK_BACKWARD, positionSeconds)
+            }
+            else -> {
+                emitSeekEvent(positionMs)
+            }
+        }
+
+        return Futures.immediateFuture(null)
+    }
+
+    override fun handleSetMediaItems(
+        mediaItems: List<MediaItem>,
+        startIndex: Int,
+        startPositionMs: Long
+    ): ListenableFuture<*> {
+        val mediaItemDataList = mediaItems.map { mediaItem ->
+            MediaItemData.Builder(mediaItem.mediaId)
+                .setMediaItem(mediaItem)
+                .build()
+        }
+
+        updateState { builder ->
+            builder.setPlaylist(mediaItemDataList)
+                .setCurrentMediaItemIndex(startIndex)
+                .setContentPositionMs(startPositionMs)
+        }
+        return Futures.immediateFuture(null)
+    }
+
+    fun emitShuffleClicked() {
+        module.sendEvent(Controls.SHUFFLE, null)
+    }
+
+    fun emitRepeatClicked() {
+        module.sendEvent(Controls.REPEAT_MODE, null)
+    }
+
+    // Custom methods for React Native integration
+    fun updateMetadata(metadata: MediaTrackMetadata) {
+        if (metadata.isPlaying == true && audioInterruptionEnabled) {
+            audioFocusListener.requestAudioFocus()
+        }
+
+        this.currentMetadata = metadata
+
+        val mediaMetadata = MediaMetadata.Builder()
+            .setTitle(metadata.title)
+            .setArtist(metadata.artist)
+            .setAlbumTitle(metadata.album)
+            .setDurationMs(metadata.duration?.times(1000)?.toLong())
+            .setIsPlayable(true)
+            .setIsBrowsable(false)
+            .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC)
+            .apply {
+                metadata.artwork?.let { artworkUrl ->
+                    setArtworkUri(artworkUrl.toUri())
+                }
+            }
+            .build()
+
+        // Create unique media ID for Android Auto
+        val mediaId = "${metadata.title}_${metadata.artist}".replace(" ", "_")
+
+        val mediaItem = MediaItem.Builder()
+            .setMediaId(mediaId)
+            .setUri("content://media/external/audio/media/1") // Placeholder URI for Android Auto
+            .setMediaMetadata(mediaMetadata)
+            .build()
+
+        val mediaItemData = MediaItemData.Builder(mediaId)
+            .setMediaItem(mediaItem)
+            .setDefaultPositionUs(metadata.position?.times(1_000_000)?.toLong() ?: 0)
+            .setDurationUs(metadata.duration?.times(1_000_000)?.toLong() ?: androidx.media3.common.C.TIME_UNSET)
+            .setIsSeekable(true)
+            .build()
+
+        updateState { builder ->
+            builder.setPlaylist(listOf(mediaItemData))
+                .setCurrentMediaItemIndex(0)
+                .setContentPositionMs(metadata.position?.times(1000)?.toLong() ?: 0)
+                .setPlayWhenReady(
+                    metadata.isPlaying ?: false,
+                    Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST
+                )
+                .setPlaybackState(Player.STATE_READY)
+                .setAvailableCommands(state.availableCommands)
+                .setRepeatMode(metadata.repeatMode)
+                .setShuffleModeEnabled(metadata.shuffleMode)
+        }
+    }
+
+    private fun State.Builder.setRepeatMode(mode: String?): State.Builder {
+        val repeatMode = when (mode) {
+            "off" -> Player.REPEAT_MODE_OFF
+            "one" -> Player.REPEAT_MODE_ONE
+            "all" -> Player.REPEAT_MODE_ALL
+            else -> null
+        }
+        if (repeatMode == null) {
+            return this
+        }
+        return this.setRepeatMode(repeatMode)
+    }
+
+    private fun State.Builder.setShuffleModeEnabled(enabled: Boolean?): State.Builder {
+        if (enabled == null) {
+            return this
+        }
+        return this.setShuffleModeEnabled(enabled)
+    }
+
+    fun setControlEnabled(controlName: Controls, enabled: Boolean) {
+        enabledControls[controlName] = enabled
+
+        // Update available commands based on enabled controls
+        val availableCommands = mutableSetOf<Int>().apply {
+            if (enabledControls[Controls.PLAY] == true || enabledControls[Controls.PAUSE] == true) add(Player.COMMAND_PLAY_PAUSE)
+            if (enabledControls[Controls.STOP] == true) add(Player.COMMAND_STOP)
+            if (enabledControls[Controls.NEXT] == true) add(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM)
+            if (enabledControls[Controls.PREVIOUS] == true) add(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM)
+            if (enabledControls[Controls.SEEK] == true) add(Player.COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM)
+            if (enabledControls[Controls.SEEK_FORWARD] == true) add(Player.COMMAND_SEEK_FORWARD)
+            if (enabledControls[Controls.SEEK_BACKWARD] == true) add(Player.COMMAND_SEEK_BACK)
+            if (enabledControls[Controls.SHUFFLE] == true) add(Player.COMMAND_SET_SHUFFLE_MODE)
+            if (enabledControls[Controls.REPEAT_MODE] == true) add(Player.COMMAND_SET_REPEAT_MODE)
+
+            add(Player.COMMAND_PREPARE)
+            add(Player.COMMAND_GET_CURRENT_MEDIA_ITEM)
+            add(Player.COMMAND_GET_METADATA)
+        }
+
+        updateState { builder ->
+            builder.setAvailableCommands(Player.Commands.Builder().addAll(*availableCommands.toIntArray()).build())
+        }
+    }
+
+    fun getAvailableCustomCommands(): Set<CommandButton> {
+        return mutableSetOf<CommandButton>().apply {
+            if(isControlEnabled(Controls.SHUFFLE)) {
+                if (state.shuffleModeEnabled) {
+                    add(CustomCommandButton.SHUFFLE_ON.commandButton)
+                } else {
+                    add(CustomCommandButton.SHUFFLE_OFF.commandButton)
+                }
+            }
+            if (isControlEnabled(Controls.REPEAT_MODE)) {
+                when (state.repeatMode) {
+                    REPEAT_MODE_OFF -> add(CustomCommandButton.REPEAT_OFF.commandButton)
+                    REPEAT_MODE_ONE -> add(CustomCommandButton.REPEAT_ONE.commandButton)
+                    REPEAT_MODE_ALL -> add(CustomCommandButton.REPEAT_ALL.commandButton)
+                }
+            }
+            if (isControlEnabled(Controls.SEEK_BACKWARD)) add(CustomCommandButton.REWIND.commandButton)
+            if (isControlEnabled(Controls.SEEK_FORWARD)) add(CustomCommandButton.FORWARD.commandButton)
+        }
+    }
+
+    fun isControlEnabled(controlName: Controls): Boolean {
+        return enabledControls[controlName] ?: false
+    }
+
+    fun setAudioInterruptionEnabled(enabled: Boolean) {
+        if (audioInterruptionEnabled == enabled) return
+        audioInterruptionEnabled = enabled
+
+        if (enabled) {
+            audioFocusListener.requestAudioFocus()
+        } else {
+            audioFocusListener.abandonAudioFocus()
+        }
+    }
+
+    fun releaseFocus() {
+        audioFocusListener.abandonAudioFocus()
+    }
+
+    fun isAudioInterruptionEnabled(): Boolean = audioInterruptionEnabled
+
+    private fun updateState(updater: (State.Builder) -> State.Builder) {
+        val newState = updater(currentState.buildUpon()).build()
+        currentState = newState
+
+        // Ensure invalidateState is called on the correct thread
+        if (Looper.myLooper() == applicationLooper) {
+            invalidateState()
+        } else {
+            Handler(applicationLooper).post {
+                invalidateState()
+            }
+        }
+    }
+
+    private fun emitPlaybackStateChanged(isPlaying: Boolean) {
+        val command = if (isPlaying) Controls.PLAY else Controls.PAUSE
+        module.sendEvent(command, null)
+    }
+
+    private fun emitSeekEvent(positionMs: Long) {
+        val positionSeconds = (positionMs / 1000).toInt()
+        module.sendEvent(Controls.SEEK, positionSeconds)
+    }
+
+    fun cleanup() {
+        scope.cancel()
+    }
+}
+
+// Data class for metadata
+data class MediaTrackMetadata(
+    val title: String,
+    val artist: String,
+    val album: String? = null,
+    val duration: Double? = null,
+    val artwork: String? = null,
+    val position: Double? = null,
+    val isPlaying: Boolean? = null,
+    val repeatMode: String? = null,
+    val shuffleMode: Boolean? = null
+)