react-native-audio-api 0.5.7 → 0.6.0-rc.1

package/RNAudioAPI.podspec

@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
     end
   end
 
-  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate'
+  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate', 'MediaPlayer', 'AVFoundation'
 
   s.compiler_flags = "#{folly_flags}"
 

package/android/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.12.0)
 project(react-native-audio-api)
 
 set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_CXX_STANDARD 20)
 
 # Detect the processor and SIMD support
@@ -14,9 +15,11 @@ endif()
 include("${REACT_NATIVE_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
 add_compile_options(${folly_FLAGS})
 
-# string(APPEND CMAKE_CXX_FLAGS
-#        " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all\
-#    -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+# frtti - enable Run-Time Type Information (dynamic_cast, typeid)
+# -std=c++20 - use C++20 standard
+# -Wall - enable all compiler's warning messages
+string(APPEND CMAKE_CXX_FLAGS
+       " -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall")
 
 if(${IS_NEW_ARCHITECTURE_ENABLED})
   string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")

package/android/build.gradle

@@ -218,6 +218,7 @@ dependencies {
   implementation 'androidx.core:core-ktx:1.13.1'
   implementation 'com.facebook.fbjni:fbjni:0.6.0'
   implementation 'com.google.oboe:oboe:1.9.0'
+  implementation 'androidx.media:media:1.7.0'
 }
 
 def assertMinimalReactNativeVersion = task assertMinimalReactNativeVersionTask {

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -6,26 +6,6 @@
 
 namespace audioapi {
 
-AudioPlayer::AudioPlayer(
-    const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio)
-    : renderAudio_(renderAudio), channelCount_(2) {
-  AudioStreamBuilder builder;
-
-  builder.setSharingMode(SharingMode::Exclusive)
-      ->setFormat(AudioFormat::Float)
-      ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(PerformanceMode::None)
-      ->setChannelCount(channelCount_)
-      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
-      ->setDataCallback(this)
-      ->openStream(mStream_);
-
-  sampleRate_ = static_cast<float>(mStream_->getSampleRate());
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
-  isInitialized_ = true;
-}
-
 AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate)

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.h

@@ -14,8 +14,6 @@ class AudioBus;
 
 class AudioPlayer : public AudioStreamDataCallback {
  public:
-  explicit AudioPlayer(
-      const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio);
   AudioPlayer(
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);

package/android/src/main/java/com/swmansion/audioapi/AudioAPIPackage.kt

@@ -10,6 +10,7 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 @ReactModuleList(
   nativeModules = [
     AudioAPIModule::class,
+    AudioManagerModule::class,
   ],
 )
 class AudioAPIPackage : BaseReactPackage() {
@@ -19,6 +20,7 @@ class AudioAPIPackage : BaseReactPackage() {
   ): NativeModule? {
     when (name) {
       AudioAPIModule.NAME -> return AudioAPIModule(reactContext)
+      AudioManagerModule.NAME -> return AudioManagerModule(reactContext)
     }
     return null
   }
@@ -37,6 +39,17 @@ class AudioAPIPackage : BaseReactPackage() {
           isCxxModule = false,
           isTurboModule = isTurboModule,
         )
+
+      moduleInfos[AudioManagerModule.NAME] =
+        ReactModuleInfo(
+          AudioManagerModule.NAME,
+          AudioManagerModule.NAME,
+          canOverrideExistingModule = true,
+          needsEagerInit = false,
+          hasConstants = true,
+          isCxxModule = false,
+          isTurboModule = false,
+        )
       moduleInfos
     }
 }

package/android/src/main/java/com/swmansion/audioapi/AudioManagerModule.kt

@@ -0,0 +1,62 @@
+package com.swmansion.audioapi
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.system.MediaSessionManager
+
+class AudioManagerModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  companion object {
+    const val NAME = "AudioManagerModule"
+  }
+
+  private val mediaSessionManager: MediaSessionManager = MediaSessionManager(reactContext)
+
+  init {
+    try {
+      System.loadLibrary("react-native-audio-api")
+    } catch (exception: UnsatisfiedLinkError) {
+      throw RuntimeException("Could not load native module AudioAPIModule", exception)
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setLockScreenInfo(info: ReadableMap?) {
+    mediaSessionManager.setLockScreenInfo(info)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun resetLockScreenInfo() {
+    mediaSessionManager.resetLockScreenInfo()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun enableRemoteCommand(
+    name: String,
+    enabled: Boolean,
+  ) {
+    mediaSessionManager.enableRemoteCommand(name, enabled)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setAudioSessionOptions(
+    category: String?,
+    mode: String?,
+    options: ReadableArray?,
+    active: Boolean,
+  ) {
+    // Nothing to do here
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getDevicePreferredSampleRate(): Double = mediaSessionManager.getDevicePreferredSampleRate()
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun observeAudioInterruptions(enable: Boolean) = mediaSessionManager.observeAudioInterruptions(enable)
+
+  override fun getName(): String = NAME
+}

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

@@ -0,0 +1,60 @@
+package com.swmansion.audioapi.system
+
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import android.util.Log
+
+class AudioFocusListener(
+  private val audioManager: AudioManager,
+  val eventEmitter: MediaSessionEventEmitter,
+  private val lockScreenManager: LockScreenManager,
+) : AudioManager.OnAudioFocusChangeListener {
+  private var playOnAudioFocus = false
+  private var focusRequest: AudioFocusRequest? = null
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        playOnAudioFocus = false
+        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to false))
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        playOnAudioFocus = lockScreenManager.isPlaying
+        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to playOnAudioFocus))
+      }
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        if (playOnAudioFocus) {
+          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to true))
+        } else {
+          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to false))
+        }
+
+        playOnAudioFocus = false
+      }
+    }
+  }
+
+  fun requestAudioFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      this.focusRequest =
+        AudioFocusRequest
+          .Builder(AudioManager.AUDIOFOCUS_GAIN)
+          .setOnAudioFocusChangeListener(this)
+          .build()
+
+      audioManager.requestAudioFocus(focusRequest!!)
+    } else {
+      audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+    }
+  }
+
+  fun abandonAudioFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && this.focusRequest != null) {
+      audioManager.abandonAudioFocusRequest(focusRequest!!)
+    } else {
+      audioManager.abandonAudioFocus(this)
+    }
+  }
+}

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)
+  }
+}