react-native-audio-api 0.6.0-rc.0 → 0.6.0-rc.2

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

@@ -0,0 +1,294 @@
+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.facebook.react.views.imagehelper.ResourceDrawableIdHelper.Companion.instance
+import java.io.IOException
+import java.net.URL
+
+class LockScreenManager(
+  private val reactContext: ReactApplicationContext,
+  private val mediaSession: MediaSessionCompat,
+  private val mediaNotificationManager: MediaNotificationManager,
+  val channelId: String,
+) {
+  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, channelId)
+
+  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 = 0
+  private var speed: Float = 1.0F
+  private var elapsedTime: Long = 0L
+  private var artwork: String? = null
+  private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
+
+  init {
+    this.pb.setActions(controls)
+
+    this.nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+    this.nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+
+    updateNotificationMediaStyle()
+
+    mediaNotificationManager.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: MediaMetadataCompat = mediaSession.controller.metadata
+            val newBuilder =
+              MediaMetadataCompat.Builder(
+                currentMetadata,
+              )
+            mediaSession.setMetadata(
+              newBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, bitmap).build(),
+            )
+
+            nb.setLargeIcon(bitmap)
+            mediaNotificationManager.show(nb, isPlaying)
+
+            artworkThread = null
+          } catch (ex: Exception) {
+            ex.printStackTrace()
+          }
+        }
+      artworkThread!!.start()
+    } else {
+      md.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, null)
+      nb.setLargeIcon(null as Bitmap?)
+    }
+
+    speed =
+      if (info.hasKey("speed")) {
+        info.getDouble("speed").toFloat()
+      } else {
+        state.playbackSpeed
+      }
+
+    elapsedTime =
+      if (info.hasKey("elapsedTime")) {
+        info.getDouble("elapsedTime").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.setMetadata(md.build())
+    mediaSession.setActive(true)
+    mediaNotificationManager.show(nb, isPlaying)
+  }
+
+  fun resetLockScreenInfo() {
+    if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
+    artworkThread = null
+
+    mediaNotificationManager.hide()
+    mediaSession.setActive(false)
+  }
+
+  fun enableRemoteCommand(
+    name: String,
+    enabled: Boolean,
+  ) {
+    var controlValue = 0L
+    when (name) {
+      "play" -> controlValue = PlaybackStateCompat.ACTION_PLAY
+      "pause" -> controlValue = PlaybackStateCompat.ACTION_PAUSE
+      "stop" -> controlValue = PlaybackStateCompat.ACTION_STOP
+      "togglePlayPause" -> controlValue = PlaybackStateCompat.ACTION_PLAY_PAUSE
+      "nextTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_NEXT
+      "previousTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
+      "skipForward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
+      "skipBackward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
+    }
+
+    controls =
+      if (enabled) {
+        controls or controlValue
+      } else {
+        controls and controlValue.inv()
+      }
+
+    mediaNotificationManager.updateActions(controls)
+    pb.setActions(controls)
+
+    state = pb.build()
+    mediaSession.setPlaybackState(state)
+
+    updateNotificationMediaStyle()
+
+    if (mediaSession.isActive) {
+      mediaNotificationManager.show(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 = instance
+        val image = helper.getResourceDrawable(reactContext, 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
+  }
+
+  fun updatePlaybackState(playbackState: Int) {
+    isPlaying = playbackState == PlaybackStateCompat.STATE_PLAYING
+
+    pb.setState(playbackState, elapsedTime, speed)
+    pb.setActions(controls)
+    state = pb.build()
+    mediaSession.setPlaybackState(state)
+  }
+
+  private fun hasControl(control: Long): Boolean = (controls and control) == control
+
+  private fun updateNotificationMediaStyle() {
+    val style = MediaStyle()
+    style.setMediaSession(mediaSession.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
+    }
+    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

@@ -0,0 +1,279 @@
+package com.swmansion.audioapi.system
+
+import android.annotation.SuppressLint
+import android.app.Notification
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.content.res.Resources
+import android.os.Binder
+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.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.swmansion.audioapi.R
+import java.lang.ref.WeakReference
+
+class MediaNotificationManager(
+  val reactContext: ReactApplicationContext,
+  val notificationId: Int,
+  val channelId: String,
+) {
+  private var smallIcon: Int = R.drawable.play
+  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"
+  }
+
+  @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.packageName
+    val openApp: Intent? = reactContext.packageManager.getLaunchIntentForPackage(packageName)
+    try {
+      builder.setContentIntent(
+        PendingIntent.getActivity(
+          reactContext,
+          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.applicationInfo.packageName)
+    builder.setDeleteIntent(
+      PendingIntent.getBroadcast(
+        reactContext,
+        0,
+        remove,
+        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+      ),
+    )
+
+    return builder.build()
+  }
+
+  @SuppressLint("MissingPermission")
+  @Synchronized
+  fun show(
+    builder: NotificationCompat.Builder?,
+    isPlaying: Boolean,
+  ) {
+    NotificationManagerCompat.from(reactContext).notify(
+      notificationId,
+      prepareNotification(
+        builder!!,
+        isPlaying,
+      ),
+    )
+  }
+
+  fun hide() {
+    NotificationManagerCompat.from(reactContext).cancel(notificationId)
+
+    try {
+      val myIntent =
+        Intent(
+          reactContext,
+          NotificationService::class.java,
+        )
+      reactContext.stopService(myIntent)
+    } catch (e: java.lang.Exception) {
+      Log.w("AudioManagerModule", "Error stopping service: ${e.message}")
+    }
+  }
+
+  @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_5",
+        "Skip Forward",
+        mask,
+        PlaybackStateCompat.ACTION_FAST_FORWARD,
+        skipForward,
+      )
+
+    skipBackward =
+      createAction(
+        "skip_backward_5",
+        "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.resources
+    val packageName: String = reactContext.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,
+        keyCode,
+        intent,
+        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+      )
+
+    return NotificationCompat.Action(icon, title, i)
+  }
+
+  class NotificationService : Service() {
+    private val binder = LocalBinder()
+    private var notification: Notification? = null
+
+    inner class LocalBinder : Binder() {
+      private var weakService: WeakReference<NotificationService>? = null
+
+      fun onBind(service: NotificationService) {
+        weakService = WeakReference(service)
+      }
+
+      fun getService(): NotificationService? = weakService?.get()
+    }
+
+    override fun onBind(intent: Intent): IBinder {
+      binder.onBind(this)
+      return binder
+    }
+
+    fun forceForeground() {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val intent = Intent(this, NotificationService::class.java)
+        ContextCompat.startForegroundService(this, intent)
+        notification =
+          MediaSessionManager.mediaNotificationManager
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
+        startForeground(MediaSessionManager.notificationId, notification)
+      }
+    }
+
+    override fun onCreate() {
+      super.onCreate()
+      try {
+        notification =
+          MediaSessionManager.mediaNotificationManager
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
+        startForeground(MediaSessionManager.notificationId, notification)
+      } catch (ex: Exception) {
+        Log.w("AudioManagerModule", "Error starting service: ${ex.message}")
+      }
+    }
+
+    override fun onStartCommand(
+      intent: Intent?,
+      flags: Int,
+      startId: Int,
+    ): Int {
+      onCreate()
+      return START_NOT_STICKY
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+      super.onTaskRemoved(rootIntent)
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        stopForeground(STOP_FOREGROUND_REMOVE)
+      }
+      stopSelf()
+    }
+
+    override fun onDestroy() {
+      super.onDestroy()
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        stopForeground(STOP_FOREGROUND_REMOVE)
+      }
+
+      stopSelf()
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+package com.swmansion.audioapi.system
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.media.AudioManager
+import android.view.KeyEvent
+import com.facebook.react.bridge.ReactApplicationContext
+
+class MediaReceiver(
+  val reactContext: ReactApplicationContext,
+  private val mediaSessionManager: MediaSessionManager,
+) : BroadcastReceiver() {
+  override fun onReceive(
+    context: Context?,
+    intent: Intent?,
+  ) {
+    val action = intent!!.action
+
+    if (MediaNotificationManager.REMOVE_NOTIFICATION == action) {
+      if (!checkApp(intent)) return
+
+      mediaSessionManager.mediaNotificationManager.hide()
+      mediaSessionManager.mediaSession.isActive = false
+
+      mediaSessionManager.eventEmitter.sendEvent("onCloseNotification", null)
+    } 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)
+      mediaSessionManager.mediaSession.controller.dispatchMediaButtonEvent(keyEvent)
+    } else if (AudioManager.ACTION_AUDIO_BECOMING_NOISY == action) {
+      mediaSessionManager.mediaSession.controller.transportControls
+        .pause()
+    }
+  }
+
+  private fun checkApp(intent: Intent): Boolean {
+    if (intent.hasExtra(MediaNotificationManager.PACKAGE_NAME)) {
+      val name = intent.getStringExtra(MediaNotificationManager.PACKAGE_NAME)
+      if (!reactContext.packageName.equals(name)) return false
+    }
+    return true
+  }
+}

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

@@ -0,0 +1,39 @@
+package com.swmansion.audioapi.system
+
+import android.support.v4.media.session.MediaSessionCompat
+import android.support.v4.media.session.PlaybackStateCompat
+
+class MediaSessionCallback(
+  val eventEmitter: MediaSessionEventEmitter,
+  private val lockScreenManager: LockScreenManager,
+) : MediaSessionCompat.Callback() {
+  override fun onPlay() {
+    lockScreenManager.updatePlaybackState(PlaybackStateCompat.STATE_PLAYING)
+    eventEmitter.onPlay()
+  }
+
+  override fun onPause() {
+    lockScreenManager.updatePlaybackState(PlaybackStateCompat.STATE_PAUSED)
+    eventEmitter.onPause()
+  }
+
+  override fun onStop() {
+    eventEmitter.onStop()
+  }
+
+  override fun onSkipToNext() {
+    eventEmitter.onSkipToNext()
+  }
+
+  override fun onSkipToPrevious() {
+    eventEmitter.onSkipToPrevious()
+  }
+
+  override fun onFastForward() {
+    eventEmitter.onFastForward()
+  }
+
+  override fun onRewind() {
+    eventEmitter.onRewind()
+  }
+}