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

package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt

@@ -0,0 +1,230 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Metadata
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.PlaybackParameters
+import androidx.media3.common.Player as MediaPlayer
+import androidx.media3.common.Timeline
+import com.audiobrowser.extension.NumberExt.Companion.toSeconds
+import com.audiobrowser.model.PlaybackMetadata
+import com.audiobrowser.util.MetadataAdapter
+import com.audiobrowser.util.PlayingStateFactory
+import com.audiobrowser.util.RepeatModeFactory
+import com.margelo.nitro.audiobrowser.PlaybackActiveTrackChangedEvent
+import com.margelo.nitro.audiobrowser.PlaybackError
+import com.margelo.nitro.audiobrowser.PlaybackPlayWhenReadyChangedEvent
+import com.margelo.nitro.audiobrowser.PlaybackState
+import java.util.Locale
+import timber.log.Timber
+
+class PlayerListener(private val player: Player) : MediaPlayer.Listener {
+  /** Called when there is metadata associated with the current playback time. */
+  override fun onMetadata(metadata: Metadata) {
+    // Extract and emit chapter metadata if present
+    val chapters = MetadataAdapter.extractChapters(metadata)
+    if (chapters.isNotEmpty()) {
+      player.callbacks?.onChapterMetadata(chapters)
+    }
+
+    // Extract and emit timed metadata (ICY, ID3, etc.)
+    PlaybackMetadata.from(metadata)?.let { player.callbacks?.onTimedMetadata(it.toNitro()) }
+  }
+
+  override fun onMediaMetadataChanged(mediaMetadata: MediaMetadata) {
+    player.callbacks?.onTrackMetadata(
+      MetadataAdapter.Companion.trackMetadataFromMediaMetadata(mediaMetadata)
+    )
+  }
+
+  /**
+   * A position discontinuity occurs when the playing period changes, the playback position jumps
+   * within the period currently being played, or when the playing period has been skipped or
+   * removed.
+   */
+  override fun onPositionDiscontinuity(
+    oldPosition: MediaPlayer.PositionInfo,
+    newPosition: MediaPlayer.PositionInfo,
+    reason: Int,
+  ) {
+    player.oldPosition = oldPosition.positionMs
+    // Position discontinuity events are not currently exposed to callbacks
+  }
+
+  /**
+   * Called when playback transitions to a media item or starts repeating a media item according to
+   * the current repeat mode. Note that this callback is also called when the playlist becomes
+   * non-empty or empty as a consequence of a playlist change.
+   */
+  override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+    val lastPosition = player.oldPosition.toSeconds()
+    // Audio item transition events are not currently exposed to callbacks
+    // Emit active track changed event with last track info
+    val event =
+      PlaybackActiveTrackChangedEvent(
+        lastIndex = player.lastIndex?.toDouble(),
+        lastTrack = player.lastTrack,
+        lastPosition = lastPosition,
+        index = player.currentIndex?.toDouble(),
+        track = player.currentTrack,
+      )
+    player.callbacks?.onPlaybackActiveTrackChanged(event)
+
+    // Check if sleep timer should trigger on track end
+    if (reason == MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_AUTO) {
+      player.checkSleepTimerOnTrackEnd()
+    }
+
+    // Update last track info for next transition
+    player.lastTrack = player.currentTrack
+    player.lastIndex = player.currentIndex
+
+    // Update favorite button state for new track
+    player.updateFavoriteButtonState(player.currentTrack?.favorited)
+
+    // Clear now playing override when track changes (new track = clean slate)
+    player.clearNowPlayingOverride()
+
+    // Reset retry timer so new track gets fresh 2-minute window
+    player.resetRetryTimer()
+
+    // Notify JS of the now playing metadata for the new track
+    player.getNowPlaying()?.let { player.callbacks?.onNowPlayingChanged(it) }
+
+    player.playbackStateStore.save()
+    player.playbackStateStore.resetPeriodicSave()
+  }
+
+  /** Called when the value returned from Player.getPlayWhenReady() changes. */
+  override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+    // Update thread-safe cache for access from non-main threads (e.g., retry policy)
+    player.playWhenReadyCache = playWhenReady
+    player.callbacks?.onPlaybackPlayWhenReadyChanged(
+      PlaybackPlayWhenReadyChangedEvent(playWhenReady)
+    )
+    val newPlayingState = PlayingStateFactory.derive(playWhenReady, player.playbackState)
+    if (newPlayingState != player.playingState) {
+      player.playingState = newPlayingState
+      player.callbacks?.onPlaybackPlayingState(player.playingState)
+    }
+
+    if (playWhenReady) {
+      player.playbackStateStore.startPeriodicSave()
+    } else {
+      player.playbackStateStore.stopPeriodicSave()
+    }
+  }
+
+  /**
+   * The generic onEvents callback provides access to the Player object and specifies the set of
+   * events that occurred together. It's always called after the callbacks that correspond to the
+   * individual events.
+   */
+  override fun onEvents(media3Player: MediaPlayer, events: MediaPlayer.Events) {
+    // Note that it is necessary to set `playerState` in order, since each mutation fires an
+    // event.
+    for (i in 0 until events.size()) {
+      when (events[i]) {
+        MediaPlayer.EVENT_PLAYBACK_STATE_CHANGED -> {
+          val state =
+            when (media3Player.playbackState) {
+              MediaPlayer.STATE_BUFFERING -> PlaybackState.BUFFERING
+              MediaPlayer.STATE_READY -> PlaybackState.READY
+              MediaPlayer.STATE_IDLE ->
+                // Avoid transitioning to idle from error or stopped
+                if (
+                  player.playbackState == PlaybackState.ERROR ||
+                    player.playbackState == PlaybackState.STOPPED
+                )
+                  null
+                else PlaybackState.NONE
+              MediaPlayer.STATE_ENDED ->
+                if (media3Player.mediaItemCount > 0) PlaybackState.ENDED else PlaybackState.NONE
+              else -> null // noop
+            }
+          if (state != null && state != player.playbackState) {
+            // Clear error when recovering from ERROR state to a successful state
+            if (player.playbackState == PlaybackState.ERROR) {
+              player.playbackError = null
+            }
+            player.setPlaybackState(state)
+          }
+        }
+        MediaPlayer.EVENT_MEDIA_ITEM_TRANSITION -> {
+          player.playbackError = null
+          if (player.currentTrack != null) {
+            player.setPlaybackState(PlaybackState.LOADING)
+            if (player.isPlaying) {
+              player.setPlaybackState(PlaybackState.READY)
+              player.setPlaybackState(PlaybackState.PLAYING)
+            }
+          }
+        }
+        MediaPlayer.EVENT_PLAY_WHEN_READY_CHANGED -> {
+          if (!player.playWhenReady && player.playbackState != PlaybackState.STOPPED) {
+            player.setPlaybackState(PlaybackState.PAUSED)
+          }
+        }
+        MediaPlayer.EVENT_IS_PLAYING_CHANGED -> {
+          if (player.isPlaying) {
+            player.setPlaybackState(PlaybackState.PLAYING)
+          }
+        }
+      }
+    }
+  }
+
+  override fun onPlayerError(error: PlaybackException) {
+    // Handle live stream recovery when playback position falls behind the live window
+    if (error.errorCode == PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW) {
+      Timber.d("Playback fell behind live window, recovering to live edge")
+      player.exoPlayer.seekToDefaultPosition()
+      player.exoPlayer.prepare()
+      return
+    }
+
+    val playbackError =
+      PlaybackError(
+        error.errorCodeName
+          .replace("ERROR_CODE_", "")
+          .lowercase(Locale.getDefault())
+          .replace("_", "-"),
+        error.message ?: "An unknown error occurred",
+      )
+    player.callbacks?.onPlaybackError(playbackError)
+    player.playbackError = playbackError
+    player.setPlaybackState(PlaybackState.ERROR)
+  }
+
+  override fun onRepeatModeChanged(repeatMode: Int) {
+    val mode = RepeatModeFactory.fromMedia3(repeatMode)
+    player.callbacks?.onPlaybackRepeatModeChanged(mode)
+    player.playbackStateStore.repeatMode = mode
+  }
+
+  override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
+    player.callbacks?.onPlaybackShuffleModeChanged(shuffleModeEnabled)
+    player.playbackStateStore.shuffleEnabled = shuffleModeEnabled
+  }
+
+  override fun onPlaybackParametersChanged(playbackParameters: PlaybackParameters) {
+    player.playbackStateStore.playbackSpeed = playbackParameters.speed
+  }
+
+  /**
+   * Called when the timeline changes (playlist add/remove/reorder). We use this to emit queue
+   * changed events to JS.
+   */
+  override fun onTimelineChanged(timeline: Timeline, reason: Int) {
+    // Only emit for playlist changes, not initial load or other reasons
+    if (reason == MediaPlayer.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
+      player.callbacks?.onPlaybackQueueChanged(player.tracks)
+    }
+  }
+
+  override fun onAudioSessionIdChanged(audioSessionId: Int) {
+    Timber.d("Audio session ID changed to: $audioSessionId")
+    player.reinitializeEqualizer(audioSessionId)
+  }
+}

package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt

@@ -0,0 +1,191 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import androidx.media3.common.PlaybackException
+import androidx.media3.datasource.HttpDataSource
+import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import kotlin.math.min
+import kotlin.math.pow
+import timber.log.Timber
+
+/**
+ * Custom LoadErrorHandlingPolicy that retries on recoverable IO errors with exponential backoff.
+ *
+ * When a network monitor is provided and the device is offline during a network error, the policy
+ * will use a shorter retry delay and the network restoration callback can trigger an immediate
+ * retry when connectivity is restored.
+ *
+ * @param maxRetries Maximum number of retries, or null for infinite retries
+ * @param maxRetryDurationMs Maximum duration to keep retrying before giving up, or null for default (2 minutes)
+ * @param shouldRetry Optional callback to check if retry should proceed (e.g., check playWhenReady)
+ * @param isOnline Optional callback to check current network state
+ * @param onRetryPending Optional callback invoked when a retry is pending (for network restoration
+ *   acceleration)
+ */
+class RetryLoadErrorHandlingPolicy(
+  private val maxRetries: Int? = null,
+  maxRetryDurationMs: Long? = null,
+  private val shouldRetry: () -> Boolean = { true },
+  private val isOnline: () -> Boolean = { true },
+  private val onRetryPending: ((isNetworkError: Boolean) -> Unit)? = null,
+) : DefaultLoadErrorHandlingPolicy() {
+
+  companion object {
+    private const val INITIAL_RETRY_DELAY_MS = 1000L // 1 second
+    private const val MAX_RETRY_DELAY_MS = 5000L // 5 seconds cap
+    private const val BACKOFF_MULTIPLIER = 1.5
+    // When offline, use a short fixed delay instead of exponential backoff.
+    // ExoPlayer's retry timer can't be interrupted, so we use a short delay to:
+    // 1. Allow our network restoration callback to trigger immediate retry
+    // 2. Keep polling in case the callback doesn't fire
+    private const val OFFLINE_RETRY_DELAY_MS = 1000L
+    // Default maximum duration to keep retrying before giving up (in milliseconds).
+    private const val DEFAULT_MAX_RETRY_DURATION_MS = 120_000L // 2 minutes
+
+    // HTTP status codes that are worth retrying
+    private val RETRYABLE_HTTP_STATUS_CODES =
+      setOf(
+        408, // Request Timeout
+        429, // Too Many Requests
+        500, // Internal Server Error
+        502, // Bad Gateway
+        503, // Service Unavailable
+        504, // Gateway Timeout
+      )
+  }
+
+  // Maximum duration to keep retrying before giving up.
+  // This prevents surprising playback resumption after long periods offline.
+  private val maxRetryDurationMs: Long = maxRetryDurationMs ?: DEFAULT_MAX_RETRY_DURATION_MS
+
+  // Track when we started retrying to enforce max duration
+  @Volatile
+  private var firstErrorTime: Long? = null
+
+  /** Resets the retry timer. Call when track changes. */
+  fun reset() {
+    firstErrorTime = null
+  }
+
+  /** Calculates exponential backoff delay: 1s -> 1.5s -> 2.3s -> 3.4s -> 5s (capped) */
+  private fun calculateBackoffDelay(errorCount: Int): Long {
+    // errorCount is 1-based (first error = 1)
+    val exponentialDelay =
+      INITIAL_RETRY_DELAY_MS * BACKOFF_MULTIPLIER.pow((errorCount - 1).toDouble())
+    return min(exponentialDelay.toLong(), MAX_RETRY_DELAY_MS)
+  }
+
+  /**
+   * Checks if an HTTP error is worth retrying based on status code. Only server errors (5xx) and
+   * specific client errors (408, 429) are retryable.
+   */
+  private fun isRetryableHttpError(exception: Throwable): Boolean {
+    // Check the exception chain for HttpDataSource.InvalidResponseCodeException
+    var current: Throwable? = exception
+    while (current != null) {
+      if (current is HttpDataSource.InvalidResponseCodeException) {
+        return current.responseCode in RETRYABLE_HTTP_STATUS_CODES
+      }
+      current = current.cause
+    }
+    return false
+  }
+
+  override fun getRetryDelayMsFor(loadErrorInfo: LoadErrorHandlingPolicy.LoadErrorInfo): Long {
+    val exception = loadErrorInfo.exception
+    val errorCount = loadErrorInfo.errorCount
+    val currentTime = System.currentTimeMillis()
+
+    // Don't retry if player is paused/stopped (e.g., another app took audio focus)
+    if (!shouldRetry()) {
+      Timber.d("Retry skipped: shouldRetry() returned false (player likely paused)")
+      return C.TIME_UNSET
+    }
+
+    // Check if we've exceeded max retries
+    if (maxRetries != null && errorCount > maxRetries) {
+      Timber.d("Max retries ($maxRetries) exceeded, not retrying")
+      return C.TIME_UNSET
+    }
+
+    // Track when we started retrying
+    if (firstErrorTime == null) {
+      firstErrorTime = currentTime
+    }
+
+    // Check if we've been retrying too long (prevents surprising resumption after long offline)
+    val startTime = firstErrorTime
+    if (startTime != null) {
+      val elapsed = currentTime - startTime
+      if (elapsed >= maxRetryDurationMs) {
+        Timber.d("Max retry duration (${maxRetryDurationMs}ms) exceeded after ${elapsed}ms, giving up")
+        return C.TIME_UNSET
+      }
+    }
+
+    // Classify the error
+    val errorClassification = classifyError(exception)
+
+    return if (errorClassification.isRecoverable) {
+      // Check if we're offline during a network error
+      val currentlyOffline = !isOnline()
+      val isNetworkError = errorClassification.isNetworkError
+
+      val delay =
+        if (currentlyOffline && isNetworkError) {
+          // Use shorter delay when offline - we'll retry immediately when network comes back
+          Timber.d(
+            "Device is offline, using short retry delay (will accelerate when network returns)"
+          )
+          OFFLINE_RETRY_DELAY_MS
+        } else {
+          calculateBackoffDelay(errorCount)
+        }
+
+      Timber.d(
+        "Retrying after IO error (attempt $errorCount, delay ${delay}ms, offline=$currentlyOffline): ${exception.message}"
+      )
+
+      // Notify that a retry is pending (for network restoration acceleration)
+      onRetryPending?.invoke(isNetworkError)
+
+      delay
+    } else {
+      // For non-recoverable errors, use default behavior (no retry)
+      super.getRetryDelayMsFor(loadErrorInfo)
+    }
+  }
+
+  /** Classification result for an error */
+  private data class ErrorClassification(val isRecoverable: Boolean, val isNetworkError: Boolean)
+
+  /** Classifies whether an error is recoverable and whether it's network-related */
+  private fun classifyError(exception: Throwable): ErrorClassification {
+    return when {
+      exception is PlaybackException -> {
+        when (exception.errorCode) {
+          // Clearly transient network errors
+          PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+          PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_TIMEOUT ->
+            ErrorClassification(isRecoverable = true, isNetworkError = true)
+          // HTTP errors - retry on server errors and specific client errors
+          PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS -> {
+            val isRetryable = isRetryableHttpError(exception)
+            ErrorClassification(isRecoverable = isRetryable, isNetworkError = isRetryable)
+          }
+          else -> ErrorClassification(isRecoverable = false, isNetworkError = false)
+        }
+      }
+      // HTTP errors outside PlaybackException wrapper
+      isRetryableHttpError(exception) ->
+        ErrorClassification(isRecoverable = true, isNetworkError = true)
+      else -> ErrorClassification(isRecoverable = false, isNetworkError = false)
+    }
+  }
+
+  override fun getMinimumLoadableRetryCount(dataType: Int): Int {
+    // Return the max retries, or MAX_VALUE for infinite
+    return maxRetries ?: Int.MAX_VALUE
+  }
+}

package/android/src/main/java/com/audiobrowser/player/SleepTimer.kt

@@ -0,0 +1,80 @@
+package com.audiobrowser.player
+
+import android.os.Handler
+import android.os.Looper
+
+/**
+ * Manages a sleep timer that calls a completion callback after a specified duration.
+ *
+ * The timer stores the expiration time as a timestamp and uses a Handler to schedule the completion
+ * callback. Supports both time-based and end-of-track modes.
+ */
+open class SleepTimer {
+  var time: Double? = null
+    private set
+
+  var sleepWhenPlayedToEnd: Boolean = false
+    private set
+
+  private var runnable: Runnable? = null
+  private val handler = Handler(Looper.getMainLooper())
+
+  val isRunning: Boolean
+    get() = time != null || sleepWhenPlayedToEnd
+
+  /**
+   * Sets a timer to complete after the specified number of seconds.
+   *
+   * @param seconds Number of seconds until the timer completes
+   */
+  fun sleepAfter(seconds: Double) {
+    stopTimer()
+    sleepWhenPlayedToEnd = false
+
+    val runnable = Runnable { complete() }
+    this.runnable = runnable
+    handler.postDelayed(runnable, (seconds * 1000).toLong())
+    time = System.currentTimeMillis() + (seconds * 1000)
+  }
+
+  /**
+   * Sets the timer to complete when the current track finishes playing. Note: The actual completion
+   * logic must be handled by the caller when the track ends.
+   */
+  fun sleepWhenPlayedToEnd() {
+    stopTimer()
+    time = null
+    sleepWhenPlayedToEnd = true
+  }
+
+  /**
+   * Clears the active timer.
+   *
+   * @return true if a timer was running and was cleared, false otherwise
+   */
+  fun clear(): Boolean {
+    val wasRunning = isRunning
+    stopTimer()
+    time = null
+    sleepWhenPlayedToEnd = false
+    return wasRunning
+  }
+
+  /** Override this method to handle timer completion. */
+  open fun onComplete() {
+    // Default implementation does nothing - override in subclass
+  }
+
+  private fun complete() {
+    if (!isRunning) return
+    clear()
+    onComplete()
+  }
+
+  private fun stopTimer() {
+    runnable?.let {
+      handler.removeCallbacks(it)
+      runnable = null
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.C
+import com.margelo.nitro.audiobrowser.AndroidAudioContentType
+
+object AndroidAudioContentTypeFactory {
+
+  fun toMedia3(value: AndroidAudioContentType): Int {
+    return when (value) {
+      AndroidAudioContentType.MUSIC -> C.AUDIO_CONTENT_TYPE_MUSIC
+      AndroidAudioContentType.SPEECH -> C.AUDIO_CONTENT_TYPE_SPEECH
+      AndroidAudioContentType.SONIFICATION -> C.AUDIO_CONTENT_TYPE_SONIFICATION
+      AndroidAudioContentType.MOVIE -> C.AUDIO_CONTENT_TYPE_MOVIE
+      AndroidAudioContentType.UNKNOWN -> C.AUDIO_CONTENT_TYPE_UNKNOWN
+    }
+  }
+}

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

@@ -0,0 +1,95 @@
+package com.audiobrowser.util
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
+
+/**
+ * Helper for checking battery optimization status and opening settings.
+ *
+ * Android has two separate battery-related restrictions:
+ * 1. Battery optimization whitelist (Doze exemption) - isIgnoringBatteryOptimizations
+ * 2. Background restriction (hard block) - isBackgroundRestricted (API 28+)
+ *
+ * Background restriction is the dominant signal - if true, foreground service starts from
+ * background will fail regardless of battery optimization status.
+ */
+object BatteryOptimizationHelper {
+  enum class Status {
+    /** App can run freely in background. User explicitly allowed it. */
+    UNRESTRICTED,
+    /** System may limit background work (Doze, App Standby). Default state. */
+    OPTIMIZED,
+    /** User or system severely limited background. Jobs/services blocked. */
+    RESTRICTED,
+  }
+
+  /**
+   * Get the current battery optimization status.
+   *
+   * Priority: Background restriction > Battery optimization whitelist
+   */
+  fun getStatus(context: Context): Status {
+    val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+    val isIgnoring = pm.isIgnoringBatteryOptimizations(context.packageName)
+
+    val isBackgroundRestricted =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        am.isBackgroundRestricted
+      } else {
+        false
+      }
+
+    // Background restriction is the dominant signal - if true, foreground service
+    // will fail regardless of battery optimization whitelist status
+    return when {
+      isBackgroundRestricted -> Status.RESTRICTED
+      isIgnoring -> Status.UNRESTRICTED
+      else -> Status.OPTIMIZED
+    }
+  }
+
+  /**
+   * Open settings to let user change battery restrictions.
+   *
+   * For OPTIMIZED status: Shows a quick dialog to disable battery optimization (one tap). For
+   * RESTRICTED status: Opens app settings where user must manually change battery setting.
+   */
+  fun openSettings(context: Context) {
+    when (getStatus(context)) {
+      Status.OPTIMIZED -> requestIgnoreBatteryOptimizations(context)
+      else -> openAppSettings(context)
+    }
+  }
+
+  /**
+   * Show system dialog to request ignoring battery optimizations. Only effective for OPTIMIZED
+   * status - won't remove background restrictions.
+   */
+  private fun requestIgnoreBatteryOptimizations(context: Context) {
+    val intent =
+      Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        data = Uri.parse("package:${context.packageName}")
+      }
+    context.startActivity(intent)
+  }
+
+  /**
+   * Open the app's settings page where user can change battery restrictions. Required for
+   * RESTRICTED status since the quick dialog won't help.
+   */
+  private fun openAppSettings(context: Context) {
+    val intent =
+      Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        data = Uri.fromParts("package", context.packageName, null)
+      }
+    context.startActivity(intent)
+  }
+}

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

@@ -0,0 +1,38 @@
+package com.audiobrowser.util
+
+import android.content.Context
+
+/**
+ * Persists foreground service start failure state using SharedPreferences.
+ *
+ * When Android 12+ blocks a foreground service start from background (e.g., Bluetooth resume while
+ * app is killed), we record this failure so the app can show a warning to the user on their next
+ * session.
+ */
+object BatteryWarningStore {
+  private const val PREFS_NAME = "audio_browser_battery"
+  private const val KEY_WARNING_PENDING = "warning_pending"
+
+  /**
+   * Record that a foreground service start failure occurred. Called when
+   * ForegroundServiceStartNotAllowedException is caught.
+   */
+  fun recordFailure(context: Context) {
+    getPrefs(context).edit().putBoolean(KEY_WARNING_PENDING, true).apply()
+  }
+
+  /** Check if a warning is pending (failure occurred and not yet dismissed). */
+  fun isWarningPending(context: Context): Boolean =
+    getPrefs(context).getBoolean(KEY_WARNING_PENDING, false)
+
+  /**
+   * Clear the pending warning. Called when user dismisses warning or when battery status becomes
+   * unrestricted.
+   */
+  fun clearWarning(context: Context) {
+    getPrefs(context).edit().putBoolean(KEY_WARNING_PENDING, false).apply()
+  }
+
+  private fun getPrefs(context: Context) =
+    context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+}