react-native-audio-api 0.11.0-nightly-db51488-20251207 → 0.11.0-nightly-6ba0571-20251209

package/android/src/main/java/com/swmansion/audioapi/system/LockScreenManager.kt

@@ -1,347 +0,0 @@
-package com.swmansion.audioapi.system
-
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.graphics.drawable.BitmapDrawable
-import android.support.v4.media.MediaMetadataCompat
-import android.support.v4.media.session.MediaSessionCompat
-import android.support.v4.media.session.PlaybackStateCompat
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import androidx.media.app.NotificationCompat.MediaStyle
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableType
-import com.swmansion.audioapi.R
-import java.io.IOException
-import java.lang.ref.WeakReference
-import java.net.URL
-
-class LockScreenManager(
-  private val reactContext: WeakReference<ReactApplicationContext>,
-  private val mediaSession: WeakReference<MediaSessionCompat>,
-  private val mediaNotificationManager: WeakReference<MediaNotificationManager>,
-) {
-  private var pb: PlaybackStateCompat.Builder = PlaybackStateCompat.Builder()
-  private var state: PlaybackStateCompat = pb.build()
-  private var controls: Long = 0
-  var isPlaying: Boolean = false
-
-  private var nb: NotificationCompat.Builder = NotificationCompat.Builder(reactContext.get()!!, MediaSessionManager.CHANNEL_ID)
-
-  private var artworkThread: Thread? = null
-
-  private var title: String? = null
-  private var artist: String? = null
-  private var album: String? = null
-  private var description: String? = null
-  private var duration: Long = 0L
-  private var speed: Float = 1.0F
-  private var elapsedTime: Long = 0L
-  private var artwork: String? = null
-  private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
-
-  init {
-    pb.setActions(controls)
-    nb.setPriority(NotificationCompat.PRIORITY_HIGH)
-    nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-
-    updateNotificationMediaStyle()
-    mediaNotificationManager.get()?.updateActions(controls)
-  }
-
-  fun setLockScreenInfo(info: ReadableMap?) {
-    if (artworkThread != null && artworkThread!!.isAlive) {
-      artworkThread!!.interrupt()
-    }
-
-    artworkThread = null
-
-    if (info == null) {
-      return
-    }
-
-    val md = MediaMetadataCompat.Builder()
-
-    if (info.hasKey("title")) {
-      title = info.getString("title")
-    }
-
-    if (info.hasKey("artist")) {
-      artist = info.getString("artist")
-    }
-
-    if (info.hasKey("album")) {
-      album = info.getString("album")
-    }
-
-    if (info.hasKey("description")) {
-      description = info.getString("description")
-    }
-
-    if (info.hasKey("duration")) {
-      duration = (info.getDouble("duration") * 1000).toLong()
-    }
-
-    md.putText(MediaMetadataCompat.METADATA_KEY_TITLE, title)
-    md.putText(MediaMetadataCompat.METADATA_KEY_ARTIST, artist)
-    md.putText(MediaMetadataCompat.METADATA_KEY_ALBUM, album)
-    md.putText(MediaMetadataCompat.METADATA_KEY_DISPLAY_DESCRIPTION, description)
-    md.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, duration)
-
-    nb.setContentTitle(title)
-    nb.setContentText(artist)
-    nb.setContentInfo(album)
-
-    if (info.hasKey("artwork")) {
-      var localArtwork = false
-
-      if (info.getType("artwork") == ReadableType.Map) {
-        artwork = info.getMap("artwork")?.getString("uri")
-        localArtwork = true
-      } else {
-        artwork = info.getString("artwork")
-      }
-
-      val artworkLocal = localArtwork
-
-      artworkThread =
-        Thread {
-          try {
-            val bitmap: Bitmap? = artwork?.let { loadArtwork(it, artworkLocal) }
-
-            val currentMetadata = mediaSession.get()?.controller?.metadata
-            val newBuilder =
-              MediaMetadataCompat.Builder(
-                currentMetadata,
-              )
-            mediaSession.get()?.setMetadata(
-              newBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, bitmap).build(),
-            )
-
-            nb.setLargeIcon(bitmap)
-            mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
-
-            artworkThread = null
-          } catch (ex: Exception) {
-            ex.printStackTrace()
-          }
-        }
-      artworkThread!!.start()
-    }
-
-    speed =
-      if (info.hasKey("speed")) {
-        info.getDouble("speed").toFloat()
-      } else {
-        state.playbackSpeed
-      }
-
-    if (isPlaying && speed == 0F) {
-      speed = 1F
-    }
-
-    elapsedTime =
-      if (info.hasKey("elapsedTime")) {
-        (info.getDouble("elapsedTime") * 1000).toLong()
-      } else {
-        state.position
-      }
-
-    if (info.hasKey("state")) {
-      val state = info.getString("state")
-
-      when (state) {
-        "state_playing" -> {
-          this.playbackState = PlaybackStateCompat.STATE_PLAYING
-        }
-
-        "state_paused" -> {
-          this.playbackState = PlaybackStateCompat.STATE_PAUSED
-        }
-      }
-    }
-
-    updatePlaybackState(this.playbackState)
-
-    mediaSession.get()?.setMetadata(md.build())
-    mediaSession.get()?.setActive(true)
-    mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
-  }
-
-  fun resetLockScreenInfo() {
-    if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
-    artworkThread = null
-
-    title = null
-    artist = null
-    album = null
-    description = null
-    duration = 0L
-    speed = 1.0F
-    elapsedTime = 0L
-    artwork = null
-    playbackState = PlaybackStateCompat.STATE_PAUSED
-    isPlaying = false
-
-    val emptyMetadata = MediaMetadataCompat.Builder().build()
-    mediaSession.get()?.setMetadata(emptyMetadata)
-
-    pb.setState(PlaybackStateCompat.STATE_NONE, 0, 0f)
-    pb.setActions(controls)
-    state = pb.build()
-    mediaSession.get()?.setPlaybackState(state)
-    mediaSession.get()?.setActive(false)
-
-    nb.setContentTitle("")
-    nb.setContentText("")
-    nb.setContentInfo("")
-
-    mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
-  }
-
-  fun enableRemoteCommand(
-    name: String,
-    enabled: Boolean,
-  ) {
-    pb = PlaybackStateCompat.Builder()
-    var controlValue = 0L
-    when (name) {
-      "remotePlay" -> controlValue = PlaybackStateCompat.ACTION_PLAY
-      "remotePause" -> controlValue = PlaybackStateCompat.ACTION_PAUSE
-      "remoteStop" -> controlValue = PlaybackStateCompat.ACTION_STOP
-      "remoteTogglePlayPause" -> controlValue = PlaybackStateCompat.ACTION_PLAY_PAUSE
-      "remoteNextTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_NEXT
-      "remotePreviousTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
-      "remoteSkipForward" -> controlValue = PlaybackStateCompat.ACTION_FAST_FORWARD
-      "remoteSkipBackward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
-      "remoteChangePlaybackPosition" -> controlValue = PlaybackStateCompat.ACTION_SEEK_TO
-    }
-
-    controls =
-      if (enabled) {
-        controls or controlValue
-      } else {
-        controls and controlValue.inv()
-      }
-
-    mediaNotificationManager.get()?.updateActions(controls)
-
-    if (hasControl(PlaybackStateCompat.ACTION_REWIND)) {
-      pb.addCustomAction(
-        PlaybackStateCompat.CustomAction
-          .Builder(
-            "SkipBackward",
-            "Skip Backward",
-            R.drawable.skip_backward_15,
-          ).build(),
-      )
-    }
-
-    pb.setActions(controls)
-
-    if (hasControl(PlaybackStateCompat.ACTION_FAST_FORWARD)) {
-      pb.addCustomAction(
-        PlaybackStateCompat.CustomAction
-          .Builder(
-            "SkipForward",
-            "Skip Forward",
-            R.drawable.skip_forward_15,
-          ).build(),
-      )
-    }
-
-    state = pb.build()
-    mediaSession.get()?.setPlaybackState(state)
-
-    updateNotificationMediaStyle()
-
-    if (mediaSession.get()?.isActive == true) {
-      mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
-    }
-  }
-
-  private fun loadArtwork(
-    url: String,
-    local: Boolean,
-  ): Bitmap? {
-    var bitmap: Bitmap? = null
-
-    try {
-      // If we are running the app in debug mode, the "local" image will be served from htt://localhost:8080, so we need to check for this case and load those images from URL
-      if (local && !url.startsWith("http")) {
-        // Gets the drawable from the RN's helper for local resources
-        val helper = com.facebook.react.views.imagehelper.ResourceDrawableIdHelper.instance
-        val image = helper.getResourceDrawable(reactContext.get()!!, url)
-
-        bitmap =
-          if (image is BitmapDrawable) {
-            image.bitmap
-          } else {
-            BitmapFactory.decodeFile(url)
-          }
-      } else {
-        // Open connection to the URL and decodes the image
-        val con = URL(url).openConnection()
-        con.connect()
-        val input = con.getInputStream()
-        bitmap = BitmapFactory.decodeStream(input)
-        input.close()
-      }
-    } catch (ex: IOException) {
-      Log.w("MediaSessionManager", "Could not load the artwork", ex)
-    } catch (ex: IndexOutOfBoundsException) {
-      Log.w("MediaSessionManager", "Could not load the artwork", ex)
-    }
-
-    return bitmap
-  }
-
-  private fun updatePlaybackState(playbackState: Int) {
-    isPlaying = playbackState == PlaybackStateCompat.STATE_PLAYING
-
-    pb.setState(playbackState, elapsedTime, speed)
-    pb.setActions(controls)
-    state = pb.build()
-    mediaSession.get()?.setPlaybackState(state)
-  }
-
-  private fun hasControl(control: Long): Boolean = (controls and control) == control
-
-  private fun updateNotificationMediaStyle() {
-    val style = MediaStyle()
-    style.setMediaSession(mediaSession.get()?.sessionToken)
-    var controlCount = 0
-    if (hasControl(PlaybackStateCompat.ACTION_PLAY) ||
-      hasControl(PlaybackStateCompat.ACTION_PAUSE) ||
-      hasControl(
-        PlaybackStateCompat.ACTION_PLAY_PAUSE,
-      )
-    ) {
-      controlCount += 1
-    }
-    if (hasControl(PlaybackStateCompat.ACTION_SKIP_TO_NEXT)) {
-      controlCount += 1
-    }
-    if (hasControl(PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS)) {
-      controlCount += 1
-    }
-    if (hasControl(PlaybackStateCompat.ACTION_FAST_FORWARD)) {
-      controlCount += 1
-    }
-    if (hasControl(PlaybackStateCompat.ACTION_REWIND)) {
-      controlCount += 1
-    }
-
-    if (hasControl(PlaybackStateCompat.ACTION_SEEK_TO)) {
-      controlCount += 1
-    }
-
-    val actions = IntArray(controlCount)
-    for (i in actions.indices) {
-      actions[i] = i
-    }
-    style.setShowActionsInCompactView(*actions)
-    nb.setStyle(style)
-  }
-}

package/android/src/main/java/com/swmansion/audioapi/system/MediaNotificationManager.kt

@@ -1,273 +0,0 @@
-package com.swmansion.audioapi.system
-
-import android.Manifest
-import android.annotation.SuppressLint
-import android.app.Notification
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Intent
-import android.content.pm.ServiceInfo
-import android.content.res.Resources
-import android.os.Build
-import android.os.IBinder
-import android.provider.ContactsContract
-import android.support.v4.media.session.PlaybackStateCompat
-import android.util.Log
-import android.view.KeyEvent
-import androidx.annotation.RequiresPermission
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.audioapi.R
-import java.lang.ref.WeakReference
-
-class MediaNotificationManager(
-  private val reactContext: WeakReference<ReactApplicationContext>,
-) {
-  private var smallIcon: Int = R.drawable.logo
-  private var customIcon: Int = 0
-
-  private var play: NotificationCompat.Action? = null
-  private var pause: NotificationCompat.Action? = null
-  private var stop: NotificationCompat.Action? = null
-  private var next: NotificationCompat.Action? = null
-  private var previous: NotificationCompat.Action? = null
-  private var skipForward: NotificationCompat.Action? = null
-  private var skipBackward: NotificationCompat.Action? = null
-
-  companion object {
-    const val REMOVE_NOTIFICATION: String = "audio_manager_remove_notification"
-    const val PACKAGE_NAME: String = "com.swmansion.audioapi.system"
-    const val MEDIA_BUTTON: String = "audio_manager_media_button"
-  }
-
-  enum class ForegroundAction {
-    START_FOREGROUND,
-    STOP_FOREGROUND,
-    ;
-
-    companion object {
-      fun fromAction(action: String?): ForegroundAction? = entries.firstOrNull { it.name == action }
-    }
-  }
-
-  @SuppressLint("RestrictedApi")
-  @Synchronized
-  fun prepareNotification(
-    builder: NotificationCompat.Builder,
-    isPlaying: Boolean,
-  ): Notification {
-    builder.mActions.clear()
-
-    if (previous != null) {
-      builder.addAction(previous)
-    }
-
-    if (skipBackward != null) {
-      builder.addAction(skipBackward)
-    }
-
-    if (play != null && !isPlaying) {
-      builder.addAction(play)
-    }
-
-    if (pause != null && isPlaying) {
-      builder.addAction(pause)
-    }
-
-    if (stop != null) {
-      builder.addAction(stop)
-    }
-
-    if (next != null) {
-      builder.addAction(next)
-    }
-
-    if (skipForward != null) {
-      builder.addAction(skipForward)
-    }
-
-    builder.setSmallIcon(if (customIcon != 0) customIcon else smallIcon)
-
-    val packageName: String? = reactContext.get()?.packageName
-    val openApp: Intent? = reactContext.get()?.packageManager?.getLaunchIntentForPackage(packageName!!)
-    try {
-      builder.setContentIntent(
-        PendingIntent.getActivity(
-          reactContext.get(),
-          0,
-          openApp,
-          PendingIntent.FLAG_IMMUTABLE,
-        ),
-      )
-    } catch (e: Exception) {
-      Log.w("AudioManagerModule", "Error creating content intent: ${e.message}")
-    }
-
-    val remove = Intent(REMOVE_NOTIFICATION)
-    remove.putExtra(PACKAGE_NAME, reactContext.get()?.applicationInfo?.packageName)
-    builder.setDeleteIntent(
-      PendingIntent.getBroadcast(
-        reactContext.get(),
-        0,
-        remove,
-        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
-      ),
-    )
-
-    return builder.build()
-  }
-
-  @RequiresPermission(Manifest.permission.POST_NOTIFICATIONS)
-  @Synchronized
-  fun updateNotification(
-    builder: NotificationCompat.Builder?,
-    isPlaying: Boolean,
-  ) {
-    NotificationManagerCompat.from(reactContext.get()!!).notify(
-      MediaSessionManager.NOTIFICATION_ID,
-      prepareNotification(builder!!, isPlaying),
-    )
-  }
-
-  fun cancelNotification() {
-    NotificationManagerCompat.from(reactContext.get()!!).cancel(MediaSessionManager.NOTIFICATION_ID)
-  }
-
-  @Synchronized
-  fun updateActions(mask: Long) {
-    play = createAction("play", "Play", mask, PlaybackStateCompat.ACTION_PLAY, play)
-    pause = createAction("pause", "Pause", mask, PlaybackStateCompat.ACTION_PAUSE, pause)
-    stop = createAction("stop", "Stop", mask, PlaybackStateCompat.ACTION_STOP, stop)
-    next = createAction("next", "Next", mask, PlaybackStateCompat.ACTION_SKIP_TO_NEXT, next)
-    previous = createAction("previous", "Previous", mask, PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS, previous)
-    skipForward = createAction("skip_forward_15", "Skip Forward", mask, PlaybackStateCompat.ACTION_FAST_FORWARD, skipForward)
-    skipBackward = createAction("skip_backward_15", "Skip Backward", mask, PlaybackStateCompat.ACTION_REWIND, skipBackward)
-  }
-
-  private fun createAction(
-    iconName: String,
-    title: String,
-    mask: Long,
-    action: Long,
-    oldAction: NotificationCompat.Action?,
-  ): NotificationCompat.Action? {
-    if ((mask and action) == 0L) {
-      return null
-    }
-
-    if (oldAction != null) {
-      return oldAction
-    }
-
-    val r: Resources? = reactContext.get()?.resources
-    val packageName: String? = reactContext.get()?.packageName
-    val icon = r?.getIdentifier(iconName, "drawable", packageName)
-
-    val keyCode = PlaybackStateCompat.toKeyCode(action)
-    val intent = Intent(MEDIA_BUTTON)
-    intent.putExtra(Intent.EXTRA_KEY_EVENT, KeyEvent(KeyEvent.ACTION_DOWN, keyCode))
-    intent.putExtra(ContactsContract.Directory.PACKAGE_NAME, packageName)
-    val i =
-      PendingIntent.getBroadcast(
-        reactContext.get(),
-        keyCode,
-        intent,
-        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
-      )
-
-    return NotificationCompat.Action(icon!!, title, i)
-  }
-
-  class AudioForegroundService : Service() {
-    private var notification: Notification? = null
-    private var isServiceStarted = false
-    private val serviceLock = Any()
-
-    override fun onBind(intent: Intent): IBinder? = null
-
-    private fun startForegroundService() {
-      synchronized(serviceLock) {
-        if (!isServiceStarted) {
-          try {
-            notification =
-              MediaSessionManager.mediaNotificationManager
-                .prepareNotification(
-                  NotificationCompat.Builder(this, MediaSessionManager.CHANNEL_ID),
-                  false,
-                )
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-              startForeground(
-                MediaSessionManager.NOTIFICATION_ID,
-                notification!!,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST,
-              )
-            } else {
-              startForeground(
-                MediaSessionManager.NOTIFICATION_ID,
-                notification,
-              )
-            }
-            isServiceStarted = true
-          } catch (ex: Exception) {
-            Log.e("AudioManagerModule", "Error starting foreground service: ${ex.message}")
-            stopSelf()
-          }
-        }
-      }
-    }
-
-    override fun onStartCommand(
-      intent: Intent?,
-      flags: Int,
-      startId: Int,
-    ): Int {
-      val action = ForegroundAction.fromAction(intent?.action)
-
-      when (action) {
-        ForegroundAction.START_FOREGROUND -> startForegroundService()
-        ForegroundAction.STOP_FOREGROUND -> stopForegroundService()
-        else -> startForegroundService()
-      }
-
-      return START_NOT_STICKY
-    }
-
-    private fun stopForegroundService() {
-      synchronized(serviceLock) {
-        if (isServiceStarted) {
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-          }
-          isServiceStarted = false
-          stopSelf()
-        }
-      }
-    }
-
-    override fun onTaskRemoved(rootIntent: Intent?) {
-      super.onTaskRemoved(rootIntent)
-      stopForegroundService()
-    }
-
-    override fun onDestroy() {
-      synchronized(serviceLock) {
-        notification = null
-        isServiceStarted = false
-      }
-      super.onDestroy()
-    }
-
-    override fun onTimeout(startId: Int) {
-      stopForegroundService()
-    }
-
-    override fun onTimeout(
-      startId: Int,
-      fgsType: Int,
-    ) {
-      stopForegroundService()
-    }
-  }
-}

package/android/src/main/java/com/swmansion/audioapi/system/MediaReceiver.kt

@@ -1,57 +0,0 @@
-package com.swmansion.audioapi.system
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.media.AudioManager
-import android.support.v4.media.session.MediaSessionCompat
-import android.view.KeyEvent
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.audioapi.AudioAPIModule
-import java.lang.ref.WeakReference
-
-class MediaReceiver(
-  private val reactContext: WeakReference<ReactApplicationContext>,
-  private val mediaSession: WeakReference<MediaSessionCompat>,
-  private val mediaNotificationManager: WeakReference<MediaNotificationManager>,
-  private val audioAPIModule: WeakReference<AudioAPIModule>,
-) : BroadcastReceiver() {
-  override fun onReceive(
-    context: Context?,
-    intent: Intent?,
-  ) {
-    val action = intent!!.action
-
-    if (MediaNotificationManager.REMOVE_NOTIFICATION == action) {
-      if (!checkApp(intent)) return
-
-      mediaNotificationManager.get()?.cancelNotification()
-      MediaSessionManager.stopForegroundServiceIfNecessary()
-      mediaSession.get()?.isActive = false
-
-      audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("closeNotification", mapOf()) // add to ts events
-    } else if (MediaNotificationManager.MEDIA_BUTTON == action || Intent.ACTION_MEDIA_BUTTON == action) {
-      if (!intent.hasExtra(Intent.EXTRA_KEY_EVENT)) return
-      if (!checkApp(intent)) return
-
-      val keyEvent = intent.getParcelableExtra<KeyEvent>(Intent.EXTRA_KEY_EVENT)
-      mediaSession.get()?.controller?.dispatchMediaButtonEvent(keyEvent)
-    } else if (AudioManager.ACTION_AUDIO_BECOMING_NOISY == action) {
-      mediaSession
-        .get()
-        ?.controller
-        ?.transportControls
-        ?.pause()
-    }
-  }
-
-  private fun checkApp(intent: Intent): Boolean {
-    if (intent.hasExtra(MediaNotificationManager.PACKAGE_NAME)) {
-      val name = intent.getStringExtra(MediaNotificationManager.PACKAGE_NAME)
-      if (!reactContext.get()?.packageName.equals(name)) {
-        return false
-      }
-    }
-    return true
-  }
-}