diff --git a/app/src/main/java/cc/skysparkle/fogwave/FogwaveApp.kt b/app/src/main/java/cc/skysparkle/fogwave/FogwaveApp.kt deleted file mode 100644 index b90d0fa..0000000 --- a/app/src/main/java/cc/skysparkle/fogwave/FogwaveApp.kt +++ /dev/null @@ -1,20 +0,0 @@ -package cc.skysparkle.fogwave - -import android.app.Application -import coil.ImageLoader -import coil.ImageLoaderFactory -import coil.memory.MemoryCache - -class FogwaveApp : Application(), ImageLoaderFactory { - override fun newImageLoader(): ImageLoader { - return ImageLoader.Builder(this) - .memoryCache { - MemoryCache.Builder(this) - .maxSizePercent(0.20) - .build() - } - .crossfade(true) - .respectCacheHeaders(false) - .build() - } -} diff --git a/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsController.kt b/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsController.kt index 7cb74d9..35447bf 100644 --- a/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsController.kt +++ b/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsController.kt @@ -42,11 +42,6 @@ object AudioEffectsController { refresh() } - fun setLoudnessGain(gainMillibel: Float) { - engine?.setLoudnessGain(gainMillibel) - refresh() - } - fun setDynamicsProcessingEnabled(enabled: Boolean) { engine?.setDynamicsProcessingEnabled(enabled) refresh() diff --git a/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsEngine.kt b/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsEngine.kt index ec94d5c..23971ab 100644 --- a/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsEngine.kt +++ b/app/src/main/java/cc/skysparkle/fogwave/player/AudioEffectsEngine.kt @@ -25,8 +25,6 @@ data class AudioEffectsState( val currentPreset: Int = -1, val loudnessAvailable: Boolean = false, val loudnessEnabled: Boolean = false, - val loudnessGainMillibel: Float = 0f, - val loudnessMaxGainMillibel: Float = 2000f, val dynamicsProcessingAvailable: Boolean = false, val dynamicsProcessingEnabled: Boolean = false ) @@ -52,7 +50,10 @@ class AudioEffectsEngine(context: Context, audioSessionId: Int) { private var equalizerEnabled = prefs.getBoolean(KEY_EQ_ENABLED, false) private var loudnessEnabled = prefs.getBoolean(KEY_LOUDNESS_ENABLED, false) - private var loudnessGain = prefs.getInt(KEY_LOUDNESS_GAIN, 0).coerceIn(0, MAX_LOUDNESS_GAIN) + // There is no gain slider, so the switch applies a fixed, moderate boost. A gain of 0 (the old + // default) made the switch do nothing. + private val loudnessGain = prefs.getInt(KEY_LOUDNESS_GAIN, DEFAULT_LOUDNESS_GAIN) + .takeIf { it > 0 }?.coerceAtMost(MAX_LOUDNESS_GAIN) ?: DEFAULT_LOUDNESS_GAIN private var dynamicsEnabled = prefs.getBoolean(KEY_DYNAMICS_ENABLED, false) init { @@ -178,7 +179,6 @@ class AudioEffectsEngine(context: Context, audioSessionId: Int) { currentPreset = if (eqAvailable) currentPresetIndex else -1, loudnessAvailable = loudnessEnhancer != null, loudnessEnabled = loudnessEnhancer != null && loudnessEnabled, - loudnessGainMillibel = if (loudnessEnhancer != null) loudnessGain.toFloat() else 0f, dynamicsProcessingAvailable = dynamicsProcessing != null, dynamicsProcessingEnabled = dynamicsProcessing != null && dynamicsEnabled ) @@ -233,17 +233,6 @@ class AudioEffectsEngine(context: Context, audioSessionId: Int) { } catch (_: Exception) {} } - fun setLoudnessGain(gainMillibel: Float) { - val le = loudnessEnhancer ?: return - val gain = gainMillibel.coerceIn(0f, MAX_LOUDNESS_GAIN.toFloat()).toInt() - if (gain == loudnessGain) return - try { - le.setTargetGain(gain) - loudnessGain = gain - prefs.edit { putInt(KEY_LOUDNESS_GAIN, gain) } - } catch (_: Exception) {} - } - fun setDynamicsProcessingEnabled(enabled: Boolean) { val dp = dynamicsProcessing ?: return try { @@ -265,6 +254,7 @@ class AudioEffectsEngine(context: Context, audioSessionId: Int) { private companion object { const val TAG = "AudioEffectsEngine" const val MAX_LOUDNESS_GAIN = 2000 + const val DEFAULT_LOUDNESS_GAIN = 600 const val KEY_EQ_ENABLED = "eq_enabled" const val KEY_PRESET = "eq_preset" const val KEY_BAND_PREFIX = "eq_band_" diff --git a/app/src/main/java/cc/skysparkle/fogwave/player/FogwavePlaybackService.kt b/app/src/main/java/cc/skysparkle/fogwave/player/FogwavePlaybackService.kt index a2d0981..afa50e1 100644 --- a/app/src/main/java/cc/skysparkle/fogwave/player/FogwavePlaybackService.kt +++ b/app/src/main/java/cc/skysparkle/fogwave/player/FogwavePlaybackService.kt @@ -15,13 +15,13 @@ import android.util.Log import androidx.annotation.OptIn import androidx.media3.common.AudioAttributes import androidx.media3.common.C +import androidx.media3.common.ForwardingSimpleBasePlayer import androidx.media3.common.MediaItem import androidx.media3.common.MediaMetadata import androidx.media3.common.PlaybackException import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi import androidx.media3.datasource.DefaultHttpDataSource -import androidx.media3.datasource.HttpDataSource import androidx.media3.exoplayer.DefaultLoadControl import androidx.media3.exoplayer.ExoPlayer import androidx.media3.exoplayer.source.DefaultMediaSourceFactory @@ -33,6 +33,7 @@ import androidx.media3.session.MediaSession import cc.skysparkle.fogwave.BuildConfig import cc.skysparkle.fogwave.MainActivity import cc.skysparkle.fogwave.R +import cc.skysparkle.fogwave.data.model.RadioStation import cc.skysparkle.fogwave.data.repository.RadioRepository import com.google.common.collect.ImmutableList import com.google.common.util.concurrent.Futures @@ -50,6 +51,10 @@ class FogwavePlaybackService : MediaLibraryService() { private var mediaLibrarySession: MediaLibrarySession? = null private lateinit var repository: RadioRepository private lateinit var player: ExoPlayer + + // Station order for next/previous from the notification, a headset or the car; sorted once, + // like the grid in the app. + private var stationOrder: List = emptyList() private var audioEffectsEngine: AudioEffectsEngine? = null private val serviceScope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob()) @@ -66,6 +71,11 @@ class FogwavePlaybackService : MediaLibraryService() { private var connectivityManager: ConnectivityManager? = null private var networkCallback: ConnectivityManager.NetworkCallback? = null private var defaultNetwork: Network? = null + private var hasNetwork = true + + // Set when a reconnect is due but there is no network: no attempts are spent while offline, + // the stream is reopened from onAvailable instead. + private var waitingForNetwork = false // ExoPlayer drops its own wake and Wi-Fi locks once the player is idle after an error, so the // backoff delay would stall while the CPU sleeps. These are held only while a reconnect is pending. @@ -136,32 +146,96 @@ class FogwavePlaybackService : MediaLibraryService() { return Futures.immediateFuture(LibraryResult.ofItem(station.toMediaItem(this@FogwavePlaybackService), null)) } + // Items coming from a controller are never trusted: only the mediaId (or a voice search + // query) is read, and the stream URI always comes from our own station list. Without this + // an item without a URI (a voice request from Assistant or Android Auto) crashed the + // player, and any app on the device could make Fogwave play an arbitrary stream. override fun onAddMediaItems( mediaSession: MediaSession, controller: MediaSession.ControllerInfo, mediaItems: MutableList ): ListenableFuture> { - val resolved = mediaItems.map { item -> - if (item.localConfiguration != null) { - item - } else { - repository.stations.find { it.id == item.mediaId } - ?.toMediaItem(this@FogwavePlaybackService) - ?: item - } - }.toMutableList() - - resolved.firstOrNull()?.let { item -> - Log.d(TAG, "MediaItem resolved: mediaId=${item.mediaId} uri=${item.localConfiguration?.uri}") - lastRequestedItem = item - retryJob?.cancel() - retryAttempt = 0 - } - + val resolved = mediaItems.map { resolveStation(it).toMediaItem(this@FogwavePlaybackService) } + .toMutableList() + resolved.firstOrNull()?.let { onNewRequest(it) } return Futures.immediateFuture(resolved) } } + private fun resolveStation(item: MediaItem): RadioStation { + val stations = repository.stations + val query = item.requestMetadata.searchQuery?.trim().orEmpty() + return stations.find { it.id == item.mediaId } + ?: query.takeIf { it.isNotEmpty() }?.let { q -> + stations.find { it.name.contains(q, ignoreCase = true) } + ?: stations.find { q.contains(it.name, ignoreCase = true) } + } + ?: stations.find { it.id == repository.getLastStationId() } + ?: stations.first() + } + + private fun onNewRequest(item: MediaItem) { + Log.d(TAG, "MediaItem resolved: mediaId=${item.mediaId}") + lastRequestedItem = item + retryJob?.cancel() + retryAttempt = 0 + waitingForNetwork = false + } + + private fun switchStation(step: Int) { + val order = stationOrder.ifEmpty { repository.stations } + val currentId = player.currentMediaItem?.mediaId ?: lastRequestedItem?.mediaId + val index = order.indexOfFirst { it.id == currentId } + val target = if (index < 0) order.first() else order[(index + step).mod(order.size)] + Log.d(TAG, "Switching station: ${target.id}") + val item = target.toMediaItem(this) + onNewRequest(item) + repository.setLastStationId(target.id) + // playWhenReady is kept: a paused player switches the station and stays paused. + player.setMediaItem(item) + player.prepare() + } + + /** + * The player only ever holds the station that is on air: with the whole list in ExoPlayer every + * stream would be prepared at once, and the HLS ones would keep refreshing their playlists in + * the background. Instead next/previous are always offered to the session (notification, + * headset buttons, Android Auto) and switch the station here, wrapping around like the app. + */ + private inner class StationSwitchingPlayer(player: Player) : ForwardingSimpleBasePlayer(player) { + override fun getState(): State { + val state = super.getState() + if (state.timeline.isEmpty()) return state + val commands = state.availableCommands.buildUpon() + .addAll( + Player.COMMAND_SEEK_TO_NEXT, + Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM, + Player.COMMAND_SEEK_TO_PREVIOUS, + Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM + ) + .remove(Player.COMMAND_SET_REPEAT_MODE) + .build() + // REPEAT_MODE_ALL makes next/previous resolve to the single item, which lands in + // handleSeek below with the original seek command. + return state.buildUpon() + .setAvailableCommands(commands) + .setRepeatMode(Player.REPEAT_MODE_ALL) + .build() + } + + override fun handleSeek(mediaItemIndex: Int, positionMs: Long, seekCommand: Int): ListenableFuture<*> { + when (seekCommand) { + Player.COMMAND_SEEK_TO_NEXT, Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM -> switchStation(+1) + Player.COMMAND_SEEK_TO_PREVIOUS, Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM -> switchStation(-1) + else -> return super.handleSeek(mediaItemIndex, positionMs, seekCommand) + } + return Futures.immediateVoidFuture() + } + + // The stream's own repeat mode stays off; a dropped stream is handled by scheduleReconnect. + override fun handleSetRepeatMode(repeatMode: Int): ListenableFuture<*> = Futures.immediateVoidFuture() + } + private val resiliencePlayerListener = object : Player.Listener { override fun onPlaybackStateChanged(playbackState: Int) { val stateName = when (playbackState) { @@ -196,6 +270,7 @@ class FogwavePlaybackService : MediaLibraryService() { Log.d(TAG, "Reconnect cancelled - playWhenReady=false (reason=$reason)") } retryJob?.cancel() + waitingForNetwork = false releaseReconnectLocks() pausedAtMs = SystemClock.elapsedRealtime() return @@ -225,25 +300,16 @@ class FogwavePlaybackService : MediaLibraryService() { } } - // A missing stream or an unsupported format will not fix itself, so it gets only a couple of - // attempts (a stale token or a short server outage can still recover); network errors get the full backoff. - private fun maxRetryAttemptsFor(error: PlaybackException): Int { - val httpCode = (error.cause as? HttpDataSource.InvalidResponseCodeException)?.responseCode - val permanent = when (error.errorCode) { - PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS -> - httpCode != null && httpCode in 400..499 && httpCode != 408 && httpCode != 429 - PlaybackException.ERROR_CODE_IO_FILE_NOT_FOUND, - PlaybackException.ERROR_CODE_IO_CLEARTEXT_NOT_PERMITTED, - PlaybackException.ERROR_CODE_PARSING_CONTAINER_UNSUPPORTED, - PlaybackException.ERROR_CODE_PARSING_MANIFEST_UNSUPPORTED, - PlaybackException.ERROR_CODE_DECODING_FORMAT_UNSUPPORTED -> true - else -> false - } - return if (permanent) MAX_PERMANENT_ERROR_RETRY_ATTEMPTS else MAX_RETRY_ATTEMPTS - } - private fun scheduleReconnect(immediate: Boolean = false, maxAttempts: Int = MAX_RETRY_ATTEMPTS) { retryJob?.cancel() + if (!immediate && !hasNetwork) { + // Attempts would only fail and run out while offline; wait for onAvailable instead. + Log.d(TAG, "No network - waiting for it before reconnecting") + waitingForNetwork = true + releaseReconnectLocks() + return + } + waitingForNetwork = false if (!immediate && retryAttempt >= maxAttempts) { // Give up instead of keeping the device busy forever; the error stays visible and a tap // on play starts over. @@ -316,13 +382,23 @@ class FogwavePlaybackService : MediaLibraryService() { private fun registerNetworkCallback() { val cm = getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager ?: return connectivityManager = cm + hasNetwork = cm.activeNetwork != null val callback = object : ConnectivityManager.NetworkCallback() { // Called on a ConnectivityManager thread; ExoPlayer must only be accessed on the main thread. override fun onAvailable(network: Network) { serviceScope.launch { val previous = defaultNetwork defaultNetwork = network + hasNetwork = true + val wasWaiting = waitingForNetwork + waitingForNetwork = false if (!player.playWhenReady || player.playbackState == Player.STATE_READY) return@launch + if (wasWaiting) { + Log.d(TAG, "Network is back - reconnecting") + retryAttempt = 0 + scheduleReconnect(immediate = true) + return@launch + } // After a switch (e.g. Wi-Fi to mobile) a stalled load can sit on a dead socket until // the read timeout, so reopen right away instead of waiting for the error. val switchedWhileStalled = previous != null && previous != network && @@ -333,6 +409,13 @@ class FogwavePlaybackService : MediaLibraryService() { } } } + + override fun onLost(network: Network) { + serviceScope.launch { + // A switch reports the new network first; only the loss of the current one counts. + if (network == defaultNetwork) hasNetwork = false + } + } } networkCallback = callback try { @@ -344,6 +427,7 @@ class FogwavePlaybackService : MediaLibraryService() { override fun onCreate() { super.onCreate() repository = RadioRepository(applicationContext) + stationOrder = repository.stationsSortedByPopularity() val audioManager = getSystemService(Context.AUDIO_SERVICE) as? AudioManager val audioSessionId = audioManager?.generateAudioSessionId()?.takeIf { it != 0 } @@ -385,7 +469,7 @@ class FogwavePlaybackService : MediaLibraryService() { PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT ) - mediaLibrarySession = MediaLibrarySession.Builder(this, player, librarySessionCallback) + mediaLibrarySession = MediaLibrarySession.Builder(this, StationSwitchingPlayer(player), librarySessionCallback) .setSessionActivity(sessionActivity) .build() } @@ -412,10 +496,13 @@ class FogwavePlaybackService : MediaLibraryService() { override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? = mediaLibrarySession + // Swiping the app away keeps only real playback alive (a short rebuffer counts): a failed + // stream, a pending reconnect or a pause stop the service. The Media3 default would also stop + // during a rebuffer, because isPlaying is false while buffering. override fun onTaskRemoved(rootIntent: Intent?) { - if (!player.playWhenReady || player.mediaItemCount == 0) { - player.pause() - stopSelf() + val reconnecting = retryJob?.isActive == true || waitingForNetwork || player.playerError != null + if (!isPlaybackOngoing() || !player.playWhenReady || player.mediaItemCount == 0 || reconnecting) { + pauseAllPlayersAndStopSelf() } } @@ -441,8 +528,6 @@ class FogwavePlaybackService : MediaLibraryService() { companion object { private const val ROOT_ID = "fogwave_root" private const val TAG = "FogwavePlaybackService" - private const val MAX_RETRY_ATTEMPTS = 12 - private const val MAX_PERMANENT_ERROR_RETRY_ATTEMPTS = 2 private const val RECONNECT_LOCK_TIMEOUT_MS = 2 * 60_000L private const val LIVE_RESYNC_AFTER_MS = 30_000L } diff --git a/app/src/main/java/cc/skysparkle/fogwave/player/PlaybackPolicy.kt b/app/src/main/java/cc/skysparkle/fogwave/player/PlaybackPolicy.kt new file mode 100644 index 0000000..cf02c01 --- /dev/null +++ b/app/src/main/java/cc/skysparkle/fogwave/player/PlaybackPolicy.kt @@ -0,0 +1,45 @@ +package cc.skysparkle.fogwave.player + +import androidx.annotation.OptIn +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import androidx.media3.datasource.HttpDataSource + +// Kept apart from the service and the UI controller so the decisions can be unit tested. + +internal const val MAX_RETRY_ATTEMPTS = 12 +internal const val MAX_PERMANENT_ERROR_RETRY_ATTEMPTS = 2 + +// A missing stream or an unsupported format will not fix itself, so it gets only a couple of +// attempts (a stale token or a short server outage can still recover); network errors get the full backoff. +@OptIn(UnstableApi::class) +internal fun maxRetryAttemptsFor(error: PlaybackException): Int { + val httpCode = (error.cause as? HttpDataSource.InvalidResponseCodeException)?.responseCode + val permanent = when (error.errorCode) { + PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS -> + httpCode != null && httpCode in 400..499 && httpCode != 408 && httpCode != 429 + PlaybackException.ERROR_CODE_IO_FILE_NOT_FOUND, + PlaybackException.ERROR_CODE_IO_CLEARTEXT_NOT_PERMITTED, + PlaybackException.ERROR_CODE_PARSING_CONTAINER_UNSUPPORTED, + PlaybackException.ERROR_CODE_PARSING_MANIFEST_UNSUPPORTED, + PlaybackException.ERROR_CODE_DECODING_FORMAT_UNSUPPORTED -> true + else -> false + } + return if (permanent) MAX_PERMANENT_ERROR_RETRY_ATTEMPTS else MAX_RETRY_ATTEMPTS +} + +/** What the UI shows for the session's player; [errorMessage] turns a playback error into text. */ +internal fun deriveState(p: Player, errorMessage: (PlaybackException) -> String): PlayerState { + p.playerError?.let { return PlayerState.Error(errorMessage(it)) } + return when (p.playbackState) { + Player.STATE_READY -> if (p.playWhenReady) PlayerState.Playing else PlayerState.Paused + Player.STATE_BUFFERING, Player.STATE_ENDED -> + if (p.playWhenReady) PlayerState.Connecting else PlayerState.Paused + else -> when { + p.mediaItemCount == 0 -> PlayerState.Idle + p.playWhenReady -> PlayerState.Connecting + else -> PlayerState.Paused + } + } +} diff --git a/app/src/main/java/cc/skysparkle/fogwave/player/RadioPlayerManager.kt b/app/src/main/java/cc/skysparkle/fogwave/player/RadioPlayerManager.kt index 53ed063..e26b090 100644 --- a/app/src/main/java/cc/skysparkle/fogwave/player/RadioPlayerManager.kt +++ b/app/src/main/java/cc/skysparkle/fogwave/player/RadioPlayerManager.kt @@ -43,7 +43,7 @@ class RadioPlayerManager(private val context: Context) { private val playerListener = object : Player.Listener { override fun onEvents(player: Player, events: Player.Events) { - _playerState.value = deriveState(player) + _playerState.value = deriveState(player, ::errorMessage) _currentMediaId.value = player.currentMediaItem?.mediaId _nowPlayingTitle.value = streamTitle(player) } @@ -88,7 +88,7 @@ class RadioPlayerManager(private val context: Context) { if (station != null) { playStation(station) } else { - _playerState.value = deriveState(c) + _playerState.value = deriveState(c, ::errorMessage) _currentMediaId.value = c.currentMediaItem?.mediaId _nowPlayingTitle.value = streamTitle(c) } @@ -117,20 +117,6 @@ class RadioPlayerManager(private val context: Context) { controllerFuture = null } - private fun deriveState(p: Player): PlayerState { - p.playerError?.let { return PlayerState.Error(errorMessage(it)) } - return when (p.playbackState) { - Player.STATE_READY -> if (p.playWhenReady) PlayerState.Playing else PlayerState.Paused - Player.STATE_BUFFERING, Player.STATE_ENDED -> - if (p.playWhenReady) PlayerState.Connecting else PlayerState.Paused - else -> when { - p.mediaItemCount == 0 -> PlayerState.Idle - p.playWhenReady -> PlayerState.Connecting - else -> PlayerState.Paused - } - } - } - // Stream metadata replaces the item's own title; the station name itself is not a song. private fun streamTitle(p: Player): String? { val title = p.mediaMetadata.title?.toString()?.trim() diff --git a/app/src/main/java/cc/skysparkle/fogwave/ui/viewmodel/RadioViewModel.kt b/app/src/main/java/cc/skysparkle/fogwave/ui/viewmodel/RadioViewModel.kt index e9b4c5f..9fe0e70 100644 --- a/app/src/main/java/cc/skysparkle/fogwave/ui/viewmodel/RadioViewModel.kt +++ b/app/src/main/java/cc/skysparkle/fogwave/ui/viewmodel/RadioViewModel.kt @@ -139,9 +139,12 @@ class RadioViewModel(application: Application) : AndroidViewModel(application) { viewModelScope.launch { playerManager.currentMediaId.collect { id -> if (id != null && id != _currentStation.value?.id) { + // Switched outside the app (notification, headset, Android Auto): count it like a tap. stations.find { it.id == id }?.let { onAir -> _currentStation.value = onAir repository.setLastStationId(onAir.id) + repository.pushRecent(onAir.id) + repository.recordStationPlayed(onAir.id) } } } @@ -250,10 +253,6 @@ class RadioViewModel(application: Application) : AndroidViewModel(application) { AudioEffectsController.setLoudnessEnabled(enabled) } - fun setLoudnessGain(gainMillibel: Float) { - AudioEffectsController.setLoudnessGain(gainMillibel) - } - fun setDynamicsProcessingEnabled(enabled: Boolean) { AudioEffectsController.setDynamicsProcessingEnabled(enabled) } diff --git a/app/src/main/res/drawable-nodpi/ic_sleep.webp b/app/src/main/res/drawable-nodpi/ic_sleep.webp deleted file mode 100644 index 987a8fa..0000000 Binary files a/app/src/main/res/drawable-nodpi/ic_sleep.webp and /dev/null differ diff --git a/app/src/main/res/xml/backup_rules.xml b/app/src/main/res/xml/backup_rules.xml deleted file mode 100644 index 0729482..0000000 --- a/app/src/main/res/xml/backup_rules.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/app/src/main/res/xml/data_extraction_rules.xml b/app/src/main/res/xml/data_extraction_rules.xml deleted file mode 100644 index e7d2d50..0000000 --- a/app/src/main/res/xml/data_extraction_rules.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - -