@5stones/react-native-audio-browser 0.1.0

package/android/src/main/java/com/audiobrowser/util/EqualizerManager.kt

@@ -0,0 +1,197 @@
+package com.audiobrowser.util
+
+import android.media.audiofx.Equalizer
+import com.margelo.nitro.audiobrowser.EqualizerSettings
+import timber.log.Timber
+
+/**
+ * Manages Android Equalizer audio effect for the audio player.
+ *
+ * Provides access to equalizer presets, band levels, and enables/disables the effect. The equalizer
+ * is attached to a specific audio session ID.
+ */
+class EqualizerManager(val audioSessionId: Int) {
+  private var equalizer: Equalizer? = null
+  private var onSettingsChanged: ((EqualizerSettings) -> Unit)? = null
+
+  init {
+    try {
+      equalizer = Equalizer(0, audioSessionId).apply { enabled = false }
+      Timber.d("Equalizer initialized with ${equalizer?.numberOfBands} bands")
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to initialize equalizer")
+      equalizer = null
+    }
+  }
+
+  /**
+   * Cleans preset name by removing null terminators and whitespace. Android's Equalizer API
+   * sometimes returns preset names with trailing null characters.
+   */
+  private fun cleanPresetName(name: String): String {
+    return name.trim().replace("\u0000", "")
+  }
+
+  /**
+   * Gets the current equalizer settings.
+   *
+   * @return Current settings or null if equalizer is not available
+   */
+  fun getSettings(): EqualizerSettings? {
+    val eq = equalizer ?: return null
+
+    return try {
+      val bandCount = eq.numberOfBands.toInt()
+      val bandLevels =
+        (0 until bandCount)
+          .map { band -> eq.getBandLevel(band.toShort()).toDouble() }
+          .toDoubleArray()
+
+      val centerFrequencies =
+        (0 until bandCount)
+          .map { band -> eq.getCenterFreq(band.toShort()).toDouble() }
+          .toDoubleArray()
+
+      val presets =
+        (0 until eq.numberOfPresets)
+          .map { preset -> cleanPresetName(eq.getPresetName(preset.toShort())) }
+          .toTypedArray()
+
+      val activePreset =
+        try {
+          val currentPreset = eq.currentPreset.toInt()
+          if (currentPreset >= 0) {
+            cleanPresetName(eq.getPresetName(currentPreset.toShort()))
+          } else {
+            null
+          }
+        } catch (e: Exception) {
+          null
+        }
+
+      EqualizerSettings(
+        activePreset = activePreset,
+        bandCount = bandCount.toDouble(),
+        bandLevels = bandLevels,
+        centerBandFrequencies = centerFrequencies,
+        enabled = eq.enabled,
+        lowerBandLevelLimit = eq.bandLevelRange[0].toDouble(),
+        presets = presets,
+        upperBandLevelLimit = eq.bandLevelRange[1].toDouble(),
+      )
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to get equalizer settings")
+      null
+    }
+  }
+
+  /**
+   * Enables or disables the equalizer.
+   *
+   * @param enabled true to enable, false to disable
+   */
+  fun setEnabled(enabled: Boolean) {
+    val eq = equalizer ?: return
+
+    // Only notify if state actually changed
+    if (eq.enabled != enabled) {
+      eq.enabled = enabled
+      notifySettingsChanged()
+    }
+  }
+
+  /**
+   * Applies a preset to the equalizer.
+   *
+   * @param presetName Name of the preset to apply
+   */
+  fun setPreset(presetName: String) {
+    val eq = equalizer ?: return
+
+    try {
+      // Get current preset first
+      val currentPreset =
+        try {
+          eq.currentPreset.toInt()
+        } catch (e: Exception) {
+          -1
+        }
+
+      // Find preset by case-insensitive name match
+      val presetIndex =
+        (0 until eq.numberOfPresets).firstOrNull { index ->
+          cleanPresetName(eq.getPresetName(index.toShort())).equals(presetName, ignoreCase = true)
+        }
+
+      if (presetIndex != null) {
+        // Only apply if it's actually a different preset
+        if (currentPreset != presetIndex) {
+          eq.usePreset(presetIndex.toShort())
+          Timber.d("Applied equalizer preset: $presetName")
+          notifySettingsChanged()
+        } else {
+          Timber.d("Preset already active: $presetName")
+        }
+      } else {
+        // Log available presets to help debug
+        val availablePresets =
+          (0 until eq.numberOfPresets).joinToString(", ") { index ->
+            cleanPresetName(eq.getPresetName(index.toShort()))
+          }
+        Timber.w("Preset not found: $presetName. Available presets: $availablePresets")
+      }
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to apply preset: $presetName")
+    }
+  }
+
+  /**
+   * Sets custom band levels for the equalizer.
+   *
+   * @param levels Array of levels in millibels for each band
+   */
+  fun setLevels(levels: DoubleArray) {
+    val eq = equalizer ?: return
+
+    try {
+      val bandCount = eq.numberOfBands.toInt()
+      if (levels.size != bandCount) {
+        Timber.w("Level array size ${levels.size} does not match band count $bandCount")
+        return
+      }
+
+      levels.forEachIndexed { index, level ->
+        eq.setBandLevel(index.toShort(), level.toInt().toShort())
+      }
+
+      Timber.d("Applied custom equalizer levels")
+      notifySettingsChanged()
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to apply custom levels")
+    }
+  }
+
+  /**
+   * Sets a callback to be invoked when equalizer settings change.
+   *
+   * @param callback Function to call with new settings
+   */
+  fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
+    onSettingsChanged = callback
+  }
+
+  private fun notifySettingsChanged() {
+    getSettings()?.let { settings -> onSettingsChanged?.invoke(settings) }
+  }
+
+  /** Releases the equalizer resources. Call this when the equalizer is no longer needed. */
+  fun release() {
+    try {
+      equalizer?.release()
+      equalizer = null
+      Timber.d("Equalizer released")
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to release equalizer")
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/util/MediaExtrasBuilder.kt

@@ -0,0 +1,75 @@
+package com.audiobrowser.util
+
+import android.os.Bundle
+import androidx.media.utils.MediaConstants
+import com.margelo.nitro.audiobrowser.ResolvedTrack
+import com.margelo.nitro.audiobrowser.Track
+import com.margelo.nitro.audiobrowser.TrackStyle
+
+/** Builds MediaMetadata extras bundle for Android Auto/AAOS content styling. */
+object MediaExtrasBuilder {
+
+  /**
+   * Maps TrackStyle to MediaConstants content style value. When artwork is an android.resource://
+   * URI, uses CATEGORY_* variants which add margins around icons (better for small vector icons).
+   *
+   * @see <a href="https://developer.android.com/training/cars/media#default-content-style">Default
+   *   content style</a>
+   */
+  private fun TrackStyle.toContentStyleValue(artwork: String?): Int {
+    val isAndroidResource = artwork?.startsWith("android.resource://") == true
+    return when (this) {
+      TrackStyle.LIST ->
+        if (isAndroidResource) {
+          MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_LIST_ITEM
+        } else {
+          MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM
+        }
+      TrackStyle.GRID ->
+        if (isAndroidResource) {
+          MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_GRID_ITEM
+        } else {
+          MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM
+        }
+    }
+  }
+
+  fun build(track: Track): Bundle =
+    build(
+      groupTitle = track.groupTitle,
+      style = track.style,
+      childrenStyle = track.childrenStyle,
+      artwork = track.artwork,
+    )
+
+  fun build(resolvedTrack: ResolvedTrack): Bundle =
+    build(
+      groupTitle = resolvedTrack.groupTitle,
+      style = resolvedTrack.style,
+      childrenStyle = resolvedTrack.childrenStyle,
+      artwork = resolvedTrack.artwork,
+    )
+
+  private fun build(
+    groupTitle: String?,
+    style: TrackStyle?,
+    childrenStyle: TrackStyle?,
+    artwork: String?,
+  ): Bundle =
+    Bundle().apply {
+      groupTitle?.let {
+        putString(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it)
+      }
+      style?.let {
+        putInt(
+          MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_SINGLE_ITEM,
+          it.toContentStyleValue(artwork),
+        )
+      }
+      childrenStyle?.let {
+        val styleValue = it.toContentStyleValue(artwork)
+        putInt(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, styleValue)
+        putInt(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, styleValue)
+      }
+    }
+}

package/android/src/main/java/com/audiobrowser/util/MetadataAdapter.kt

@@ -0,0 +1,97 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Metadata
+import androidx.media3.extractor.metadata.id3.ChapterFrame
+import androidx.media3.extractor.metadata.id3.TextInformationFrame
+import androidx.media3.extractor.metadata.id3.UrlLinkFrame
+import com.margelo.nitro.audiobrowser.ChapterMetadata
+import com.margelo.nitro.audiobrowser.TrackMetadata
+
+sealed class MetadataAdapter {
+  companion object {
+    /**
+     * Extracts chapter metadata from ID3 ChapterFrames.
+     * Returns a list of ChapterMetadata, one per chapter.
+     */
+    fun extractChapters(metadata: Metadata): List<ChapterMetadata> {
+      val chapters = mutableListOf<ChapterMetadata>()
+
+      for (i in 0 until metadata.length()) {
+        val entry = metadata[i]
+        if (entry is ChapterFrame) {
+          // TODO: Artwork extraction missing. Requires converting ApicFrame binary
+          // image data to a URL (base64 data URL or temp file).
+          // See also: iOS implementation in ChapterMetadata+AVFoundation.swift
+          var title: String? = null
+          var url: String? = null
+
+          // Parse sub-frames for chapter metadata
+          for (j in 0 until entry.subFrameCount) {
+            when (val subFrame = entry.getSubFrame(j)) {
+              is TextInformationFrame -> {
+                when (subFrame.id.uppercase()) {
+                  "TIT2", "TT2" -> title = subFrame.values.firstOrNull()
+                }
+              }
+              is UrlLinkFrame -> {
+                url = subFrame.url
+              }
+            }
+          }
+
+          // Convert milliseconds to seconds
+          val startTime = entry.startTimeMs / 1_000.0
+          val endTime = entry.endTimeMs / 1_000.0
+
+          chapters.add(
+            ChapterMetadata(
+              startTime = startTime,
+              endTime = endTime,
+              title = title ?: entry.id,
+              url = url,
+            )
+          )
+        }
+      }
+
+      return chapters
+    }
+
+    fun trackMetadataFromMediaMetadata(metadata: MediaMetadata): TrackMetadata {
+      // Handle creation date from recording day and month
+      val creationDate =
+        (metadata.recordingDay to metadata.recordingMonth).let { (day, month) ->
+          // if both are not null, combine them into a single string
+          if (day != null && month != null) {
+            "${String.format("%02d", day)}${String.format("%02d", month)}"
+          } else if (day != null) {
+            String.format("%02d", day)
+          } else if (month != null) {
+            String.format("%02d", month)
+          } else {
+            null
+          }
+        }
+
+      return TrackMetadata(
+        title = metadata.title as String?,
+        artist = metadata.artist as String?,
+        albumTitle = metadata.albumTitle as String?,
+        subtitle = metadata.subtitle as String?,
+        description = metadata.description as String?,
+        artworkUri = metadata.artworkUri?.toString(),
+        trackNumber = metadata.trackNumber?.toString(),
+        composer = metadata.composer as String?,
+        conductor = metadata.conductor as String?,
+        genre = metadata.genre as String?,
+        compilation = metadata.compilation as String?,
+        station = metadata.station as String?,
+        mediaType = metadata.mediaType?.toString(),
+        creationDate = creationDate,
+        creationYear = metadata.recordingYear?.toString(),
+        url = null,
+      )
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/util/NetworkConnectivityMonitor.kt

@@ -0,0 +1,121 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import timber.log.Timber
+
+/**
+ * Monitors network connectivity state and notifies listeners when the connection state changes.
+ *
+ * This class uses Android's ConnectivityManager.NetworkCallback to detect when the device goes
+ * online or offline, which is useful for updating UI in Android Auto and other contexts.
+ *
+ * Monitoring starts automatically on construction.
+ */
+class NetworkConnectivityMonitor(private val context: Context) {
+  private val connectivityManager =
+    context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+  private var destroyed = false
+
+  // Compute initial state before creating StateFlow to avoid race condition
+  private val _isOnline = MutableStateFlow(checkInitialNetworkState())
+  val isOnline: StateFlow<Boolean> = _isOnline.asStateFlow()
+
+  /**
+   * Gets the current network connectivity state.
+   *
+   * @return true if device is online, false otherwise
+   */
+  fun getOnline(): Boolean = _isOnline.value
+
+  /**
+   * Observes network state changes and invokes the callback when state changes. The callback is
+   * invoked on the scope's dispatcher.
+   */
+  fun observeOnline(scope: CoroutineScope, onStateChanged: (Boolean) -> Unit) {
+    isOnline.onEach { isOnline -> onStateChanged(isOnline) }.launchIn(scope)
+  }
+
+  private fun checkInitialNetworkState(): Boolean {
+    return connectivityManager.activeNetwork
+      ?.let { connectivityManager.getNetworkCapabilities(it) }
+      ?.let {
+        it.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+          it.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+      } ?: false
+  }
+
+  private val networkCallback =
+    object : ConnectivityManager.NetworkCallback() {
+      override fun onAvailable(network: Network) {
+        Timber.d("Network available: $network")
+        updateNetworkState(true)
+      }
+
+      override fun onLost(network: Network) {
+        Timber.d("Network lost: $network")
+        updateNetworkState(false)
+      }
+
+      override fun onCapabilitiesChanged(
+        network: Network,
+        networkCapabilities: NetworkCapabilities,
+      ) {
+        val hasInternet =
+          networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+        val isValidated =
+          networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+        Timber.d("Network capabilities changed: hasInternet=$hasInternet, isValidated=$isValidated")
+        updateNetworkState(hasInternet && isValidated)
+      }
+    }
+
+  private fun updateNetworkState(isOnline: Boolean) {
+    if (_isOnline.value != isOnline) {
+      _isOnline.value = isOnline
+    }
+  }
+
+  init {
+    try {
+      val networkRequest =
+        NetworkRequest.Builder()
+          .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+          .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+          .build()
+
+      connectivityManager.registerNetworkCallback(networkRequest, networkCallback)
+
+      Timber.d(
+        "Network monitoring started, initial state: ${if (_isOnline.value) "online" else "offline"}"
+      )
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to start network monitoring")
+    }
+  }
+
+  /** Stops monitoring and cleans up resources. */
+  fun destroy() {
+    if (destroyed) {
+      return
+    }
+
+    try {
+      connectivityManager.unregisterNetworkCallback(networkCallback)
+      destroyed = true
+      Timber.d("Network monitoring stopped")
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to stop network monitoring")
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/util/PlayingStateFactory.kt

@@ -0,0 +1,25 @@
+package com.audiobrowser.util
+
+import com.margelo.nitro.audiobrowser.PlaybackState
+import com.margelo.nitro.audiobrowser.PlayingState
+
+object PlayingStateFactory {
+  /**
+   * Derives a PlayingState from playWhenReady and state.
+   *
+   * @param playWhenReady Whether the player wants to play when ready
+   * @param playbackState The current player state
+   * @return A PlayingState representing the current playing/buffering status
+   */
+  fun derive(playWhenReady: Boolean, playbackState: PlaybackState): PlayingState {
+    val playing =
+      playWhenReady &&
+        !(playbackState == PlaybackState.ERROR ||
+          playbackState == PlaybackState.ENDED ||
+          playbackState == PlaybackState.NONE)
+    val buffering =
+      playWhenReady &&
+        (playbackState == PlaybackState.LOADING || playbackState == PlaybackState.BUFFERING)
+    return PlayingState(playing, buffering)
+  }
+}

package/android/src/main/java/com/audiobrowser/util/RatingFactory.kt

@@ -0,0 +1,72 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating as Media3HeartRating
+import androidx.media3.common.PercentageRating as Media3PercentRating
+import androidx.media3.common.Rating
+import androidx.media3.common.StarRating as Media3StarRating
+import androidx.media3.common.ThumbRating as Media3ThumbRating
+import com.margelo.nitro.audiobrowser.HeartRating
+import com.margelo.nitro.audiobrowser.PercentageRating
+import com.margelo.nitro.audiobrowser.StarRating
+import com.margelo.nitro.audiobrowser.ThumbsRating
+import com.margelo.nitro.audiobrowser.Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
+
+object RatingFactory {
+  fun media3ToBridge(
+    rating: Rating
+  ): Variant_HeartRating_ThumbsRating_StarRating_PercentageRating? {
+    return when (rating) {
+      is Media3HeartRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            HeartRating(rating.isHeart)
+          )
+        } else null
+      }
+
+      is Media3ThumbRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            ThumbsRating(rating.isThumbsUp)
+          )
+        } else null
+      }
+
+      is Media3StarRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            StarRating(rating.starRating.toDouble())
+          )
+        } else null
+      }
+
+      is Media3PercentRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            PercentageRating(rating.percent.toDouble())
+          )
+        } else null
+      }
+
+      else -> null
+    }
+  }
+
+  fun bridgeToMedia3(
+    rating: Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
+  ): Rating? {
+    return when (rating) {
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.First ->
+        Media3HeartRating(rating.value.hasHeart)
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Second ->
+        Media3ThumbRating(rating.value.isThumbsUp)
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Third ->
+        Media3StarRating(5, rating.value.stars.toFloat())
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Fourth ->
+        Media3PercentRating(rating.value.percentage.toFloat())
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/util/RepeatModeFactory.kt

@@ -0,0 +1,22 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.Player
+import com.margelo.nitro.audiobrowser.RepeatMode
+
+object RepeatModeFactory {
+  fun toMedia3(repeatMode: RepeatMode): Int {
+    return when (repeatMode) {
+      RepeatMode.OFF -> Player.REPEAT_MODE_OFF
+      RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+      RepeatMode.QUEUE -> Player.REPEAT_MODE_ALL
+    }
+  }
+
+  fun fromMedia3(repeatMode: Int): RepeatMode {
+    return when (repeatMode) {
+      Player.REPEAT_MODE_ALL -> RepeatMode.QUEUE
+      Player.REPEAT_MODE_ONE -> RepeatMode.TRACK
+      else -> RepeatMode.OFF
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/util/ResolvedTrackFactory.kt

@@ -0,0 +1,36 @@
+package com.audiobrowser.util
+
+import androidx.core.net.toUri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import com.margelo.nitro.audiobrowser.ResolvedTrack
+
+object ResolvedTrackFactory {
+
+  fun toMedia3(resolvedTrack: ResolvedTrack): MediaItem {
+    val extras = MediaExtrasBuilder.build(resolvedTrack)
+
+    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
+    val artworkUri = resolvedTrack.artworkSource?.uri ?: resolvedTrack.artwork
+
+    val mediaMetadata =
+      MediaMetadata.Builder()
+        .setTitle(resolvedTrack.title)
+        .setArtist(resolvedTrack.artist)
+        .setAlbumTitle(resolvedTrack.album)
+        .setDescription(resolvedTrack.description)
+        .setGenre(resolvedTrack.genre)
+        .setArtworkUri(artworkUri?.toUri())
+        .setIsBrowsable(resolvedTrack.src == null)
+        .setIsPlayable(resolvedTrack.src != null)
+        .setExtras(extras)
+        .build()
+
+    return MediaItem.Builder()
+      .setMediaId(resolvedTrack.url)
+      .setUri(resolvedTrack.src)
+      .setMediaMetadata(mediaMetadata)
+      .setTag(resolvedTrack)
+      .build()
+  }
+}