chore: bump version to 1.3.0+154 [ci skip]

.gitea/workflows/build.yml

@@ -68,18 +68,7 @@ jobs:
           echo "keyPassword=$KEYSTORE_PASSWORD" >> android/key.properties
           echo "✅ Keystore configurado"
 
-      # PRO owns the version NAME; every branch advances the build NUMBER.
-      #
-      # Previously main also bumped its patch on every push, so main's semver
-      # raced permanently ahead of PRO's (main hit 1.3.3 while the branch that
-      # actually ships sat at 1.3.0). That buried the release artifacts under a
-      # dev branch on builds.freetimelab.es, which sorts by version, and made
-      # every main<->PRO merge conflict on pubspec.yaml.
-      #
-      # The build number still advances everywhere: Google Play requires it to
-      # be monotonic across the whole app, so two branches must never mint the
-      # same code.
-      - name: Bump versión + commit
+      - name: Bump versión patch + commit
         run: |
           BRANCH="${CURRENT_REF#refs/heads/}"
           git config user.name "ShanaiaBot"
@@ -88,20 +77,12 @@ jobs:
           SEMVER=$(echo "$CURRENT" | cut -d'+' -f1)
           BUILD=$(echo "$CURRENT" | cut -d'+' -f2)
           NEW_BUILD=$((BUILD + 1))
-
-          # Look for [version set] across EVERY commit this push introduced,
-          # not just the tip. `git pull` inserts an auto-generated merge commit
-          # whose message carries no marker, which silently discarded a pinned
-          # version name and bumped 1.3.0 to 1.3.1 behind our backs.
-          RANGO="${{ gitea.event.before }}..${{ gitea.sha }}"
-          if git log "$RANGO" --pretty=%B 2>/dev/null | grep -q '\[version set\]'; then
-            MARCADOR="si"
-          else
-            MARCADOR="no"
-          fi
-
-          if [ "$BRANCH" != "PRO" ] || [ "$MARCADOR" = "si" ]; then
-            # Non-release branches never touch the name; PRO respects a pin.
+          # If the triggering commit explicitly pins the version name via the
+          # [version set] marker, ship that semver as-is (a milestone like 1.0.0
+          # or a major/minor jump the automatic patch bump cannot reach) and only
+          # advance the build number, which Google Play requires to stay
+          # monotonic. Otherwise keep the default automatic patch+build bump.
+          if git log -1 --pretty=%B | grep -q '\[version set\]'; then
             NEW_VERSION="${SEMVER}+${NEW_BUILD}"
           else
             MAJOR=$(echo "$SEMVER" | cut -d. -f1)
@@ -110,8 +91,6 @@ jobs:
             NEW_PATCH=$((PATCH + 1))
             NEW_VERSION="${MAJOR}.${MINOR}.${NEW_PATCH}+${NEW_BUILD}"
           fi
-
-          echo "rama=${BRANCH} marcador=${MARCADOR} ${CURRENT} -> ${NEW_VERSION}"
           sed -i '' "s/^version: .*/version: ${NEW_VERSION}/" pubspec.yaml
           git add pubspec.yaml
           git commit -m "chore: bump version to ${NEW_VERSION} [ci skip]"
@@ -258,47 +237,12 @@ jobs:
       - name: Build AAB release
         run: flutter build appbundle --release
 
-      # El nombre lleva RAMA y CÓDIGO DE VERSIÓN, no solo el semver.
-      #
-      # Antes, cada build de 1.3.0 se llamaba `pluriwave-v1.3.0.aab` y caía en
-      # la misma carpeta, así que main y PRO se pisaban y tres builds distintos
-      # eran indistinguibles una vez descargados: el navegador los guarda como
-      # "(1)", "(2)"... y ya no se sabe cuál es cuál. Eso costó subir a Play
-      # Console un código de versión ya usado, dos veces.
-      #
-      # Con `pluriwave-PRO-v1.3.0+156.aab` el archivo se identifica solo,
-      # incluso semanas después y fuera de este repo.
       - name: Publicar en ftl-builds (Zimaboard)
         run: |
           VERSION="${{ steps.version.outputs.version }}"
-          BUILD_NUMBER="${{ steps.version.outputs.build_number }}"
-          BRANCH="${CURRENT_REF#refs/heads/}"
-          ETIQUETA="${BRANCH}-v${VERSION}+${BUILD_NUMBER}"
-          APK_NOMBRE="pluriwave-${ETIQUETA}.apk"
-          AAB_NOMBRE="pluriwave-${ETIQUETA}.aab"
-          # La rama va en el NOMBRE DE LA APP, no en una subcarpeta.
-          #
-          # El objetivo sigue siendo el de siempre: que main y PRO no se mezclen
-          # en el portal, que ordena por número de versión y mostraba el build
-          # de desarrollo como "última versión" por delante del de release.
-          #
-          # Pero la primera solución metía la rama como TERCER nivel
-          # (pluriwave/main/v1.3.3/) y el portal indexa solo DOS —
-          # <app>/<versión>/<ficheros> —, así que desde el 29-08 ningún build de
-          # main volvió a aparecer en builds.freetimelab.es aunque el job saliera
-          # verde: el scp subía bien, a una ruta que el indexador no lee. Nada
-          # avisaba, y el echo de abajo se comía la rama y mandaba a la carpeta
-          # antigua, que llevaba congelada desde el +157.
-          #
-          # Con la rama en el nombre, PRO conserva la entrada limpia "pluriwave"
-          # y main tiene la suya, igual que ya conviven radar-foral y
-          # radar-foral-android.
-          if [ "$BRANCH" = "PRO" ]; then
-            APP="pluriwave"
-          else
-            APP="pluriwave-$(echo "$BRANCH" | tr '/' '-')"
-          fi
-          DESTINO="/opt/ftl-builds/builds/${APP}/v${VERSION}"
+          APK_NOMBRE="pluriwave-v${VERSION}.apk"
+          AAB_NOMBRE="pluriwave-v${VERSION}.aab"
+          DESTINO="/opt/ftl-builds/builds/pluriwave/v${VERSION}"
           SSH_KEY="/Users/freetlab/.openclaw/workspace/.secure/zimaboard_ed25519"
 
           ssh -i "$SSH_KEY" -o StrictHostKeyChecking=no ShanaiaBot@192.168.0.33 "mkdir -p ${DESTINO}"
@@ -308,46 +252,28 @@ jobs:
           scp -i "$SSH_KEY" -o StrictHostKeyChecking=no \
             build/app/outputs/bundle/release/app-release.aab \
             "ShanaiaBot@192.168.0.33:${DESTINO}/${AAB_NOMBRE}"
-          # La ruta se imprime desde ${APP}, no a mano: la version anterior tenia
-          # "pluriwave" escrito a fuego y mandaba a la carpeta equivocada cada
-          # vez que se compilaba algo que no fuera PRO.
-          echo "✅ APK: builds.freetimelab.es → ${APP} → v${VERSION} → ${APK_NOMBRE}"
-          echo "✅ AAB: builds.freetimelab.es → ${APP} → v${VERSION} → ${AAB_NOMBRE}"
+          echo "✅ APK: builds.freetimelab.es → pluriwave → v${VERSION}"
+          echo "✅ AAB: builds.freetimelab.es → pluriwave → v${VERSION}"
 
-      # La publicacion automatica en Google Play es OPCIONAL.
-      #
-      # Este paso hacia `exit 1` cuando faltaba el secreto, asi que TODA
-      # compilacion de PRO terminaba en rojo por una funcion que nunca llego a
-      # activarse: el secreto no se configuro nunca y las subidas a Play se han
-      # hecho siempre a mano. Un rojo permanente entrena a ignorar los rojos, y
-      # entonces el dia que falle algo de verdad tampoco se mira.
-      #
-      # Ahora se omite con un aviso. El AAB ya esta compilado, firmado y subido
-      # a ftl-builds por el paso anterior, asi que no se pierde nada. El dia que
-      # se configure el secreto, los tres pasos se activan solos.
       - name: Preparar credenciales de Google Play
-        id: credenciales_play
         if: ${{ gitea.ref == 'refs/heads/PRO' }}
         env:
           GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
         run: |
           if [ -z "$GOOGLE_PLAY_SERVICE_ACCOUNT_JSON" ]; then
-            echo "disponible=no" >> "$GITHUB_OUTPUT"
-            echo "AVISO: falta el secreto GOOGLE_PLAY_SERVICE_ACCOUNT_JSON."
-            echo "Se omite la publicacion en Google Play; sube el AAB a mano."
-            exit 0
+            echo "ERROR: falta el secreto GOOGLE_PLAY_SERVICE_ACCOUNT_JSON"
+            exit 1
           fi
           mkdir -p fastlane/credentials
           printf '%s' "$GOOGLE_PLAY_SERVICE_ACCOUNT_JSON" > fastlane/credentials/google-play-service-account.json
-          echo "disponible=si" >> "$GITHUB_OUTPUT"
 
       - name: Instalar Fastlane
-        if: ${{ gitea.ref == 'refs/heads/PRO' && steps.credenciales_play.outputs.disponible == 'si' }}
+        if: ${{ gitea.ref == 'refs/heads/PRO' }}
         run: |
           gem list -i fastlane >/dev/null 2>&1 || gem install fastlane --no-document
 
       - name: Publicar AAB en Google Play Internal Testing
-        if: ${{ gitea.ref == 'refs/heads/PRO' && steps.credenciales_play.outputs.disponible == 'si' }}
+        if: ${{ gitea.ref == 'refs/heads/PRO' }}
         env:
           PLAY_JSON_KEY_PATH: fastlane/credentials/google-play-service-account.json
           PLAY_AAB_PATH: build/app/outputs/bundle/release/app-release.aab
@@ -365,11 +291,8 @@ jobs:
           if [ -z "$BOT_TOKEN" ]; then exit 0; fi
           if [ "${{ job.status }}" = "success" ]; then
             MSG="✅ *PluriWave* v${VERSION} · rama ${BRANCH} · ${COMMIT}%0AAPK + AAB generados"
-            # Solo se anuncia la subida a Play cuando de verdad ocurrio.
-            if [ "$BRANCH" = "PRO" ] && [ "${{ steps.credenciales_play.outputs.disponible }}" = "si" ]; then
+            if [ "$BRANCH" = "PRO" ]; then
               MSG="${MSG}%0APublicado en Google Play · Internal Testing"
-            elif [ "$BRANCH" = "PRO" ]; then
-              MSG="${MSG}%0AEn builds.freetimelab.es · sube el AAB a Play a mano"
             else
               MSG="${MSG}%0APublicado en builds.freetimelab.es"
             fi

android/app/src/main/kotlin/es/freetimelab/pluriwave/MainActivity.kt

@@ -10,6 +10,7 @@ import android.content.pm.PackageManager
 import android.media.AudioDeviceCallback
 import android.media.AudioDeviceInfo
 import android.media.AudioManager
+import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.media.audiofx.Visualizer
 import android.app.AlarmManager
@@ -25,7 +26,6 @@ import android.util.Log
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.FileProvider
 import com.ryanheise.audioservice.AudioServiceActivity
-import es.freetimelab.pluriwave.fileactions.FileActionsHandler
 import io.flutter.embedding.engine.FlutterEngine
 import io.flutter.plugin.common.EventChannel
 import io.flutter.plugin.common.MethodChannel
@@ -269,31 +269,10 @@ class MainActivity : AudioServiceActivity() {
         }
         activeInstance = this
 
-        // fix/android-auto-musica-local: los cuatro metodos SAF que solo
-        // necesitan un ContentResolver viven en FileActionsHandler, dentro del
-        // paquete plugin `packages/pluriwave_file_actions`. Alli
-        // PluriWaveFileActionsPlugin los registra en TODOS los engines via
-        // GeneratedPluginRegistrant -- incluido el headless que audio_service
-        // crea para Android Auto, donde este configureFlutterEngine nunca
-        // corre.
-        //
-        // Este engine SI tiene Activity, asi que instala UN solo handler para
-        // todo el canal, superconjunto del del plugin: primero delega en el
-        // handler compartido (misma y unica implementacion) y, si este no
-        // reconoce el metodo, atiende sus propios metodos ligados a la
-        // Activity (picker SAF e intents de la carpeta de grabaciones).
-        //
-        // El orden esta garantizado: GeneratedPluginRegistrant corre DENTRO
-        // del constructor de FlutterEngine, y configureFlutterEngine solo
-        // puede ejecutarse despues, con el engine ya construido. Este handler
-        // siempre pisa al del plugin en una Activity, nunca al reves.
-        val fileActionsHandler = FileActionsHandler(applicationContext)
-
         MethodChannel(
             flutterEngine.dartExecutor.binaryMessenger,
             fileActionsChannel
         ).setMethodCallHandler { call, result ->
-            if (fileActionsHandler.manejar(call, result)) return@setMethodCallHandler
             when (call.method) {
                 "openDirectory" -> {
                     val path = call.argument<String>("path")
@@ -348,11 +327,53 @@ class MainActivity : AudioServiceActivity() {
                         pendingMusicFolderResult = null
                     }
                 }
-                // listAudioChildren / resolvePlayableUri /
-                // hasPersistedPermission / readAudioMetadataBatch los
-                // atiende FileActionsHandler arriba (item 3): no necesitan
-                // Activity, asi que tienen que poder registrarse tambien en
-                // un engine que no la tiene.
+                "listAudioChildren" -> {
+                    val treeUri = call.argument<String>("treeUri")
+                    val parentDocumentId = call.argument<String>("parentDocumentId") ?: ""
+                    Log.d(
+                        tag,
+                        "file_actions.listAudioChildren treeUri=$treeUri parentDocumentId=$parentDocumentId"
+                    )
+                    if (treeUri.isNullOrBlank()) {
+                        result.success(emptyList<Map<String, Any>>())
+                    } else {
+                        result.success(listAudioChildren(treeUri, parentDocumentId))
+                    }
+                }
+                "resolvePlayableUri" -> {
+                    val treeUri = call.argument<String>("treeUri")
+                    val documentId = call.argument<String>("documentId")
+                    Log.d(
+                        tag,
+                        "file_actions.resolvePlayableUri treeUri=$treeUri documentId=$documentId"
+                    )
+                    if (treeUri.isNullOrBlank() || documentId.isNullOrBlank()) {
+                        result.success(null)
+                    } else {
+                        result.success(resolvePlayableUri(treeUri, documentId))
+                    }
+                }
+                "hasPersistedPermission" -> {
+                    val treeUri = call.argument<String>("treeUri")
+                    Log.d(tag, "file_actions.hasPersistedPermission treeUri=$treeUri")
+                    result.success(
+                        if (treeUri.isNullOrBlank()) false else hasPersistedPermission(treeUri)
+                    )
+                }
+                // ---- android-auto-local-music-phase2 (static review only) ----
+                "readAudioMetadataBatch" -> {
+                    val treeUri = call.argument<String>("treeUri")
+                    val documentIds = call.argument<List<String>>("documentIds") ?: emptyList()
+                    Log.d(
+                        tag,
+                        "file_actions.readAudioMetadataBatch treeUri=$treeUri count=${documentIds.size}"
+                    )
+                    if (treeUri.isNullOrBlank()) {
+                        result.success(emptyList<Map<String, Any?>>())
+                    } else {
+                        result.success(readAudioMetadataBatch(treeUri, documentIds))
+                    }
+                }
                 else -> result.notImplemented()
             }
         }
@@ -402,6 +423,241 @@ class MainActivity : AudioServiceActivity() {
         super.onActivityResult(requestCode, resultCode, data)
     }
 
+    /**
+     * Walks ONE level of the SAF tree rooted at [treeUri] (android-auto-local-music,
+     * static review only — Design "Lazy per-folder enumeration, never an
+     * eager tree dump"): [parentDocumentId] blank means the tree root
+     * itself, otherwise the given subfolder's documentId. Filters files to
+     * audio MIME types at the native layer (lean payload); each returned row
+     * also carries `mime` so the Dart side can re-validate via
+     * `esArchivoAudio` (defense-in-depth). Any query failure degrades to an
+     * empty list rather than throwing.
+     */
+    private fun listAudioChildren(treeUri: String, parentDocumentId: String): List<Map<String, Any>> {
+        return try {
+            val parsedTree = Uri.parse(treeUri)
+            val parentId = parentDocumentId.ifBlank {
+                DocumentsContract.getTreeDocumentId(parsedTree)
+            }
+            val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(parsedTree, parentId)
+            val projection = arrayOf(
+                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+                DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+                DocumentsContract.Document.COLUMN_MIME_TYPE
+            )
+            val resultado = mutableListOf<Map<String, Any>>()
+            contentResolver.query(childrenUri, projection, null, null, null)?.use { cursor ->
+                val idxDocId = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
+                val idxNombre = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
+                val idxMime = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_MIME_TYPE)
+                while (cursor.moveToNext()) {
+                    val documentId = cursor.getString(idxDocId) ?: continue
+                    val nombre = cursor.getString(idxNombre) ?: continue
+                    val mime = cursor.getString(idxMime) ?: ""
+                    val esDirectorio = mime == DocumentsContract.Document.MIME_TYPE_DIR
+                    if (!esDirectorio && !mime.startsWith("audio/")) continue
+                    resultado.add(
+                        mapOf(
+                            "documentId" to documentId,
+                            "nombre" to nombre,
+                            "esDirectorio" to esDirectorio,
+                            "mime" to mime
+                        )
+                    )
+                }
+            }
+            resultado
+        } catch (error: Throwable) {
+            Log.e(tag, "file_actions.listAudioChildren failed treeUri=$treeUri parentDocumentId=$parentDocumentId", error)
+            emptyList()
+        }
+    }
+
+    /**
+     * Resolves a leaf [documentId] within [treeUri] to its playable
+     * `content://` URI (android-auto-local-music, static review only).
+     * Returns `null` on any failure instead of throwing.
+     */
+    private fun resolvePlayableUri(treeUri: String, documentId: String): String? {
+        return try {
+            val parsedTree = Uri.parse(treeUri)
+            DocumentsContract.buildDocumentUriUsingTree(parsedTree, documentId).toString()
+        } catch (error: Throwable) {
+            Log.e(tag, "file_actions.resolvePlayableUri failed treeUri=$treeUri documentId=$documentId", error)
+            null
+        }
+    }
+
+    /**
+     * Checks whether [treeUri]'s read permission is still among
+     * [android.content.ContentResolver.getPersistedUriPermissions]
+     * (android-auto-local-music, static review only) — used for cold-start
+     * / revoked-permission detection (Spec "Permission revoked or never
+     * granted"). Returns `false` (never throws) on a malformed [treeUri] or
+     * any other failure.
+     */
+    private fun hasPersistedPermission(treeUri: String): Boolean {
+        return try {
+            val parsed = Uri.parse(treeUri)
+            contentResolver.persistedUriPermissions.any { it.uri == parsed && it.isReadPermission }
+        } catch (error: Throwable) {
+            Log.e(tag, "file_actions.hasPersistedPermission failed treeUri=$treeUri", error)
+            false
+        }
+    }
+
+    /**
+     * Batched embedded-metadata extraction (android-auto-local-music-phase2,
+     * static review only — Design "Interfaces / Contracts"): for each of
+     * [documentIds], extracts title/artist/bitrate/sample-rate and the
+     * embedded picture via [extraerMetadatosPista]. Never throws across the
+     * channel boundary — a malformed [treeUri] (or any other unexpected
+     * failure) degrades the WHOLE call to `[]`; a per-entry failure is
+     * already isolated inside [extraerMetadatosPista].
+     */
+    private fun readAudioMetadataBatch(treeUri: String, documentIds: List<String>): List<Map<String, Any?>> {
+        return try {
+            val parsedTree = Uri.parse(treeUri)
+            documentIds.map { documentId -> extraerMetadatosPista(parsedTree, documentId) }
+        } catch (error: Throwable) {
+            Log.e(tag, "file_actions.readAudioMetadataBatch failed treeUri=$treeUri", error)
+            emptyList()
+        }
+    }
+
+    /**
+     * Extracts one [documentId]'s embedded metadata via
+     * [MediaMetadataRetriever] (android-auto-local-music-phase2, static
+     * review only — mirrors [listAudioChildren]/[resolvePlayableUri]'s
+     * never-throws shape). `METADATA_KEY_SAMPLERATE` (raw key `38`, no
+     * public constant below API 31) is gated behind
+     * `Build.VERSION.SDK_INT >= 31` (Design ADR-5); every other field is
+     * available since API 10 and read unconditionally. A resolvable
+     * embedded picture is handed to [cachearArteEmbebido]; art-cache
+     * failures degrade that single field to `null` without failing the
+     * whole entry. On ANY failure for this [documentId] (unsupported
+     * format, permission edge case, corrupt file), the row degrades to an
+     * all-null-but-`documentId` entry instead of throwing —
+     * `retriever.release()` always runs via `finally`.
+     */
+    private fun extraerMetadatosPista(parsedTree: Uri, documentId: String): Map<String, Any?> {
+        val retriever = MediaMetadataRetriever()
+        return try {
+            val documentUri = DocumentsContract.buildDocumentUriUsingTree(parsedTree, documentId)
+            retriever.setDataSource(this, documentUri)
+
+            val titulo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE)
+            val artista = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)
+            val bitrate = retriever
+                .extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)
+                ?.toIntOrNull()
+            val sampleRate = if (Build.VERSION.SDK_INT >= 31) {
+                // METADATA_KEY_SAMPLERATE = 38 (API 31+, Design ADR-5); no
+                // public constant exists on this minSdk, so the raw key is
+                // used directly, guarded by the version check above.
+                retriever.extractMetadata(38)?.toIntOrNull()
+            } else {
+                null
+            }
+            val artUri = try {
+                retriever.embeddedPicture?.let { cachearArteEmbebido(documentId, it) }
+            } catch (error: Throwable) {
+                Log.e(
+                    tag,
+                    "file_actions.readAudioMetadataBatch embeddedPicture failed documentId=$documentId",
+                    error
+                )
+                null
+            }
+
+            mapOf(
+                "documentId" to documentId,
+                "titulo" to titulo,
+                "artista" to artista,
+                "bitrate" to bitrate,
+                "sampleRate" to sampleRate,
+                "artUri" to artUri
+            )
+        } catch (error: Throwable) {
+            Log.e(
+                tag,
+                "file_actions.readAudioMetadataBatch entry failed documentId=$documentId",
+                error
+            )
+            mapOf(
+                "documentId" to documentId,
+                "titulo" to null,
+                "artista" to null,
+                "bitrate" to null,
+                "sampleRate" to null,
+                "artUri" to null
+            )
+        } finally {
+            try {
+                retriever.release()
+            } catch (_: Throwable) {
+                // release() failing is not actionable — the retriever is
+                // being discarded regardless.
+            }
+        }
+    }
+
+    /**
+     * Embedded-art cache write + LRU trim (android-auto-local-music-phase2,
+     * static review only — Design ADR-1). Writes [picture] bytes to
+     * `cacheDir/pluriwave_art/<hash(documentId)>` (skips the write when the
+     * file already exists, so re-parsing the same track reuses it), returns
+     * the `content://` URI served via the EXISTING
+     * `${applicationId}.fileprovider` authority
+     * (`AndroidManifest.xml:97-105`, `pluriwave_file_paths.xml`'s
+     * `cache-path path="."` — confirmed present, zero manifest changes
+     * needed) and trims `pluriwave_art/` via [trimArtCache]. `hash` uses
+     * SHA-256 hex because a raw `documentId` may contain `:`/`/`, which are
+     * illegal in filenames on most filesystems.
+     */
+    private fun cachearArteEmbebido(documentId: String, picture: ByteArray): String? {
+        return try {
+            val artDir = File(cacheDir, "pluriwave_art").apply { mkdirs() }
+            val artFile = File(artDir, hashDocumentId(documentId))
+            if (!artFile.exists()) {
+                artFile.writeBytes(picture)
+            }
+            trimArtCache(artDir)
+            FileProvider.getUriForFile(this, "$packageName.fileprovider", artFile).toString()
+        } catch (error: Throwable) {
+            Log.e(tag, "file_actions.cachearArteEmbebido failed documentId=$documentId", error)
+            null
+        }
+    }
+
+    private fun hashDocumentId(documentId: String): String {
+        val digest = java.security.MessageDigest.getInstance("SHA-256")
+        val bytes = digest.digest(documentId.toByteArray(Charsets.UTF_8))
+        return bytes.joinToString("") { "%02x".format(it) }
+    }
+
+    /**
+     * LRU-by-`lastModified` trim of the embedded-art cache dir (Design
+     * ADR-1): after each write, keeps at most 256 files AND at most 32 MB
+     * total, deleting the OLDEST-by-mtime entries first. Kept as a
+     * trivially reviewable loop — these files are native-owned, so
+     * round-tripping names to Dart to pick deletions would add channel
+     * chatter with no testability gain (the `delete()` is native
+     * regardless, per ADR-1's rationale).
+     */
+    private fun trimArtCache(artDir: File) {
+        val maxArchivos = 256
+        val maxBytes = 32L * 1024 * 1024
+        val archivos = artDir.listFiles()?.sortedByDescending { it.lastModified() }?.toMutableList()
+            ?: return
+        var totalBytes = archivos.sumOf { it.length() }
+        while (archivos.isNotEmpty() && (archivos.size > maxArchivos || totalBytes > maxBytes)) {
+            val masViejo = archivos.removeAt(archivos.size - 1)
+            totalBytes -= masViejo.length()
+            masViejo.delete()
+        }
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         setIntent(intent)

android/gradle.properties

@@ -1,6 +1,2 @@
 org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
-# This builtInKotlin flag was added automatically by Flutter migrator
-android.builtInKotlin=false
-# This newDsl flag was added automatically by Flutter migrator
-android.newDsl=false

lib/estado/estado_ecualizador.dart

@@ -98,13 +98,6 @@ class EstadoEcualizador extends ChangeNotifier {
   /// `_actualizarControlesEq()`, regardless of who triggered it), compare
   /// the handler's current EQ state against our cached copy and adopt it on
   /// divergence.
-  ///
-  /// Since eq-estado-unico this is a DISPLAY concern only. The handler owns
-  /// the flag and persists it itself, so this subscription no longer closes
-  /// a persistence gap — it just keeps the phone's toggle showing what the
-  /// engine is really doing. It also cannot be the fix on its own: it exists
-  /// only while an [EstadoEcualizador] does, and the headless Android Auto
-  /// engine that produced the bug report never builds one.
   StreamSubscription<EstadoReproduccion>? _suscripcionEstadoAudioEq;
 
   PresetEcualizador get presetActual => _presetActual;
@@ -377,16 +370,8 @@ class EstadoEcualizador extends ChangeNotifier {
   /// `setEcualizadorActivo`/`aplicarPreset`): doing so would re-trigger the
   /// handler's own `_actualizarControlesEq()` re-push, which would tick
   /// [ServicioAudio.estadoStream] again and re-enter this method forever.
-  /// Only a local field write and [notifyListeners] happen here, so a
-  /// divergence is resolved in a single pass.
-  ///
-  /// It is now a PURE UI ADOPT — it does not persist (eq-estado-unico item
-  /// B). `PluriWaveAudioHandler` writes its own toggle through the port
-  /// `registrarHandler` injects, so the value is saved on every engine
-  /// rather than only on one that happens to have built a widget tree. This
-  /// method could never have been the owner of that fact: it only runs while
-  /// an [EstadoEcualizador] exists, and on the headless Android Auto engine
-  /// behind the bug report none ever does.
+  /// Only a local field write, [servicio] persistence and [notifyListeners]
+  /// happen here, so a divergence is resolved in a single pass.
   ///
   /// Wrapped in try/catch like every other handler-facing read in this
   /// class (e.g. [_sembrarDispositivoActual]): a test double or an
@@ -402,10 +387,13 @@ class EstadoEcualizador extends ChangeNotifier {
       if (!activoDiverge && !presetDiverge) return;
 
       if (activoDiverge) {
-        // Display-only adopt: the handler already persisted this value
-        // through its own write port before it ever reached us. See the
-        // doc above.
         _activo = activoHandler;
+        // Closes the persistence gap: `PluriWaveAudioHandler` never
+        // persists anything itself (it must stay headless-constructible,
+        // with zero SharedPreferences/Provider access) — [servicio] is the
+        // only owner of EQ persistence, so a car/notification toggle must
+        // be saved HERE or it is lost on the next process restart.
+        await servicio.guardarActivo(activoHandler);
       }
       if (presetDiverge) {
         _presetActual = presetHandler;
@@ -663,29 +651,12 @@ class EstadoEcualizador extends ChangeNotifier {
   /// Each step then re-checks [_activo]: a newer tap that landed mid-flight
   /// owns the outcome, and this superseded call must not apply a preset or
   /// persist a value the user has already changed their mind about.
-  ///
-  /// The handler can also REFUSE the change: when the native `setEnabled`
-  /// throws, `PluriWaveAudioHandler._aplicarEcualizadorActivo` rolls its own
-  /// flag back and skips its persistence write, so the value we optimistically
-  /// published never happened. Reading [ServicioAudio.ecualizadorActivo] back
-  /// (the handler is the single owner of the flag — eq-estado-unico) is how we
-  /// learn that: on divergence we adopt the handler's real value and return
-  /// WITHOUT persisting, instead of showing a lie and writing a rejected value
-  /// to disk that would resurrect it on the next start. The supersede check
-  /// runs FIRST so a newer tap still owns the outcome; the read-back only
-  /// speaks for a call nobody overtook.
   Future<void> cambiarActivo(bool activo) async {
     _activo = activo;
     notifyListeners();
 
     await audio.setEcualizadorActivo(activo);
     if (_activo != activo) return;
-    final aceptado = audio.ecualizadorActivo;
-    if (aceptado != activo) {
-      _activo = aceptado;
-      notifyListeners();
-      return;
-    }
     if (activo) {
       await audio.aplicarPreset(_presetActual);
       if (_activo != activo) return;
@@ -724,21 +695,12 @@ class EstadoEcualizador extends ChangeNotifier {
 
   /// Replaces the whole EQ configuration (backup import path): persists it,
   /// re-applies the preset effective for the current station and notifies.
-  ///
-  /// [activo] is the imported on/off toggle (S4-R4/eq-export-toggle). When
-  /// `null` — an old backup with no `ecualizadorActivo` field — the CURRENT
-  /// toggle is left untouched: an absent flag must never flip the user's live
-  /// setting to an arbitrary value. When non-null, applies it through
-  /// [cambiarActivo], the same path a manual toggle uses, so the import
-  /// persists it AND pushes it to the live audio engine instead of just
-  /// updating [_activo] in memory.
   Future<void> importarConfiguracion({
     required PresetEcualizador principal,
     required Map<String, PresetEcualizador> porEmisora,
     Map<String, PresetEcualizador>? presetsDispositivo,
     Map<String, PresetEcualizador>? presetsMatriz,
     bool? eqMultiDeviceEnabled,
-    bool? activo,
   }) async {
     _presetPrincipal = principal;
     _presetsEmisoraMap
@@ -773,11 +735,6 @@ class EstadoEcualizador extends ChangeNotifier {
     final presetEfectivoActual =
         uuid == null ? _presetPrincipal : _resolverPresetActivo();
     await aplicarPresetActivo(presetEfectivoActual);
-
-    if (activo != null) {
-      await cambiarActivo(activo);
-    }
-
     notifyListeners();
   }
 

lib/estado/estado_entitlement.dart

@@ -3,7 +3,7 @@ import 'dart:async';
 import 'package:flutter/foundation.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
-import '../servicios/servicio_audio.dart' show invalidarArbolAuto;
+import '../servicios/servicio_audio.dart' show notificarDesbloqueoAuto;
 import '../servicios/servicio_compras.dart';
 
 /// Versioned persistence key (Design ADR-1) for the permanent, non-consumable
@@ -181,7 +181,7 @@ class EstadoEntitlement extends ChangeNotifier {
       // Orchestrator-resolved open question (design.md): actively
       // invalidate the Android Auto browse cache on the free -> premium
       // transition, rather than waiting for the head unit's own re-bind.
-      invalidarArbolAuto();
+      notificarDesbloqueoAuto();
     }
   }
 

lib/estado/estado_radio.dart

@@ -338,6 +338,24 @@ class EstadoRadio extends ChangeNotifier {
     }
   }
 
+  /// Best-effort remembers [emisora] as the last used station (issue 4) so
+  /// [_restaurarUltimaEmisora] can bring it back after a restart. Fire-and-
+  /// forget, same treatment [reproducir] already gives other non-critical
+  /// side effects (e.g. `radio.registrarClick`) — a failed write here must
+  /// never block or fail actual playback.
+  Future<void> _persistirUltimaEmisora(Emisora emisora) async {
+    try {
+      final prefs = await _resolverPrefs();
+      await prefs.setString(_keyUltimaEmisora, jsonEncode(emisora.toMap()));
+    } catch (e) {
+      registrarSaltoPersistencia(
+        subsistema: 'ultima_emisora',
+        detalle: 'persistir ${emisora.uuid}',
+        razon: e.toString(),
+      );
+    }
+  }
+
   /// Escucha el stream de estado del audio y gestiona errores de reproducción.
   void _escucharErroresReproduccion() {
     _suscripcionEstadoAudio = audio.estadoStream.listen((estado) {
@@ -357,12 +375,9 @@ class EstadoRadio extends ChangeNotifier {
       final actual = audio.emisoraActual;
       if (actual != null && actual.uuid != _emisoraSeleccionada?.uuid) {
         _emisoraSeleccionada = actual;
-        // Issue 4's write used to live here as well. It is gone: the handler
-        // persists every station itself from `_cambiarFuente`, which is the
-        // same source change that moved `audio.emisoraActual` and is the
-        // reason this branch runs at all. Writing again here would make the
-        // key's final value depend on how two independent fire-and-forget
-        // chains interleave on a fast station switch.
+        // Issue 4: an Android-Auto-initiated selection is a real station
+        // change too — remember it the same way `reproducir` does.
+        unawaited(_persistirUltimaEmisora(actual));
       }
       notifyListeners();
     });
@@ -573,13 +588,10 @@ class EstadoRadio extends ChangeNotifier {
     }
     _emisoraSeleccionada = emisora;
     notifyListeners();
-    // Issue 4's `ultima_emisora_v1` write used to be here. It now happens
-    // once, inside the handler's `_cambiarFuente`, which `audio.reproducir`
-    // below reaches for this very station — see
-    // [GuardarUltimaEmisoraPersistida]. Persisting here as well would have
-    // left the key with TWO fire-and-forget writers whose relative order
-    // decides the value after a fast A -> B switch, and this one cannot see
-    // the revision guard that already cancels a superseded change.
+    // Issue 4: remembers the station the user just picked so it survives a
+    // restart — fire-and-forget, same treatment as `radio.registrarClick`
+    // below (a persistence failure here must never block playback).
+    unawaited(_persistirUltimaEmisora(emisora));
     try {
       await audio.reproducir(emisora);
       if (revision != _revisionReproduccion) return;
@@ -795,10 +807,9 @@ class EstadoRadio extends ChangeNotifier {
 
   static const _keyAlarmasConfig = 'alarmas_musicales_v1';
 
-  /// Genera el JSON de toda la configuración (v4 — portabilidad completa
-  /// con presets por dispositivo, matriz multi-device y el toggle
-  /// on/off del ecualizador).
-  /// La forma del sobre vive en [ServicioExportImport] (S4-R4).
+  /// Genera el JSON de toda la configuración (v3 — portabilidad completa
+  /// con presets por dispositivo y matriz multi-device).
+  /// La forma del sobre v3 vive en [ServicioExportImport] (S4-R4).
   Future<Map<String, dynamic>> exportarConfig() async {
     final favs = await favoritos.obtenerTodos();
     final grupos = await favoritos.obtenerGrupos();
@@ -826,8 +837,6 @@ class EstadoRadio extends ChangeNotifier {
       presetsPorDispositivo: ecualizador.presetsDispositivo,
       presetsMatriz: ecualizador.presetsMatriz,
       eqMultiDeviceEnabled: ecualizador.eqMultiDeviceEnabled,
-      // v4 extension — equalizer global on/off toggle.
-      ecualizadorActivo: ecualizador.activo,
     );
   }
 
@@ -841,11 +850,10 @@ class EstadoRadio extends ChangeNotifier {
 
   /// Importa configuración desde un JSON exportado previamente.
   /// Soporta v1 (sin grupos, sin alarmas), v2 (portabilidad completa),
-  /// v3 (+ presets por dispositivo, presets matriz, toggle multi-device)
-  /// y v4 (+ toggle on/off del ecualizador).
+  /// y v3 (+ presets por dispositivo, presets matriz, toggle multi-device).
   Future<void> importarConfig(Map<String, dynamic> data) async {
     final version = data['version'] as int? ?? 1;
-    if (version > 4) throw Exception(_textos.unsupportedConfigVersion);
+    if (version > 3) throw Exception(_textos.unsupportedConfigVersion);
 
     final prefs = await _resolverPrefs();
 
@@ -865,12 +873,7 @@ class EstadoRadio extends ChangeNotifier {
     final favRaw = data['favoritos'] as List? ?? [];
     for (final raw in favRaw) {
       final emisora = Emisora.fromMap(Map<String, dynamic>.from(raw as Map));
-      // `restaurarFavorito`, NO `agregar`: `agregar` es la primitiva de
-      // «marcar como favorita» y fuerza `sin_asignar` + un `orden` al final,
-      // que es justo lo que la copia trae y hay que conservar. Con `agregar`
-      // los grupos restaurados arriba volvían como cascarones vacíos y todas
-      // las emisoras aterrizaban en «Sin asignar».
-      await favoritos.restaurarFavorito(emisora);
+      await favoritos.agregar(emisora);
     }
 
     // ── Emisoras custom ───────────────────────────────────────────────────
@@ -929,20 +932,12 @@ class EstadoRadio extends ChangeNotifier {
       eqMultiDeviceEnabled = data['eqMultiDeviceEnabled'] as bool?;
     }
 
-    // v4 extension: equalizer on/off toggle. Read unconditionally — the key
-    // is simply absent on any pre-v4 backup, which resolves to `null` and
-    // leaves the user's CURRENT toggle untouched (see
-    // `EstadoEcualizador.importarConfiguracion` doc): an old backup must
-    // never flip a live setting it never carried.
-    final ecualizadorActivo = data['ecualizadorActivo'] as bool?;
-
     await ecualizador.importarConfiguracion(
       principal: presetPrincipal,
       porEmisora: presetsPorEmisora,
       presetsDispositivo: presetsDispositivo,
       presetsMatriz: presetsMatriz,
       eqMultiDeviceEnabled: eqMultiDeviceEnabled,
-      activo: ecualizadorActivo,
     );
 
     // ── Alarmas (v2) ──────────────────────────────────────────────────────
@@ -950,12 +945,7 @@ class EstadoRadio extends ChangeNotifier {
       final alarmasData = data['alarmas'];
       if (alarmasData is Map<String, dynamic>) {
         // Escribimos el bloque JSON tal como estaba en el dispositivo origen.
-        // EstadoAlarmas es un ChangeNotifier independiente y de larga vida
-        // que ya cargó sus alarmas en memoria: NO relee este storage por sí
-        // solo. El llamador (pantalla_ajustes_backup.dart) es responsable de
-        // invocar `EstadoAlarmas.cargarPersistidasSinRecalcular()` seguido
-        // de `refrescarProgramacion()` tras un import exitoso; EstadoRadio
-        // se mantiene deliberadamente sin depender de EstadoAlarmas.
+        // ServicioAlarmas lo leerá con su propio fromJson al siguiente acceso.
         await prefs.setString(_keyAlarmasConfig, jsonEncode(alarmasData));
       }
     }

lib/l10n/app_ar.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "استعادة المشتريات",
   "compraError": "تعذّر إتمام عملية الشراء. حاول مرة أخرى.",
   "restauracionSinCompras": "لم نجد أي عملية شراء سابقة في هذا الحساب.",
-  "premiumActivo": "النسخة المميزة مفعّلة",
-  "premiumHojaTitulo": "افتح PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "بدون إعلانات في التطبيق بالكامل",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "تسجيل المحطات",
-  "premiumBeneficioVacaciones": "فترات إجازة للمنبهات",
-  "premiumBeneficioAlarmasIlimitadas": "منبهات غير محدودة (تسمح الخطة المجانية بحتى 5)",
-  "premiumPagoUnico": "دفعة واحدة، للأبد. ليس اشتراكًا.",
-  "premiumAhoraNo": "ليس الآن",
-  "autoErrorEmisoraPremium": "هذه المحطة ضمن Premium. افتح PluriWave على هاتفك لفتحها.",
-  "autoErrorBusquedaSinResultados": "لم نعثر على تلك المحطة. جرّب اسمًا آخر.",
-  "autoCarpetaEscuchar": "الاستماع",
-  "autoCarpetaFavoritos": "المفضلة",
-  "autoCarpetaTodas": "كل المحطات",
-  "autoCarpetaMisEmisoras": "محطاتي",
-  "autoCarpetaMusicaLocal": "الموسيقى المحلية",
-  "autoMusicaLocalNoDisponible": "افتح PluriWave على هاتفك لقراءة موسيقاك",
-  "autoCargarMas": "المزيد…",
-  "autoOrdenarPorCalidad": "الترتيب حسب الجودة",
-  "autoReproducirCarpeta": "تشغيل المجلد",
-  "autoReproducirAleatorio": "تشغيل عشوائي",
-  "autoPistaSinNombre": "مقطع بلا اسم"
+  "premiumActivo": "النسخة المميزة مفعّلة"
 }

lib/l10n/app_bn.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "কেনাকাটা পুনরুদ্ধার করুন",
   "compraError": "কেনাকাটা সম্পূর্ণ করা যায়নি। আবার চেষ্টা করুন।",
   "restauracionSinCompras": "এই অ্যাকাউন্টে আমরা আগের কোনো কেনাকাটা খুঁজে পাইনি।",
-  "premiumActivo": "প্রিমিয়াম সক্রিয়",
-  "premiumHojaTitulo": "PluriWave Premium আনলক করুন",
-  "premiumBeneficioSinAnuncios": "পুরো অ্যাপে কোনো বিজ্ঞাপন নেই",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "স্টেশন রেকর্ডিং",
-  "premiumBeneficioVacaciones": "অ্যালার্মের জন্য ছুটির সময়কাল",
-  "premiumBeneficioAlarmasIlimitadas": "সীমাহীন অ্যালার্ম (ফ্রি প্ল্যানে সর্বোচ্চ ৫টি অনুমোদিত)",
-  "premiumPagoUnico": "একবারের পেমেন্ট, চিরকালের জন্য। এটি সাবস্ক্রিপশন নয়।",
-  "premiumAhoraNo": "এখন নয়",
-  "autoErrorEmisoraPremium": "এই স্টেশনটি Premium। আনলক করতে ফোনে PluriWave খুলুন।",
-  "autoErrorBusquedaSinResultados": "সেই স্টেশনটি খুঁজে পাওয়া যায়নি। অন্য নাম চেষ্টা করুন।",
-  "autoCarpetaEscuchar": "শুনুন",
-  "autoCarpetaFavoritos": "প্রিয়",
-  "autoCarpetaTodas": "সব স্টেশন",
-  "autoCarpetaMisEmisoras": "আমার স্টেশন",
-  "autoCarpetaMusicaLocal": "স্থানীয় সঙ্গীত",
-  "autoMusicaLocalNoDisponible": "আপনার গান পড়তে ফোনে PluriWave খুলুন",
-  "autoCargarMas": "আরও…",
-  "autoOrdenarPorCalidad": "মান অনুসারে সাজান",
-  "autoReproducirCarpeta": "ফোল্ডার চালান",
-  "autoReproducirAleatorio": "এলোমেলোভাবে চালান",
-  "autoPistaSinNombre": "নামহীন ট্র্যাক"
+  "premiumActivo": "প্রিমিয়াম সক্রিয়"
 }

lib/l10n/app_de.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Käufe wiederherstellen",
   "compraError": "Der Kauf konnte nicht abgeschlossen werden. Bitte versuche es erneut.",
   "restauracionSinCompras": "Wir haben auf diesem Konto keinen früheren Kauf gefunden.",
-  "premiumActivo": "Premium aktiv",
-  "premiumHojaTitulo": "PluriWave Premium freischalten",
-  "premiumBeneficioSinAnuncios": "Keine Werbung in der gesamten App",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Sender aufnehmen",
-  "premiumBeneficioVacaciones": "Urlaubszeiträume für Wecker",
-  "premiumBeneficioAlarmasIlimitadas": "Unbegrenzte Wecker (die kostenlose Version erlaubt bis zu 5)",
-  "premiumPagoUnico": "Einmalzahlung, für immer. Kein Abonnement.",
-  "premiumAhoraNo": "Nicht jetzt",
-  "autoErrorEmisoraPremium": "Dieser Sender ist Premium. Öffne PluriWave auf dem Handy, um ihn freizuschalten.",
-  "autoErrorBusquedaSinResultados": "Wir haben diesen Sender nicht gefunden. Versuch es mit einem anderen Namen.",
-  "autoCarpetaEscuchar": "Hören",
-  "autoCarpetaFavoritos": "Favoriten",
-  "autoCarpetaTodas": "Alle Sender",
-  "autoCarpetaMisEmisoras": "Meine Sender",
-  "autoCarpetaMusicaLocal": "Lokale Musik",
-  "autoMusicaLocalNoDisponible": "Öffne PluriWave auf dem Handy, um deine Musik zu lesen",
-  "autoCargarMas": "Mehr…",
-  "autoOrdenarPorCalidad": "Nach Qualität sortieren",
-  "autoReproducirCarpeta": "Ordner abspielen",
-  "autoReproducirAleatorio": "Zufallswiedergabe",
-  "autoPistaSinNombre": "Unbenannter Titel"
+  "premiumActivo": "Premium aktiv"
 }

lib/l10n/app_en.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Restore purchases",
   "compraError": "We couldn't complete the purchase. Please try again.",
   "restauracionSinCompras": "We didn't find any previous purchase on this account.",
-  "premiumActivo": "Premium active",
-  "premiumHojaTitulo": "Unlock PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "No ads anywhere in the app",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Station recording",
-  "premiumBeneficioVacaciones": "Vacation ranges for alarms",
-  "premiumBeneficioAlarmasIlimitadas": "Unlimited alarms (the free plan allows up to 5)",
-  "premiumPagoUnico": "One-time purchase, forever. Not a subscription.",
-  "premiumAhoraNo": "Not now",
-  "autoErrorEmisoraPremium": "This station is Premium. Open PluriWave on your phone to unlock it.",
-  "autoErrorBusquedaSinResultados": "We couldn't find that station. Try another name.",
-  "autoCarpetaEscuchar": "Listen",
-  "autoCarpetaFavoritos": "Favorites",
-  "autoCarpetaTodas": "All stations",
-  "autoCarpetaMisEmisoras": "My stations",
-  "autoCarpetaMusicaLocal": "Local music",
-  "autoMusicaLocalNoDisponible": "Open PluriWave on your phone to read your music",
-  "autoCargarMas": "More…",
-  "autoOrdenarPorCalidad": "Sort by quality",
-  "autoReproducirCarpeta": "Play folder",
-  "autoReproducirAleatorio": "Shuffle play",
-  "autoPistaSinNombre": "Untitled track"
+  "premiumActivo": "Premium active"
 }

lib/l10n/app_es.arb

@@ -863,26 +863,5 @@
   "restaurarCompras": "Restaurar compras",
   "compraError": "No se ha podido completar la compra. Inténtalo de nuevo.",
   "restauracionSinCompras": "No hemos encontrado ninguna compra anterior en esta cuenta.",
-  "premiumActivo": "Premium activo",
-  "premiumHojaTitulo": "Desbloquea PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Sin publicidad en toda la app",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Grabación de emisoras",
-  "premiumBeneficioVacaciones": "Rangos de vacaciones para las alarmas",
-  "premiumBeneficioAlarmasIlimitadas": "Alarmas ilimitadas (el plan gratuito permite hasta 5)",
-  "premiumPagoUnico": "Pago único, para siempre. No es una suscripción.",
-  "premiumAhoraNo": "Ahora no",
-  "autoErrorEmisoraPremium": "Esta emisora es Premium. Abre PluriWave en el móvil para desbloquearla.",
-  "autoErrorBusquedaSinResultados": "No hemos encontrado esa emisora. Prueba con otro nombre.",
-  "autoCarpetaEscuchar": "Escuchar",
-  "autoCarpetaFavoritos": "Favoritos",
-  "autoCarpetaTodas": "Todas las emisoras",
-  "autoCarpetaMisEmisoras": "Mis emisoras",
-  "autoCarpetaMusicaLocal": "Música Local",
-  "autoMusicaLocalNoDisponible": "Abre PluriWave en el móvil para leer tu música",
-  "autoCargarMas": "Más…",
-  "autoOrdenarPorCalidad": "Ordenar por calidad",
-  "autoReproducirCarpeta": "Reproducir carpeta",
-  "autoReproducirAleatorio": "Reproducir aleatorio",
-  "autoPistaSinNombre": "Pista sin nombre"
+  "premiumActivo": "Premium activo"
 }

lib/l10n/app_fr.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Restaurer les achats",
   "compraError": "Impossible de finaliser l'achat. Veuillez réessayer.",
   "restauracionSinCompras": "Nous n'avons trouvé aucun achat antérieur sur ce compte.",
-  "premiumActivo": "Premium actif",
-  "premiumHojaTitulo": "Débloquer PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Aucune publicité dans toute l'application",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Enregistrement des stations",
-  "premiumBeneficioVacaciones": "Périodes de vacances pour les alarmes",
-  "premiumBeneficioAlarmasIlimitadas": "Alarmes illimitées (la version gratuite en autorise jusqu'à 5)",
-  "premiumPagoUnico": "Achat unique, pour toujours. Ce n'est pas un abonnement.",
-  "premiumAhoraNo": "Plus tard",
-  "autoErrorEmisoraPremium": "Cette station est Premium. Ouvre PluriWave sur ton téléphone pour la débloquer.",
-  "autoErrorBusquedaSinResultados": "Nous n'avons pas trouvé cette station. Essaie un autre nom.",
-  "autoCarpetaEscuchar": "Écouter",
-  "autoCarpetaFavoritos": "Favoris",
-  "autoCarpetaTodas": "Toutes les stations",
-  "autoCarpetaMisEmisoras": "Mes stations",
-  "autoCarpetaMusicaLocal": "Musique locale",
-  "autoMusicaLocalNoDisponible": "Ouvrez PluriWave sur votre téléphone pour lire votre musique",
-  "autoCargarMas": "Plus…",
-  "autoOrdenarPorCalidad": "Trier par qualité",
-  "autoReproducirCarpeta": "Lire le dossier",
-  "autoReproducirAleatorio": "Lecture aléatoire",
-  "autoPistaSinNombre": "Piste sans nom"
+  "premiumActivo": "Premium actif"
 }

lib/l10n/app_hi.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "खरीदारी पुनर्स्थापित करें",
   "compraError": "खरीद पूरी नहीं हो सकी। कृपया फिर से प्रयास करें।",
   "restauracionSinCompras": "इस खाते में हमें कोई पिछली खरीद नहीं मिली।",
-  "premiumActivo": "प्रीमियम सक्रिय",
-  "premiumHojaTitulo": "PluriWave Premium अनलॉक करें",
-  "premiumBeneficioSinAnuncios": "पूरे ऐप में कोई विज्ञापन नहीं",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "स्टेशन रिकॉर्डिंग",
-  "premiumBeneficioVacaciones": "अलार्म के लिए छुट्टी की अवधि",
-  "premiumBeneficioAlarmasIlimitadas": "असीमित अलार्म (मुफ़्त प्लान में अधिकतम 5 की अनुमति है)",
-  "premiumPagoUnico": "एकमुश्त भुगतान, हमेशा के लिए। यह सदस्यता नहीं है।",
-  "premiumAhoraNo": "अभी नहीं",
-  "autoErrorEmisoraPremium": "यह स्टेशन Premium है। इसे अनलॉक करने के लिए फ़ोन पर PluriWave खोलें।",
-  "autoErrorBusquedaSinResultados": "वह स्टेशन नहीं मिला। कोई दूसरा नाम आज़माएँ।",
-  "autoCarpetaEscuchar": "सुनें",
-  "autoCarpetaFavoritos": "पसंदीदा",
-  "autoCarpetaTodas": "सभी स्टेशन",
-  "autoCarpetaMisEmisoras": "मेरे स्टेशन",
-  "autoCarpetaMusicaLocal": "लोकल संगीत",
-  "autoMusicaLocalNoDisponible": "अपना संगीत पढ़ने के लिए फ़ोन पर PluriWave खोलें",
-  "autoCargarMas": "और…",
-  "autoOrdenarPorCalidad": "गुणवत्ता के अनुसार क्रमबद्ध करें",
-  "autoReproducirCarpeta": "फ़ोल्डर चलाएँ",
-  "autoReproducirAleatorio": "शफ़ल चलाएँ",
-  "autoPistaSinNombre": "बिना नाम का ट्रैक"
+  "premiumActivo": "प्रीमियम सक्रिय"
 }

lib/l10n/app_id.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Pulihkan pembelian",
   "compraError": "Pembelian tidak dapat diselesaikan. Silakan coba lagi.",
   "restauracionSinCompras": "Kami tidak menemukan pembelian sebelumnya di akun ini.",
-  "premiumActivo": "Premium aktif",
-  "premiumHojaTitulo": "Buka PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Tanpa iklan di seluruh aplikasi",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Perekaman stasiun",
-  "premiumBeneficioVacaciones": "Rentang liburan untuk alarm",
-  "premiumBeneficioAlarmasIlimitadas": "Alarm tanpa batas (paket gratis mengizinkan hingga 5)",
-  "premiumPagoUnico": "Pembelian sekali bayar, untuk selamanya. Bukan langganan.",
-  "premiumAhoraNo": "Nanti saja",
-  "autoErrorEmisoraPremium": "Stasiun ini Premium. Buka PluriWave di ponsel untuk membukanya.",
-  "autoErrorBusquedaSinResultados": "Kami tidak menemukan stasiun itu. Coba nama lain.",
-  "autoCarpetaEscuchar": "Dengarkan",
-  "autoCarpetaFavoritos": "Favorit",
-  "autoCarpetaTodas": "Semua stasiun",
-  "autoCarpetaMisEmisoras": "Stasiun saya",
-  "autoCarpetaMusicaLocal": "Musik lokal",
-  "autoMusicaLocalNoDisponible": "Buka PluriWave di ponsel untuk membaca musik Anda",
-  "autoCargarMas": "Lainnya…",
-  "autoOrdenarPorCalidad": "Urutkan menurut kualitas",
-  "autoReproducirCarpeta": "Putar folder",
-  "autoReproducirAleatorio": "Putar acak",
-  "autoPistaSinNombre": "Trek tanpa nama"
+  "premiumActivo": "Premium aktif"
 }

lib/l10n/app_it.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Ripristina acquisti",
   "compraError": "Non è stato possibile completare l'acquisto. Riprova.",
   "restauracionSinCompras": "Non abbiamo trovato acquisti precedenti su questo account.",
-  "premiumActivo": "Premium attivo",
-  "premiumHojaTitulo": "Sblocca PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Nessuna pubblicità in tutta l'app",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Registrazione delle stazioni",
-  "premiumBeneficioVacaciones": "Intervalli di vacanza per le sveglie",
-  "premiumBeneficioAlarmasIlimitadas": "Sveglie illimitate (il piano gratuito ne consente fino a 5)",
-  "premiumPagoUnico": "Acquisto unico, per sempre. Non è un abbonamento.",
-  "premiumAhoraNo": "Non ora",
-  "autoErrorEmisoraPremium": "Questa stazione è Premium. Apri PluriWave sul telefono per sbloccarla.",
-  "autoErrorBusquedaSinResultados": "Non abbiamo trovato quella stazione. Prova con un altro nome.",
-  "autoCarpetaEscuchar": "Ascolta",
-  "autoCarpetaFavoritos": "Preferiti",
-  "autoCarpetaTodas": "Tutte le emittenti",
-  "autoCarpetaMisEmisoras": "Le mie emittenti",
-  "autoCarpetaMusicaLocal": "Musica locale",
-  "autoMusicaLocalNoDisponible": "Apri PluriWave sul telefono per leggere la tua musica",
-  "autoCargarMas": "Altro…",
-  "autoOrdenarPorCalidad": "Ordina per qualità",
-  "autoReproducirCarpeta": "Riproduci cartella",
-  "autoReproducirAleatorio": "Riproduzione casuale",
-  "autoPistaSinNombre": "Traccia senza nome"
+  "premiumActivo": "Premium attivo"
 }

lib/l10n/app_ja.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "購入を復元",
   "compraError": "購入を完了できませんでした。もう一度お試しください。",
   "restauracionSinCompras": "このアカウントでは以前の購入が見つかりませんでした。",
-  "premiumActivo": "プレミアム有効",
-  "premiumHojaTitulo": "PluriWave Premiumのロックを解除",
-  "premiumBeneficioSinAnuncios": "アプリ全体で広告なし",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "放送局の録音",
-  "premiumBeneficioVacaciones": "アラームの休暇期間設定",
-  "premiumBeneficioAlarmasIlimitadas": "アラーム数無制限(無料プランは5個まで)",
-  "premiumPagoUnico": "買い切りの一度きりの支払いで永久に使用可能。サブスクリプションではありません。",
-  "premiumAhoraNo": "後で",
-  "autoErrorEmisoraPremium": "この放送局は Premium です。スマートフォンで PluriWave を開いてロックを解除してください。",
-  "autoErrorBusquedaSinResultados": "その放送局は見つかりませんでした。別の名前をお試しください。",
-  "autoCarpetaEscuchar": "聴く",
-  "autoCarpetaFavoritos": "お気に入り",
-  "autoCarpetaTodas": "すべての局",
-  "autoCarpetaMisEmisoras": "マイ局",
-  "autoCarpetaMusicaLocal": "ローカルの音楽",
-  "autoMusicaLocalNoDisponible": "音楽を読み込むにはスマートフォンで PluriWave を開いてください",
-  "autoCargarMas": "もっと見る…",
-  "autoOrdenarPorCalidad": "音質順に並べ替え",
-  "autoReproducirCarpeta": "フォルダを再生",
-  "autoReproducirAleatorio": "シャッフル再生",
-  "autoPistaSinNombre": "名称未設定のトラック"
+  "premiumActivo": "プレミアム有効"
 }

lib/l10n/app_pt.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Restaurar compras",
   "compraError": "Não foi possível concluir a compra. Tente novamente.",
   "restauracionSinCompras": "Não encontramos nenhuma compra anterior nesta conta.",
-  "premiumActivo": "Premium ativo",
-  "premiumHojaTitulo": "Desbloqueie o PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Sem anúncios em todo o app",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Gravação de emissoras",
-  "premiumBeneficioVacaciones": "Períodos de férias para os alarmes",
-  "premiumBeneficioAlarmasIlimitadas": "Alarmes ilimitados (o plano gratuito permite até 5)",
-  "premiumPagoUnico": "Pagamento único, para sempre. Não é uma assinatura.",
-  "premiumAhoraNo": "Agora não",
-  "autoErrorEmisoraPremium": "Esta estação é Premium. Abra o PluriWave no telemóvel para a desbloquear.",
-  "autoErrorBusquedaSinResultados": "Não encontrámos essa estação. Tente outro nome.",
-  "autoCarpetaEscuchar": "Ouvir",
-  "autoCarpetaFavoritos": "Favoritos",
-  "autoCarpetaTodas": "Todas as estações",
-  "autoCarpetaMisEmisoras": "As minhas estações",
-  "autoCarpetaMusicaLocal": "Música local",
-  "autoMusicaLocalNoDisponible": "Abra o PluriWave no telemóvel para ler a sua música",
-  "autoCargarMas": "Mais…",
-  "autoOrdenarPorCalidad": "Ordenar por qualidade",
-  "autoReproducirCarpeta": "Reproduzir pasta",
-  "autoReproducirAleatorio": "Reprodução aleatória",
-  "autoPistaSinNombre": "Faixa sem nome"
+  "premiumActivo": "Premium ativo"
 }

lib/l10n/app_ru.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "Восстановить покупки",
   "compraError": "Не удалось завершить покупку. Попробуйте ещё раз.",
   "restauracionSinCompras": "Мы не нашли предыдущих покупок на этом аккаунте.",
-  "premiumActivo": "Премиум активен",
-  "premiumHojaTitulo": "Разблокировать PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "Никакой рекламы во всём приложении",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "Запись радиостанций",
-  "premiumBeneficioVacaciones": "Периоды отпуска для будильников",
-  "premiumBeneficioAlarmasIlimitadas": "Неограниченное количество будильников (бесплатный план позволяет до 5)",
-  "premiumPagoUnico": "Единоразовая покупка, навсегда. Это не подписка.",
-  "premiumAhoraNo": "Не сейчас",
-  "autoErrorEmisoraPremium": "Эта станция доступна в Premium. Откройте PluriWave на телефоне, чтобы разблокировать её.",
-  "autoErrorBusquedaSinResultados": "Мы не нашли такую станцию. Попробуйте другое название.",
-  "autoCarpetaEscuchar": "Слушать",
-  "autoCarpetaFavoritos": "Избранное",
-  "autoCarpetaTodas": "Все станции",
-  "autoCarpetaMisEmisoras": "Мои станции",
-  "autoCarpetaMusicaLocal": "Локальная музыка",
-  "autoMusicaLocalNoDisponible": "Откройте PluriWave на телефоне, чтобы прочитать вашу музыку",
-  "autoCargarMas": "Ещё…",
-  "autoOrdenarPorCalidad": "Сортировать по качеству",
-  "autoReproducirCarpeta": "Воспроизвести папку",
-  "autoReproducirAleatorio": "Случайное воспроизведение",
-  "autoPistaSinNombre": "Трек без названия"
+  "premiumActivo": "Премиум активен"
 }

lib/l10n/app_zh.arb

@@ -904,26 +904,5 @@
   "restaurarCompras": "恢复购买",
   "compraError": "无法完成购买，请重试。",
   "restauracionSinCompras": "未在此账户中找到以前的购买记录。",
-  "premiumActivo": "高级版已解锁",
-  "premiumHojaTitulo": "解锁 PluriWave Premium",
-  "premiumBeneficioSinAnuncios": "全应用无广告",
-  "premiumBeneficioAndroidAuto": "Android Auto",
-  "premiumBeneficioGrabacion": "电台录音",
-  "premiumBeneficioVacaciones": "闹钟的假期时间段",
-  "premiumBeneficioAlarmasIlimitadas": "无限闹钟(免费版最多支持5个)",
-  "premiumPagoUnico": "一次性付费,永久使用,不是订阅。",
-  "premiumAhoraNo": "以后再说",
-  "autoErrorEmisoraPremium": "该电台属于 Premium 内容。请在手机上打开 PluriWave 解锁。",
-  "autoErrorBusquedaSinResultados": "没有找到该电台。请换个名称再试。",
-  "autoCarpetaEscuchar": "收听",
-  "autoCarpetaFavoritos": "收藏",
-  "autoCarpetaTodas": "全部电台",
-  "autoCarpetaMisEmisoras": "我的电台",
-  "autoCarpetaMusicaLocal": "本地音乐",
-  "autoMusicaLocalNoDisponible": "请在手机上打开 PluriWave 以读取您的音乐",
-  "autoCargarMas": "更多…",
-  "autoOrdenarPorCalidad": "按音质排序",
-  "autoReproducirCarpeta": "播放文件夹",
-  "autoReproducirAleatorio": "随机播放",
-  "autoPistaSinNombre": "未命名曲目"
+  "premiumActivo": "高级版已解锁"
 }

lib/l10n/gen/app_localizations.dart

@@ -3367,132 +3367,6 @@ abstract class AppLocalizations {
   /// In es, this message translates to:
   /// **'Premium activo'**
   String get premiumActivo;
-
-  /// No description provided for @premiumHojaTitulo.
-  ///
-  /// In es, this message translates to:
-  /// **'Desbloquea PluriWave Premium'**
-  String get premiumHojaTitulo;
-
-  /// No description provided for @premiumBeneficioSinAnuncios.
-  ///
-  /// In es, this message translates to:
-  /// **'Sin publicidad en toda la app'**
-  String get premiumBeneficioSinAnuncios;
-
-  /// No description provided for @premiumBeneficioAndroidAuto.
-  ///
-  /// In es, this message translates to:
-  /// **'Android Auto'**
-  String get premiumBeneficioAndroidAuto;
-
-  /// No description provided for @premiumBeneficioGrabacion.
-  ///
-  /// In es, this message translates to:
-  /// **'Grabación de emisoras'**
-  String get premiumBeneficioGrabacion;
-
-  /// No description provided for @premiumBeneficioVacaciones.
-  ///
-  /// In es, this message translates to:
-  /// **'Rangos de vacaciones para las alarmas'**
-  String get premiumBeneficioVacaciones;
-
-  /// No description provided for @premiumBeneficioAlarmasIlimitadas.
-  ///
-  /// In es, this message translates to:
-  /// **'Alarmas ilimitadas (el plan gratuito permite hasta 5)'**
-  String get premiumBeneficioAlarmasIlimitadas;
-
-  /// No description provided for @premiumPagoUnico.
-  ///
-  /// In es, this message translates to:
-  /// **'Pago único, para siempre. No es una suscripción.'**
-  String get premiumPagoUnico;
-
-  /// No description provided for @premiumAhoraNo.
-  ///
-  /// In es, this message translates to:
-  /// **'Ahora no'**
-  String get premiumAhoraNo;
-
-  /// No description provided for @autoErrorEmisoraPremium.
-  ///
-  /// In es, this message translates to:
-  /// **'Esta emisora es Premium. Abre PluriWave en el móvil para desbloquearla.'**
-  String get autoErrorEmisoraPremium;
-
-  /// No description provided for @autoErrorBusquedaSinResultados.
-  ///
-  /// In es, this message translates to:
-  /// **'No hemos encontrado esa emisora. Prueba con otro nombre.'**
-  String get autoErrorBusquedaSinResultados;
-
-  /// No description provided for @autoCarpetaEscuchar.
-  ///
-  /// In es, this message translates to:
-  /// **'Escuchar'**
-  String get autoCarpetaEscuchar;
-
-  /// No description provided for @autoCarpetaFavoritos.
-  ///
-  /// In es, this message translates to:
-  /// **'Favoritos'**
-  String get autoCarpetaFavoritos;
-
-  /// No description provided for @autoCarpetaTodas.
-  ///
-  /// In es, this message translates to:
-  /// **'Todas las emisoras'**
-  String get autoCarpetaTodas;
-
-  /// No description provided for @autoCarpetaMisEmisoras.
-  ///
-  /// In es, this message translates to:
-  /// **'Mis emisoras'**
-  String get autoCarpetaMisEmisoras;
-
-  /// No description provided for @autoCarpetaMusicaLocal.
-  ///
-  /// In es, this message translates to:
-  /// **'Música Local'**
-  String get autoCarpetaMusicaLocal;
-
-  /// No description provided for @autoMusicaLocalNoDisponible.
-  ///
-  /// In es, this message translates to:
-  /// **'Abre PluriWave en el móvil para leer tu música'**
-  String get autoMusicaLocalNoDisponible;
-
-  /// No description provided for @autoCargarMas.
-  ///
-  /// In es, this message translates to:
-  /// **'Más…'**
-  String get autoCargarMas;
-
-  /// No description provided for @autoOrdenarPorCalidad.
-  ///
-  /// In es, this message translates to:
-  /// **'Ordenar por calidad'**
-  String get autoOrdenarPorCalidad;
-
-  /// No description provided for @autoReproducirCarpeta.
-  ///
-  /// In es, this message translates to:
-  /// **'Reproducir carpeta'**
-  String get autoReproducirCarpeta;
-
-  /// No description provided for @autoReproducirAleatorio.
-  ///
-  /// In es, this message translates to:
-  /// **'Reproducir aleatorio'**
-  String get autoReproducirAleatorio;
-
-  /// No description provided for @autoPistaSinNombre.
-  ///
-  /// In es, this message translates to:
-  /// **'Pista sin nombre'**
-  String get autoPistaSinNombre;
 }
 
 class _AppLocalizationsDelegate

lib/l10n/gen/app_localizations_ar.dart

@@ -1863,71 +1863,4 @@ class AppLocalizationsAr extends AppLocalizations {
 
   @override
   String get premiumActivo => 'النسخة المميزة مفعّلة';
-
-  @override
-  String get premiumHojaTitulo => 'افتح PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'بدون إعلانات في التطبيق بالكامل';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'تسجيل المحطات';
-
-  @override
-  String get premiumBeneficioVacaciones => 'فترات إجازة للمنبهات';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'منبهات غير محدودة (تسمح الخطة المجانية بحتى 5)';
-
-  @override
-  String get premiumPagoUnico => 'دفعة واحدة، للأبد. ليس اشتراكًا.';
-
-  @override
-  String get premiumAhoraNo => 'ليس الآن';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'هذه المحطة ضمن Premium. افتح PluriWave على هاتفك لفتحها.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'لم نعثر على تلك المحطة. جرّب اسمًا آخر.';
-
-  @override
-  String get autoCarpetaEscuchar => 'الاستماع';
-
-  @override
-  String get autoCarpetaFavoritos => 'المفضلة';
-
-  @override
-  String get autoCarpetaTodas => 'كل المحطات';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'محطاتي';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'الموسيقى المحلية';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'افتح PluriWave على هاتفك لقراءة موسيقاك';
-
-  @override
-  String get autoCargarMas => 'المزيد…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'الترتيب حسب الجودة';
-
-  @override
-  String get autoReproducirCarpeta => 'تشغيل المجلد';
-
-  @override
-  String get autoReproducirAleatorio => 'تشغيل عشوائي';
-
-  @override
-  String get autoPistaSinNombre => 'مقطع بلا اسم';
 }

lib/l10n/gen/app_localizations_bn.dart

@@ -1874,72 +1874,4 @@ class AppLocalizationsBn extends AppLocalizations {
 
   @override
   String get premiumActivo => 'প্রিমিয়াম সক্রিয়';
-
-  @override
-  String get premiumHojaTitulo => 'PluriWave Premium আনলক করুন';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'পুরো অ্যাপে কোনো বিজ্ঞাপন নেই';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'স্টেশন রেকর্ডিং';
-
-  @override
-  String get premiumBeneficioVacaciones => 'অ্যালার্মের জন্য ছুটির সময়কাল';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'সীমাহীন অ্যালার্ম (ফ্রি প্ল্যানে সর্বোচ্চ ৫টি অনুমোদিত)';
-
-  @override
-  String get premiumPagoUnico =>
-      'একবারের পেমেন্ট, চিরকালের জন্য। এটি সাবস্ক্রিপশন নয়।';
-
-  @override
-  String get premiumAhoraNo => 'এখন নয়';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'এই স্টেশনটি Premium। আনলক করতে ফোনে PluriWave খুলুন।';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'সেই স্টেশনটি খুঁজে পাওয়া যায়নি। অন্য নাম চেষ্টা করুন।';
-
-  @override
-  String get autoCarpetaEscuchar => 'শুনুন';
-
-  @override
-  String get autoCarpetaFavoritos => 'প্রিয়';
-
-  @override
-  String get autoCarpetaTodas => 'সব স্টেশন';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'আমার স্টেশন';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'স্থানীয় সঙ্গীত';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'আপনার গান পড়তে ফোনে PluriWave খুলুন';
-
-  @override
-  String get autoCargarMas => 'আরও…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'মান অনুসারে সাজান';
-
-  @override
-  String get autoReproducirCarpeta => 'ফোল্ডার চালান';
-
-  @override
-  String get autoReproducirAleatorio => 'এলোমেলোভাবে চালান';
-
-  @override
-  String get autoPistaSinNombre => 'নামহীন ট্র্যাক';
 }

lib/l10n/gen/app_localizations_de.dart

@@ -1888,71 +1888,4 @@ class AppLocalizationsDe extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium aktiv';
-
-  @override
-  String get premiumHojaTitulo => 'PluriWave Premium freischalten';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'Keine Werbung in der gesamten App';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Sender aufnehmen';
-
-  @override
-  String get premiumBeneficioVacaciones => 'Urlaubszeiträume für Wecker';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Unbegrenzte Wecker (die kostenlose Version erlaubt bis zu 5)';
-
-  @override
-  String get premiumPagoUnico => 'Einmalzahlung, für immer. Kein Abonnement.';
-
-  @override
-  String get premiumAhoraNo => 'Nicht jetzt';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Dieser Sender ist Premium. Öffne PluriWave auf dem Handy, um ihn freizuschalten.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Wir haben diesen Sender nicht gefunden. Versuch es mit einem anderen Namen.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Hören';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favoriten';
-
-  @override
-  String get autoCarpetaTodas => 'Alle Sender';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Meine Sender';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Lokale Musik';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Öffne PluriWave auf dem Handy, um deine Musik zu lesen';
-
-  @override
-  String get autoCargarMas => 'Mehr…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Nach Qualität sortieren';
-
-  @override
-  String get autoReproducirCarpeta => 'Ordner abspielen';
-
-  @override
-  String get autoReproducirAleatorio => 'Zufallswiedergabe';
-
-  @override
-  String get autoPistaSinNombre => 'Unbenannter Titel';
 }

lib/l10n/gen/app_localizations_en.dart

@@ -1867,72 +1867,4 @@ class AppLocalizationsEn extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium active';
-
-  @override
-  String get premiumHojaTitulo => 'Unlock PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'No ads anywhere in the app';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Station recording';
-
-  @override
-  String get premiumBeneficioVacaciones => 'Vacation ranges for alarms';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Unlimited alarms (the free plan allows up to 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'One-time purchase, forever. Not a subscription.';
-
-  @override
-  String get premiumAhoraNo => 'Not now';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'This station is Premium. Open PluriWave on your phone to unlock it.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'We couldn\'t find that station. Try another name.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Listen';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favorites';
-
-  @override
-  String get autoCarpetaTodas => 'All stations';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'My stations';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Local music';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Open PluriWave on your phone to read your music';
-
-  @override
-  String get autoCargarMas => 'More…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Sort by quality';
-
-  @override
-  String get autoReproducirCarpeta => 'Play folder';
-
-  @override
-  String get autoReproducirAleatorio => 'Shuffle play';
-
-  @override
-  String get autoPistaSinNombre => 'Untitled track';
 }

lib/l10n/gen/app_localizations_es.dart

@@ -1881,73 +1881,4 @@ class AppLocalizationsEs extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium activo';
-
-  @override
-  String get premiumHojaTitulo => 'Desbloquea PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'Sin publicidad en toda la app';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Grabación de emisoras';
-
-  @override
-  String get premiumBeneficioVacaciones =>
-      'Rangos de vacaciones para las alarmas';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Alarmas ilimitadas (el plan gratuito permite hasta 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Pago único, para siempre. No es una suscripción.';
-
-  @override
-  String get premiumAhoraNo => 'Ahora no';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Esta emisora es Premium. Abre PluriWave en el móvil para desbloquearla.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'No hemos encontrado esa emisora. Prueba con otro nombre.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Escuchar';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favoritos';
-
-  @override
-  String get autoCarpetaTodas => 'Todas las emisoras';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Mis emisoras';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Música Local';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Abre PluriWave en el móvil para leer tu música';
-
-  @override
-  String get autoCargarMas => 'Más…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Ordenar por calidad';
-
-  @override
-  String get autoReproducirCarpeta => 'Reproducir carpeta';
-
-  @override
-  String get autoReproducirAleatorio => 'Reproducir aleatorio';
-
-  @override
-  String get autoPistaSinNombre => 'Pista sin nombre';
 }

lib/l10n/gen/app_localizations_fr.dart

@@ -1894,74 +1894,4 @@ class AppLocalizationsFr extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium actif';
-
-  @override
-  String get premiumHojaTitulo => 'Débloquer PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios =>
-      'Aucune publicité dans toute l\'application';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Enregistrement des stations';
-
-  @override
-  String get premiumBeneficioVacaciones =>
-      'Périodes de vacances pour les alarmes';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Alarmes illimitées (la version gratuite en autorise jusqu\'à 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Achat unique, pour toujours. Ce n\'est pas un abonnement.';
-
-  @override
-  String get premiumAhoraNo => 'Plus tard';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Cette station est Premium. Ouvre PluriWave sur ton téléphone pour la débloquer.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Nous n\'avons pas trouvé cette station. Essaie un autre nom.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Écouter';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favoris';
-
-  @override
-  String get autoCarpetaTodas => 'Toutes les stations';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Mes stations';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Musique locale';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Ouvrez PluriWave sur votre téléphone pour lire votre musique';
-
-  @override
-  String get autoCargarMas => 'Plus…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Trier par qualité';
-
-  @override
-  String get autoReproducirCarpeta => 'Lire le dossier';
-
-  @override
-  String get autoReproducirAleatorio => 'Lecture aléatoire';
-
-  @override
-  String get autoPistaSinNombre => 'Piste sans nom';
 }

lib/l10n/gen/app_localizations_hi.dart

@@ -1867,72 +1867,4 @@ class AppLocalizationsHi extends AppLocalizations {
 
   @override
   String get premiumActivo => 'प्रीमियम सक्रिय';
-
-  @override
-  String get premiumHojaTitulo => 'PluriWave Premium अनलॉक करें';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'पूरे ऐप में कोई विज्ञापन नहीं';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'स्टेशन रिकॉर्डिंग';
-
-  @override
-  String get premiumBeneficioVacaciones => 'अलार्म के लिए छुट्टी की अवधि';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'असीमित अलार्म (मुफ़्त प्लान में अधिकतम 5 की अनुमति है)';
-
-  @override
-  String get premiumPagoUnico =>
-      'एकमुश्त भुगतान, हमेशा के लिए। यह सदस्यता नहीं है।';
-
-  @override
-  String get premiumAhoraNo => 'अभी नहीं';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'यह स्टेशन Premium है। इसे अनलॉक करने के लिए फ़ोन पर PluriWave खोलें।';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'वह स्टेशन नहीं मिला। कोई दूसरा नाम आज़माएँ।';
-
-  @override
-  String get autoCarpetaEscuchar => 'सुनें';
-
-  @override
-  String get autoCarpetaFavoritos => 'पसंदीदा';
-
-  @override
-  String get autoCarpetaTodas => 'सभी स्टेशन';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'मेरे स्टेशन';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'लोकल संगीत';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'अपना संगीत पढ़ने के लिए फ़ोन पर PluriWave खोलें';
-
-  @override
-  String get autoCargarMas => 'और…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'गुणवत्ता के अनुसार क्रमबद्ध करें';
-
-  @override
-  String get autoReproducirCarpeta => 'फ़ोल्डर चलाएँ';
-
-  @override
-  String get autoReproducirAleatorio => 'शफ़ल चलाएँ';
-
-  @override
-  String get autoPistaSinNombre => 'बिना नाम का ट्रैक';
 }

lib/l10n/gen/app_localizations_id.dart

@@ -1878,72 +1878,4 @@ class AppLocalizationsId extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium aktif';
-
-  @override
-  String get premiumHojaTitulo => 'Buka PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'Tanpa iklan di seluruh aplikasi';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Perekaman stasiun';
-
-  @override
-  String get premiumBeneficioVacaciones => 'Rentang liburan untuk alarm';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Alarm tanpa batas (paket gratis mengizinkan hingga 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Pembelian sekali bayar, untuk selamanya. Bukan langganan.';
-
-  @override
-  String get premiumAhoraNo => 'Nanti saja';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Stasiun ini Premium. Buka PluriWave di ponsel untuk membukanya.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Kami tidak menemukan stasiun itu. Coba nama lain.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Dengarkan';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favorit';
-
-  @override
-  String get autoCarpetaTodas => 'Semua stasiun';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Stasiun saya';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Musik lokal';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Buka PluriWave di ponsel untuk membaca musik Anda';
-
-  @override
-  String get autoCargarMas => 'Lainnya…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Urutkan menurut kualitas';
-
-  @override
-  String get autoReproducirCarpeta => 'Putar folder';
-
-  @override
-  String get autoReproducirAleatorio => 'Putar acak';
-
-  @override
-  String get autoPistaSinNombre => 'Trek tanpa nama';
 }

lib/l10n/gen/app_localizations_it.dart

@@ -1891,74 +1891,4 @@ class AppLocalizationsIt extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium attivo';
-
-  @override
-  String get premiumHojaTitulo => 'Sblocca PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios =>
-      'Nessuna pubblicità in tutta l\'app';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Registrazione delle stazioni';
-
-  @override
-  String get premiumBeneficioVacaciones =>
-      'Intervalli di vacanza per le sveglie';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Sveglie illimitate (il piano gratuito ne consente fino a 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Acquisto unico, per sempre. Non è un abbonamento.';
-
-  @override
-  String get premiumAhoraNo => 'Non ora';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Questa stazione è Premium. Apri PluriWave sul telefono per sbloccarla.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Non abbiamo trovato quella stazione. Prova con un altro nome.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Ascolta';
-
-  @override
-  String get autoCarpetaFavoritos => 'Preferiti';
-
-  @override
-  String get autoCarpetaTodas => 'Tutte le emittenti';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Le mie emittenti';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Musica locale';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Apri PluriWave sul telefono per leggere la tua musica';
-
-  @override
-  String get autoCargarMas => 'Altro…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Ordina per qualità';
-
-  @override
-  String get autoReproducirCarpeta => 'Riproduci cartella';
-
-  @override
-  String get autoReproducirAleatorio => 'Riproduzione casuale';
-
-  @override
-  String get autoPistaSinNombre => 'Traccia senza nome';
 }

lib/l10n/gen/app_localizations_ja.dart

@@ -1812,69 +1812,4 @@ class AppLocalizationsJa extends AppLocalizations {
 
   @override
   String get premiumActivo => 'プレミアム有効';
-
-  @override
-  String get premiumHojaTitulo => 'PluriWave Premiumのロックを解除';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'アプリ全体で広告なし';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => '放送局の録音';
-
-  @override
-  String get premiumBeneficioVacaciones => 'アラームの休暇期間設定';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas => 'アラーム数無制限(無料プランは5個まで)';
-
-  @override
-  String get premiumPagoUnico => '買い切りの一度きりの支払いで永久に使用可能。サブスクリプションではありません。';
-
-  @override
-  String get premiumAhoraNo => '後で';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'この放送局は Premium です。スマートフォンで PluriWave を開いてロックを解除してください。';
-
-  @override
-  String get autoErrorBusquedaSinResultados => 'その放送局は見つかりませんでした。別の名前をお試しください。';
-
-  @override
-  String get autoCarpetaEscuchar => '聴く';
-
-  @override
-  String get autoCarpetaFavoritos => 'お気に入り';
-
-  @override
-  String get autoCarpetaTodas => 'すべての局';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'マイ局';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'ローカルの音楽';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      '音楽を読み込むにはスマートフォンで PluriWave を開いてください';
-
-  @override
-  String get autoCargarMas => 'もっと見る…';
-
-  @override
-  String get autoOrdenarPorCalidad => '音質順に並べ替え';
-
-  @override
-  String get autoReproducirCarpeta => 'フォルダを再生';
-
-  @override
-  String get autoReproducirAleatorio => 'シャッフル再生';
-
-  @override
-  String get autoPistaSinNombre => '名称未設定のトラック';
 }

lib/l10n/gen/app_localizations_pt.dart

@@ -1878,72 +1878,4 @@ class AppLocalizationsPt extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Premium ativo';
-
-  @override
-  String get premiumHojaTitulo => 'Desbloqueie o PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => 'Sem anúncios em todo o app';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Gravação de emissoras';
-
-  @override
-  String get premiumBeneficioVacaciones => 'Períodos de férias para os alarmes';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Alarmes ilimitados (o plano gratuito permite até 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Pagamento único, para sempre. Não é uma assinatura.';
-
-  @override
-  String get premiumAhoraNo => 'Agora não';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Esta estação é Premium. Abra o PluriWave no telemóvel para a desbloquear.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Não encontrámos essa estação. Tente outro nome.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Ouvir';
-
-  @override
-  String get autoCarpetaFavoritos => 'Favoritos';
-
-  @override
-  String get autoCarpetaTodas => 'Todas as estações';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'As minhas estações';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Música local';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Abra o PluriWave no telemóvel para ler a sua música';
-
-  @override
-  String get autoCargarMas => 'Mais…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Ordenar por qualidade';
-
-  @override
-  String get autoReproducirCarpeta => 'Reproduzir pasta';
-
-  @override
-  String get autoReproducirAleatorio => 'Reprodução aleatória';
-
-  @override
-  String get autoPistaSinNombre => 'Faixa sem nome';
 }

lib/l10n/gen/app_localizations_ru.dart

@@ -1884,73 +1884,4 @@ class AppLocalizationsRu extends AppLocalizations {
 
   @override
   String get premiumActivo => 'Премиум активен';
-
-  @override
-  String get premiumHojaTitulo => 'Разблокировать PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios =>
-      'Никакой рекламы во всём приложении';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => 'Запись радиостанций';
-
-  @override
-  String get premiumBeneficioVacaciones => 'Периоды отпуска для будильников';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas =>
-      'Неограниченное количество будильников (бесплатный план позволяет до 5)';
-
-  @override
-  String get premiumPagoUnico =>
-      'Единоразовая покупка, навсегда. Это не подписка.';
-
-  @override
-  String get premiumAhoraNo => 'Не сейчас';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      'Эта станция доступна в Premium. Откройте PluriWave на телефоне, чтобы разблокировать её.';
-
-  @override
-  String get autoErrorBusquedaSinResultados =>
-      'Мы не нашли такую станцию. Попробуйте другое название.';
-
-  @override
-  String get autoCarpetaEscuchar => 'Слушать';
-
-  @override
-  String get autoCarpetaFavoritos => 'Избранное';
-
-  @override
-  String get autoCarpetaTodas => 'Все станции';
-
-  @override
-  String get autoCarpetaMisEmisoras => 'Мои станции';
-
-  @override
-  String get autoCarpetaMusicaLocal => 'Локальная музыка';
-
-  @override
-  String get autoMusicaLocalNoDisponible =>
-      'Откройте PluriWave на телефоне, чтобы прочитать вашу музыку';
-
-  @override
-  String get autoCargarMas => 'Ещё…';
-
-  @override
-  String get autoOrdenarPorCalidad => 'Сортировать по качеству';
-
-  @override
-  String get autoReproducirCarpeta => 'Воспроизвести папку';
-
-  @override
-  String get autoReproducirAleatorio => 'Случайное воспроизведение';
-
-  @override
-  String get autoPistaSinNombre => 'Трек без названия';
 }

lib/l10n/gen/app_localizations_zh.dart

@@ -1797,68 +1797,4 @@ class AppLocalizationsZh extends AppLocalizations {
 
   @override
   String get premiumActivo => '高级版已解锁';
-
-  @override
-  String get premiumHojaTitulo => '解锁 PluriWave Premium';
-
-  @override
-  String get premiumBeneficioSinAnuncios => '全应用无广告';
-
-  @override
-  String get premiumBeneficioAndroidAuto => 'Android Auto';
-
-  @override
-  String get premiumBeneficioGrabacion => '电台录音';
-
-  @override
-  String get premiumBeneficioVacaciones => '闹钟的假期时间段';
-
-  @override
-  String get premiumBeneficioAlarmasIlimitadas => '无限闹钟(免费版最多支持5个)';
-
-  @override
-  String get premiumPagoUnico => '一次性付费,永久使用,不是订阅。';
-
-  @override
-  String get premiumAhoraNo => '以后再说';
-
-  @override
-  String get autoErrorEmisoraPremium =>
-      '该电台属于 Premium 内容。请在手机上打开 PluriWave 解锁。';
-
-  @override
-  String get autoErrorBusquedaSinResultados => '没有找到该电台。请换个名称再试。';
-
-  @override
-  String get autoCarpetaEscuchar => '收听';
-
-  @override
-  String get autoCarpetaFavoritos => '收藏';
-
-  @override
-  String get autoCarpetaTodas => '全部电台';
-
-  @override
-  String get autoCarpetaMisEmisoras => '我的电台';
-
-  @override
-  String get autoCarpetaMusicaLocal => '本地音乐';
-
-  @override
-  String get autoMusicaLocalNoDisponible => '请在手机上打开 PluriWave 以读取您的音乐';
-
-  @override
-  String get autoCargarMas => '更多…';
-
-  @override
-  String get autoOrdenarPorCalidad => '按音质排序';
-
-  @override
-  String get autoReproducirCarpeta => '播放文件夹';
-
-  @override
-  String get autoReproducirAleatorio => '随机播放';
-
-  @override
-  String get autoPistaSinNombre => '未命名曲目';
 }

lib/main.dart

@@ -10,15 +10,12 @@ import 'package:shared_preferences/shared_preferences.dart';
 import 'app.dart';
 import 'estado/estado_entitlement.dart';
 import 'servicios/arranque_audio.dart';
-import 'servicios/contexto_reproduccion.dart';
-import 'servicios/emisoras_destacadas.dart';
 import 'servicios/musica_local_auto.dart';
 import 'servicios/navegacion_auto.dart';
 import 'servicios/servicio_audio.dart';
 import 'servicios/servicio_audio_session.dart';
 import 'servicios/servicio_compras.dart';
 import 'servicios/servicio_consentimiento.dart';
-import 'servicios/servicio_ecualizador.dart';
 import 'servicios/servicio_presets_personalizados.dart';
 import 'tema/pluriwave_tokens.dart';
 
@@ -91,7 +88,7 @@ Future<void> main() async {
   //
   // Regression this fixes, self-inflicted by the reordering above: the root
   // menu decides whether to offer "Música Local" with
-  // `fuenteLocal != null && await fuenteLocal.estadoCarpeta() != noConfigurada`.
+  // `fuenteLocal != null && await fuenteLocal.hayCarpetaConfigurada()`.
   // Moving ONLY the station source above the awaits meant the car could get
   // a root response in the window before this line ran, find a null source,
   // and be told there is no local music — and Android Auto caches the browse
@@ -106,7 +103,7 @@ Future<void> main() async {
   registrarFuenteMusicaLocal(FuenteMusicaLocalAutoImpl());
 
   // Cosmetic, and deliberately NOT awaited: a display preference must never
-  // gate `runApp`. `OrientacionResponsiveApp.didChangeDependencies` applies
+  // gate `runApp`. `_OrientacionResponsiveApp.didChangeDependencies` applies
   // it again as soon as a real view exists, which is the only moment it can
   // actually take effect anyway.
   unawaited(aplicarPoliticaOrientacion());
@@ -154,18 +151,6 @@ Future<void> main() async {
   final presetsPersonalizados = ServicioPresetsPersonalizados(prefs: prefs);
   registrarFuentePresetsPersonalizados(presetsPersonalizados.listar);
 
-  // eq-estado-unico items A/B: the handler's own link to the equalizer's
-  // persisted on/off flag. `ServicioEcualizador` needs nothing but the
-  // `prefs` instance resolved just above — no widget tree, no Provider — so
-  // it is available on EVERY engine, including the headless one Android Auto
-  // starts. Before this, the persisted value only reached the handler
-  // through `EstadoEcualizador.cargarPersistido()`, which that engine never
-  // runs: the handler played with the equalizer forced on while disk and the
-  // phone UI both said off, and a toggle made in the car was lost on
-  // restart. Passed as two narrow function ports, mirroring the
-  // read-function convention used for the preset folder right above.
-  final ecualizador = ServicioEcualizador(prefs: prefs);
-
   // Silent-error channel (fix/notificacion-media): `AudioService.asyncError`
   // had ZERO subscribers app-wide, and a `PublishSubject` with no listeners
   // drops what it is given — so every exception `audio_service` catches
@@ -194,33 +179,7 @@ Future<void> main() async {
   // radio; headphones unplugged pauses it. Shared by both the on-time and
   // degraded/late-completion paths below.
   void conectarHandler(PluriWaveAudioHandler handler) {
-    registrarHandler(
-      handler,
-      leerEqActivoPersistido: ecualizador.leerActivo,
-      guardarEqActivoPersistido: ecualizador.guardarActivo,
-      // The PRESET's half of the same seam. Without it the handler enabled
-      // the equalizer with its hardcoded FLAT preset on any engine where the
-      // phone UI never ran — i.e. every headless Android Auto bind. There is
-      // no write port: `EstadoEcualizador` still owns saving presets (a car
-      // preset choice goes through it), so the handler only ever reads.
-      leerPresetPersistido: ecualizador.leerPresetPrincipal,
-      // Skip context («in which list am I»). Bound here, on the audio
-      // bootstrap path of EVERY engine, precisely because the headless
-      // Android Auto engine builds no widget tree and therefore no
-      // `EstadoRadio`: a context only the phone UI could write would be a
-      // context the car could never have.
-      leerContextoSalto: contextoSaltoPersistido,
-      guardarContextoSalto: guardarContextoSalto,
-      // Last played station (`ultima_emisora_v1`). Bound here for the SAME
-      // reason as the skip context: `EstadoRadio` — which used to be its only
-      // writer — belongs to the widget tree, and the Android Auto engine
-      // builds none, so a session that happened only in the car never updated
-      // the key and the head unit was offered whatever the PHONE last played.
-      // The write port is now the key's single writer; the read port feeds the
-      // cold-start metadata seed and the bare-`play()` resume.
-      leerUltimaEmisora: ultimaEmisoraPersistida,
-      guardarUltimaEmisora: guardarUltimaEmisoraPersistida,
-    );
+    registrarHandler(handler);
     // The handler is the only thing this app ever tears down
     // (`onTaskRemoved`), so the asyncError subscription's `cancel` travels
     // with it and can never leak — same "register from main.dart" convention
@@ -230,7 +189,7 @@ Future<void> main() async {
     unawaited(sesionAudio.configurar());
   }
 
-  Widget construirApp() => OrientacionResponsiveApp(
+  Widget construirApp() => _OrientacionResponsiveApp(
     child: PluriWaveApp(prefs: prefs, fuenteAuto: fuenteAuto, compras: compras),
   );
 
@@ -309,80 +268,20 @@ Future<void> aplicarPoliticaOrientacion({
   }
 }
 
-/// Whether the Android Auto browse tree must be invalidated right now
-/// (fix/android-auto-musica-local, item 4 — CORRECTED trigger).
-///
-/// The trigger used to be `View.maybeOf(context) != null` inside
-/// `didChangeDependencies`, latched once, on the premise that «a View means
-/// there is an Activity». That premise is FALSE: `runApp` unconditionally
-/// wraps the tree in a `View` built from
-/// `platformDispatcher.implicitView` and throws a `StateError` when there is
-/// none (`flutter/lib/src/widgets/binding.dart`, `wrapWithDefaultView`). So
-/// on the headless `audio_service` engine — which demonstrably reaches
-/// `runApp`, see [aplicarPoliticaOrientacion] — the View is ALREADY there at
-/// the first `didChangeDependencies`. The one-shot latch was spent at the
-/// exact moment it could accomplish nothing (`_childrenSubjects` still
-/// empty, so `notificarHijosCambiaron` is a silent no-op) and could never
-/// fire again, because `didChangeDependencies` does not re-run when an
-/// Activity later attaches to that same cached engine.
-///
-/// Two conditions replace it, both required:
-///
-/// * [estado] is [AppLifecycleState.resumed] — the only state that genuinely
-///   means «an Activity is attached and in the foreground». It reaches Dart
-///   exclusively through `SystemChannels.lifecycle` (or
-///   `PlatformDispatcher.initialLifecycleState`, which buffers the same
-///   messages), and on Android only `LifecycleChannel.appIsResumed()` sends
-///   it, driven by the Activity's own `onResume`.
-///   `AudioServicePlugin.getFlutterEngine` builds its engine from the
-///   APPLICATION context and runs the Dart entrypoint immediately, with no
-///   Activity and no `FlutterActivityAndFragmentDelegate`, so nothing sends
-///   it on the headless engine.
-/// * [hayCocheSuscrito] — a head unit has actually subscribed to at least
-///   one browse id (`hayCocheSuscritoAlArbol`). This is what makes the latch
-///   worth spending, and it is also the belt to `resumed`'s braces: even if
-///   a lifecycle event did somehow arrive during a headless cold start,
-///   nothing has subscribed yet, so the latch survives for the moment an
-///   Activity really does attach.
-///
-/// [yaInvalidado] keeps it one-shot: an app foregrounded twenty times must
-/// not send twenty `notifyChildrenChanged` storms to the car.
-///
-/// Pure, so the whole policy is testable without an engine.
-@visibleForTesting
-bool debeInvalidarArbolAutoAlReanudar({
-  required AppLifecycleState estado,
-  required bool hayCocheSuscrito,
-  required bool yaInvalidado,
-}) =>
-    !yaInvalidado && hayCocheSuscrito && estado == AppLifecycleState.resumed;
-
-/// Root wrapper that keeps the orientation policy applied and owns the
-/// Android Auto browse-tree recovery hook.
-///
-/// Public only so a test can mount it and drive real lifecycle events
-/// through [debeInvalidarArbolAutoAlReanudar]'s call site — the previous
-/// trigger shipped broken precisely because nothing could reach it.
-@visibleForTesting
-class OrientacionResponsiveApp extends StatefulWidget {
-  const OrientacionResponsiveApp({super.key, required this.child});
+class _OrientacionResponsiveApp extends StatefulWidget {
+  const _OrientacionResponsiveApp({required this.child});
 
   final Widget child;
 
   @override
-  State<OrientacionResponsiveApp> createState() =>
+  State<_OrientacionResponsiveApp> createState() =>
       _OrientacionResponsiveAppState();
 }
 
-class _OrientacionResponsiveAppState extends State<OrientacionResponsiveApp>
+class _OrientacionResponsiveAppState extends State<_OrientacionResponsiveApp>
     with WidgetsBindingObserver {
   ui.Display? _display;
 
-  /// fix/android-auto-musica-local, item 4: la invalidación del árbol del
-  /// coche se dispara UNA sola vez. Ver
-  /// [debeInvalidarArbolAutoAlReanudar].
-  bool _arbolAutoInvalidado = false;
-
   @override
   void initState() {
     super.initState();
@@ -396,27 +295,6 @@ class _OrientacionResponsiveAppState extends State<OrientacionResponsiveApp>
     unawaited(aplicarPoliticaOrientacion(display: _display));
   }
 
-  /// `resumed` es lo único que significa de verdad «ya hay Activity
-  /// adjunta», y con ella el handler nativo de `pluriwave/file_actions` que
-  /// `MainActivity.configureFlutterEngine` instala. Si el coche había
-  /// navegado la raíz ANTES (arranque headless), la cacheó sin poder
-  /// resolver la música local; Android Auto no vuelve a preguntar por su
-  /// cuenta, así que se lo decimos aquí. Ver
-  /// [debeInvalidarArbolAutoAlReanudar] para las tres condiciones.
-  @override
-  void didChangeAppLifecycleState(AppLifecycleState state) {
-    super.didChangeAppLifecycleState(state);
-    if (!debeInvalidarArbolAutoAlReanudar(
-      estado: state,
-      hayCocheSuscrito: hayCocheSuscritoAlArbol(),
-      yaInvalidado: _arbolAutoInvalidado,
-    )) {
-      return;
-    }
-    _arbolAutoInvalidado = true;
-    invalidarArbolAuto();
-  }
-
   @override
   void didChangeMetrics() {
     unawaited(aplicarPoliticaOrientacion(display: _display));

lib/pantallas/ajustes/pantalla_ajustes_backup.dart

@@ -6,45 +6,12 @@ import 'package:path_provider/path_provider.dart';
 import 'package:provider/provider.dart';
 import 'package:share_plus/share_plus.dart' show Share, XFile;
 
-import '../../estado/estado_alarmas.dart';
 import '../../estado/estado_radio.dart';
 import '../../l10n/gen/app_localizations.dart';
 import '../../widgets/pluri_glass_surface.dart';
 import '../../widgets/pluri_layout.dart';
 import '../../widgets/pluri_push_scaffold.dart';
 
-/// Applies a successfully-parsed backup to BOTH independent notifiers that
-/// own pieces of it (fix/import-alarmas-y-paywall).
-///
-/// `EstadoRadio.importarConfig` writes the raw alarm/vacation/exception JSON
-/// block straight to SharedPreferences, but `EstadoAlarmas` is a separate
-/// long-lived `ChangeNotifier` that loaded its alarms into memory at
-/// construction and never re-reads storage on its own — `EstadoRadio` stays
-/// deliberately free of a dependency on it. Without the two calls below the
-/// imported block is invisible to the running app: the UI keeps showing the
-/// pre-import alarms, a later edit would persist that stale in-memory list
-/// OVER the imported one, and the imported alarms would never be
-/// (re)scheduled with the Android native layer even after a restart.
-///
-/// Extracted as a top-level function (rather than inlined in `_importar`)
-/// so this exact production sequence — not a reimplementation of it — is
-/// directly unit-testable without depending on the `file_picker` platform
-/// channel or the confirmation dialog.
-Future<void> aplicarImportacionConfig(
-  EstadoRadio estado,
-  EstadoAlarmas alarmas,
-  Map<String, dynamic> json,
-) async {
-  await estado.importarConfig(json);
-  // Re-reads from storage — clears ServicioAlarmas' in-memory cache so the
-  // just-imported alarms/vacations/exceptions (same JSON block, same
-  // notifier) replace the stale ones.
-  await alarmas.cargarPersistidasSinRecalcular();
-  // Recomputes next-run times against the (now fresh) imported data and
-  // re-syncs every alarm with the Android native scheduler.
-  await alarmas.refrescarProgramacion();
-}
-
 /// APLICACIÓN group · "Copia de seguridad" (design ADR-3). Body moved
 /// verbatim from the former `_SeccionBackup` in `pantalla_ajustes.dart` —
 /// only the panel header's icon and title were removed (the pushed screen's
@@ -135,9 +102,8 @@ class _CuerpoBackup extends StatelessWidget {
         if (confirmar != true) return;
         if (context.mounted) {
           final estado = context.read<EstadoRadio>();
-          final alarmas = context.read<EstadoAlarmas>();
           final messenger = ScaffoldMessenger.of(context);
-          await aplicarImportacionConfig(estado, alarmas, json);
+          await estado.importarConfig(json);
           messenger.showSnackBar(
             SnackBar(content: Text(l10n.backupImportSuccess)),
           );

lib/pantallas/ajustes/pantalla_ajustes_musica_local.dart

@@ -2,7 +2,6 @@ import 'package:flutter/material.dart';
 
 import '../../l10n/gen/app_localizations.dart';
 import '../../servicios/musica_local_auto.dart';
-import '../../servicios/servicio_audio.dart' show invalidarArbolAuto;
 import '../../widgets/pluri_glass_surface.dart';
 import '../../widgets/pluri_layout.dart';
 import '../../widgets/pluri_push_scaffold.dart';
@@ -55,15 +54,6 @@ class _CuerpoMusicaLocalState extends State<_CuerpoMusicaLocal> {
       final uri = await _fuente.elegirCarpeta();
       if (uri == null) return; // Cancelled — no snackbar, matches the SAF
       // picker's own "nothing changed" affordance.
-
-      // fix/android-auto-musica-local, item 4: acaba de aparecer música
-      // local donde antes no había. Android Auto cachea la raíz y no
-      // vuelve a preguntar por su cuenta, así que sin esto el coche seguía
-      // sin ofrecer «Música Local» hasta el siguiente re-bind — que puede
-      // no llegar en toda la sesión. Fuera del `context.mounted` de abajo:
-      // el árbol del coche no depende de que esta pantalla siga viva.
-      invalidarArbolAuto();
-
       if (!context.mounted) return;
       setState(() {
         _carpetaActual = Future.value(uri);

lib/servicios/arranque_audio.dart

@@ -5,17 +5,11 @@ import 'package:flutter/material.dart';
 import '../tema/pluriwave_tokens.dart';
 
 /// Timeout applied to the `AudioService.init` MediaBrowser handshake (Design
-/// "Timeout without re-init"): the `audio_service` plugin's self-bind has no
-/// native timeout and an unhandled `onConnectionSuspended` case, so under
-/// bind contention (Android Auto cold start) the handshake can hang forever.
-/// Top-level const so tests can reference the production value without
-/// duplicating it.
-///
-/// This doc called the plugin "vendored". It is not: `pubspec.lock` pins the
-/// hosted pub.dev `audio_service` 0.18.18 and `pubspec.yaml` declares no
-/// `dependency_overrides`. Anyone reading the sentence above would go looking
-/// for a local copy to patch, and there is none — the behaviour described is
-/// upstream's, so the workaround has to live here.
+/// "Timeout without re-init"): the vendored `audio_service` plugin's
+/// self-bind has no native timeout and an unhandled `onConnectionSuspended`
+/// case, so under bind contention (Android Auto cold start) the handshake
+/// can hang forever. Top-level const so tests can reference the production
+/// value without duplicating it.
 const timeoutArranqueAudio = Duration(seconds: 8);
 
 /// Outcome of racing an `AudioService.init` future against

lib/servicios/cola_local.dart

@@ -6,10 +6,8 @@ import '../modelos/pista_local.dart';
 /// instance rather than mutating in place, mirroring how
 /// `ControladorReconexion` was extracted from `PluriWaveAudioHandler`
 /// (`controlador_reconexion.dart`) so this stays fully unit-testable without
-/// the handler. (That last clause used to read "which cannot be instantiated
-/// in unit tests"; it can — see `construirControlesTransporte`'s doc in
-/// `servicio_audio.dart`. Keeping the queue logic out of the handler is
-/// still worth it, but for design reasons, not for that one.)
+/// the handler (which cannot be instantiated in unit tests — see this
+/// module's sibling test file's doc comment).
 class ColaLocal {
   const ColaLocal({required this.pistas, this.indice = 0});
 

lib/servicios/contexto_reproduccion.dart

@@ -1,278 +0,0 @@
-import 'dart:convert';
-
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../modelos/emisora.dart';
-import '../modelos/grupo_favoritos.dart';
-
-/// The skip context's persistence key.
-///
-/// Same headless-safe shape as `emisoras_destacadas.dart`: this file imports
-/// nothing but `shared_preferences` and the models, never `EstadoRadio` nor
-/// anything that drags a `ChangeNotifier` graph in. Android Auto starts the
-/// engine WITHOUT an Activity, so there is no widget tree and `EstadoRadio` is
-/// never constructed there — a context only that class could write would be a
-/// context the car can never have.
-///
-/// `contexto_reproduccion_test.dart` pins the literal so a rename fails loudly
-/// instead of silently leaving every driver context-less after an update.
-const claveContextoSalto = 'contexto_salto_v1';
-
-/// Which LIST the driver is walking with the car's previous/next buttons.
-///
-/// The type is the durable part; the members are not. A group's contents
-/// change between sessions (the phone renames it, empties it, deletes it), so
-/// remembering the members would be remembering something that expires —
-/// [resolverListaContexto] re-resolves against the LIVE lists every time.
-enum TipoContextoSalto {
-  /// One favourites group. The only type that carries [ContextoSalto.grupoFavoritosId].
-  grupoFavoritos,
-  favoritos,
-  misEmisoras,
-
-  /// The `populares` catalogue snapshot.
-  todas,
-
-  /// The free tier's curated set (`emisorasDestacadas`). The ONLY type that
-  /// carries [ContextoSalto.uuidsOrdenados] — see that field.
-  destacadas,
-}
-
-/// The remembered playback context: the smallest thing that still identifies
-/// the list on the other side of a process restart.
-class ContextoSalto {
-  /// One favourites group, named by its stable id.
-  const ContextoSalto.grupo(String grupoId)
-    : tipo = TipoContextoSalto.grupoFavoritos,
-      grupoFavoritosId = grupoId,
-      uuidsOrdenados = const [];
-
-  const ContextoSalto.favoritos()
-    : tipo = TipoContextoSalto.favoritos,
-      grupoFavoritosId = null,
-      uuidsOrdenados = const [];
-
-  const ContextoSalto.misEmisoras()
-    : tipo = TipoContextoSalto.misEmisoras,
-      grupoFavoritosId = null,
-      uuidsOrdenados = const [];
-
-  const ContextoSalto.todas()
-    : tipo = TipoContextoSalto.todas,
-      grupoFavoritosId = null,
-      uuidsOrdenados = const [];
-
-  /// The free tier's set, FROZEN in [uuids] order.
-  const ContextoSalto.destacadas(List<String> uuids)
-    : tipo = TipoContextoSalto.destacadas,
-      grupoFavoritosId = null,
-      uuidsOrdenados = uuids;
-
-  final TipoContextoSalto tipo;
-
-  /// Set only for [TipoContextoSalto.grupoFavoritos].
-  final String? grupoFavoritosId;
-
-  /// The frozen order, set only for [TipoContextoSalto.destacadas].
-  ///
-  /// Every other type resolves against a list that HAS a stable, user-owned
-  /// order (the favourites' `orden` column, the custom-stations file, the
-  /// catalogue snapshot), so freezing it would only mean ignoring a reorder
-  /// the user just made on the phone. The free set is the exception:
-  /// `resolverEmisorasDestacadas` rebuilds it as `[última reproducida,
-  /// ...curadas]`, so it REORDERS ITSELF as the driver skips, and `previous`
-  /// stops being the inverse of `next`. Freezing that order is the fix.
-  final List<String> uuidsOrdenados;
-
-  Map<String, dynamic> aMapa() => {
-    'tipo': tipo.name,
-    if (grupoFavoritosId != null) 'grupoId': grupoFavoritosId,
-    if (uuidsOrdenados.isNotEmpty) 'uuids': uuidsOrdenados,
-  };
-
-  /// Parses a persisted map, or `null` when it is unusable.
-  ///
-  /// Tolerant on purpose: this payload survives app updates, backups and
-  /// hand-edited preference files, and it is read from a steering-wheel
-  /// button. An unreadable context must mean "derive it again", never a
-  /// crash.
-  static ContextoSalto? desdeMapa(Map<String, dynamic> mapa) {
-    final tipoRaw = mapa['tipo'];
-    if (tipoRaw is! String) return null;
-    final tipo = TipoContextoSalto.values
-        .where((t) => t.name == tipoRaw)
-        .firstOrNull;
-    if (tipo == null) return null;
-    switch (tipo) {
-      case TipoContextoSalto.grupoFavoritos:
-        final grupoId = mapa['grupoId'];
-        // A group context with no group is not a context.
-        if (grupoId is! String || grupoId.isEmpty) return null;
-        return ContextoSalto.grupo(grupoId);
-      case TipoContextoSalto.favoritos:
-        return const ContextoSalto.favoritos();
-      case TipoContextoSalto.misEmisoras:
-        return const ContextoSalto.misEmisoras();
-      case TipoContextoSalto.todas:
-        return const ContextoSalto.todas();
-      case TipoContextoSalto.destacadas:
-        final uuids = mapa['uuids'];
-        if (uuids is! List) return null;
-        return ContextoSalto.destacadas(uuids.whereType<String>().toList());
-    }
-  }
-
-  @override
-  bool operator ==(Object other) =>
-      other is ContextoSalto &&
-      other.tipo == tipo &&
-      other.grupoFavoritosId == grupoFavoritosId &&
-      _mismosUuids(other.uuidsOrdenados, uuidsOrdenados);
-
-  @override
-  int get hashCode => Object.hash(
-    tipo,
-    grupoFavoritosId,
-    Object.hashAll(uuidsOrdenados),
-  );
-
-  @override
-  String toString() =>
-      'ContextoSalto(${tipo.name}, grupo=$grupoFavoritosId, '
-      'uuids=${uuidsOrdenados.length})';
-
-  static bool _mismosUuids(List<String> a, List<String> b) {
-    if (a.length != b.length) return false;
-    for (var i = 0; i < a.length; i++) {
-      if (a[i] != b[i]) return false;
-    }
-    return true;
-  }
-}
-
-/// Persists [contexto]. Never throws — a failed write costs the driver a
-/// re-derivation, an exception would cost them the station change.
-Future<void> guardarContextoSalto(
-  ContextoSalto contexto, {
-  SharedPreferences? prefs,
-}) async {
-  try {
-    final resueltas = prefs ?? await SharedPreferences.getInstance();
-    await resueltas.setString(claveContextoSalto, jsonEncode(contexto.aMapa()));
-  } catch (_) {
-    // Deliberately swallowed — see the doc above.
-  }
-}
-
-/// Reads the persisted context, or `null` when there is none, the payload is
-/// unreadable, or prefs themselves fail.
-///
-/// Follows the same inject-or-`getInstance()` convention as
-/// `esPremiumPersistido` and `resolverEmisorasDestacadas`, so a test pins
-/// prefs without a platform channel.
-Future<ContextoSalto?> contextoSaltoPersistido({
-  SharedPreferences? prefs,
-}) async {
-  try {
-    final resueltas = prefs ?? await SharedPreferences.getInstance();
-    final raw = resueltas.getString(claveContextoSalto);
-    if (raw == null) return null;
-    final decodificado = jsonDecode(raw);
-    if (decodificado is! Map) return null;
-    return ContextoSalto.desdeMapa(Map<String, dynamic>.from(decodificado));
-  } catch (_) {
-    return null;
-  }
-}
-
-/// The LIVE, ordered list a remembered [contexto] resolves to right now, or an
-/// empty list when it no longer resolves at all.
-///
-/// Pure — no handler, no prefs — so every degradation rule below is testable
-/// on its own. An empty result means "this memory has expired": the caller
-/// derives a fresh context instead (and, failing that, leaves playback alone —
-/// never jumps somewhere arbitrary mid-drive).
-///
-/// Degradation rules, all of them deliberate. The group chain is the owner's,
-/// decided from real use in the car:
-///   * remembered group ALIVE -> it is walked, even when the playing station
-///     has LEFT it (the caller then takes the group's first station) and even
-///     when it is down to a single member (skipping there simply leaves the
-///     driver where they are — a one-station group is still a group).
-///   * remembered group DELETED, or alive but EMPTY -> widen to all
-///     favourites, whether or not the playing station is still one of them:
-///     "if the whole group is gone, pick a station from the favourites".
-///   * no favourites left -> empty, i.e. the no-stations behaviour.
-///   * every OTHER context type still expires when the playing station left
-///     its list (unfavourited, removed from the catalogue snapshot) — the
-///     owner's decision was about the group chain only.
-///   * [TipoContextoSalto.destacadas] alone honours
-///     [ContextoSalto.uuidsOrdenados] — see that field for why.
-List<Emisora> resolverListaContexto({
-  required ContextoSalto contexto,
-  required Emisora actual,
-  required List<Emisora> favoritos,
-  required List<Emisora> misEmisoras,
-  required List<Emisora> todas,
-  required List<Emisora> destacadas,
-  required List<GrupoFavoritos> grupos,
-}) {
-  bool contiene(List<Emisora> lista) =>
-      lista.any((e) => e.uuid == actual.uuid);
-
-  switch (contexto.tipo) {
-    case TipoContextoSalto.grupoFavoritos:
-      final grupoId = contexto.grupoFavoritosId;
-      if (grupoId == null || grupoId == GrupoFavoritos.sinAsignarId) {
-        return const [];
-      }
-      final existe = grupos.any((g) => g.id == grupoId);
-      final miembros =
-          favoritos.where((e) => e.grupoFavoritosId == grupoId).toList();
-      if (existe && miembros.isNotEmpty) {
-        // A surviving group is honoured as-is. The station does NOT have to
-        // still be in it — the caller takes the group's first station rather
-        // than wandering off to another list.
-        return miembros;
-      }
-      // Group deleted (or alive but empty, which offers no station to take):
-      // widen to all favourites. Unlike the other context types this does not
-      // require the station to still BE a favourite — the caller takes the
-      // first one.
-      return favoritos;
-    case TipoContextoSalto.favoritos:
-      return contiene(favoritos) ? favoritos : const [];
-    case TipoContextoSalto.misEmisoras:
-      return contiene(misEmisoras) ? misEmisoras : const [];
-    case TipoContextoSalto.todas:
-      return contiene(todas) ? todas : const [];
-    case TipoContextoSalto.destacadas:
-      // The frozen order is authoritative. `actual` is resolvable from itself
-      // so a station frozen into the walk from a previous session still
-      // resolves even when it never belonged to the curated set.
-      final porUuid = <String, Emisora>{
-        for (final e in destacadas) e.uuid: e,
-        actual.uuid: actual,
-      };
-      final lista = <Emisora>[
-        for (final uuid in contexto.uuidsOrdenados)
-          if (porUuid[uuid] != null) porUuid[uuid]!,
-      ];
-      return lista.any((e) => e.uuid == actual.uuid) ? lista : const [];
-  }
-}
-
-/// The free tier's frozen walk order: the curated set in its compiled-in
-/// order, with [actual] prepended when it does not belong to it.
-///
-/// Prepending rather than dropping keeps both buttons alive for a station left
-/// over from a premium session (or from `ultima_emisora_v1`): a walk the
-/// playing station is not part of would make `emisoraVecina` return `null` and
-/// both buttons would be dead.
-List<String> uuidsCongeladosDestacadas({
-  required Emisora actual,
-  required List<Emisora> destacadas,
-}) => [
-  if (!destacadas.any((e) => e.uuid == actual.uuid)) actual.uuid,
-  ...destacadas.map((e) => e.uuid),
-];

lib/servicios/emisoras_destacadas.dart

@@ -1,196 +0,0 @@
-import 'dart:convert';
-
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../modelos/emisora.dart';
-
-/// The last-played station's persistence key.
-///
-/// MUST stay byte-identical to `EstadoRadio._keyUltimaEmisora`
-/// (`lib/estado/estado_radio.dart`), which is the only writer. It is
-/// duplicated here rather than exported from there on purpose: this file has
-/// to be readable from the headless Android Auto engine, where `EstadoRadio`
-/// is never constructed, and importing a `ChangeNotifier` that pulls in the
-/// whole app-state graph just to read one string constant would drag the
-/// entire phone-side stack into a car bind. `emisoras_destacadas_test.dart`
-/// pins the literal so a rename on either side fails loudly.
-const claveUltimaEmisora = 'ultima_emisora_v1';
-
-/// The stations a FREE-tier driver can browse and play in the car
-/// (fix/auto-quality-guidelines, item 6).
-///
-/// Compiled into the binary, on purpose. Everything else the car could show
-/// is empty on the bind a Play reviewer actually performs: a fresh install
-/// is free tier (`esPremiumPersistido` is `getBool(...) ?? false`, no trial
-/// key), `FuenteEmisorasAutoLocal.todas()` is literally
-/// `_snapshotTodas ?? const []` until `EstadoRadio` pushes a network
-/// snapshot that a headless bind never fetches, favourites and custom
-/// stations are empty, and `ultima_emisora_v1` is absent. A curated const
-/// list is the ONLY thing that can put real, playable rows in front of that
-/// reviewer.
-///
-/// Deliberately small. This is not a catalogue — the catalogue is the
-/// premium feature. Six rows is enough to prove the app works and short
-/// enough to read at a glance from a driving position.
-///
-/// `favicon` is null for every entry on purpose: `artUriPara` then resolves
-/// the on-brand bundled `station_art_*` drawable, so a browse row needs no
-/// network at all to render its artwork.
-///
-/// `uuid`s are app-owned (`pw-destacada-*`), not Radio Browser uuids: these
-/// rows must resolve identically whether or not the catalogue is reachable,
-/// and a Radio Browser uuid we cannot re-fetch would be a promise this file
-/// cannot keep.
-const List<Emisora> emisorasDestacadas = [
-  Emisora(
-    uuid: 'pw-destacada-fip',
-    nombre: 'FIP',
-    url: 'https://icecast.radiofrance.fr/fip-midfi.mp3',
-    pais: 'France',
-    codigoPais: 'FR',
-    idioma: 'french',
-  ),
-  Emisora(
-    uuid: 'pw-destacada-france-inter',
-    nombre: 'France Inter',
-    url: 'https://icecast.radiofrance.fr/franceinter-midfi.mp3',
-    pais: 'France',
-    codigoPais: 'FR',
-    idioma: 'french',
-  ),
-  Emisora(
-    uuid: 'pw-destacada-deutschlandfunk',
-    nombre: 'Deutschlandfunk',
-    url: 'https://st01.sslstream.dlf.de/dlf/01/128/mp3/stream.mp3',
-    pais: 'Germany',
-    codigoPais: 'DE',
-    idioma: 'german',
-  ),
-  Emisora(
-    uuid: 'pw-destacada-kexp',
-    nombre: 'KEXP 90.3 FM',
-    url: 'https://kexp-mp3-128.streamguys1.com/kexp128.mp3',
-    pais: 'United States',
-    codigoPais: 'US',
-    idioma: 'english',
-  ),
-  Emisora(
-    uuid: 'pw-destacada-radio-paradise',
-    nombre: 'Radio Paradise',
-    url: 'https://stream.radioparadise.com/mp3-128',
-    pais: 'United States',
-    codigoPais: 'US',
-    idioma: 'english',
-  ),
-  Emisora(
-    uuid: 'pw-destacada-soma-groove-salad',
-    nombre: 'SomaFM Groove Salad',
-    url: 'https://ice1.somafm.com/groovesalad-128-mp3',
-    pais: 'United States',
-    codigoPais: 'US',
-    idioma: 'english',
-  ),
-];
-
-/// The free tier's complete, ordered station set: the last station the user
-/// actually played (when one is persisted) first, then [emisorasDestacadas],
-/// deduplicated by `uuid`.
-///
-/// Last-played goes first because it is the single row a returning driver is
-/// most likely to want, and because it is the only entry that can make the
-/// free folder feel like *their* app rather than a demo. It is NOT appended
-/// a second time when it already belongs to the curated set.
-///
-/// Follows `esPremiumPersistido({SharedPreferences? prefs})`'s
-/// inject-or-`getInstance()` convention (`estado_entitlement.dart`), so a
-/// test can pin prefs without a platform channel.
-///
-/// Never throws: a corrupt/foreign `ultima_emisora_v1` payload, or a
-/// `SharedPreferences` failure, degrades to the curated set alone. This runs
-/// inside `getChildren`, and a browse call that throws is a dead folder.
-Future<List<Emisora>> resolverEmisorasDestacadas({
-  SharedPreferences? prefs,
-}) async {
-  final ultima = await _ultimaEmisora(prefs: prefs);
-  if (ultima == null) return emisorasDestacadas;
-  return [
-    ultima,
-    ...emisorasDestacadas.where((e) => e.uuid != ultima.uuid),
-  ];
-}
-
-/// Whether [uuid] belongs to [destacadas] — the predicate every play-path
-/// gate reads to tell "free content" from "the premium catalogue".
-///
-/// Pure, and takes the free universe rather than resolving it, so a caller
-/// that already holds the list (every one of them does — it also needs it to
-/// build the response) asks the question without a second prefs round trip.
-///
-/// A `null` or empty [uuid] is never free: `emisora:` with no tail is a
-/// malformed id, and matching it against an entry with an empty uuid would be
-/// a resolution hole rather than a feature.
-bool esEmisoraGratuita(String? uuid, List<Emisora> destacadas) =>
-    uuid != null && uuid.isNotEmpty && destacadas.any((e) => e.uuid == uuid);
-
-/// [esEmisoraGratuita] against the CURRENT free set, resolved here. For
-/// callers that do not already hold the list.
-Future<bool> esEmisoraGratuitaPorUuid(
-  String uuid, {
-  SharedPreferences? prefs,
-}) async =>
-    esEmisoraGratuita(uuid, await resolverEmisorasDestacadas(prefs: prefs));
-
-/// Reads the persisted last-played station, or `null` when there is none.
-///
-/// Public because the Android Auto "recent" browse root
-/// (`AudioService.recentRootId`) needs exactly this one station and nothing
-/// else: `onGetRoot` (`AudioService.java:817-821`) answers `recent` whenever
-/// the head unit sends `EXTRA_RECENT`, which Android Auto does on every
-/// reconnect, and the platform expects a SINGLE resume item there — not a
-/// station list, and not an empty folder.
-///
-/// Tier-independent on purpose: this station is by definition one the user
-/// has already played on this device, so offering to resume it is never
-/// leaking premium content they have not already had.
-Future<Emisora?> ultimaEmisoraPersistida({SharedPreferences? prefs}) =>
-    _ultimaEmisora(prefs: prefs);
-
-/// Writes [emisora] as the last-played station — the SINGLE writer of
-/// [claveUltimaEmisora].
-///
-/// It lives beside [ultimaEmisoraPersistida] rather than in `EstadoRadio`
-/// because the key has to be written from the engine Android Auto starts,
-/// which builds no widget tree and therefore never constructs `EstadoRadio`
-/// at all: a session that happened only in the car used to leave the key
-/// holding whatever the PHONE last played, so the head unit's resume row and
-/// the free tier's featured folder were both stale on the next connect.
-///
-/// Deliberately NOT swallowing failures here: the handler port that calls it
-/// traces and swallows (a persistence failure must never break playback),
-/// and a silent `catch` in BOTH places would make a dead write channel
-/// invisible from a car logcat.
-Future<void> guardarUltimaEmisoraPersistida(
-  Emisora emisora, {
-  SharedPreferences? prefs,
-}) async {
-  final resueltas = prefs ?? await SharedPreferences.getInstance();
-  await resueltas.setString(claveUltimaEmisora, jsonEncode(emisora.toMap()));
-}
-
-/// Reads the persisted last-played station, or `null` when there is none,
-/// the payload is unreadable, or prefs themselves fail.
-Future<Emisora?> _ultimaEmisora({SharedPreferences? prefs}) async {
-  try {
-    final resueltas = prefs ?? await SharedPreferences.getInstance();
-    final raw = resueltas.getString(claveUltimaEmisora);
-    if (raw == null) return null;
-    final emisora = Emisora.fromMap(jsonDecode(raw) as Map<String, dynamic>);
-    // A record with no uuid or no url cannot be turned into a playable
-    // `emisora:<uuid>` row, so it is worse than absent: it would occupy the
-    // first slot with a row that does nothing when tapped.
-    if (emisora.uuid.isEmpty || emisora.url.isEmpty) return null;
-    return emisora;
-  } catch (_) {
-    return null;
-  }
-}

lib/servicios/musica_local_auto.dart

@@ -1,6 +1,5 @@
 import 'dart:collection';
 
-import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
@@ -72,24 +71,6 @@ String nombreCarpetaDesdeUri(String treeUri, {required String nombreGenerico}) {
   return recortado.isEmpty ? nombreGenerico : recortado;
 }
 
-/// Three-valued answer to «¿hay música local usable?»
-/// (fix/android-auto-musica-local).
-///
-/// Sustituye al `bool` anterior, que colapsaba dos causas MUY distintas en
-/// el mismo `false`:
-///
-/// * [noConfigurada] — no hay URI persistida, o el nativo respondió que el
-///   permiso ya no es válido (el usuario nunca eligió carpeta, o la
-///   revocó). Es la única respuesta que justifica ocultar el nodo.
-/// * [configurada] — hay URI persistida y el nativo confirma el permiso.
-/// * [canalNoDisponible] — hay URI persistida pero el canal
-///   `pluriwave/file_actions` NO tiene handler nativo, así que no se puede
-///   saber nada del permiso. Es lo que ocurre en el motor Flutter headless
-///   que `audio_service` levanta cuando Android Auto arranca la app sin
-///   Activity: `MainActivity.configureFlutterEngine` (único sitio donde se
-///   registra ese canal) nunca corre. NO significa «no hay carpeta».
-enum EstadoCarpetaLocal { noConfigurada, configurada, canalNoDisponible }
-
 /// Browse-source abstraction for the local-music branch of the Android Auto
 /// tree (Design "Interfaces / Contracts"), mirroring [FuenteEmisorasAuto]'s
 /// (`navegacion_auto.dart`) cold-start-safe, never-throws contract. Kept as
@@ -97,11 +78,9 @@ enum EstadoCarpetaLocal { noConfigurada, configurada, canalNoDisponible }
 /// browse domain, not a station source.
 abstract class FuenteMusicaLocalAuto {
   /// Whether a local-music root folder is picked AND its permission is
-  /// still valid — o si esa pregunta no se puede contestar porque el canal
-  /// nativo no existe en este motor. Never throws: cualquier fallo degrada
-  /// a un valor de [EstadoCarpetaLocal], nunca a una excepción (Spec
-  /// "Permission revoked or never granted").
-  Future<EstadoCarpetaLocal> estadoCarpeta();
+  /// still valid. Never throws — a revoked/never-granted permission
+  /// degrades to `false` (Spec "Permission revoked or never granted").
+  Future<bool> hayCarpetaConfigurada();
 
   /// Immediate children of [documentId] (`''` = the tree root itself), one
   /// SAF level deep (Design "Lazy per-folder enumeration, never an eager
@@ -218,56 +197,18 @@ class FuenteMusicaLocalAutoImpl implements FuenteMusicaLocalAuto {
   }
 
   @override
-  Future<EstadoCarpetaLocal> estadoCarpeta() async {
-    // Its OWN try, deliberately not merged with the channel one below.
-    //
-    // Never-throws restoration: the three-valued refactor moved this read
-    // outside the try, and the only caller (`getChildren`'s root branch)
-    // awaits it inline — so a prefs failure took the whole browse root down
-    // and emptied the car, against this method's own interface doc.
-    //
-    // Kept SEPARATE because a prefs failure and a channel failure both
-    // surface as `MissingPluginException`: one shared `on
-    // MissingPluginException` clause would answer `canalNoDisponible` —
-    // «hay carpeta pero no puedo comprobar el permiso» — for a store that
-    // never told us whether a folder exists at all. That would put an
-    // unreachable «Música Local» node in the car explaining a channel
-    // problem that is not happening, which is precisely the collapse the
-    // three-valued [EstadoCarpetaLocal] exists to prevent.
-    //
-    // `noConfigurada` is the honest answer here (the app cannot prove a
-    // folder was ever picked) and is what this path returned before the
-    // refactor, when the read still sat inside the catch-all below.
-    final String? uri;
-    try {
-      uri = await _uriPersistida();
-    } catch (e) {
-      debugPrint('[PluriWave][musica_local] no se pudo leer la URI local: $e');
-      return EstadoCarpetaLocal.noConfigurada;
-    }
-    if (uri == null || uri.isEmpty) return EstadoCarpetaLocal.noConfigurada;
+  Future<bool> hayCarpetaConfigurada() async {
     try {
+      final uri = await _uriPersistida();
+      if (uri == null || uri.isEmpty) return false;
       final valido = await _canal.invokeMethod<bool>('hasPersistedPermission', {
         'treeUri': uri,
       });
-      return valido == true
-          ? EstadoCarpetaLocal.configurada
-          : EstadoCarpetaLocal.noConfigurada;
-    } on MissingPluginException catch (e) {
-      // El canal no tiene handler en ESTE motor. Antes esto caía en el
-      // mismo `catch (_)` que un permiso revocado y devolvía `false`, que
-      // es exactamente por lo que «Música Local» desaparecía del árbol de
-      // Android Auto cuando el coche arrancaba la app sin Activity.
-      debugPrint(
-        '[PluriWave][musica_local] hasPersistedPermission sin handler '
-        'nativo (motor sin Activity): $e',
-      );
-      return EstadoCarpetaLocal.canalNoDisponible;
-    } catch (e) {
+      return valido ?? false;
+    } catch (_) {
       // Cold-start / revoked-permission safety (Spec "Permission revoked or
       // never granted"): never throw, degrade to "not configured".
-      debugPrint('[PluriWave][musica_local] hasPersistedPermission ERROR $e');
-      return EstadoCarpetaLocal.noConfigurada;
+      return false;
     }
   }
 

lib/servicios/navegacion_auto.dart

@@ -10,8 +10,6 @@ import '../modelos/emisora.dart';
 import '../modelos/grupo_favoritos.dart';
 import '../modelos/pista_local.dart';
 import '../modelos/preset_ecualizador.dart';
-import 'contexto_reproduccion.dart';
-import 'emisoras_destacadas.dart';
 import 'musica_local_auto.dart';
 import 'persistencia_tolerante.dart';
 import 'servicio_favoritos.dart';
@@ -202,97 +200,10 @@ abstract class FuenteEmisorasAuto {
   }) {}
 }
 
-/// Every user-readable label of the Android Auto browse tree, already
-/// resolved to one locale by the caller.
-///
-/// THE RULE (fix/auto-quality-guidelines, l10n item): anything a user can
-/// read gets translated. This bundle replaces the previous
-/// "car-tree labels are hardcoded Spanish, deliberately NOT an arb key"
-/// convention, which was defensible only while those labels sat deep inside
-/// a premium tree and stopped being defensible the moment Google Play
-/// reviewed the car surface on an English head unit.
-///
-/// It exists as a plain value object rather than an `AppLocalizations`
-/// dependency so [ConstructorArbolAuto] stays a PURE builder — the same
-/// reason `itemsEcualizadorAuto` lives in `servicio_audio.dart`. The handler,
-/// which can resolve localizations headlessly through
-/// `resolverLocalizacionesRespaldo`, builds one via
-/// `etiquetasArbolAutoDesde` and hands it in.
-///
-/// NOT in here on purpose: the alphabetical bucket labels (`'A-F'`, `'G-M'`,
-/// …). Those are ranges of Latin letters, not prose — translating them would
-/// make them lie about which filenames they contain.
-class EtiquetasArbolAuto {
-  const EtiquetasArbolAuto({
-    required this.escuchar,
-    required this.favoritos,
-    required this.todasLasEmisoras,
-    required this.misEmisoras,
-    required this.musicaLocal,
-    required this.musicaLocalNoDisponible,
-    required this.cargarMas,
-    required this.ordenarPorCalidad,
-    required this.reproducirCarpeta,
-    required this.reproducirAleatorio,
-    required this.pistaSinNombre,
-  });
-
-  /// Fallback bundle for callers that have no localizations to hand: pure
-  /// builder tests, and any future non-car consumer.
-  ///
-  /// It is NOT what the car shows. `ServicioAudio` always injects a bundle
-  /// resolved from `AppLocalizations`, in every browse and playback path
-  /// that can produce a label — `etiquetas_arbol_auto_test.dart` is the
-  /// guard that no NEW hardcoded label can be introduced alongside these.
-  static const respaldo = EtiquetasArbolAuto(
-    escuchar: 'Escuchar',
-    favoritos: 'Favoritos',
-    todasLasEmisoras: 'Todas las emisoras',
-    misEmisoras: 'Mis emisoras',
-    musicaLocal: 'Música Local',
-    musicaLocalNoDisponible: 'Abre PluriWave en el móvil para leer tu música',
-    cargarMas: 'Más…',
-    ordenarPorCalidad: 'Ordenar por calidad',
-    reproducirCarpeta: 'Reproducir carpeta',
-    reproducirAleatorio: 'Reproducir aleatorio',
-    pistaSinNombre: 'Pista sin nombre',
-  );
-
-  /// The free tier's single root folder ([ConstructorArbolAuto.idDestacadas]).
-  final String escuchar;
-
-  /// Premium root folders.
-  final String favoritos;
-  final String todasLasEmisoras;
-  final String misEmisoras;
-  final String musicaLocal;
-
-  /// The non-playable row shown when the local-music folder cannot be read
-  /// from the car ([ConstructorArbolAuto.idLocalNoLista]).
-  final String musicaLocalNoDisponible;
-
-  /// Trailing "load more" row of every paged local-music view.
-  final String cargarMas;
-
-  /// Local-folder navigation and action rows.
-  final String ordenarPorCalidad;
-  final String reproducirCarpeta;
-  final String reproducirAleatorio;
-
-  /// Fallback title for a local file whose name is blank after stripping.
-  final String pistaSinNombre;
-}
-
 /// Pure builder for the Android Auto browse tree: folders, leaf items, id
 /// resolution. No platform dependency — fully testable without a running
 /// car or a real `AudioHandler`.
 class ConstructorArbolAuto {
-  const ConstructorArbolAuto({this.etiquetas = EtiquetasArbolAuto.respaldo});
-
-  /// The already-localized labels this builder stamps onto every
-  /// user-readable `MediaItem` it produces.
-  final EtiquetasArbolAuto etiquetas;
-
   /// Root folder ids (Design "media-id scheme"). The tree root itself is
   /// identified by [AudioService.browsableRootId], not by a constant here —
   /// the handler compares against it directly before calling [raiz].
@@ -300,17 +211,6 @@ class ConstructorArbolAuto {
   static const idTodas = 'todas';
   static const idMisEmisoras = 'mis_emisoras';
 
-  /// Root folder id for the FREE tier's only browsable folder
-  /// (fix/auto-quality-guidelines, item 8).
-  ///
-  /// Deliberately NOT added to [_idsCarpetas] — like [idMusicaLocal] and
-  /// [idEcualizador] it has its own dedicated children ([hijosDestacadas]),
-  /// fed by `emisoras_destacadas.dart`'s compiled-in set rather than by the
-  /// generic station-list [hijos] path over a `FuenteEmisorasAuto` that is
-  /// empty on the bind a Play reviewer actually performs.
-  static const idDestacadas = 'destacadas';
-
-
   /// Root folder id for the local-music browsable root (Design "media-id
   /// scheme"). Deliberately NOT added to [_idsCarpetas] — it has its own
   /// dedicated branch (`hijosMusicaLocal`), not the generic station-list
@@ -329,17 +229,6 @@ class ConstructorArbolAuto {
   /// hidden.
   static const idEcualizador = 'ecualizador';
 
-  /// Non-playable "no puedo leer la carpeta desde aquí" item
-  /// (fix/android-auto-musica-local). La raíz ya no oculta [idMusicaLocal]
-  /// cuando el canal nativo `pluriwave/file_actions` no está disponible en
-  /// este motor, así que abrir la carpeta tenía que dejar de mostrar una
-  /// lista vacía: vacío se lee como «no tengo música», que es justo la
-  /// conclusión equivocada. Este item dice qué pasa de verdad.
-  ///
-  /// Colisión imposible con los prefijos `carpeta_local:` / `pista:` /
-  /// `emisora:` / `grupo:` — no lleva ninguno de ellos.
-  static const idLocalNoLista = 'musica_local_no_disponible';
-
   static const _idsCarpetas = {idFavoritos, idTodas, idMisEmisoras};
   static const _maxItemsPorCarpeta = 50;
 
@@ -422,10 +311,8 @@ class ConstructorArbolAuto {
     'android.media.browse.CONTENT_STYLE_PLAYABLE_HINT': 2,
   };
 
-  /// The root folders, all non-playable, and TIER-DEPENDENT: Favoritos,
-  /// Todas las emisoras, Mis emisoras and optionally Música Local for a
-  /// premium driver; the single [idDestacadas] folder for a free one (see
-  /// [premium] below).
+  /// The root folders (Favoritos, Todas las emisoras, Mis emisoras,
+  /// optionally Música Local, Ecualizador), all non-playable.
   ///
   /// Decision `auto/ecualizador-diseno` SUPERSEDES the "no equalizer
   /// There is NO `Ecualizador` folder. The car's only equalizer control is
@@ -444,78 +331,41 @@ class ConstructorArbolAuto {
   ///
   /// `Música Local` is OMITTED entirely (not just empty) unless
   /// [incluirMusicaLocal] is `true` (Design "Local root hidden until a folder
-  /// is configured") — the caller lo deriva de
-  /// `premium && fuente.estadoCarpeta() != EstadoCarpetaLocal.noConfigurada`
-  /// (fix/android-auto-musica-local: un canal nativo ausente ya NO oculta el
-  /// nodo; fix/auto-quality-guidelines item 9: el `premium &&` va delante a
-  /// propósito, para que el tier gratuito ni siquiera pague ese round trip
-  /// nativo), keeping this builder itself synchronous and side-effect free.
+  /// is configured") — the caller passes `fuente.hayCarpetaConfigurada()`,
+  /// keeping this builder itself synchronous and side-effect free.
   ///
-  /// [premium] (fix/auto-quality-guidelines, item 8) is finally READ. It used
-  /// to be accepted and ignored, on the theory that "the root keeps the same
-  /// visible folder labels for free users" was friendlier than a reduced
-  /// menu. It was not: every one of those four folders dead-ended on a single
-  /// non-playable "Función Premium" row, and Google Play cited exactly that
-  /// against the Android for Cars App Quality Guidelines.
-  ///
-  /// The free root is therefore ONE browsable folder, [idDestacadas], and the
-  /// premium-only folders are OMITTED rather than shown-and-blocked: a folder
-  /// a driver cannot use is worse than a folder that is not there.
-  ///
-  /// It must stay at least one BROWSABLE item, never a bare playable one:
-  /// `audio_service` 0.18.18 discards `rootHints`
-  /// (`AudioService.java:817-826`), so this code cannot detect whether the
-  /// head unit accepts a `FLAG_PLAYABLE` root child, and the documented
-  /// default of `BROWSER_ROOT_HINTS_KEY_ROOT_CHILDREN_SUPPORTED_FLAGS` is
-  /// `FLAG_BROWSABLE` alone — a root of one playable item renders EMPTY on
-  /// such a unit.
-  ///
-  /// Every label here comes from [etiquetas], already resolved to the head
-  /// unit's locale — the free root's [EtiquetasArbolAuto.escuchar] AND the
-  /// four premium folders.
-  ///
-  /// The four premium ones used to be hardcoded Spanish, on the theory that
-  /// they were leaf rows deep inside a tree only a user who had already
-  /// chosen the app would reach. That was never a rule, only an untested
-  /// assumption, and it is retired: anything a user can read gets
-  /// translated. `escuchar` was localized first (it is 100% of what a free
-  /// Play reviewer sees), which is exactly why the rest had to follow.
-  ///
-  /// [tituloDestacadas] stays as an explicit per-call override of
-  /// [EtiquetasArbolAuto.escuchar]; `null` (the default) uses the bundle.
+  /// [premium] (iap-freemium-unlock, Design ADR-4): the ROOT keeps the exact
+  /// same visible folder labels for every tier — "keeps the same visible
+  /// folder labels for free users" is the explicit design choice, so a free
+  /// driver still sees a real, familiar menu rather than a wall of "Función
+  /// Premium" rows. The lock itself is enforced one level DOWN, at the
+  /// `getChildren` choke point (see [itemPremiumBloqueado] and
+  /// [respuestaBloqueadaPorEntitlement] below) — tapping any of these
+  /// folders as a free user reveals the lock there, never here.
   List<MediaItem> raiz({
     required bool incluirMusicaLocal,
     required bool premium,
-    String? tituloDestacadas,
-  }) =>
-      premium
-          ? [
-            _carpeta(idFavoritos, etiquetas.favoritos),
-            _carpeta(idTodas, etiquetas.todasLasEmisoras),
-            _carpeta(idMisEmisoras, etiquetas.misEmisoras),
-            if (incluirMusicaLocal)
-              _carpeta(idMusicaLocal, etiquetas.musicaLocal),
-          ]
-          : [_carpeta(idDestacadas, tituloDestacadas ?? etiquetas.escuchar)];
+  }) => [
+    _carpeta(idFavoritos, 'Favoritos'),
+    _carpeta(idTodas, 'Todas las emisoras'),
+    _carpeta(idMisEmisoras, 'Mis emisoras'),
+    if (incluirMusicaLocal) _carpeta(idMusicaLocal, 'Música Local'),
+  ];
 
-  /// The free tier's playable station rows (fix/auto-quality-guidelines,
-  /// items 8/9): [emisoras] mapped through the SAME [itemEmisora] the premium
-  /// folders use, capped like every other folder.
-  ///
-  /// Separate from [hijos] because that path is gated on [_idsCarpetas] and
-  /// fed by a `FuenteEmisorasAuto` whose lists are all empty on a cold
-  /// headless bind — which is precisely the bind this folder has to survive.
-  /// An empty [emisoras] returns `[]` rather than any placeholder row: a
-  /// non-playable row in the car tree is the thing Play cited.
-  List<MediaItem> hijosDestacadas(List<Emisora> emisoras) =>
-      emisoras.take(_maxItemsPorCarpeta).map(itemEmisora).toList();
+  /// Free-tier id prefix reserved id (iap-freemium-unlock, Design ADR-4):
+  /// the single non-playable item every non-root folder collapses to for a
+  /// free-tier user. Hardcoded Spanish label, matching every other car-tree
+  /// label in this file (never routed through `AppLocalizations` —
+  /// established convention, see [_tituloMasLocal]'s doc).
+  static const idPremiumInfo = 'premium:info';
 
-  /// El item de [idLocalNoLista]. Rotulado con
-  /// [EtiquetasArbolAuto.musicaLocalNoDisponible], ya resuelto al idioma del
-  /// head unit. No reproducible — seleccionarlo es un no-op.
-  MediaItem itemLocalNoDisponible() => MediaItem(
-    id: idLocalNoLista,
-    title: etiquetas.musicaLocalNoDisponible,
+  /// The single locked item shown for ANY non-root folder when the browsing
+  /// user is free tier (Design ADR-4, android-auto-media spec "Free-Tier
+  /// Reduced Root Browse"). Non-playable — selecting it is a no-op, never a
+  /// crash (Spec "Free-tier user selects a locked item").
+  MediaItem itemPremiumBloqueado() => MediaItem(
+    id: idPremiumInfo,
+    title: 'Función Premium',
     playable: false,
     extras: _contentStyleLista,
   );
@@ -614,15 +464,20 @@ class ConstructorArbolAuto {
     return (documentId, pagina);
   }
 
+  /// Hardcoded-Spanish car-tree label for the trailing "load more" item
+  /// (Design ADR-5) — matches every other car-tree label in this file
+  /// (`'Favoritos'`, `'Música Local'`, [_tituloLocalFallback]), none of
+  /// which go through `AppLocalizations`. Deliberately NOT an arb key.
+  static const _tituloMasLocal = 'Más…';
+
   /// The trailing "load more" `MediaItem` (Design ADR-5): non-playable, no
   /// `artUri` (the label alone is the affordance, like [_carpeta]), id
   /// `carpeta_local_pag:<siguientePagina>:<documentIdPadre>` — round-trips
   /// via [paginaCarpetaLocalDesde] back to the parent folder's next page.
-  /// Rotulado con [EtiquetasArbolAuto.cargarMas].
   MediaItem _itemMasLocal(String documentIdPadre, int siguientePagina) =>
       MediaItem(
         id: '$_prefijoCarpetaLocalPaginada$siguientePagina:$documentIdPadre',
-        title: etiquetas.cargarMas,
+        title: _tituloMasLocal,
         playable: false,
         extras: _contentStyleLista,
       );
@@ -747,41 +602,41 @@ class ConstructorArbolAuto {
   /// for small folders.
   bool ofreceBuckets(int totalPistas) => totalPistas > _minPistasParaBuckets;
 
-  /// The "sort by quality" mode-entry `MediaItem` (Design ADR-4):
+  /// The "Ordenar por calidad" mode-entry `MediaItem` (Design ADR-4):
   /// non-playable, id `carpeta_local_ord:calidad:0:<documentIdPadre>` —
   /// always page 0 of the sorted view, round-trips via [ordenLocalDesde].
-  /// Rotulado con [EtiquetasArbolAuto.ordenarPorCalidad].
+  /// Hardcoded Spanish label, matching every other car-tree label in this
+  /// file — never routed through `AppLocalizations` (established
+  /// car-tree-label precedent, see [_tituloMasLocal]).
   MediaItem _itemModoOrdenCalidad(String documentIdPadre) => _carpeta(
     '${_prefijoCarpetaLocalOrd}calidad:0:$documentIdPadre',
-    etiquetas.ordenarPorCalidad,
+    'Ordenar por calidad',
   );
 
   /// A single bucket-folder `MediaItem` (Design ADR-4): non-playable, id
   /// `carpeta_local_bucket:<idx>:0:<documentIdPadre>` — always page 0,
-  /// round-trips via [bucketLocalDesde].
-  ///
-  /// [etiqueta] is an alphabetical RANGE (e.g. `'A-F'`), and it is the one
-  /// user-visible car-tree string that deliberately does NOT go through
-  /// [EtiquetasArbolAuto]: it names the Latin letters the folder's filenames
-  /// actually start with, so translating it would make it lie.
+  /// round-trips via [bucketLocalDesde]. [etiqueta] is the hardcoded
+  /// alphabetical-range label (e.g. `'A-F'`), matching every other
+  /// car-tree label in this file — never routed through `AppLocalizations`.
   MediaItem _itemBucket(String documentIdPadre, int idx, String etiqueta) =>
       _carpeta('$_prefijoCarpetaLocalBucket$idx:0:$documentIdPadre', etiqueta);
 
-  /// The "play folder" playable action item (Design ADR-5): id
-  /// `carpeta_local_reproducir:<documentIdPadre>`. Rotulado con
-  /// [EtiquetasArbolAuto.reproducirCarpeta].
+  /// The "Reproducir carpeta" playable action item (Design ADR-5): id
+  /// `carpeta_local_reproducir:<documentIdPadre>`. Hardcoded Spanish label,
+  /// matching every other car-tree label in this file — never routed
+  /// through `AppLocalizations`.
   MediaItem _itemReproducirCarpeta(String documentIdPadre) => MediaItem(
     id: '$_prefijoCarpetaLocalReproducir$documentIdPadre',
-    title: etiquetas.reproducirCarpeta,
+    title: 'Reproducir carpeta',
     playable: true,
     extras: _contentStyleGrid,
   );
 
-  /// The "shuffle play" playable action item (Design ADR-5),
+  /// The "Reproducir aleatorio" playable action item (Design ADR-5),
   /// mirrors [_itemReproducirCarpeta].
   MediaItem _itemReproducirAleatorio(String documentIdPadre) => MediaItem(
     id: '$_prefijoCarpetaLocalAleatorio$documentIdPadre',
-    title: etiquetas.reproducirAleatorio,
+    title: 'Reproducir aleatorio',
     playable: true,
     extras: _contentStyleGrid,
   );
@@ -863,7 +718,7 @@ class ConstructorArbolAuto {
     int siguientePagina,
   ) => MediaItem(
     id: '$_prefijoCarpetaLocalOrd$modo:$siguientePagina:$documentIdPadre',
-    title: etiquetas.cargarMas,
+    title: _tituloMasLocal,
     playable: false,
     extras: _contentStyleLista,
   );
@@ -877,7 +732,7 @@ class ConstructorArbolAuto {
     int siguientePagina,
   ) => MediaItem(
     id: '$_prefijoCarpetaLocalBucket$idxBucket:$siguientePagina:$documentIdPadre',
-    title: etiquetas.cargarMas,
+    title: _tituloMasLocal,
     playable: false,
     extras: _contentStyleLista,
   );
@@ -957,7 +812,7 @@ class ConstructorArbolAuto {
     final titulo =
         (tituloMeta != null && tituloMeta.isNotEmpty)
             ? tituloMeta
-            : _tituloDesdeNombre(nodo.nombre, etiquetas.pistaSinNombre);
+            : _tituloDesdeNombre(nodo.nombre);
     final artUriMeta = meta?.artUri?.trim();
     final artUri =
         (artUriMeta != null && artUriMeta.isNotEmpty)
@@ -1074,56 +929,24 @@ class ConstructorArbolAuto {
   }
 }
 
-/// Whether [parentMediaId] is content the FREE tier is allowed to browse
-/// (fix/auto-quality-guidelines, item 10): the browsable root itself, the
-/// free folder [ConstructorArbolAuto.idDestacadas], and an `emisora:<uuid>`
-/// whose uuid belongs to [destacadas].
-///
-/// Everything else — the catalogue folders, favourites, custom stations,
-/// local music, the equalizer folder, group folders, local tracks, and any
-/// station uuid that is not in the free set — is premium content.
-///
-/// Pure and id-shaped, with the free universe INJECTED, so the whole matrix
-/// is testable without prefs or a handler.
-bool idPermitidoEnFree(
-  String parentMediaId, {
-  required List<Emisora> destacadas,
-}) {
-  if (parentMediaId == AudioService.browsableRootId) return true;
-  if (parentMediaId == ConstructorArbolAuto.idDestacadas) return true;
-  if (!parentMediaId.startsWith(_prefijoEmisora)) return false;
-  final uuid = parentMediaId.substring(_prefijoEmisora.length);
-  if (uuid.isEmpty) return false;
-  return destacadas.any((e) => e.uuid == uuid);
-}
-
-/// Pure Android Auto browse-gate decision: the AUTHORITATIVE `getChildren`
-/// choke point, called BEFORE any other resolution.
-///
-/// REWRITTEN (fix/auto-quality-guidelines, item 10) from action-blocking to
-/// content-scoping. It used to answer ANY non-root id, for a free-tier user,
-/// with a single non-playable "Función Premium" row — which is what Google
-/// Play cited on version code 157 ("clicking on stop button makes the entire
-/// app useless" was the headline, but the browse tree it was reviewed
-/// against was four folders that each dead-ended on that row). A
-/// non-playable row reachable from a head unit's CACHED tree is a citation
-/// waiting to happen, so there is no longer any code path that can produce
-/// one: the blocked branch returns the free tier's own playable stations.
-///
-/// Returns `null` when the caller should proceed with its normal resolution
-/// (premium, or free-tier content the free tier owns).
-///
-/// [destacadas] is the free universe (`resolverEmisorasDestacadas()`); the
-/// caller resolves it once per browse. Passing an empty list is legal and
-/// yields an empty blocked response — still never a dead row.
+/// Pure Android Auto browse-gate decision (iap-freemium-unlock, Design
+/// ADR-4): the AUTHORITATIVE `getChildren` choke point, called BEFORE any
+/// other resolution. For the root itself this NEVER blocks (the root always
+/// resolves through [ConstructorArbolAuto.raiz] instead, which stays
+/// visible for every tier). For any non-root [parentMediaId] and a free-tier
+/// [premium], it returns the single locked item regardless of what the id
+/// actually is — a stale/deep-linked `emisora:<uuid>` or folder id from
+/// before a downgrade is blocked exactly the same way as a legitimate
+/// current folder id (android-auto-media spec "Free-Tier Browse Never
+/// Leaks Real Content (Authoritative Backstop)"). Returns `null` when the
+/// caller should proceed with its normal resolution (root, or premium).
 List<MediaItem>? respuestaBloqueadaPorEntitlement({
   required String parentMediaId,
   required bool premium,
-  required List<Emisora> destacadas,
 }) {
+  if (parentMediaId == AudioService.browsableRootId) return null;
   if (premium) return null;
-  if (idPermitidoEnFree(parentMediaId, destacadas: destacadas)) return null;
-  return ConstructorArbolAuto().hijosDestacadas(destacadas);
+  return [ConstructorArbolAuto().itemPremiumBloqueado()];
 }
 
 /// Routing seam between a car-tapped `emisora:<uuid>` media id and the
@@ -1135,21 +958,17 @@ List<MediaItem>? respuestaBloqueadaPorEntitlement({
 /// A stale/unknown id (or a malformed one) is a no-op: [reproducir] is
 /// never called and no exception propagates (Spec "Unknown or stale media
 /// id").
-///
-/// RETURNS whether it actually dispatched (fix/auto-quality-guidelines,
-/// item 12). The caller needs to tell "played" from "resolved to nothing"
-/// so the second case can publish an explained error to the car instead of
-/// leaving the driver with a tap that did nothing and said nothing.
-Future<bool> reproducirPorMediaId(
+Future<void> reproducirPorMediaId(
   String id, {
   required FuenteEmisorasAuto fuente,
   required Future<void> Function(MediaItem) reproducir,
 }) async {
-  final uuid = uuidDeMediaIdEmisora(id);
-  if (uuid == null) return false;
+  if (!id.startsWith(_prefijoEmisora)) return;
+  final uuid = id.substring(_prefijoEmisora.length);
+  if (uuid.isEmpty) return;
 
   final emisora = await fuente.porUuid(uuid);
-  if (emisora == null) return false;
+  if (emisora == null) return;
 
   final item = MediaItem(
     id: emisora.url,
@@ -1165,58 +984,6 @@ Future<bool> reproducirPorMediaId(
     extras: {'uuid': emisora.uuid},
   );
   await reproducir(item);
-  return true;
-}
-
-/// The uuid inside an `emisora:<uuid>` media id, or `null` for any other
-/// shape — no prefix (a `pista:`/`carpeta_local_*`/`eq_preset:` id, or a
-/// folder id) and an empty tail both answer `null`.
-///
-/// Extracted (fix/auto-quality-guidelines, item 11) because the play-path
-/// entitlement gate has to ask the same question `reproducirPorMediaId` asks,
-/// one step earlier: "is this a station id, and which station?".
-String? uuidDeMediaIdEmisora(String id) {
-  if (!id.startsWith(_prefijoEmisora)) return null;
-  final uuid = id.substring(_prefijoEmisora.length);
-  return uuid.isEmpty ? null : uuid;
-}
-
-/// A [FuenteEmisorasAuto] over nothing but the free tier's station set
-/// (fix/auto-quality-guidelines, item 12).
-///
-/// Stands in for `_fuenteNavegacionGlobal` while that is still `null` — the
-/// window between the headless Android Auto engine starting and `main.dart`
-/// registering the real source. A tap arriving in that window used to return
-/// in silence; the free set is compiled into the binary, so it can always be
-/// answered.
-///
-/// Reports the free stations through [todas] (they are, from the car's point
-/// of view, everything there is) and nothing through the curated lists, which
-/// a headless bind could not populate anyway.
-class FuenteEmisorasAutoDestacadas extends FuenteEmisorasAuto {
-  FuenteEmisorasAutoDestacadas(this._destacadas);
-
-  final List<Emisora> _destacadas;
-
-  @override
-  Future<List<Emisora>> favoritos() async => const [];
-
-  @override
-  Future<List<Emisora>> misEmisoras() async => const [];
-
-  @override
-  Future<List<Emisora>> todas() async => _destacadas;
-
-  @override
-  Future<List<GrupoFavoritos>> grupos() async => const [];
-
-  @override
-  Future<Emisora?> porUuid(String uuid) async {
-    for (final emisora in _destacadas) {
-      if (emisora.uuid == uuid) return emisora;
-    }
-    return null;
-  }
 }
 
 /// Which list previous/next should walk for [actual]: the NARROWEST context
@@ -1247,52 +1014,6 @@ List<Emisora> listaParaSaltoEmisora({
   required List<Emisora> favoritos,
   required List<Emisora> misEmisoras,
   required List<Emisora> todas,
-}) {
-  final contexto = contextoParaSaltoEmisora(
-    actual: actual,
-    favoritos: favoritos,
-    misEmisoras: misEmisoras,
-    todas: todas,
-  );
-  if (contexto == null) return const [];
-  switch (contexto.tipo) {
-    case TipoContextoSalto.grupoFavoritos:
-      return favoritos
-          .where((e) => e.grupoFavoritosId == contexto.grupoFavoritosId)
-          .toList();
-    case TipoContextoSalto.favoritos:
-      return favoritos;
-    case TipoContextoSalto.misEmisoras:
-      return misEmisoras;
-    case TipoContextoSalto.todas:
-      return todas;
-    case TipoContextoSalto.destacadas:
-      // Never produced by [contextoParaSaltoEmisora] — the free set is
-      // resolved by the handler, which owns the entitlement read.
-      return const [];
-  }
-}
-
-/// The same decision as [listaParaSaltoEmisora], NAMED instead of materialised
-/// — so it can be remembered across a process restart.
-///
-/// The car kills and restarts the engine on every reconnect, and a list of
-/// stations is not something that survives that: its members change while the
-/// app is dead. The NAME of the list does survive, which is what
-/// [ContextoSalto] persists and [resolverListaContexto] re-resolves against
-/// whatever the lists hold next time.
-///
-/// [listaParaSaltoEmisora] is implemented on top of this so the walked list
-/// and the remembered context can never disagree (pinned by a test that runs
-/// both over the same scenarios).
-///
-/// Returns `null` when [actual] belongs to none of the three lists — the
-/// caller then has no context to remember and leaves playback alone.
-ContextoSalto? contextoParaSaltoEmisora({
-  required Emisora actual,
-  required List<Emisora> favoritos,
-  required List<Emisora> misEmisoras,
-  required List<Emisora> todas,
 }) {
   Emisora? enLista(List<Emisora> lista) {
     for (final e in lista) {
@@ -1310,13 +1031,13 @@ ContextoSalto? contextoParaSaltoEmisora({
     if (grupo != GrupoFavoritos.sinAsignarId) {
       final delGrupo =
           favoritos.where((e) => e.grupoFavoritosId == grupo).toList();
-      if (delGrupo.length > 1) return ContextoSalto.grupo(grupo);
+      if (delGrupo.length > 1) return delGrupo;
     }
-    return const ContextoSalto.favoritos();
+    return favoritos;
   }
-  if (enLista(misEmisoras) != null) return const ContextoSalto.misEmisoras();
-  if (enLista(todas) != null) return const ContextoSalto.todas();
-  return null;
+  if (enLista(misEmisoras) != null) return misEmisoras;
+  if (enLista(todas) != null) return todas;
+  return const [];
 }
 
 /// The station before or after [actual] in [lista], wrapping around at both
@@ -1443,22 +1164,25 @@ Future<void> seleccionarPresetEqPorMediaId(
   if (!activo) await activarEcualizador(true);
 }
 
+/// Fallback title (Design "Title = filename minus extension") for a blank
+/// or otherwise empty-after-stripping local filename — hardcoded Spanish,
+/// matching every other car-tree label in this file (`'Favoritos'`,
+/// `'Música Local'`, etc.), none of which go through `AppLocalizations`.
+const _tituloLocalFallback = 'Pista sin nombre';
+
 /// Filename → display title (Design "Title = filename minus extension"):
 /// strips the LAST `.ext` (the whole trimmed name is kept when there is no
 /// dot, or the dot is the first character — e.g. a hidden file like
-/// `.mp3`), falling back to [sinNombre] when the result would be blank.
-///
-/// [sinNombre] is [EtiquetasArbolAuto.pistaSinNombre], passed in rather than
-/// hardcoded: it is a title the driver reads, so it is translated like every
-/// other car-tree label.
-String _tituloDesdeNombre(String nombre, String sinNombre) {
+/// `.mp3`), falling back to [_tituloLocalFallback] when the result would be
+/// blank.
+String _tituloDesdeNombre(String nombre) {
   final recortado = nombre.trim();
-  if (recortado.isEmpty) return sinNombre;
+  if (recortado.isEmpty) return _tituloLocalFallback;
   final ultimoPunto = recortado.lastIndexOf('.');
   final sinExtension =
       ultimoPunto > 0 ? recortado.substring(0, ultimoPunto) : recortado;
   final resultado = sinExtension.trim();
-  return resultado.isEmpty ? sinNombre : resultado;
+  return resultado.isEmpty ? _tituloLocalFallback : resultado;
 }
 
 /// Resolves the on-brand fallback `artUri` for a local track (Design "art =
@@ -1731,13 +1455,12 @@ Future<void> reproducirCarpetaLocal(
 Future<MediaItem?> construirMediaItemColaLocal(
   NodoLocal nodo, {
   required FuenteMusicaLocalAuto fuente,
-  EtiquetasArbolAuto etiquetas = EtiquetasArbolAuto.respaldo,
 }) async {
   final contentUri = await fuente.uriContenidoDePista(nodo.documentId);
   if (contentUri == null || contentUri.isEmpty) return null;
   return MediaItem(
     id: contentUri,
-    title: _tituloDesdeDocumentId(nodo.documentId, etiquetas.pistaSinNombre),
+    title: _tituloDesdeDocumentId(nodo.documentId),
     album: 'PluriWave',
     // Item 3: a queued local track had NO artUri at all before — reuses
     // [artUriLocal] (the SAME on-brand rotation the browse tree's
@@ -1801,9 +1524,8 @@ Future<Map<String, MetadatosPista>> _metadatosDeConCache(
 Future<List<MediaItem>?> hijosMusicaLocal(
   String parentMediaId, {
   required FuenteMusicaLocalAuto? fuente,
-  EtiquetasArbolAuto etiquetas = EtiquetasArbolAuto.respaldo,
 }) async {
-  final constructor = ConstructorArbolAuto(etiquetas: etiquetas);
+  final constructor = ConstructorArbolAuto();
 
   // Sort-mode and bucket views (Design ADR-4, Phase 2) are routed FIRST —
   // routing order is irrelevant to correctness (every prefix in this file
@@ -1862,24 +1584,13 @@ Future<List<MediaItem>?> hijosMusicaLocal(
   if (fuente == null) return const [];
   try {
     final nodos = await fuente.hijos(documentId);
-    final items = await constructor.itemsLocales(
+    return await constructor.itemsLocales(
       nodos,
       documentIdPadre: documentId,
       pagina: pagina,
       metadatosDe: (ids) => _metadatosDeConCache(ids, fuente: fuente),
       fuente: fuente,
     );
-    // fix/android-auto-musica-local: si no salió NADA, el motivo importa.
-    // Con el canal nativo caído (motor sin Activity) `hijos` degrada a `[]`
-    // igual que una carpeta realmente vacía, y una carpeta vacía en el
-    // coche se lee como «no tengo música». El estado se consulta SOLO en
-    // ese caso vacío, así que la ruta normal no paga ningún round trip
-    // extra.
-    if (items.isEmpty &&
-        await fuente.estadoCarpeta() == EstadoCarpetaLocal.canalNoDisponible) {
-      return [constructor.itemLocalNoDisponible()];
-    }
-    return items;
   } catch (_) {
     return const [];
   }
@@ -1894,11 +1605,11 @@ Future<List<MediaItem>?> hijosMusicaLocal(
 /// the SAME [_tituloDesdeNombre] rule the browse tree uses. This keeps the
 /// Now Playing title consistent with what the user tapped without requiring
 /// a second native round trip.
-String _tituloDesdeDocumentId(String documentId, String sinNombre) {
+String _tituloDesdeDocumentId(String documentId) {
   final ultimaBarra = documentId.lastIndexOf('/');
   final segmento =
       ultimaBarra >= 0 ? documentId.substring(ultimaBarra + 1) : documentId;
-  return _tituloDesdeNombre(segmento, sinNombre);
+  return _tituloDesdeNombre(segmento);
 }
 
 /// Routing seam between a car-tapped `pista:<docId>` media id and the
@@ -1917,7 +1628,6 @@ Future<void> reproducirPistaLocal(
   String id, {
   required FuenteMusicaLocalAuto fuente,
   required Future<void> Function(MediaItem) reproducir,
-  EtiquetasArbolAuto etiquetas = EtiquetasArbolAuto.respaldo,
 }) async {
   if (!esPistaMediaId(id)) return;
   final documentId = id.substring(_prefijoPista.length);
@@ -1928,7 +1638,7 @@ Future<void> reproducirPistaLocal(
 
   final pista = PistaLocal(
     documentId: documentId,
-    titulo: _tituloDesdeDocumentId(documentId, etiquetas.pistaSinNombre),
+    titulo: _tituloDesdeDocumentId(documentId),
     contentUri: contentUri,
   );
 
@@ -2023,16 +1733,6 @@ class FuenteEmisorasAutoLocal implements FuenteEmisorasAuto {
     return _snapshotTodas ?? const [];
   }
 
-  /// Resolves a station uuid across every list this source can reach.
-  ///
-  /// The free tier's set ([resolverEmisorasDestacadas]) is searched LAST
-  /// (fix/auto-quality-guidelines, item 7). It has to be searched at all
-  /// because on a cold headless bind the three lists above are all empty —
-  /// `todas()` is `_snapshotTodas ?? const []`, favourites and custom
-  /// stations have nothing persisted on a fresh install — so a curated
-  /// `emisora:<uuid>` resolved to `null` and tapping the row did NOTHING.
-  /// It is searched last so a live catalogue/favourite record for the same
-  /// uuid (richer metadata, the user's own group assignment) still wins.
   @override
   Future<Emisora?> porUuid(String uuid) async {
     final listas = await Future.wait([favoritos(), misEmisoras(), todas()]);
@@ -2041,9 +1741,6 @@ class FuenteEmisorasAutoLocal implements FuenteEmisorasAuto {
         if (emisora.uuid == uuid) return emisora;
       }
     }
-    for (final emisora in await resolverEmisorasDestacadas()) {
-      if (emisora.uuid == uuid) return emisora;
-    }
     return null;
   }
 

lib/servicios/servicio_compras.dart

@@ -127,19 +127,12 @@ class ServicioComprasPlayBilling implements PuertoCompras {
 
   void _alRecibirCompras(List<PurchaseDetails> compras) {
     if (compras.isEmpty) {
-      // `restorePurchases()` with nothing to restore pushes an EMPTY batch
-      // (`in_app_purchase_android` does `_purchaseUpdatedController.add(
-      // pastPurchases)` unconditionally) — there is no per-call correlation
-      // in this stream, so this fires on ANY empty batch. In practice
-      // `restorePurchases` on an account with nothing to restore is the only
-      // source of an empty batch this stream would ever emit.
-      //
-      // Returning silently here (as this did before) left
-      // [TipoEventoCompra.noEncontrada] NEVER emitted, so
-      // `EstadoEntitlement._compraEnCurso` stayed `true` forever and
-      // `hoja_premium.dart` kept BOTH buttons disabled — restore AND buy.
-      // A paywall that cannot be paid.
-      _eventos.add(const EventoCompra(TipoEventoCompra.noEncontrada));
+      // `restorePurchases()` with nothing to restore completes without ever
+      // pushing a PurchaseDetails (Spec "Restore finds nothing") — there is
+      // no per-call correlation in this stream, so this fires on ANY empty
+      // batch. In practice `queryPastPurchases`/`restorePurchases` on an
+      // account with nothing to restore is the only source of an empty
+      // batch this stream would ever emit.
       return;
     }
     for (final compra in compras) {

lib/servicios/servicio_ecualizador.dart

@@ -238,45 +238,6 @@ class ServicioEcualizador {
     await prefs.setBool(_keyActivo, activo);
   }
 
-  /// The persisted equalizer on/off flag, or `null` when the user has never
-  /// touched the toggle.
-  ///
-  /// Deliberately narrower than [cargar] (eq-estado-unico item A): it reads
-  /// ONE key and runs none of the migrations, because its caller is
-  /// `registrarHandler`, on the audio bootstrap path of EVERY engine —
-  /// including the headless one Android Auto starts, where there is no
-  /// widget tree and `EstadoEcualizador` never exists. It must stay cheap
-  /// and it must never mutate anything.
-  ///
-  /// `null` is preserved rather than collapsed to a default so that
-  /// `estadoEqInicial` — not this service — owns the "never persisted"
-  /// policy in exactly one place.
-  Future<bool?> leerActivo() async {
-    final prefs = await _resolverPrefs();
-    return prefs.getBool(_keyActivo);
-  }
-
-  /// The persisted principal preset, or `null` when the user has never saved
-  /// one.
-  ///
-  /// The exact sibling of [leerActivo] and narrow for the same reason: its
-  /// caller is `registrarHandler`, on the audio bootstrap path of EVERY
-  /// engine — including the headless one Android Auto starts, where there is
-  /// no widget tree and `EstadoEcualizador` never exists to push a preset
-  /// into the handler. It reads ONE key, runs none of [cargar]'s migrations
-  /// and mutates nothing.
-  ///
-  /// `null` (nothing saved, or an unreadable value) is preserved rather than
-  /// collapsed to [PresetEcualizador.flat] so the handler's own default —
-  /// not this service — decides what "never persisted" means, and so a seed
-  /// with nothing to say does not overwrite anything.
-  Future<PresetEcualizador?> leerPresetPrincipal() async {
-    final prefs = await _resolverPrefs();
-    final raw = prefs.getString(_keyPresetPrincipal);
-    if (raw == null || raw.isEmpty) return null;
-    return _leerPresetPrincipal(prefs);
-  }
-
   Future<void> eliminarPorEmisora(String uuid) async {
     final prefs = await _resolverPrefs();
     final mapa = _leerPresetsPorEmisora(prefs);

lib/servicios/servicio_export_import.dart

@@ -7,33 +7,26 @@ import '../modelos/preset_ecualizador.dart';
 /// Owns the backup (export/import) JSON serialization (S4-R4).
 ///
 /// v3 extends v2 with `presetsPorDispositivo`, `presetsMatriz`, and
-/// `eqMultiDeviceEnabled`. v4 extends v3 with `ecualizadorActivo` (the
-/// equalizer's global ON/OFF toggle). When the version-N extension
-/// parameters are all omitted the export stays at the lower version for
-/// backward compat with older app builds. State APPLICATION (writing
-/// favorites, EQ, alarms back into the app) stays in
+/// `eqMultiDeviceEnabled`. When those optional parameters are omitted the
+/// export stays at v2 for backward compat with the old app. State APPLICATION
+/// (writing favorites, EQ, alarms back into the app) stays in
 /// `EstadoRadio.importarConfig` — this service only owns serialization,
 /// parsing and the envelope shape.
 class ServicioExportImport {
   const ServicioExportImport();
 
-  /// Current backup schema version (v4 — equalizer on/off toggle).
-  static const int versionActual = 4;
-
-  /// v3 version constant (multi-device EQ) kept for clarity.
-  static const int versionV3 = 3;
+  /// Current backup schema version (v3 — multi-device EQ).
+  static const int versionActual = 3;
 
   /// Legacy v2 version constant kept for clarity.
   static const int versionV2 = 2;
 
   /// Builds the export envelope.
   ///
-  /// When [presetsPorDispositivo] or [presetsMatriz] or
-  /// [eqMultiDeviceEnabled] are provided (non-null), at least [versionV3] (3)
-  /// is written. When [ecualizadorActivo] is ALSO provided (non-null),
-  /// [versionActual] (4) is written. Omitting all of them behaves identically
-  /// to the original v2 format (version key stays 2) so old backups keep
-  /// round-tripping without version bumps.
+  /// When [presetsPorDispositivo] or [presetsMatriz] are provided (non-null),
+  /// [versionActual] (3) is written. When both are omitted the call behaves
+  /// identically to the original v2 format (version key stays 2) so old
+  /// backups keep round-tripping without version bumps.
   ///
   /// The `alarmas` block is the RAW JSON map persisted by ServicioAlarmas
   /// and passes through untouched (no re-parsing here).
@@ -52,27 +45,14 @@ class ServicioExportImport {
     Map<String, PresetEcualizador>? presetsPorDispositivo,
     Map<String, PresetEcualizador>? presetsMatriz,
     bool? eqMultiDeviceEnabled,
-    // v4 extension — the equalizer's global ON/OFF toggle. Omitting it
-    // produces a v3 (or v2)-compatible export.
-    bool? ecualizadorActivo,
   }) {
     final tieneExtensionesV3 =
         presetsPorDispositivo != null ||
         presetsMatriz != null ||
         eqMultiDeviceEnabled != null;
-    final tieneExtensionV4 = ecualizadorActivo != null;
-
-    final int version;
-    if (tieneExtensionV4) {
-      version = versionActual;
-    } else if (tieneExtensionesV3) {
-      version = versionV3;
-    } else {
-      version = versionV2;
-    }
 
     final envelope = <String, dynamic>{
-      'version': version,
+      'version': tieneExtensionesV3 ? versionActual : versionV2,
       'exportedAt': (exportadoEn ?? DateTime.now()).toIso8601String(),
       // Favorites + groups (preserves grupo_id assignments per station).
       // The protected "sin asignar" group is implicit and never exported.
@@ -108,11 +88,6 @@ class ServicioExportImport {
       envelope['eqMultiDeviceEnabled'] = eqMultiDeviceEnabled ?? false;
     }
 
-    // v4 extension: only written when explicitly provided.
-    if (tieneExtensionV4) {
-      envelope['ecualizadorActivo'] = ecualizadorActivo;
-    }
-
     return envelope;
   }
 

lib/servicios/servicio_favoritos.dart

@@ -213,43 +213,6 @@ class ServicioFavoritos {
     );
   }
 
-  /// Restaura un favorito tal como estaba en el dispositivo de origen,
-  /// preservando su `orden` y su `grupo_id`.
-  /// Usado exclusivamente por importarConfig, igual que [restaurarGrupo].
-  ///
-  /// Existe porque [agregar] NO sirve como primitiva de restauración: es la
-  /// primitiva de «marcar como favorita» y fuerza `sin_asignar` más un
-  /// `orden` al final de la lista, cosa correcta para una emisora recién
-  /// marcada (que de verdad no pertenece a ningún grupo) y destructiva para
-  /// una copia de seguridad, que trae ambos campos. Reusarla era la causa de
-  /// que los grupos volvieran vacíos tras restaurar.
-  ///
-  /// El grupo se valida igual que en [asignarGrupo]: un `grupo_id` que no
-  /// existe en `grupos_favoritos` cae a [GrupoFavoritos.sinAsignarId], de modo
-  /// que una copia editada a mano o restaurada a medias no puede dejar
-  /// emisoras apuntando a un grupo inexistente. `importarConfig` restaura los
-  /// grupos ANTES de este bucle, así que en el camino normal siempre existen.
-  Future<void> restaurarFavorito(Emisora emisora) async {
-    final db = await _database;
-    final existe =
-        Sqflite.firstIntValue(
-          await db.rawQuery(
-            'SELECT COUNT(*) FROM grupos_favoritos WHERE id = ?',
-            [emisora.grupoFavoritosId],
-          ),
-        ) ??
-        0;
-    final restaurada =
-        existe > 0
-            ? emisora
-            : emisora.copyWith(grupoFavoritosId: GrupoFavoritos.sinAsignarId);
-    await db.insert(
-      'favoritos',
-      restaurada.toMap(),
-      conflictAlgorithm: ConflictAlgorithm.replace,
-    );
-  }
-
   Future<void> eliminarGrupo(String id) async {
     if (id == GrupoFavoritos.sinAsignarId) return;
     final db = await _database;

lib/widgets/hoja_premium.dart

@@ -53,42 +53,14 @@ class HojaPremium extends StatelessWidget {
                 const SizedBox(width: 10),
                 Expanded(
                   child: Text(
-                    l10n.premiumHojaTitulo,
+                    l10n.funcionPremium,
                     style: Theme.of(context).textTheme.titleLarge?.copyWith(
                       fontWeight: FontWeight.w900,
                     ),
                   ),
                 ),
-                // Explicit, obvious dismiss affordance (fix/import-alarmas-y-
-                // paywall): a purchase sheet the user cannot easily escape is
-                // a dark pattern and a Play policy risk. Reachable without
-                // buying or restoring, same weight as any other icon button.
-                IconButton(
-                  key: const ValueKey('hoja-premium-cerrar'),
-                  icon: const Icon(Icons.close_rounded),
-                  tooltip: l10n.closeAction,
-                  onPressed: () => Navigator.of(context).maybePop(),
-                ),
               ],
             ),
-            const SizedBox(height: 12),
-            // Concrete, honest value list — accuracy is non-negotiable here:
-            // these five are the ONLY things premium unlocks. The phone
-            // equalizer stays free for everyone and must NEVER appear here;
-            // only its Android Auto surface is affected, as a consequence of
-            // Auto itself being gated.
-            _BeneficioPremium(texto: l10n.premiumBeneficioSinAnuncios),
-            _BeneficioPremium(texto: l10n.premiumBeneficioAndroidAuto),
-            _BeneficioPremium(texto: l10n.premiumBeneficioGrabacion),
-            _BeneficioPremium(texto: l10n.premiumBeneficioVacaciones),
-            _BeneficioPremium(texto: l10n.premiumBeneficioAlarmasIlimitadas),
-            const SizedBox(height: 12),
-            Text(
-              l10n.premiumPagoUnico,
-              style: Theme.of(
-                context,
-              ).textTheme.bodyMedium?.copyWith(fontWeight: FontWeight.w600),
-            ),
             const SizedBox(height: 20),
             // FIX 3 (code review): user-facing feedback for a failed
             // purchase/restore, or a restore that found nothing — before
@@ -171,49 +143,9 @@ class HojaPremium extends StatelessWidget {
                       : () => entitlement.restaurar(),
               child: Text(l10n.restaurarCompras),
             ),
-            if (!entitlement.esPremium) ...[
-              const SizedBox(height: 4),
-              // Clearly-labelled, always-reachable decline — same weight as
-              // any other secondary action, never made harder to find than
-              // buying (hard constraint: no dark patterns, no guilt-shaming
-              // decline copy).
-              TextButton(
-                key: const ValueKey('hoja-premium-ahora-no'),
-                onPressed: () => Navigator.of(context).maybePop(),
-                child: Text(l10n.premiumAhoraNo),
-              ),
-            ],
           ],
         ),
       ),
     );
   }
 }
-
-/// One concrete, honest value-list row (fix/import-alarmas-y-paywall).
-class _BeneficioPremium extends StatelessWidget {
-  const _BeneficioPremium({required this.texto});
-
-  final String texto;
-
-  @override
-  Widget build(BuildContext context) {
-    return Padding(
-      padding: const EdgeInsets.only(bottom: 8),
-      child: Row(
-        crossAxisAlignment: CrossAxisAlignment.start,
-        children: [
-          Icon(
-            Icons.check_circle_rounded,
-            size: 18,
-            color: PluriWaveTokens.brand,
-          ),
-          const SizedBox(width: 8),
-          Expanded(
-            child: Text(texto, style: Theme.of(context).textTheme.bodyMedium),
-          ),
-        ],
-      ),
-    );
-  }
-}

packages/pluriwave_file_actions/android/build.gradle.kts

@@ -1,44 +0,0 @@
-group = "es.freetimelab.pluriwave.fileactions"
-version = "1.0-SNAPSHOT"
-
-// Sin bloque `buildscript` a proposito: este modulo solo se construye desde
-// `android/settings.gradle.kts` de la app, cuyo `pluginManagement` ya pone
-// AGP 8.11.1 y Kotlin 2.2.20 en el classpath compartido. Declarar aqui otro
-// classpath de AGP arriesga un choque de versiones con el de la app.
-plugins {
-    id("com.android.library")
-    id("org.jetbrains.kotlin.android")
-}
-
-android {
-    namespace = "es.freetimelab.pluriwave.fileactions"
-
-    compileSdk = 36
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_17.toString()
-    }
-
-    sourceSets {
-        getByName("main") {
-            java.srcDirs("src/main/kotlin")
-        }
-    }
-
-    defaultConfig {
-        // Igual que `flutter.minSdkVersion` en Flutter 3.44 (FlutterExtension.kt).
-        minSdk = 24
-    }
-}
-
-dependencies {
-    // `androidx.core.content.FileProvider`, para servir la caratula embebida
-    // cacheada desde la autoridad `${applicationId}.fileprovider` que declara
-    // el manifiesto del modulo de app.
-    implementation("androidx.core:core-ktx:1.16.0")
-}

packages/pluriwave_file_actions/android/settings.gradle

@@ -1 +0,0 @@
-rootProject.name = 'pluriwave_file_actions'

packages/pluriwave_file_actions/android/src/main/AndroidManifest.xml

@@ -1,2 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>

packages/pluriwave_file_actions/android/src/main/kotlin/es/freetimelab/pluriwave/fileactions/FileActionsHandler.kt

@@ -1,363 +0,0 @@
-package es.freetimelab.pluriwave.fileactions
-
-import android.content.Context
-import android.media.MediaMetadataRetriever
-import android.net.Uri
-import android.os.Build
-import android.provider.DocumentsContract
-import android.util.Log
-import androidx.core.content.FileProvider
-import io.flutter.plugin.common.MethodCall
-import io.flutter.plugin.common.MethodChannel
-import java.io.File
-
-/**
- * Activity-FREE half of the `pluriwave/file_actions` channel
- * (fix/android-auto-musica-local, item 3).
- *
- * These four methods -- `hasPersistedPermission`, `listAudioChildren`,
- * `resolvePlayableUri`, `readAudioMetadataBatch` -- only ever needed a
- * [ContentResolver][android.content.ContentResolver], which is an
- * app-scoped API: they never touch an Activity, a window, or
- * `startActivityForResult`. They were nevertheless trapped inside
- * `MainActivity.configureFlutterEngine`, the ONE place in the whole repo
- * that installed a handler on this channel.
- *
- * That is the reported bug: when Android Auto binds the MediaBrowserService
- * before the phone app has been opened, `audio_service` builds a bare
- * `FlutterEngine` with no Activity, `configureFlutterEngine` never runs, the
- * channel has no handler at all, and every `invokeMethod` on it throws
- * `MissingPluginException`. Dart could not tell that apart from "permission
- * revoked" and silently dropped "Musica Local" from the car's browse tree.
- *
- * Living in a real plugin package is what makes them registerable on ANY
- * engine: [PluriWaveFileActionsPlugin] is listed in
- * `GeneratedPluginRegistrant`, which the `FlutterEngine(Context)` constructor
- * runs by itself, headless engine included. An app-module class never could.
- *
- * `pickMusicFolder` and the recordings-folder intents are deliberately NOT
- * here: they need `startActivityForResult` / `startActivity` plus an
- * `onActivityResult` callback, so they stay on `MainActivity` in the app
- * module, which delegates everything else to this same class -- so both
- * engines answer the four SAF methods identically, from ONE implementation.
- */
-class FileActionsHandler(private val context: Context) {
-
-    private val tag = "PluriWave"
-
-    /**
-     * Answers [call] if it is one of the Activity-free methods, replying
-     * through [result] and returning `true`. Returns `false` -- WITHOUT
-     * touching [result] -- for anything else, so `MainActivity` can fall
-     * through to its own Activity-bound methods on the same channel.
-     */
-    fun manejar(call: MethodCall, result: MethodChannel.Result): Boolean {
-        when (call.method) {
-            "listAudioChildren" -> {
-                val treeUri = call.argument<String>("treeUri")
-                val parentDocumentId = call.argument<String>("parentDocumentId") ?: ""
-                Log.d(
-                    tag,
-                    "file_actions.listAudioChildren treeUri=$treeUri parentDocumentId=$parentDocumentId"
-                )
-                if (treeUri.isNullOrBlank()) {
-                    result.success(emptyList<Map<String, Any>>())
-                } else {
-                    result.success(listAudioChildren(treeUri, parentDocumentId))
-                }
-            }
-            "resolvePlayableUri" -> {
-                val treeUri = call.argument<String>("treeUri")
-                val documentId = call.argument<String>("documentId")
-                Log.d(
-                    tag,
-                    "file_actions.resolvePlayableUri treeUri=$treeUri documentId=$documentId"
-                )
-                if (treeUri.isNullOrBlank() || documentId.isNullOrBlank()) {
-                    result.success(null)
-                } else {
-                    result.success(resolvePlayableUri(treeUri, documentId))
-                }
-            }
-            "hasPersistedPermission" -> {
-                val treeUri = call.argument<String>("treeUri")
-                Log.d(tag, "file_actions.hasPersistedPermission treeUri=$treeUri")
-                result.success(
-                    if (treeUri.isNullOrBlank()) false else hasPersistedPermission(treeUri)
-                )
-            }
-            "readAudioMetadataBatch" -> {
-                val treeUri = call.argument<String>("treeUri")
-                val documentIds = call.argument<List<String>>("documentIds") ?: emptyList()
-                Log.d(
-                    tag,
-                    "file_actions.readAudioMetadataBatch treeUri=$treeUri count=${documentIds.size}"
-                )
-                if (treeUri.isNullOrBlank()) {
-                    result.success(emptyList<Map<String, Any?>>())
-                } else {
-                    result.success(readAudioMetadataBatch(treeUri, documentIds))
-                }
-            }
-            else -> return false
-        }
-        return true
-    }
-
-    /**
-     * Traza el rechazo de un metodo que exige Activity, para que el log
-     * distinga "no hay Activity aqui" de "el canal no existe". Lo usa
-     * [PluriWaveFileActionsPlugin] antes de responder `notImplemented()`.
-     */
-    fun trazarNoDisponibleSinActividad(metodo: String) {
-        Log.d(tag, "file_actions.$metodo needs an Activity; not available here")
-    }
-
-    /**
-     * Walks ONE level of the SAF tree rooted at [treeUri] (android-auto-local-music,
-     * static review only -- Design "Lazy per-folder enumeration, never an
-     * eager tree dump"): [parentDocumentId] blank means the tree root
-     * itself, otherwise the given subfolder's documentId. Filters files to
-     * audio MIME types at the native layer (lean payload); each returned row
-     * also carries `mime` so the Dart side can re-validate via
-     * `esArchivoAudio` (defense-in-depth). Any query failure degrades to an
-     * empty list rather than throwing.
-     */
-    private fun listAudioChildren(treeUri: String, parentDocumentId: String): List<Map<String, Any>> {
-        return try {
-            val parsedTree = Uri.parse(treeUri)
-            val parentId = parentDocumentId.ifBlank {
-                DocumentsContract.getTreeDocumentId(parsedTree)
-            }
-            val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(parsedTree, parentId)
-            val projection = arrayOf(
-                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
-                DocumentsContract.Document.COLUMN_DISPLAY_NAME,
-                DocumentsContract.Document.COLUMN_MIME_TYPE
-            )
-            val resultado = mutableListOf<Map<String, Any>>()
-            context.contentResolver.query(childrenUri, projection, null, null, null)?.use { cursor ->
-                val idxDocId = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
-                val idxNombre = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
-                val idxMime = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_MIME_TYPE)
-                while (cursor.moveToNext()) {
-                    val documentId = cursor.getString(idxDocId) ?: continue
-                    val nombre = cursor.getString(idxNombre) ?: continue
-                    val mime = cursor.getString(idxMime) ?: ""
-                    val esDirectorio = mime == DocumentsContract.Document.MIME_TYPE_DIR
-                    if (!esDirectorio && !mime.startsWith("audio/")) continue
-                    resultado.add(
-                        mapOf(
-                            "documentId" to documentId,
-                            "nombre" to nombre,
-                            "esDirectorio" to esDirectorio,
-                            "mime" to mime
-                        )
-                    )
-                }
-            }
-            resultado
-        } catch (error: Throwable) {
-            Log.e(tag, "file_actions.listAudioChildren failed treeUri=$treeUri parentDocumentId=$parentDocumentId", error)
-            emptyList()
-        }
-    }
-
-    /**
-     * Resolves a leaf [documentId] within [treeUri] to its playable
-     * `content://` URI (android-auto-local-music, static review only).
-     * Returns `null` on any failure instead of throwing.
-     */
-    private fun resolvePlayableUri(treeUri: String, documentId: String): String? {
-        return try {
-            val parsedTree = Uri.parse(treeUri)
-            DocumentsContract.buildDocumentUriUsingTree(parsedTree, documentId).toString()
-        } catch (error: Throwable) {
-            Log.e(tag, "file_actions.resolvePlayableUri failed treeUri=$treeUri documentId=$documentId", error)
-            null
-        }
-    }
-
-    /**
-     * Checks whether [treeUri]'s read permission is still among
-     * [android.content.ContentResolver.getPersistedUriPermissions]
-     * (android-auto-local-music, static review only) -- used for cold-start
-     * / revoked-permission detection (Spec "Permission revoked or never
-     * granted"). Returns `false` (never throws) on a malformed [treeUri] or
-     * any other failure.
-     *
-     * Persisted URI grants are taken by the app, not by the Activity, so
-     * this answers identically on an engine with no Activity -- which is
-     * exactly why it belongs in this class.
-     */
-    private fun hasPersistedPermission(treeUri: String): Boolean {
-        return try {
-            val parsed = Uri.parse(treeUri)
-            context.contentResolver.persistedUriPermissions.any {
-                it.uri == parsed && it.isReadPermission
-            }
-        } catch (error: Throwable) {
-            Log.e(tag, "file_actions.hasPersistedPermission failed treeUri=$treeUri", error)
-            false
-        }
-    }
-
-    /**
-     * Batched embedded-metadata extraction (android-auto-local-music-phase2,
-     * static review only -- Design "Interfaces / Contracts"): for each of
-     * [documentIds], extracts title/artist/bitrate/sample-rate and the
-     * embedded picture via [extraerMetadatosPista]. Never throws across the
-     * channel boundary -- a malformed [treeUri] (or any other unexpected
-     * failure) degrades the WHOLE call to `[]`; a per-entry failure is
-     * already isolated inside [extraerMetadatosPista].
-     */
-    private fun readAudioMetadataBatch(treeUri: String, documentIds: List<String>): List<Map<String, Any?>> {
-        return try {
-            val parsedTree = Uri.parse(treeUri)
-            documentIds.map { documentId -> extraerMetadatosPista(parsedTree, documentId) }
-        } catch (error: Throwable) {
-            Log.e(tag, "file_actions.readAudioMetadataBatch failed treeUri=$treeUri", error)
-            emptyList()
-        }
-    }
-
-    /**
-     * Extracts one [documentId]'s embedded metadata via
-     * [MediaMetadataRetriever] (android-auto-local-music-phase2, static
-     * review only -- mirrors [listAudioChildren]/[resolvePlayableUri]'s
-     * never-throws shape). `METADATA_KEY_SAMPLERATE` (raw key `38`, no
-     * public constant below API 31) is gated behind
-     * `Build.VERSION.SDK_INT >= 31` (Design ADR-5); every other field is
-     * available since API 10 and read unconditionally. A resolvable
-     * embedded picture is handed to [cachearArteEmbebido]; art-cache
-     * failures degrade that single field to `null` without failing the
-     * whole entry. On ANY failure for this [documentId] (unsupported
-     * format, permission edge case, corrupt file), the row degrades to an
-     * all-null-but-`documentId` entry instead of throwing --
-     * `retriever.release()` always runs via `finally`.
-     */
-    private fun extraerMetadatosPista(parsedTree: Uri, documentId: String): Map<String, Any?> {
-        val retriever = MediaMetadataRetriever()
-        return try {
-            val documentUri = DocumentsContract.buildDocumentUriUsingTree(parsedTree, documentId)
-            retriever.setDataSource(context, documentUri)
-
-            val titulo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE)
-            val artista = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)
-            val bitrate = retriever
-                .extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)
-                ?.toIntOrNull()
-            val sampleRate = if (Build.VERSION.SDK_INT >= 31) {
-                // METADATA_KEY_SAMPLERATE = 38 (API 31+, Design ADR-5); no
-                // public constant exists on this minSdk, so the raw key is
-                // used directly, guarded by the version check above.
-                retriever.extractMetadata(38)?.toIntOrNull()
-            } else {
-                null
-            }
-            val artUri = try {
-                retriever.embeddedPicture?.let { cachearArteEmbebido(documentId, it) }
-            } catch (error: Throwable) {
-                Log.e(
-                    tag,
-                    "file_actions.readAudioMetadataBatch embeddedPicture failed documentId=$documentId",
-                    error
-                )
-                null
-            }
-
-            mapOf(
-                "documentId" to documentId,
-                "titulo" to titulo,
-                "artista" to artista,
-                "bitrate" to bitrate,
-                "sampleRate" to sampleRate,
-                "artUri" to artUri
-            )
-        } catch (error: Throwable) {
-            Log.e(
-                tag,
-                "file_actions.readAudioMetadataBatch entry failed documentId=$documentId",
-                error
-            )
-            mapOf(
-                "documentId" to documentId,
-                "titulo" to null,
-                "artista" to null,
-                "bitrate" to null,
-                "sampleRate" to null,
-                "artUri" to null
-            )
-        } finally {
-            try {
-                retriever.release()
-            } catch (_: Throwable) {
-                // release() failing is not actionable -- the retriever is
-                // being discarded regardless.
-            }
-        }
-    }
-
-    /**
-     * Embedded-art cache write + LRU trim (android-auto-local-music-phase2,
-     * static review only -- Design ADR-1). Writes [picture] bytes to
-     * `cacheDir/pluriwave_art/<hash(documentId)>` (skips the write when the
-     * file already exists, so re-parsing the same track reuses it), returns
-     * the `content://` URI served via the EXISTING
-     * `${applicationId}.fileprovider` authority
-     * (`AndroidManifest.xml`, `pluriwave_file_paths.xml`'s
-     * `cache-path path="."`) and trims `pluriwave_art/` via [trimArtCache].
-     * `hash` uses SHA-256 hex because a raw `documentId` may contain
-     * `:`/`/`, which are illegal in filenames on most filesystems.
-     */
-    private fun cachearArteEmbebido(documentId: String, picture: ByteArray): String? {
-        return try {
-            val artDir = File(context.cacheDir, "pluriwave_art").apply { mkdirs() }
-            val artFile = File(artDir, hashDocumentId(documentId))
-            if (!artFile.exists()) {
-                artFile.writeBytes(picture)
-            }
-            trimArtCache(artDir)
-            FileProvider.getUriForFile(
-                context,
-                "${context.packageName}.fileprovider",
-                artFile
-            ).toString()
-        } catch (error: Throwable) {
-            Log.e(tag, "file_actions.cachearArteEmbebido failed documentId=$documentId", error)
-            null
-        }
-    }
-
-    private fun hashDocumentId(documentId: String): String {
-        val digest = java.security.MessageDigest.getInstance("SHA-256")
-        val bytes = digest.digest(documentId.toByteArray(Charsets.UTF_8))
-        return bytes.joinToString("") { "%02x".format(it) }
-    }
-
-    /**
-     * LRU-by-`lastModified` trim of the embedded-art cache dir (Design
-     * ADR-1): after each write, keeps at most 256 files AND at most 32 MB
-     * total, deleting the OLDEST-by-mtime entries first. Kept as a
-     * trivially reviewable loop -- these files are native-owned, so
-     * round-tripping names to Dart to pick deletions would add channel
-     * chatter with no testability gain (the `delete()` is native
-     * regardless, per ADR-1's rationale).
-     */
-    private fun trimArtCache(artDir: File) {
-        val maxArchivos = 256
-        val maxBytes = 32L * 1024 * 1024
-        val archivos = artDir.listFiles()?.sortedByDescending { it.lastModified() }?.toMutableList()
-            ?: return
-        var totalBytes = archivos.sumOf { it.length() }
-        while (archivos.isNotEmpty() && (archivos.size > maxArchivos || totalBytes > maxBytes)) {
-            val masViejo = archivos.removeAt(archivos.size - 1)
-            totalBytes -= masViejo.length()
-            masViejo.delete()
-        }
-    }
-
-    companion object {
-        const val CHANNEL = "pluriwave/file_actions"
-    }
-}

packages/pluriwave_file_actions/android/src/main/kotlin/es/freetimelab/pluriwave/fileactions/PluriWaveFileActionsPlugin.kt

@@ -1,76 +0,0 @@
-package es.freetimelab.pluriwave.fileactions
-
-import io.flutter.embedding.engine.plugins.FlutterPlugin
-import io.flutter.plugin.common.MethodChannel
-
-/**
- * Registra `pluriwave/file_actions` en TODOS los FlutterEngine de la app.
- *
- * ## Por que un paquete plugin y no una clase del modulo de app
- *
- * `AudioServicePlugin.getFlutterEngine` (audio_service 0.18.18,
- * `AudioServicePlugin.java:70-75`) construye el engine compartido con
- * `new FlutterEngine(context.getApplicationContext())`. Ese constructor
- * encadena hasta el maestro con `automaticallyRegisterPlugins = true`
- * (verificado en el bytecode de `FlutterEngine`: `FlutterEngine(Context)` ->
- * `FlutterEngine(Context, String[])` con `iconst_1`) y ejecuta
- * `GeneratedPluginRegister.registerGeneratedPlugins(this)`, que reflexiona
- * sobre `io.flutter.plugins.GeneratedPluginRegistrant`.
- *
- * Es decir: el engine headless registra PLUGINS por si mismo. Por eso
- * `shared_preferences` y `just_audio` ya funcionan cuando Android Auto arranca
- * la app con el movil bloqueado, y por eso un handler instalado unicamente en
- * `MainActivity.configureFlutterEngine` no podia funcionar nunca ahi: sin
- * Activity, `configureFlutterEngine` jamas se ejecuta, el canal se queda sin
- * handler y cada `invokeMethod` lanza `MissingPluginException`. El nodo
- * "Musica Local" desaparecia del arbol del coche.
- *
- * ## Reparto con MainActivity (decision deliberada)
- *
- * Este plugin atiende SOLO los cuatro metodos que no necesitan Activity
- * ([FileActionsHandler.manejar]) y responde `notImplemented()` al resto, que es
- * la respuesta correcta en un engine sin Activity: `pickMusicFolder`,
- * `openDirectory`, `viewDirectory` y `openFile` no pueden funcionar sin una.
- *
- * En el engine CON Activity ambos escriben en el mismo canal, y gana el
- * ultimo: el orden es estructural, no casual. `GeneratedPluginRegistrant` corre
- * dentro del constructor de `FlutterEngine`, o sea antes de que el engine
- * exista como argumento; `FlutterActivityAndFragmentDelegate.onAttach` llama a
- * `host.configureFlutterEngine(flutterEngine)` despues, necesariamente con un
- * engine ya construido. Asi que en una Activity siempre gana el handler
- * combinado de `MainActivity`, que es el superconjunto: delega los cuatro
- * metodos SAF en esta MISMA clase [FileActionsHandler] y añade los suyos.
- *
- * Se descarto hacer el plugin `ActivityAware` y moverle tambien los metodos con
- * Activity: obligaria a trasladar ~400 lineas de malabares de `Intent`
- * (FileProvider, DocumentsUI, fallbacks de `ACTION_VIEW`) mas el round trip de
- * `onActivityResult`, todo ello sin cobertura de `flutter test`, para arreglar
- * un bug que no los toca. El reparto de arriba deja UNA sola implementacion de
- * la logica compartida, que era el objetivo real.
- */
-class PluriWaveFileActionsPlugin : FlutterPlugin {
-
-    private var canal: MethodChannel? = null
-
-    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        // applicationContext a proposito: los cuatro metodos solo usan el
-        // ContentResolver y la cacheDir del proceso, asi que sobreviven a
-        // cualquier Activity y valen igual en el engine headless.
-        val handler = FileActionsHandler(binding.applicationContext)
-        canal = MethodChannel(binding.binaryMessenger, FileActionsHandler.CHANNEL).apply {
-            setMethodCallHandler { call, result ->
-                if (!handler.manejar(call, result)) {
-                    handler.trazarNoDisponibleSinActividad(call.method)
-                    result.notImplemented()
-                }
-            }
-        }
-    }
-
-    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        // Solo ocurre al destruir el engine, de modo que nunca puede pisar el
-        // handler combinado que instala MainActivity sobre este mismo canal.
-        canal?.setMethodCallHandler(null)
-        canal = null
-    }
-}

packages/pluriwave_file_actions/lib/pluriwave_file_actions.dart

@@ -1,20 +0,0 @@
-/// Este paquete NO expone API Dart.
-///
-/// Existe por una sola razon estructural: un `MethodChannel` registrado desde
-/// el modulo de aplicacion (`MainActivity.configureFlutterEngine`) solo vive en
-/// el engine que tiene Activity. `audio_service` construye ademas un
-/// FlutterEngine *headless* (`AudioServicePlugin.getFlutterEngine`, que llama a
-/// `new FlutterEngine(context.getApplicationContext())`) cuando Android Auto
-/// enlaza el `MediaBrowserService` con la app cerrada. Ese constructor invoca
-/// `GeneratedPluginRegister.registerGeneratedPlugins`, que reflexiona sobre
-/// `io.flutter.plugins.GeneratedPluginRegistrant`; es decir, registra los
-/// PLUGINS, nunca una clase suelta del modulo de app.
-///
-/// Empaquetando el lado nativo aqui, `GeneratedPluginRegistrant` lo instala en
-/// los dos engines sin tocar el manifiesto ni forkear `audio_service`.
-///
-/// Los llamantes Dart siguen usando `MethodChannel('pluriwave/file_actions')`
-/// directamente (`lib/servicios/musica_local_auto.dart`,
-/// `lib/estado/estado_grabacion.dart`), asi que este fichero se queda vacio a
-/// proposito: cualquier fachada aqui seria una segunda forma de decir lo mismo.
-library;

packages/pluriwave_file_actions/pubspec.yaml

@@ -1,23 +0,0 @@
-name: pluriwave_file_actions
-description: >-
-  Canal nativo `pluriwave/file_actions` de PluriWave empaquetado como plugin
-  Flutter, para que quede registrado en TODOS los FlutterEngine de la app --
-  incluido el engine headless que audio_service crea cuando Android Auto
-  arranca el MediaBrowserService sin Activity.
-version: 0.0.1
-publish_to: 'none'
-
-environment:
-  sdk: ^3.7.0
-  flutter: '>=3.3.0'
-
-dependencies:
-  flutter:
-    sdk: flutter
-
-flutter:
-  plugin:
-    platforms:
-      android:
-        package: es.freetimelab.pluriwave.fileactions
-        pluginClass: PluriWaveFileActionsPlugin

pubspec.lock

@@ -629,13 +629,6 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.1.8"
-  pluriwave_file_actions:
-    dependency: "direct main"
-    description:
-      path: "packages/pluriwave_file_actions"
-      relative: true
-    source: path
-    version: "0.0.1"
   provider:
     dependency: "direct main"
     description:

pubspec.yaml

@@ -1,7 +1,7 @@
 name: pluriwave
 description: "Radio mundial con ecualizador, reconocimiento de canciones y UI premium"
 publish_to: 'none'
-version: 1.3.3+162
+version: 1.3.0+154
 
 environment:
   sdk: ^3.7.0
@@ -56,15 +56,6 @@ dependencies:
   # In-app purchase
   in_app_purchase: ^3.2.0
 
-  # Canal nativo SAF (`pluriwave/file_actions`) empaquetado como plugin para
-  # que GeneratedPluginRegistrant lo instale TAMBIEN en el FlutterEngine
-  # headless que audio_service crea al arrancar desde Android Auto. Sin esto
-  # el canal solo existia en el engine de MainActivity y "Musica Local"
-  # desaparecia del arbol del coche. No expone API Dart: los llamantes siguen
-  # usando MethodChannel('pluriwave/file_actions').
-  pluriwave_file_actions:
-    path: packages/pluriwave_file_actions
-
   # Song recognition (activar con AudD key)
   # permission_handler: ^11.3.1
 

test/arranque_invalidacion_arbol_auto_test.dart

@@ -1,207 +0,0 @@
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter/material.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/main.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-import 'helpers/handlers_audio.dart';
-
-/// fix/android-auto-musica-local item 4 — CORRECCIÓN del disparador.
-///
-/// El disparador anterior era `View.maybeOf(context) != null` dentro de
-/// `didChangeDependencies`, con un latch de un solo uso y este comentario:
-/// «Que exista una View significa que hay Activity». La premisa es FALSA.
-///
-/// `runApp` envuelve SIEMPRE el árbol en una `View` construida a partir de
-/// `platformDispatcher.implicitView`, y lanza `StateError` si no la hay
-/// (`flutter/lib/src/widgets/binding.dart`, `wrapWithDefaultView`). Así que
-/// en el motor headless que `audio_service` levanta sin Activity —el mismo
-/// que demostrablemente llega a `runApp`, ver la doc de
-/// `aplicarPoliticaOrientacion`— `View.maybeOf(context)` ya es no-nulo en el
-/// PRIMER `didChangeDependencies`.
-///
-/// Consecuencia: el latch se gastaba durante el arranque headless, justo en
-/// el instante en que no podía conseguir nada (`_childrenSubjects` sigue
-/// vacío, y `notificarHijosCambiaron` es `_childrenSubjects[id]?.add(...)`,
-/// un no-op silencioso). Y no podía volver a dispararse nunca, porque
-/// `didChangeDependencies` no se re-ejecuta cuando más tarde se adjunta una
-/// Activity al MISMO motor cacheado. La vía de recuperación estaba muerta en
-/// los dos motores.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  group('debeInvalidarArbolAutoAlReanudar (decisión pura)', () {
-    test('resumed + coche ya suscrito + latch libre invalida', () {
-      expect(
-        debeInvalidarArbolAutoAlReanudar(
-          estado: AppLifecycleState.resumed,
-          hayCocheSuscrito: true,
-          yaInvalidado: false,
-        ),
-        isTrue,
-      );
-    });
-
-    test('sin suscripción del coche NO invalida — y por tanto no gasta el '
-        'latch en el arranque headless', () {
-      expect(
-        debeInvalidarArbolAutoAlReanudar(
-          estado: AppLifecycleState.resumed,
-          hayCocheSuscrito: false,
-          yaInvalidado: false,
-        ),
-        isFalse,
-        reason:
-            'notificarHijosCambiaron solo empuja a un sujeto que ya existe, '
-            'así que invalidar antes de que el coche se suscriba a NADA es '
-            'demostrablemente un no-op',
-      );
-    });
-
-    test('ningún estado del ciclo de vida distinto de resumed invalida', () {
-      for (final estado in [
-        AppLifecycleState.detached,
-        AppLifecycleState.inactive,
-        AppLifecycleState.hidden,
-        AppLifecycleState.paused,
-      ]) {
-        expect(
-          debeInvalidarArbolAutoAlReanudar(
-            estado: estado,
-            hayCocheSuscrito: true,
-            yaInvalidado: false,
-          ),
-          isFalse,
-          reason:
-              '$estado no significa «hay una Activity adjunta en primer '
-              'plano»; solo resumed lo significa',
-        );
-      }
-    });
-
-    test('con el latch ya gastado no vuelve a invalidar (nada de tormenta '
-        'de notificaciones)', () {
-      expect(
-        debeInvalidarArbolAutoAlReanudar(
-          estado: AppLifecycleState.resumed,
-          hayCocheSuscrito: true,
-          yaInvalidado: true,
-        ),
-        isFalse,
-      );
-    });
-  });
-
-  group('OrientacionResponsiveApp — cableado real del disparador', () {
-    testWidgets('bajo pumpWidget/runApp SIEMPRE existe una View, que es '
-        'exactamente por qué el disparador anterior no valía', (tester) async {
-      await tester.pumpWidget(
-        const OrientacionResponsiveApp(child: SizedBox.shrink()),
-      );
-
-      expect(
-        View.maybeOf(tester.element(find.byType(SizedBox))),
-        isNotNull,
-        reason:
-            'wrapWithDefaultView envuelve el árbol en una View o lanza '
-            'StateError: no hay ningún motor bajo runApp sin View',
-      );
-    });
-
-    testWidgets('arranque headless: hay View desde el primer frame, pero sin '
-        'Activity ni coche suscrito el latch NO se gasta y sigue disponible '
-        'para cuando el coche por fin navegue', (tester) async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      var invalidaciones = 0;
-      registrarInvalidacionArbolAuto(() => invalidaciones++);
-
-      await tester.pumpWidget(
-        const OrientacionResponsiveApp(child: SizedBox.shrink()),
-      );
-      await tester.pump();
-
-      expect(
-        invalidaciones,
-        0,
-        reason: 'el primer frame no prueba que haya Activity',
-      );
-
-      // Incluso si un evento de ciclo de vida llegara en frío: el coche no
-      // ha navegado nada todavía, así que no hay ningún sujeto al que
-      // empujar y el latch debe sobrevivir.
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
-      await tester.pump();
-      expect(invalidaciones, 0);
-
-      // Ahora el coche navega la raíz (esto es lo que crea el sujeto), y la
-      // siguiente vuelta a primer plano sí encuentra algo que invalidar.
-      handler.subscribeToChildren(AudioService.browsableRootId);
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
-      await tester.pump();
-
-      expect(invalidaciones, 1);
-    });
-
-    testWidgets('con el coche YA suscrito, adjuntar una Activity (resumed) '
-        'empuja de verdad por el stream de hijos de la raíz', (tester) async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      // El coche navegó la raíz durante el arranque headless: el sujeto
-      // existe y el head unit tiene el listado cacheado.
-      final eventos = <Map<String, dynamic>>[];
-      final sub = handler
-          .subscribeToChildren(AudioService.browsableRootId)
-          .listen(eventos.add);
-      addTearDown(sub.cancel);
-
-      await tester.pumpWidget(
-        const OrientacionResponsiveApp(child: SizedBox.shrink()),
-      );
-      await tester.pump();
-      expect(
-        eventos,
-        isEmpty,
-        reason: 'todavía no hay Activity, solo una View',
-      );
-
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
-      await tester.pump();
-
-      expect(
-        eventos,
-        hasLength(1),
-        reason:
-            'esta es la ÚNICA vía de recuperación cuando el registro del '
-            'canal pluriwave/file_actions falló en el motor headless',
-      );
-
-      // Y no una por cada rebote de ciclo de vida.
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.paused);
-      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
-      await tester.pump();
-
-      expect(eventos, hasLength(1));
-    });
-  });
-
-  group('hayCocheSuscritoAlArbol', () {
-    test('es false sin handler suscrito y true en cuanto el coche navega un '
-        'id', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      expect(hayCocheSuscritoAlArbol(), isFalse);
-
-      handler.subscribeToChildren(AudioService.browsableRootId);
-
-      expect(hayCocheSuscritoAlArbol(), isTrue);
-    });
-  });
-}

test/estado/estado_alarmas_import_test.dart

@@ -1,284 +0,0 @@
-import 'dart:convert';
-import 'dart:io';
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/estado/estado_alarmas.dart';
-import 'package:pluriwave/estado/estado_radio.dart';
-import 'package:pluriwave/modelos/alarma_musical.dart';
-import 'package:pluriwave/pantallas/ajustes/pantalla_ajustes_backup.dart';
-import 'package:pluriwave/servicios/servicio_alarmas.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/fakes.dart';
-import '../helpers/fakes_alarmas.dart';
-
-/// Regression coverage for the data-loss bug (fix/import-alarmas-y-paywall):
-/// `EstadoRadio.importarConfig` writes the imported alarm block straight to
-/// SharedPreferences, but `EstadoAlarmas` is a separate long-lived
-/// `ChangeNotifier` that loaded its alarms into memory at construction and
-/// never re-reads on its own. These tests exercise the EXACT sequence the
-/// real call site (`pantalla_ajustes_backup.dart`'s `_importar`) now runs
-/// after a successful import: `EstadoRadio.importarConfig` followed by
-/// `EstadoAlarmas.cargarPersistidasSinRecalcular()` +
-/// `EstadoAlarmas.refrescarProgramacion()` — bypassing the file_picker
-/// platform channel and the confirmation dialog, which are pure UI
-/// plumbing already covered by `pantalla_ajustes_backup_test.dart`.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  late Directory tempDir;
-
-  setUp(() async {
-    SharedPreferences.setMockInitialValues({});
-    // A PRIVATE per-test file, never the shared `test/fixtures/` one:
-    // `EstadoRadio.importarConfig` unconditionally calls
-    // `_guardarEmisorasCustom()`, which WRITES to whatever
-    // `resolverArchivoCustom` resolves to — pointing that at the shared
-    // fixture previously clobbered its committed BOM on disk as a side
-    // effect of running this file's tests.
-    tempDir = await Directory.systemTemp.createTemp(
-      'pluriwave_estado_alarmas_import_test',
-    );
-  });
-
-  tearDown(() async {
-    if (tempDir.existsSync()) {
-      await tempDir.delete(recursive: true);
-    }
-  });
-
-  Future<File> archivoCustomVacio() async {
-    final file = File('${tempDir.path}/emisoras_custom.json');
-    if (!file.existsSync()) {
-      await file.writeAsString('[]');
-    }
-    return file;
-  }
-
-  Map<String, dynamic> jsonAlarma(AlarmaMusical a) => {
-    'id': a.id,
-    'nombre': a.nombre,
-    'activa': a.activa,
-    'hora': a.hora,
-    'minuto': a.minuto,
-    'tipoProgramacion': a.tipoProgramacion.name,
-    'diasSemana': a.diasSemana,
-  };
-
-  const alarmaVieja = AlarmaMusical(
-    id: 'vieja',
-    nombre: 'Alarma vieja (pre-import)',
-    hora: 6,
-    minuto: 0,
-    tipoProgramacion: TipoProgramacionAlarma.diaria,
-    diasSemana: [1, 2, 3, 4, 5],
-  );
-
-  const alarmaImportada = AlarmaMusical(
-    id: 'importada',
-    nombre: 'Alarma importada',
-    hora: 8,
-    minuto: 15,
-    tipoProgramacion: TipoProgramacionAlarma.diaria,
-    diasSemana: [6, 7],
-  );
-
-  /// Builds the pair the app wires together: `EstadoRadio` (owns
-  /// `importarConfig`) and `EstadoAlarmas` (owns the alarm reload +
-  /// re-scheduling this bugfix adds), sharing ONE `SharedPreferences`
-  /// instance exactly like the real app's provider tree does.
-  Future<
-    ({
-      EstadoRadio radio,
-      EstadoAlarmas alarmas,
-      FakePuertoAlarmasAndroid android,
-    })
-  >
-  crearPar() async {
-    final prefs = await SharedPreferences.getInstance();
-    await prefs.setString(
-      'alarmas_musicales_v1',
-      jsonEncode({
-        'alarmas': [jsonAlarma(alarmaVieja)],
-        'vacaciones': [],
-        'excepciones': [],
-      }),
-    );
-    final android = FakePuertoAlarmasAndroid();
-    final alarmas = EstadoAlarmas(
-      esPremium: () => true,
-      servicio: ServicioAlarmas(prefs: prefs),
-      android: android,
-      prefs: prefs,
-      iniciarAutomaticamente: false,
-    );
-    // Loads + native-syncs the pre-import alarm WITHOUT arming
-    // `inicializar()`'s periodic timers (irrelevant to this bugfix and a
-    // needless liability for a `flutter test` run).
-    await alarmas.refrescarProgramacion();
-
-    final radio = EstadoRadio(
-      esPremium: () => true,
-      audio: FakeServicioAudio(),
-      favoritos: FakeServicioFavoritos(),
-      radio: FakeServicioRadio(),
-      servicioEcualizador: FakeServicioEcualizador(),
-      servicioGrabacion: FakeServicioGrabacionRadioInactiva(),
-      resolverArchivoCustom: archivoCustomVacio,
-      prefs: prefs,
-      iniciarAutomaticamente: false,
-    );
-
-    return (radio: radio, alarmas: alarmas, android: android);
-  }
-
-  Map<String, dynamic> backupCon({
-    required List<AlarmaMusical> alarmas,
-    List<Map<String, dynamic>> vacaciones = const [],
-    List<Map<String, dynamic>> excepciones = const [],
-    String ordenListas = 'nombre',
-  }) => {
-    'version': 2,
-    'gruposFavoritos': [],
-    'favoritos': [],
-    'emisorasCustom': [],
-    'presetsEcualizador': {},
-    'alarmas': {
-      'alarmas': alarmas.map(jsonAlarma).toList(),
-      'vacaciones': vacaciones,
-      'excepciones': excepciones,
-    },
-    'emisoraPreferidaUuid': null,
-    'ordenListas': ordenListas,
-    'timerSuenoPresetsSegundos': <int>[300, 600],
-  };
-
-  test('after import, EstadoAlarmas reflects the imported alarms, not the '
-      'pre-import ones', () async {
-    final par = await crearPar();
-    addTearDown(par.radio.dispose);
-    addTearDown(par.alarmas.dispose);
-    addTearDown(par.android.dispose);
-
-    expect(par.alarmas.alarmas.map((a) => a.id), ['vieja']);
-
-    await aplicarImportacionConfig(
-      par.radio,
-      par.alarmas,
-      backupCon(alarmas: [alarmaImportada]),
-    );
-
-    expect(par.alarmas.alarmas.map((a) => a.id), ['importada']);
-    expect(par.alarmas.alarmas.single.nombre, 'Alarma importada');
-  });
-
-  test('native re-scheduling is triggered after an import', () async {
-    final par = await crearPar();
-    addTearDown(par.radio.dispose);
-    addTearDown(par.alarmas.dispose);
-    addTearDown(par.android.dispose);
-
-    // Sanity: the pre-import alarm was already scheduled.
-    expect(par.android.programadas.map((a) => a.id), contains('vieja'));
-
-    await aplicarImportacionConfig(
-      par.radio,
-      par.alarmas,
-      backupCon(alarmas: [alarmaImportada]),
-    );
-
-    // The imported alarm was handed to the native Android bridge — this is
-    // what makes it actually ring, not just appear in the list.
-    expect(par.android.programadas.map((a) => a.id), contains('importada'));
-  });
-
-  test(
-    'vacation ranges and alarm exceptions in the same block come back too',
-    () async {
-      final par = await crearPar();
-      addTearDown(par.radio.dispose);
-      addTearDown(par.alarmas.dispose);
-      addTearDown(par.android.dispose);
-
-      expect(par.alarmas.vacaciones, isEmpty);
-      expect(par.alarmas.excepciones, isEmpty);
-
-      await aplicarImportacionConfig(
-        par.radio,
-        par.alarmas,
-        backupCon(
-          alarmas: [alarmaImportada],
-          vacaciones: [
-            {
-              'id': 'vac1',
-              'nombre': 'Verano',
-              'inicio': '2026-07-01T00:00:00.000',
-              'fin': '2026-07-15T00:00:00.000',
-              'activo': true,
-            },
-          ],
-          excepciones: [
-            {
-              'alarmaId': 'importada',
-              'ejecucion': '2026-08-30T08:15:00.000',
-              'tipo': 'skipNext',
-            },
-          ],
-        ),
-      );
-
-      expect(par.alarmas.vacaciones.map((v) => v.id), ['vac1']);
-      expect(par.alarmas.excepciones.map((e) => e.alarmaId), ['importada']);
-    },
-  );
-
-  test('a failed import (e.g. malformed/unsupported version) leaves existing '
-      'alarms untouched', () async {
-    final par = await crearPar();
-    addTearDown(par.radio.dispose);
-    addTearDown(par.alarmas.dispose);
-    addTearDown(par.android.dispose);
-
-    final backupNoSoportado = backupCon(alarmas: [alarmaImportada])
-      ..['version'] = 99;
-
-    // Runs the SAME production function the call site uses: a throw from
-    // `importarConfig` must propagate before either reload call runs.
-    await expectLater(
-      aplicarImportacionConfig(par.radio, par.alarmas, backupNoSoportado),
-      throwsA(anything),
-    );
-
-    expect(par.alarmas.alarmas.map((a) => a.id), ['vieja']);
-    expect(par.android.programadas.map((a) => a.id), ['vieja']);
-  });
-
-  test('a cancelled import (dialog declined, importarConfig never called) '
-      'leaves existing alarms untouched', () async {
-    final par = await crearPar();
-    addTearDown(par.radio.dispose);
-    addTearDown(par.alarmas.dispose);
-    addTearDown(par.android.dispose);
-
-    // Simulates the user declining the confirm dialog: the call site
-    // returns before `importarConfig` and the two reload calls ever run.
-    expect(par.alarmas.alarmas.map((a) => a.id), ['vieja']);
-    expect(par.android.programadas.map((a) => a.id), ['vieja']);
-  });
-
-  test('regression: importing still restores preferences (ordenListas) '
-      'exactly as before', () async {
-    final par = await crearPar();
-    addTearDown(par.radio.dispose);
-    addTearDown(par.alarmas.dispose);
-    addTearDown(par.android.dispose);
-
-    await aplicarImportacionConfig(
-      par.radio,
-      par.alarmas,
-      backupCon(alarmas: [alarmaImportada], ordenListas: 'nombre'),
-    );
-
-    expect(par.radio.ordenListas.name, 'nombre');
-  });
-}

test/estado/estado_ecualizador_test.dart

@@ -1569,83 +1569,6 @@ void main() {
     });
   });
 
-  group(
-    'EstadoEcualizador — importarConfiguracion(activo:) '
-    '(equalizer on/off export/import gap)',
-    () {
-      test(
-        'activo: false turns the equalizer off — persisted AND pushed to '
-        'the live audio engine (reuses cambiarActivo, not a bare field set)',
-        () async {
-          final servicio = FakeServicioEcualizador(activo: true);
-          final audio = FakeServicioAudio();
-          final eq = EstadoEcualizador(audio: audio, servicio: servicio);
-          await eq.cargarPersistido();
-          audio.cambiosEcualizadorActivo.clear();
-
-          await eq.importarConfiguracion(
-            principal: PresetEcualizador.flat,
-            porEmisora: {},
-            activo: false,
-          );
-
-          expect(eq.activo, isFalse);
-          expect(audio.cambiosEcualizadorActivo, contains(false));
-          expect(servicio.config.activo, isFalse);
-          expect(servicio.guardarActivoLlamadas, 1);
-          eq.dispose();
-        },
-      );
-
-      test(
-        'activo: true turns the equalizer on — persisted AND pushed to '
-        'the live audio engine',
-        () async {
-          final servicio = FakeServicioEcualizador(activo: false);
-          final audio = FakeServicioAudio();
-          final eq = EstadoEcualizador(audio: audio, servicio: servicio);
-          await eq.cargarPersistido();
-          audio.cambiosEcualizadorActivo.clear();
-
-          await eq.importarConfiguracion(
-            principal: PresetEcualizador.flat,
-            porEmisora: {},
-            activo: true,
-          );
-
-          expect(eq.activo, isTrue);
-          expect(audio.cambiosEcualizadorActivo, contains(true));
-          expect(servicio.config.activo, isTrue);
-          expect(servicio.guardarActivoLlamadas, 1);
-          eq.dispose();
-        },
-      );
-
-      test(
-        'activo: null (old backup, no field) leaves the current toggle '
-        'untouched and does not persist anything for it',
-        () async {
-          final servicio = FakeServicioEcualizador(activo: false);
-          final audio = FakeServicioAudio();
-          final eq = EstadoEcualizador(audio: audio, servicio: servicio);
-          await eq.cargarPersistido();
-          audio.cambiosEcualizadorActivo.clear();
-
-          await eq.importarConfiguracion(
-            principal: PresetEcualizador.flat,
-            porEmisora: {},
-            // activo omitted — simulates a pre-v4 backup.
-          );
-
-          expect(eq.activo, isFalse);
-          expect(audio.cambiosEcualizadorActivo, isEmpty);
-          expect(servicio.guardarActivoLlamadas, 0);
-          eq.dispose();
-        },
-      );
-    },
-  );
-
   group('EstadoEcualizador — bonded Bluetooth names', () {
     const deviceId = 'bt_a2dp:AA:BB:CC:DD:EE:FF';
 
@@ -1868,8 +1791,8 @@ void main() {
     );
 
     test(
-      'a handler-initiated toggle is ADOPTED for display and NOT written '
-      'again from here (eq-estado-unico: the handler owns the write)',
+      'a handler-initiated toggle is persisted through ServicioEcualizador '
+      '(survives a restart)',
       () async {
         final fakeAudio = FakeServicioAudio();
         final fakeServicio = FakeServicioEcualizador(activo: true);
@@ -1879,21 +1802,8 @@ void main() {
         fakeAudio.simularCambioEqDesdeHandler(activo: false);
         await Future<void>.delayed(const Duration(milliseconds: 50));
 
-        expect(
-          eq.activo,
-          isFalse,
-          reason: 'the phone toggle must show what the engine is really doing',
-        );
-        expect(
-          fakeServicio.guardarActivoLlamadas,
-          equals(0),
-          reason:
-              'persistence moved to PluriWaveAudioHandler itself, because '
-              'this resync only exists while an EstadoEcualizador does — and '
-              'on the headless Android Auto engine that produced the bug, '
-              'none ever does. A second write from here would be a second '
-              'owner of the same fact.',
-        );
+        expect(fakeServicio.config.activo, isFalse);
+        expect(fakeServicio.guardarActivoLlamadas, equals(1));
         eq.dispose();
       },
     );
@@ -1944,59 +1854,6 @@ void main() {
       },
     );
   });
-
-  // ---------------------------------------------------------------------------
-  // The handler REJECTED the toggle (native setEnabled threw): the handler
-  // rolls its own flag back, so this class must not keep — nor persist — a
-  // value the engine refused.
-  // ---------------------------------------------------------------------------
-
-  group('EstadoEcualizador — cambiarActivo cuando el handler rechaza', () {
-    test(
-      'adopta el valor real del handler y NO persiste el valor rechazado',
-      () async {
-        final fakeAudio = _FakeAudioEqRechazaConmutacion();
-        final fakeServicio = FakeServicioEcualizador(activo: true);
-        final eq = EstadoEcualizador(audio: fakeAudio, servicio: fakeServicio);
-        await eq.cargarPersistido();
-        fakeAudio.cambiosEcualizadorActivo.clear();
-        fakeServicio.guardarActivoLlamadas = 0;
-
-        var avisos = 0;
-        eq.addListener(() => avisos++);
-
-        await eq.cambiarActivo(false);
-        await Future<void>.delayed(const Duration(milliseconds: 50));
-
-        // The native call failed, so the handler kept the equalizer ON.
-        expect(fakeAudio.ecualizadorActivo, isTrue);
-        expect(
-          eq.activo,
-          isTrue,
-          reason: 'the UI must show what the engine really does',
-        );
-        expect(avisos, greaterThanOrEqualTo(1));
-        expect(
-          fakeServicio.guardarActivoLlamadas,
-          equals(0),
-          reason: 'a rejected value must never reach disk',
-        );
-        expect(fakeServicio.config.activo, isTrue);
-        eq.dispose();
-      },
-    );
-  });
-}
-
-/// Fake handler that REFUSES every on/off change: it records the call (the
-/// UI-initiated path did reach the engine) but leaves [ecualizadorActivo]
-/// untouched, exactly like `PluriWaveAudioHandler._aplicarEcualizadorActivo`
-/// rolling its flag back when the native `setEnabled` throws.
-class _FakeAudioEqRechazaConmutacion extends FakeServicioAudio {
-  @override
-  Future<void> setEcualizadorActivo(bool activo) async {
-    cambiosEcualizadorActivo.add(activo);
-  }
 }
 
 /// Fake whose [guardarActivo] stays pending until released, and releases the

test/estado/estado_entitlement_test.dart

@@ -159,34 +159,6 @@ void main() {
       expect(estado.compraEnCurso, isFalse);
     });
 
-    test('tras restaurar() sin compras el paywall NO queda bloqueado: se '
-        'puede volver a comprar', () async {
-      final compras = _PuertoComprasFalso();
-      addTearDown(compras.dispose);
-      final estado = EstadoEntitlement(
-        prefs: await SharedPreferences.getInstance(),
-        compras: compras,
-      );
-      addTearDown(estado.dispose);
-      await Future<void>.delayed(Duration.zero);
-
-      unawaited(estado.restaurar());
-      await Future<void>.delayed(Duration.zero);
-      expect(estado.compraEnCurso, isTrue);
-
-      compras.emitir(const EventoCompra(TipoEventoCompra.noEncontrada));
-      await Future<void>.delayed(Duration.zero);
-
-      // `compraEnCurso` deshabilita AMBOS botones de `hoja_premium.dart`
-      // (comprar y restaurar): si se queda pegado en `true`, el usuario ya no
-      // puede pagar nunca más.
-      expect(estado.compraEnCurso, isFalse);
-
-      unawaited(estado.comprar());
-      await Future<void>.delayed(Duration.zero);
-      expect(compras.comprasIntentadas, 1);
-    });
-
     test(
       'un error en el flujo de compra no bloquea al pagador (fail-open)',
       () async {

test/estado/estado_radio_export_import_eq_activo_test.dart

@@ -1,171 +0,0 @@
-import 'dart:io';
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/estado/estado_radio.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/fakes.dart';
-import '../helpers/fakes_alarmas.dart';
-
-/// Closes the last remaining export/import gap: `EstadoEcualizador._activo`
-/// (the equalizer's global ON/OFF toggle) was not part of the backup
-/// envelope at all, so restoring a backup on another device silently kept
-/// whatever that device's toggle happened to be. These tests exercise the
-/// flag end to end through `EstadoRadio.exportarConfig`/`importarConfig`,
-/// the real call sites `pantalla_ajustes_backup.dart` uses.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  late Directory tempDir;
-
-  setUp(() async {
-    SharedPreferences.setMockInitialValues({});
-    // A PRIVATE per-test file, never the shared `test/fixtures/` one — see
-    // `estado_alarmas_import_test.dart` for why: `importarConfig`
-    // unconditionally writes to whatever `resolverArchivoCustom` resolves to.
-    tempDir = await Directory.systemTemp.createTemp(
-      'pluriwave_eq_activo_export_test',
-    );
-  });
-
-  tearDown(() async {
-    if (tempDir.existsSync()) {
-      await tempDir.delete(recursive: true);
-    }
-  });
-
-  Future<EstadoRadio> crearRadio({bool ecualizadorActivo = true}) async {
-    final prefs = await SharedPreferences.getInstance();
-    final archivoCustom = File('${tempDir.path}/emisoras_custom.json');
-    if (!archivoCustom.existsSync()) {
-      await archivoCustom.writeAsString('[]');
-    }
-    final radio = EstadoRadio(
-      esPremium: () => true,
-      audio: FakeServicioAudio(),
-      favoritos: FakeServicioFavoritos(),
-      radio: FakeServicioRadio(),
-      servicioEcualizador: FakeServicioEcualizador(activo: ecualizadorActivo),
-      servicioGrabacion: FakeServicioGrabacionRadioInactiva(),
-      resolverArchivoCustom: () async => archivoCustom,
-      prefs: prefs,
-      iniciarAutomaticamente: false,
-    );
-    await radio.ecualizador.cargarPersistido();
-    return radio;
-  }
-
-  Map<String, dynamic> backupBase({
-    required int version,
-    bool? ecualizadorActivo,
-  }) {
-    final data = <String, dynamic>{
-      'version': version,
-      'gruposFavoritos': [],
-      'favoritos': [],
-      'emisorasCustom': [],
-      'presetsEcualizador': {},
-      'alarmas': null,
-      'emisoraPreferidaUuid': null,
-      'ordenListas': 'nombre',
-      'timerSuenoPresetsSegundos': <int>[300, 600],
-    };
-    if (ecualizadorActivo != null) {
-      data['ecualizadorActivo'] = ecualizadorActivo;
-    }
-    return data;
-  }
-
-  group('EstadoRadio export/import — equalizer on/off toggle (v4)', () {
-    test('exportarConfig includes the flag when the equalizer is ON', () async {
-      final radio = await crearRadio(ecualizadorActivo: true);
-      addTearDown(radio.dispose);
-
-      final exportado = await radio.exportarConfig();
-
-      expect(exportado['ecualizadorActivo'], isTrue);
-      expect(exportado['version'], 4);
-    });
-
-    test(
-      'exportarConfig includes the flag when the equalizer is OFF',
-      () async {
-        final radio = await crearRadio(ecualizadorActivo: false);
-        addTearDown(radio.dispose);
-
-        final exportado = await radio.exportarConfig();
-
-        expect(exportado['ecualizadorActivo'], isFalse);
-        expect(exportado['version'], 4);
-      },
-    );
-
-    test('importarConfig(activo: false) turns the equalizer off — persisted '
-        'and reflected in EstadoEcualizador.activo', () async {
-      final radio = await crearRadio(ecualizadorActivo: true);
-      addTearDown(radio.dispose);
-      expect(radio.ecualizador.activo, isTrue);
-
-      await radio.importarConfig(
-        backupBase(version: 4, ecualizadorActivo: false),
-      );
-
-      expect(radio.ecualizador.activo, isFalse);
-    });
-
-    test('importarConfig(activo: true) turns the equalizer on — persisted '
-        'and reflected in EstadoEcualizador.activo', () async {
-      final radio = await crearRadio(ecualizadorActivo: false);
-      addTearDown(radio.dispose);
-      expect(radio.ecualizador.activo, isFalse);
-
-      await radio.importarConfig(
-        backupBase(version: 4, ecualizadorActivo: true),
-      );
-
-      expect(radio.ecualizador.activo, isTrue);
-    });
-
-    test('importing an OLD backup (no ecualizadorActivo field) does not throw '
-        'and leaves the current toggle untouched', () async {
-      final radio = await crearRadio(ecualizadorActivo: false);
-      addTearDown(radio.dispose);
-      expect(radio.ecualizador.activo, isFalse);
-
-      await radio.importarConfig(backupBase(version: 2));
-
-      expect(radio.ecualizador.activo, isFalse);
-    });
-
-    test(
-      'full round-trip: export -> import restores the equalizer toggle',
-      () async {
-        final origen = await crearRadio(ecualizadorActivo: false);
-        addTearDown(origen.dispose);
-        final exportado = await origen.exportarConfig();
-
-        final destino = await crearRadio(ecualizadorActivo: true);
-        addTearDown(destino.dispose);
-        expect(destino.ecualizador.activo, isTrue);
-
-        await destino.importarConfig(exportado);
-
-        expect(destino.ecualizador.activo, isFalse);
-      },
-    );
-
-    test('regression: other fields still round-trip exactly as before '
-        '(ordenListas, timerSuenoPresetsSegundos)', () async {
-      final origen = await crearRadio();
-      addTearDown(origen.dispose);
-      await origen.guardarTimerSuenoPresetsSegundos([120, 900]);
-      final exportado = await origen.exportarConfig();
-
-      final destino = await crearRadio();
-      addTearDown(destino.dispose);
-      await destino.importarConfig(exportado);
-
-      expect(destino.ordenListas.name, origen.ordenListas.name);
-    });
-  });
-}

test/estado/estado_radio_export_import_grupos_test.dart

@@ -1,177 +0,0 @@
-import 'dart:io';
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/estado/estado_radio.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/modelos/grupo_favoritos.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/fakes.dart';
-import '../helpers/fakes_alarmas.dart';
-
-/// Copia de seguridad — ROUND TRIP de los grupos de favoritos y de la
-/// asignación emisora -> grupo.
-///
-/// Reportado desde el uso real: al restaurar una copia en otro dispositivo
-/// los grupos volvían VACÍOS y todas las emisoras aparecían en «Sin
-/// asignar». El sobre exportado siempre llevó ambas cosas (`gruposFavoritos`
-/// desde v2, y `grupo_id` dentro de cada entrada de `favoritos`, porque es
-/// una clave intrínseca de `Emisora.toMap()`); lo que fallaba era la
-/// APLICACIÓN del estado: `importarConfig` reusaba `ServicioFavoritos.agregar`,
-/// la primitiva de «marcar como favorita», que fuerza `sin_asignar` y un
-/// `orden` nuevo a propósito.
-///
-/// Por eso estos tests prueban el VIAJE COMPLETO (origen -> exportar ->
-/// destino limpio -> importar), no la forma del sobre: la forma ya estaba
-/// bien y aun así el usuario perdía sus grupos.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  late Directory tempDir;
-
-  setUp(() async {
-    SharedPreferences.setMockInitialValues({});
-    tempDir = await Directory.systemTemp.createTemp(
-      'pluriwave_export_grupos_test',
-    );
-  });
-
-  tearDown(() async {
-    if (tempDir.existsSync()) {
-      await tempDir.delete(recursive: true);
-    }
-  });
-
-  var contadorArchivos = 0;
-
-  Future<EstadoRadio> crearRadio() async {
-    final prefs = await SharedPreferences.getInstance();
-    // Un archivo POR instancia: `importarConfig` escribe siempre en el que
-    // resuelva `resolverArchivoCustom`, y origen y destino no pueden
-    // compartirlo.
-    final archivoCustom = File(
-      '${tempDir.path}/emisoras_custom_${contadorArchivos++}.json',
-    );
-    if (!archivoCustom.existsSync()) {
-      await archivoCustom.writeAsString('[]');
-    }
-    final radio = EstadoRadio(
-      esPremium: () => true,
-      audio: FakeServicioAudio(),
-      favoritos: FakeServicioFavoritos(),
-      radio: FakeServicioRadio(),
-      servicioEcualizador: FakeServicioEcualizador(),
-      servicioGrabacion: FakeServicioGrabacionRadioInactiva(),
-      resolverArchivoCustom: () async => archivoCustom,
-      prefs: prefs,
-      iniciarAutomaticamente: false,
-    );
-    await radio.ecualizador.cargarPersistido();
-    return radio;
-  }
-
-  Emisora emisora(String uuid, String nombre) => Emisora(
-    uuid: uuid,
-    nombre: nombre,
-    url: 'https://example.com/$uuid.mp3',
-  );
-
-  group('EstadoRadio export/import — grupos de favoritos', () {
-    test('round trip: los grupos y la asignación de CADA emisora sobreviven '
-        'al viaje origen -> copia -> destino limpio', () async {
-      final origen = await crearRadio();
-      await origen.toggleFavorito(emisora('rock-1', 'Rock Uno'));
-      await origen.toggleFavorito(emisora('rock-2', 'Rock Dos'));
-      await origen.toggleFavorito(emisora('jazz-1', 'Jazz Uno'));
-      await origen.toggleFavorito(emisora('suelta', 'Sin grupo'));
-      await origen.crearGrupoFavoritos('Rock');
-      await origen.crearGrupoFavoritos('Jazz');
-      final rock = origen.gruposFavoritos.firstWhere((g) => g.nombre == 'Rock');
-      final jazz = origen.gruposFavoritos.firstWhere((g) => g.nombre == 'Jazz');
-      await origen.asignarGrupoFavorito('rock-1', rock.id);
-      await origen.asignarGrupoFavorito('rock-2', rock.id);
-      await origen.asignarGrupoFavorito('jazz-1', jazz.id);
-
-      final copia = await origen.exportarConfig();
-
-      final destino = await crearRadio();
-      await destino.importarConfig(copia);
-
-      // Los grupos vuelven, con su nombre y su orden.
-      final gruposDestino = destino.gruposFavoritos;
-      expect(
-        gruposDestino.map((g) => g.id),
-        containsAll(<String>[rock.id, jazz.id]),
-      );
-      expect(gruposDestino.firstWhere((g) => g.id == rock.id).nombre, 'Rock');
-      expect(gruposDestino.firstWhere((g) => g.id == jazz.id).nombre, 'Jazz');
-
-      // Y la asignación de CADA emisora vuelve con ellos.
-      String grupoDe(String uuid) =>
-          destino.listaFavoritos.firstWhere((e) => e.uuid == uuid)
-              .grupoFavoritosId;
-      expect(grupoDe('rock-1'), rock.id);
-      expect(grupoDe('rock-2'), rock.id);
-      expect(grupoDe('jazz-1'), jazz.id);
-      expect(grupoDe('suelta'), GrupoFavoritos.sinAsignarId);
-    });
-
-    test('una copia ANTIGUA sin `gruposFavoritos` importa limpiamente y deja '
-        'intactos los grupos que ya existen en el dispositivo', () async {
-      final destino = await crearRadio();
-      await destino.crearGrupoFavoritos('Mío');
-      final propio = destino.gruposFavoritos.firstWhere(
-        (g) => g.nombre == 'Mío',
-      );
-      await destino.toggleFavorito(emisora('local-1', 'Local Uno'));
-      await destino.asignarGrupoFavorito('local-1', propio.id);
-
-      // v1: ni `gruposFavoritos` ni `alarmas` ni preferencias. La regla del
-      // sobre es que un campo AUSENTE no toca ese estado.
-      await destino.importarConfig(<String, dynamic>{
-        'version': 1,
-        'favoritos': <Map<String, dynamic>>[],
-        'emisorasCustom': <Map<String, dynamic>>[],
-        'presetsEcualizador': <String, dynamic>{},
-      });
-
-      expect(destino.gruposFavoritos.any((g) => g.id == propio.id), isTrue);
-      expect(
-        destino.gruposFavoritos.firstWhere((g) => g.id == propio.id).nombre,
-        'Mío',
-      );
-      expect(
-        destino.listaFavoritos.firstWhere((e) => e.uuid == 'local-1')
-            .grupoFavoritosId,
-        propio.id,
-      );
-    });
-
-    test('los grupos importados quedan visibles SIN reiniciar: importarConfig '
-        'recarga la lista en memoria y notifica', () async {
-      final origen = await crearRadio();
-      await origen.toggleFavorito(emisora('rock-1', 'Rock Uno'));
-      await origen.crearGrupoFavoritos('Rock');
-      final rock = origen.gruposFavoritos.firstWhere((g) => g.nombre == 'Rock');
-      await origen.asignarGrupoFavorito('rock-1', rock.id);
-      final copia = await origen.exportarConfig();
-
-      final destino = await crearRadio();
-      var notificaciones = 0;
-      destino.addListener(() => notificaciones++);
-
-      await destino.importarConfig(copia);
-
-      expect(notificaciones, greaterThan(0));
-      expect(destino.gruposFavoritos.any((g) => g.id == rock.id), isTrue);
-      expect(
-        destino.listaFavoritos.single.grupoFavoritosId,
-        rock.id,
-        reason:
-            'la vista de favoritos agrupa por `grupoFavoritosId`: si la lista '
-            'en memoria no se recarga tras restaurar los grupos, la pantalla '
-            'sigue mostrando todo en «Sin asignar» hasta reiniciar',
-      );
-    });
-  });
-}

test/estado/estado_radio_test.dart

@@ -7,7 +7,6 @@ import 'package:pluriwave/estado/estado_radio.dart';
 import 'package:pluriwave/modelos/emisora.dart';
 import 'package:pluriwave/modelos/grupo_favoritos.dart';
 import 'package:pluriwave/modelos/preset_ecualizador.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
 import 'package:pluriwave/servicios/navegacion_auto.dart';
 import 'package:pluriwave/servicios/servicio_audio.dart';
 import 'package:shared_preferences/shared_preferences.dart';
@@ -793,16 +792,21 @@ void main() {
         '(reinicio) como emisoraActual DETENIDA -- no arranca audio, no '
         'reproduce, sólo queda seleccionada', () async {
       final emisora = emisoraDemo(uuid: 'last-1', nombre: 'Ultima FM');
-      // The record is now written by the audio handler's `_cambiarFuente`
-      // (`GuardarUltimaEmisoraPersistida`), which is the SINGLE writer of
-      // `ultima_emisora_v1` and the only one that also exists on the headless
-      // Android Auto engine — `EstadoRadio` used to write it too and no
-      // longer does. Seeded through that same production function here, so
-      // this test covers what `EstadoRadio` actually owns (the RESTORE) with
-      // a real payload instead of one a fake invented. The write itself is
-      // covered end to end in
-      // `test/servicios/servicio_audio_ultima_emisora_test.dart`.
-      await guardarUltimaEmisoraPersistida(emisora);
+      final estadoUno = EstadoRadio(
+        esPremium: () => true,
+        audio: FakeServicioAudio(),
+        favoritos: FakeServicioFavoritos(),
+        radio: FakeServicioRadio(),
+        servicioEcualizador: FakeServicioEcualizador(),
+        resolverArchivoCustom: _archivoCustomVacio,
+        iniciarAutomaticamente: false,
+      );
+      await estadoUno.inicializar();
+      await estadoUno.reproducir(emisora);
+      await estadoUno.detenerReproduccion();
+      // Lets the fire-and-forget persistence write settle before
+      // spinning up the "restart" instance.
+      await Future<void>.delayed(Duration.zero);
 
       final audioDos = FakeServicioAudio();
       final estadoDos = EstadoRadio(
@@ -844,18 +848,9 @@ void main() {
     });
 
     test('una emisora seleccionada desde el auto (fuera de reproducir()) '
-        'deja de estar ensombrecida por la seleccion previa del telefono',
-        () async {
-      // The PERSISTENCE half of this scenario moved to the handler, which is
-      // the only writer that exists on a car-only session — it is covered by
-      // «playFromMediaId desde el coche persiste ESA emisora» in
-      // `test/servicios/servicio_audio_ultima_emisora_test.dart`. What
-      // `EstadoRadio` still owns here, and what this test now pins, is the
-      // shadowing fix: a car selection bypasses `reproducir()`, so without
-      // the `estadoStream` listener `_emisoraSeleccionada` would keep
-      // shadowing the car's station on the `emisoraActual` getter.
+        'también se recuerda para la próxima instancia', () async {
       final audio = _AudioControlado();
-      final estado = EstadoRadio(
+      final estadoUno = EstadoRadio(
         esPremium: () => true,
         audio: audio,
         favoritos: FakeServicioFavoritos(),
@@ -864,16 +859,7 @@ void main() {
         resolverArchivoCustom: _archivoCustomVacio,
         iniciarAutomaticamente: false,
       );
-      await estado.inicializar();
-      final desdeElTelefono = emisoraDemo(
-        uuid: 'phone-picked',
-        nombre: 'Elegida en el telefono',
-      );
-      unawaited(estado.reproducir(desdeElTelefono));
-      audio.completar(desdeElTelefono.uuid);
-      await Future<void>.delayed(Duration.zero);
-      expect(estado.emisoraActual?.uuid, desdeElTelefono.uuid);
-
+      await estadoUno.inicializar();
       final desdeCoche = emisoraDemo(
         uuid: 'auto-remembered',
         nombre: 'Recordada desde el auto',
@@ -881,14 +867,18 @@ void main() {
       audio.seleccionarDesdeAuto(desdeCoche);
       await Future<void>.delayed(Duration.zero);
 
-      expect(
-        estado.emisoraActual?.uuid,
-        desdeCoche.uuid,
-        reason:
-            'the car changed the station without going through reproducir(); '
-            'the phone UI must follow it instead of keeping the previous '
-            'selection on screen',
+      final estadoDos = EstadoRadio(
+        esPremium: () => true,
+        audio: FakeServicioAudio(),
+        favoritos: FakeServicioFavoritos(),
+        radio: FakeServicioRadio(),
+        servicioEcualizador: FakeServicioEcualizador(),
+        resolverArchivoCustom: _archivoCustomVacio,
+        iniciarAutomaticamente: false,
       );
+      await estadoDos.inicializar();
+
+      expect(estadoDos.emisoraActual?.uuid, desdeCoche.uuid);
     });
   });
 }

test/helpers/fakes.dart

@@ -171,45 +171,7 @@ class FakeServicioFavoritos extends ServicioFavoritos {
   @override
   Future<void> agregar(Emisora emisora) async {
     _favoritos.removeWhere((e) => e.uuid == emisora.uuid);
-    // FIEL a producción (`ServicioFavoritos.agregar`): esta es la primitiva de
-    // «marcar como favorita», y fuerza `sin_asignar` además de un `orden`
-    // nuevo. El doble NO lo hacía, así que cualquier test de import escrito
-    // contra él salía verde mientras el dispositivo real perdía la asignación
-    // de grupo. Para RESTAURAR una copia existe `restaurarFavorito`.
-    _favoritos.add(
-      emisora.copyWith(
-        orden: _favoritos.length,
-        grupoFavoritosId: GrupoFavoritos.sinAsignarId,
-      ),
-    );
-  }
-
-  @override
-  Future<void> restaurarFavorito(Emisora emisora) async {
-    // Fiel a producción: preserva `orden` y `grupo_id`, cayendo a
-    // `sin_asignar` cuando el grupo de la copia no existe.
-    _favoritos.removeWhere((e) => e.uuid == emisora.uuid);
-    final existe = _grupos.any((g) => g.id == emisora.grupoFavoritosId);
-    _favoritos.add(
-      existe
-          ? emisora
-          : emisora.copyWith(grupoFavoritosId: GrupoFavoritos.sinAsignarId),
-    );
-  }
-
-  @override
-  Future<void> restaurarGrupo(GrupoFavoritos grupo) async {
-    // Sin este override la llamada caía en la implementación REAL de sqflite
-    // y explotaba con «databaseFactory not initialized»; solo pasaba
-    // desapercibido porque todos los tests de import existentes mandaban
-    // `gruposFavoritos: []`.
-    if (grupo.esSinAsignar) return;
-    final index = _grupos.indexWhere((g) => g.id == grupo.id);
-    if (index == -1) {
-      _grupos.add(grupo);
-    } else {
-      _grupos[index] = grupo;
-    }
+    _favoritos.add(emisora.copyWith(orden: _favoritos.length));
   }
 
   @override
@@ -452,17 +414,6 @@ class FakeServicioEcualizador extends ServicioEcualizador {
     );
   }
 
-  /// Overridden like every other write below: without this, calls fall
-  /// through to the real `ServicioEcualizador.guardarConfiguracion`, which
-  /// hits real SharedPreferences and needs a Flutter test binding — a
-  /// footgun for any test that reaches `EstadoEcualizador.importarConfiguracion`
-  /// (the backup-import path) through this Fake without also wiring
-  /// `TestWidgetsFlutterBinding`/mock prefs.
-  @override
-  Future<void> guardarConfiguracion(ConfiguracionEcualizador config) async {
-    _config = config;
-  }
-
   @override
   Future<void> guardarPorEmisora(String uuid, PresetEcualizador preset) async {
     final mapa = Map<String, PresetEcualizador>.from(_config.porEmisora);

test/helpers/handlers_audio.dart

@@ -1,46 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-/// Test-isolation seam for [PluriWaveAudioHandler].
-///
-/// A handler nobody releases keeps running after the test that built it: its
-/// terminal-state floor timer, its `ControladorReconexion` backoff (1/2/4/8/16
-/// s, longer than most of the tests that arm it) and anything still queued on
-/// its source-change chain. When one of those finally performs a source change
-/// it calls `_crearPlayer()`, which reads the CURRENT
-/// [PluriWaveAudioHandler.fabricaReproductorPrueba] — so a dead handler builds
-/// a double bound to a LATER test's script and drives it, incrementing that
-/// test's counters for work it never asked for.
-///
-/// That is why `servicio_audio_transporte_test.dart` behaved differently run
-/// alone and run inside the whole suite. A suite that passes under those
-/// conditions passes by luck, and luck runs out on a broken build exactly when
-/// it matters.
-///
-/// Usage — call ONCE at the top of `main()` and build every handler through
-/// the returned function:
-///
-/// ```dart
-/// final crearHandler = registrarHandlersLiberables();
-/// ...
-/// final handler = crearHandler();
-/// ```
-///
-/// The `tearDown` it registers covers every group in the file.
-PluriWaveAudioHandler Function() registrarHandlersLiberables() {
-  final creados = <PluriWaveAudioHandler>[];
-  tearDown(() async {
-    // Released in reverse creation order so a handler built on top of an
-    // earlier one is torn down first. `liberar` is idempotent, so a test that
-    // already released its own handler is fine.
-    for (final handler in creados.reversed) {
-      await handler.liberar();
-    }
-    creados.clear();
-  });
-  return () {
-    final handler = PluriWaveAudioHandler();
-    creados.add(handler);
-    return handler;
-  };
-}

test/l10n/identical_value_allowlist.dart

@@ -46,20 +46,6 @@ const Set<(String locale, String key)> identicalValueAllowlist = {
   ('pt', 'welcomeBullet2Title'),
   ('ru', 'welcomeBullet2Title'),
   ('zh', 'welcomeBullet2Title'),
-  (
-    'ar',
-    'premiumBeneficioAndroidAuto',
-  ), // "Android Auto" -- Google product name (fix/import-alarmas-y-paywall)
-  ('bn', 'premiumBeneficioAndroidAuto'),
-  ('de', 'premiumBeneficioAndroidAuto'),
-  ('fr', 'premiumBeneficioAndroidAuto'),
-  ('hi', 'premiumBeneficioAndroidAuto'),
-  ('id', 'premiumBeneficioAndroidAuto'),
-  ('it', 'premiumBeneficioAndroidAuto'),
-  ('ja', 'premiumBeneficioAndroidAuto'),
-  ('pt', 'premiumBeneficioAndroidAuto'),
-  ('ru', 'premiumBeneficioAndroidAuto'),
-  ('zh', 'premiumBeneficioAndroidAuto'),
 
   // ---------------------------------------------------------------------
   // Pure symbols / placeholders -- no translatable text at all.
@@ -300,10 +286,4 @@ const Set<(String locale, String key)> identicalValueAllowlist = {
     'restaurarCompras',
   ), // iap-freemium-unlock new key -- "Restaurar compras" is the standard
   // Portuguese store wording and coincides with es word for word.
-  (
-    'pt',
-    'autoCarpetaFavoritos',
-  ), // fix/auto-quality-guidelines car-tree label -- "Favoritos" is the same
-  // word in pt and es, exactly like the already-listed ('pt',
-  // 'favoritesTitle') above, which carries this very value.
 };

test/pantallas/ajustes/pantalla_ajustes_musica_local_test.dart

@@ -1,10 +1,7 @@
 import 'package:flutter/material.dart';
-import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pluriwave/l10n/gen/app_localizations.dart';
 import 'package:pluriwave/pantallas/ajustes/pantalla_ajustes_musica_local.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart'
-    show registrarInvalidacionArbolAuto;
 import 'package:pluriwave/widgets/pluri_push_scaffold.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
@@ -68,81 +65,4 @@ void main() {
 
     expect(find.text('No folder selected'), findsOneWidget);
   });
-
-  /// fix/android-auto-musica-local, item 4 — the browse-tree invalidation
-  /// after a successful folder pick had ZERO coverage and no testability
-  /// excuse: this file already mounts the screen, `registrarInvalidacionArbolAuto`
-  /// already takes a fake hook, and `pickMusicFolder` mocks exactly like
-  /// `hasPersistedPermission` does in `musica_local_auto_test.dart`.
-  ///
-  /// It matters because Android Auto CACHES the browse root and never asks
-  /// again on its own: without the call, a driver who picks a folder on the
-  /// phone keeps getting a car with no «Música Local» entry for the rest of
-  /// the session.
-  group('invalidación del árbol de Android Auto tras elegir carpeta', () {
-    const canal = MethodChannel('pluriwave/file_actions');
-
-    tearDown(() {
-      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-          .setMockMethodCallHandler(canal, null);
-    });
-
-    Future<int> pulsarElegirCarpeta(
-      WidgetTester tester, {
-      required String? uriDevuelta,
-    }) async {
-      SharedPreferences.setMockInitialValues({});
-      var invalidaciones = 0;
-      registrarInvalidacionArbolAuto(() => invalidaciones++);
-      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-          .setMockMethodCallHandler(canal, (call) async {
-            expect(call.method, 'pickMusicFolder');
-            return uriDevuelta;
-          });
-
-      await tester.pumpWidget(buildScreen());
-      await tester.pump();
-      await tester.pump(const Duration(milliseconds: 100));
-
-      await tester.tap(find.text('Choose folder'));
-      await tester.pump();
-      await tester.pump(const Duration(milliseconds: 100));
-
-      return invalidaciones;
-    }
-
-    testWidgets('elegir una carpeta invalida el árbol cacheado del coche', (
-      tester,
-    ) async {
-      final invalidaciones = await pulsarElegirCarpeta(
-        tester,
-        uriDevuelta: 'content://com.android.externalstorage.documents/tree/'
-            'primary%3AMusic%2FMyFolder',
-      );
-
-      expect(
-        invalidaciones,
-        1,
-        reason:
-            'acaba de aparecer música local donde antes no había, y el head '
-            'unit no vuelve a preguntar por su cuenta',
-      );
-    });
-
-    testWidgets('cancelar el selector NO invalida nada (el `if (uri == null) '
-        'return` es deliberado)', (tester) async {
-      final invalidaciones = await pulsarElegirCarpeta(
-        tester,
-        uriDevuelta: null,
-      );
-
-      expect(
-        invalidaciones,
-        0,
-        reason:
-            'nada cambió, así que forzar un re-browse del árbol entero sería '
-            'trabajo gratis para el coche',
-      );
-    });
-  });
 }

test/pantallas/pantalla_alarmas_tier5_test.dart

@@ -2,7 +2,6 @@ import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pluriwave/estado/estado_alarmas.dart';
 import 'package:pluriwave/estado/estado_radio.dart';
-import 'package:pluriwave/l10n/formato_fechas.dart';
 import 'package:pluriwave/l10n/gen/app_localizations.dart';
 import 'package:pluriwave/modelos/alarma_musical.dart';
 import 'package:pluriwave/modelos/emisora.dart';
@@ -138,29 +137,16 @@ void main() {
     ) async {
       final estado = crearEstado();
       addTearDown(estado.dispose);
-      // The pill only renders for the ACTIVE or NEXT range
-      // (`EstadoAlarmas.vacacionesProximas` keeps `inicioDia.isAfter(hoy)`), so
-      // the range has to be in the future RELATIVE TO THE RUN. Hardcoded
-      // calendar dates silently rot into the past and turn this into a
-      // date-dependent failure; anchor on next month instead, days 4-18 so the
-      // range never straddles a month boundary and the label stays "d–d MON".
-      final ahora = DateTime.now();
-      final mesSiguiente = DateTime(ahora.year, ahora.month + 1);
-      final inicio = DateTime(mesSiguiente.year, mesSiguiente.month, 4);
-      final fin = DateTime(mesSiguiente.year, mesSiguiente.month, 18);
       await estado.crearRangoVacaciones(
         estado.servicio.crearRangoVacaciones(
-          inicio: inicio,
-          fin: fin,
+          inicio: DateTime(2026, 8, 4),
+          fin: DateTime(2026, 8, 18),
           nombre: 'Summer',
         ),
       );
       await montar(tester, estadoAlarmas: estado);
 
-      // Assert against the same pure formatter the widget uses, so this stays
-      // a check that the pill IS rendered in the right shape rather than a
-      // duplicate of the formatter's own logic.
-      expect(find.text(rangoFechasCorto('en', inicio, fin)), findsOneWidget);
+      expect(find.text('4–18 AUG'), findsOneWidget);
     });
   });
 

test/servicios/auto_salto_emisora_test.dart

@@ -1,7 +1,6 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pluriwave/modelos/emisora.dart';
 import 'package:pluriwave/modelos/grupo_favoritos.dart';
-import 'package:pluriwave/servicios/contexto_reproduccion.dart';
 import 'package:pluriwave/servicios/navegacion_auto.dart';
 
 /// Requested: the Android Auto playback screen must offer previous/next for
@@ -173,145 +172,4 @@ void main() {
       );
     });
   });
-
-  group('contextoParaSaltoEmisora — la MISMA decisión, nombrada para poder '
-      'recordarla entre procesos', () {
-    Emisora favorita(String uuid, String grupo) => Emisora(
-      uuid: uuid,
-      nombre: uuid,
-      url: 'https://example.com/$uuid',
-      grupoFavoritosId: grupo,
-    );
-
-    final rock1 = favorita('rock1', 'g-rock');
-    final rock2 = favorita('rock2', 'g-rock');
-    final jazz1 = favorita('jazz1', 'g-jazz');
-
-    test('nombra el grupo cuando el salto se queda dentro del grupo', () {
-      expect(
-        contextoParaSaltoEmisora(
-          actual: rock1,
-          favoritos: [rock1, jazz1, rock2],
-          misEmisoras: const [],
-          todas: const [],
-        ),
-        const ContextoSalto.grupo('g-rock'),
-      );
-    });
-
-    test('nombra la lista de cada uno de los otros tres casos', () {
-      expect(
-        contextoParaSaltoEmisora(
-          actual: jazz1,
-          favoritos: [rock1, jazz1, rock2],
-          misEmisoras: const [],
-          todas: const [],
-        ),
-        const ContextoSalto.favoritos(),
-        reason: 'un grupo de un solo miembro cae a todos los favoritos',
-      );
-      expect(
-        contextoParaSaltoEmisora(
-          actual: c,
-          favoritos: [a, b],
-          misEmisoras: [c, a],
-          todas: [a, b, c],
-        ),
-        const ContextoSalto.misEmisoras(),
-      );
-      expect(
-        contextoParaSaltoEmisora(
-          actual: c,
-          favoritos: [a],
-          misEmisoras: [b],
-          todas: [a, b, c],
-        ),
-        const ContextoSalto.todas(),
-      );
-    });
-
-    test('null cuando la emisora no está en ninguna lista', () {
-      expect(
-        contextoParaSaltoEmisora(
-          actual: emisora('huerfana'),
-          favoritos: [a],
-          misEmisoras: [b],
-          todas: [a, b],
-        ),
-        isNull,
-      );
-    });
-
-    test('CONCUERDA con listaParaSaltoEmisora en todos los casos: son la '
-        'misma decisión y no pueden divergir', () {
-      final escenarios = <List<List<Emisora>>>[
-        [
-          [rock1],
-          [rock1, jazz1, rock2],
-          const [],
-          const [],
-        ],
-        [
-          [jazz1],
-          [rock1, jazz1, rock2],
-          const [],
-          const [],
-        ],
-        [
-          [c],
-          [a, b],
-          [c, a],
-          [a, b, c],
-        ],
-        [
-          [c],
-          [a],
-          [b],
-          [a, b, c],
-        ],
-        [
-          [emisora('huerfana')],
-          [a],
-          [b],
-          [a, b],
-        ],
-      ];
-      for (final escenario in escenarios) {
-        final actual = escenario[0].single;
-        final favoritos = escenario[1];
-        final misEmisoras = escenario[2];
-        final todas = escenario[3];
-        final contexto = contextoParaSaltoEmisora(
-          actual: actual,
-          favoritos: favoritos,
-          misEmisoras: misEmisoras,
-          todas: todas,
-        );
-        final porContexto =
-            contexto == null
-                ? const <Emisora>[]
-                : resolverListaContexto(
-                  contexto: contexto,
-                  actual: actual,
-                  favoritos: favoritos,
-                  misEmisoras: misEmisoras,
-                  todas: todas,
-                  destacadas: const [],
-                  grupos: const [
-                    GrupoFavoritos(id: 'g-rock', nombre: 'Rock', orden: 1),
-                    GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-                  ],
-                );
-        expect(
-          porContexto,
-          listaParaSaltoEmisora(
-            actual: actual,
-            favoritos: favoritos,
-            misEmisoras: misEmisoras,
-            todas: todas,
-          ),
-        );
-      }
-    });
-  });
 }

test/servicios/contexto_reproduccion_test.dart

@@ -1,308 +0,0 @@
-import 'dart:convert';
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/modelos/grupo_favoritos.dart';
-import 'package:pluriwave/servicios/contexto_reproduccion.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-/// Contexto de reproducción — el «en qué lista estoy» que sobrevive a que el
-/// proceso muera.
-///
-/// Mismo molde headless-safe que `emisoras_destacadas.dart`: solo
-/// `shared_preferences` y modelos, jamás `EstadoRadio` ni un `ChangeNotifier`,
-/// porque este módulo tiene que leerse desde el motor sin árbol de widgets que
-/// levanta Android Auto.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  Emisora emisora(String uuid, {String grupo = GrupoFavoritos.sinAsignarId}) =>
-      Emisora(
-        uuid: uuid,
-        nombre: uuid,
-        url: 'https://example.com/$uuid',
-        grupoFavoritosId: grupo,
-      );
-
-  group('ContextoSalto — serialización', () {
-    test('la clave de persistencia queda fijada literalmente', () {
-      // Un rename silencioso aquí no rompe nada en compilación y deja al
-      // conductor sin contexto tras actualizar: se fija a propósito.
-      expect(claveContextoSalto, 'contexto_salto_v1');
-    });
-
-    test('round trip de los tres tipos que llevan carga útil', () {
-      for (final contexto in [
-        const ContextoSalto.grupo('g-rock'),
-        const ContextoSalto.favoritos(),
-        const ContextoSalto.misEmisoras(),
-        const ContextoSalto.todas(),
-        const ContextoSalto.destacadas(['a', 'b', 'c']),
-      ]) {
-        expect(ContextoSalto.desdeMapa(contexto.aMapa()), contexto);
-      }
-    });
-
-    test('un payload corrupto o ajeno devuelve null en vez de lanzar', () {
-      expect(ContextoSalto.desdeMapa(const {}), isNull);
-      expect(ContextoSalto.desdeMapa(const {'tipo': 'inventado'}), isNull);
-      expect(
-        ContextoSalto.desdeMapa(const {'tipo': 'grupoFavoritos'}),
-        isNull,
-        reason: 'un contexto de grupo sin id de grupo no resuelve a nada',
-      );
-      expect(
-        ContextoSalto.desdeMapa(const {'tipo': 'destacadas', 'uuids': 7}),
-        isNull,
-      );
-    });
-  });
-
-  group('persistencia', () {
-    setUp(() => SharedPreferences.setMockInitialValues({}));
-
-    test('round trip por disco', () async {
-      final prefs = await SharedPreferences.getInstance();
-
-      await guardarContextoSalto(
-        const ContextoSalto.grupo('g-rock'),
-        prefs: prefs,
-      );
-
-      expect(
-        await contextoSaltoPersistido(prefs: prefs),
-        const ContextoSalto.grupo('g-rock'),
-      );
-    });
-
-    test('sin nada persistido devuelve null', () async {
-      final prefs = await SharedPreferences.getInstance();
-      expect(await contextoSaltoPersistido(prefs: prefs), isNull);
-    });
-
-    test('un JSON ilegible degrada a null, nunca lanza: esto se lee desde un '
-        'botón del volante', () async {
-      SharedPreferences.setMockInitialValues({
-        claveContextoSalto: 'esto no es json',
-      });
-      final prefs = await SharedPreferences.getInstance();
-      expect(await contextoSaltoPersistido(prefs: prefs), isNull);
-
-      SharedPreferences.setMockInitialValues({
-        claveContextoSalto: jsonEncode({'tipo': 'inventado'}),
-      });
-      expect(
-        await contextoSaltoPersistido(
-          prefs: await SharedPreferences.getInstance(),
-        ),
-        isNull,
-      );
-    });
-  });
-
-  group('resolverListaContexto — degradación del contexto recordado', () {
-    final rock1 = emisora('rock1', grupo: 'g-rock');
-    final rock2 = emisora('rock2', grupo: 'g-rock');
-    final jazz1 = emisora('jazz1', grupo: 'g-jazz');
-    final suelta = emisora('suelta');
-    final favoritos = [rock1, jazz1, rock2, suelta];
-    const grupos = [
-      GrupoFavoritos(id: 'g-rock', nombre: 'Rock', orden: 1),
-      GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-    ];
-
-    List<Emisora> resolver(
-      ContextoSalto contexto,
-      Emisora actual, {
-      List<Emisora>? favs,
-      List<GrupoFavoritos>? gruposVivos,
-      List<Emisora> misEmisoras = const [],
-      List<Emisora> todas = const [],
-      List<Emisora> destacadas = const [],
-    }) => resolverListaContexto(
-      contexto: contexto,
-      actual: actual,
-      favoritos: favs ?? favoritos,
-      misEmisoras: misEmisoras,
-      todas: todas,
-      destacadas: destacadas,
-      grupos: gruposVivos ?? grupos,
-    );
-
-    test('el grupo recordado se recorre con sus miembros VIVOS, no con el '
-        'snapshot', () {
-      final nuevo = emisora('rock3', grupo: 'g-rock');
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-rock'),
-          rock1,
-          favs: [rock1, jazz1, rock2, nuevo],
-        ),
-        [rock1, rock2, nuevo],
-      );
-    });
-
-    test('el grupo recordado ya NO existe -> cae a todos los favoritos', () {
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-borrado'),
-          rock1,
-          gruposVivos: const [
-            GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-          ],
-        ),
-        favoritos,
-      );
-    });
-
-    test('el grupo SIGUE VIVO con un solo miembro -> se honra igual: un grupo '
-        'de una emisora sigue siendo el grupo que eligió el conductor', () {
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-jazz'),
-          jazz1,
-        ),
-        [jazz1],
-      );
-    });
-
-    test('el grupo sigue vivo pero la emisora que suena ya NO pertenece a él '
-        '-> se PERMANECE en el grupo (el llamador coge su primera emisora)',
-        () {
-      expect(
-        resolver(const ContextoSalto.grupo('g-rock'), jazz1),
-        [rock1, rock2],
-      );
-    });
-
-    test('el grupo sigue vivo pero se quedó VACÍO -> no hay primera emisora '
-        'que coger, así que se ensancha a todos los favoritos', () {
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-rock'),
-          jazz1,
-          favs: [jazz1, suelta],
-        ),
-        [jazz1, suelta],
-      );
-    });
-
-    test('el grupo fue borrado y la emisora ya NO es favorita -> aun así se '
-        'cae a los favoritos: el llamador elegirá una de ellas', () {
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-borrado'),
-          emisora('fuera'),
-          gruposVivos: const [],
-        ),
-        favoritos,
-      );
-    });
-
-    test('no quedan favoritos -> lista vacía: el comportamiento de siempre '
-        'cuando no hay emisoras agregadas', () {
-      expect(
-        resolver(
-          const ContextoSalto.grupo('g-rock'),
-          emisora('fuera'),
-          favs: const [],
-          gruposVivos: const [],
-        ),
-        isEmpty,
-      );
-    });
-
-    test('la emisora salió de favoritos por completo -> el contexto de '
-        'FAVORITOS se descarta', () {
-      expect(
-        resolver(const ContextoSalto.favoritos(), emisora('fuera')),
-        isEmpty,
-      );
-    });
-
-    test('favoritos / misEmisoras / todas se resuelven contra su lista viva', () {
-      expect(resolver(const ContextoSalto.favoritos(), rock1), favoritos);
-      final propia = emisora('propia');
-      expect(
-        resolver(
-          const ContextoSalto.misEmisoras(),
-          propia,
-          misEmisoras: [propia, suelta],
-        ),
-        [propia, suelta],
-      );
-      final catalogo = emisora('catalogo');
-      expect(
-        resolver(
-          const ContextoSalto.todas(),
-          catalogo,
-          todas: [catalogo, rock1],
-        ),
-        [catalogo, rock1],
-      );
-    });
-
-    test('destacadas respeta el ORDEN CONGELADO, que es la razón de existir '
-        'del snapshot: la lista viva se reordena sola en cada lectura', () {
-      final fip = emisora('fip');
-      final soma = emisora('soma');
-      final ajena = emisora('ajena');
-      expect(
-        resolver(
-          const ContextoSalto.destacadas(['ajena', 'fip', 'soma']),
-          ajena,
-          destacadas: [fip, soma],
-        ),
-        [ajena, fip, soma],
-        reason:
-            'la emisora que suena entra en la lista aunque no esté en el set '
-            'curado; si no, ambos botones morirían',
-      );
-    });
-
-    test('destacadas: un uuid del snapshot que ya no resuelve se descarta', () {
-      final fip = emisora('fip');
-      final soma = emisora('soma');
-      expect(
-        resolver(
-          const ContextoSalto.destacadas(['fip', 'retirada', 'soma']),
-          fip,
-          destacadas: [fip, soma],
-        ),
-        [fip, soma],
-      );
-    });
-
-    test('destacadas: si la emisora que suena no está en el snapshot el '
-        'contexto se descarta', () {
-      final fip = emisora('fip');
-      expect(
-        resolver(
-          const ContextoSalto.destacadas(['fip']),
-          emisora('otra'),
-          destacadas: [fip],
-        ),
-        isEmpty,
-      );
-    });
-  });
-
-  group('uuidsCongeladosDestacadas', () {
-    test('respeta el orden curado y antepone la emisora que suena cuando no '
-        'pertenece al set', () {
-      final fip = emisora('fip');
-      final soma = emisora('soma');
-      expect(
-        uuidsCongeladosDestacadas(actual: fip, destacadas: [fip, soma]),
-        ['fip', 'soma'],
-      );
-      expect(
-        uuidsCongeladosDestacadas(
-          actual: emisora('ajena'),
-          destacadas: [fip, soma],
-        ),
-        ['ajena', 'fip', 'soma'],
-      );
-    });
-  });
-}

test/servicios/emisoras_destacadas_test.dart

@@ -1,125 +0,0 @@
-import 'dart:convert';
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-/// Free-tier featured set (fix/auto-quality-guidelines, item 6).
-///
-/// The whole compliance story rests on this: a Play reviewer on a fresh
-/// install is ALWAYS free tier, has no network catalogue snapshot, no
-/// favourites, no custom stations and no `ultima_emisora_v1` — so the free
-/// root's single folder MUST still resolve to real, playable stations from
-/// nothing but the binary itself.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  const ultima = Emisora(
-    uuid: 'uuid-ultima',
-    nombre: 'Ultima escuchada',
-    url: 'https://ultima.example/stream',
-  );
-
-  group('resolverEmisorasDestacadas', () {
-    test('cold bind: sin red, sin EstadoRadio y con prefs vacías devuelve '
-        '>= 3 emisoras reales', () async {
-      SharedPreferences.setMockInitialValues({});
-
-      final destacadas = await resolverEmisorasDestacadas();
-
-      expect(destacadas.length, greaterThanOrEqualTo(3));
-      expect(
-        destacadas.every((e) => e.uuid.isNotEmpty),
-        isTrue,
-        reason: 'un uuid vacío no se puede resolver desde emisora:<uuid>',
-      );
-      expect(
-        destacadas.every(
-          (e) => e.url.startsWith('http://') || e.url.startsWith('https://'),
-        ),
-        isTrue,
-      );
-      expect(
-        destacadas.map((e) => e.uuid).toSet().length,
-        destacadas.length,
-        reason: 'uuids duplicados romperían porUuid',
-      );
-    });
-
-    test('con ultima_emisora_v1 presente: va PRIMERA y no se duplica',
-        () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora: jsonEncode(ultima.toMap()),
-      });
-
-      final destacadas = await resolverEmisorasDestacadas();
-
-      expect(destacadas.first.uuid, ultima.uuid);
-      expect(
-        destacadas.where((e) => e.uuid == ultima.uuid).length,
-        1,
-        reason: 'la última escuchada no puede aparecer dos veces',
-      );
-      expect(destacadas.length, emisorasDestacadas.length + 1);
-    });
-
-    test('la última escuchada YA curada no añade una segunda fila', () async {
-      final yaCurada = emisorasDestacadas.first;
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora: jsonEncode(yaCurada.toMap()),
-      });
-
-      final destacadas = await resolverEmisorasDestacadas();
-
-      expect(destacadas.first.uuid, yaCurada.uuid);
-      expect(destacadas.length, emisorasDestacadas.length);
-    });
-
-    test('ultima_emisora_v1 corrupta degrada al set curado, nunca lanza',
-        () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora: 'no-es-json{{',
-      });
-
-      final destacadas = await resolverEmisorasDestacadas();
-
-      expect(destacadas.length, emisorasDestacadas.length);
-    });
-  });
-
-  group('esEmisoraGratuitaPorUuid', () {
-    test('un uuid curado es gratuito', () async {
-      SharedPreferences.setMockInitialValues({});
-
-      expect(
-        await esEmisoraGratuitaPorUuid(emisorasDestacadas.first.uuid),
-        isTrue,
-      );
-    });
-
-    test('la última escuchada es gratuita aunque no esté curada', () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora: jsonEncode(ultima.toMap()),
-      });
-
-      expect(await esEmisoraGratuitaPorUuid(ultima.uuid), isTrue);
-    });
-
-    test('un uuid del catálogo Radio Browser NO es gratuito', () async {
-      SharedPreferences.setMockInitialValues({});
-
-      expect(await esEmisoraGratuitaPorUuid('uuid-del-catalogo'), isFalse);
-    });
-
-    test('uuid vacío nunca es gratuito', () async {
-      SharedPreferences.setMockInitialValues({});
-
-      expect(await esEmisoraGratuitaPorUuid(''), isFalse);
-    });
-  });
-
-  test('claveUltimaEmisora coincide con la que persiste EstadoRadio', () {
-    expect(claveUltimaEmisora, 'ultima_emisora_v1');
-  });
-}

test/servicios/musica_local_auto_prefs_test.dart

@@ -1,54 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/servicios/musica_local_auto.dart';
-
-/// `FuenteMusicaLocalAuto.estadoCarpeta` promises, in its own interface doc,
-/// «Never throws: cualquier fallo degrada a un valor de
-/// [EstadoCarpetaLocal], nunca a una excepción». The refactor to the
-/// three-valued enum moved `await _uriPersistida()` OUTSIDE the try/catch,
-/// so a SharedPreferences failure escaped again — and the only caller,
-/// `PluriWaveAudioHandler.getChildren`'s root branch, awaits it inline, so
-/// the throw takes the whole browse root down and empties the car.
-///
-/// DELIBERATE FILE SEPARATION: nothing here may call
-/// `SharedPreferences.setMockInitialValues`. That call swaps
-/// `SharedPreferencesStorePlatform.instance` for an in-memory store for the
-/// rest of the isolate, and an in-memory store cannot fail. Left alone, the
-/// default store answers a real `getAll` platform call that nothing handles
-/// under `flutter test`, which is exactly the failure being exercised —
-/// hence its own file, not a group inside `musica_local_auto_test.dart`.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  group('FuenteMusicaLocalAutoImpl.estadoCarpeta — fallo de prefs', () {
-    test('un fallo leyendo SharedPreferences degrada a noConfigurada en vez '
-        'de propagar y vaciar la raíz del coche', () async {
-      // Sin prefs inyectadas: `_resolverPrefs` cae en
-      // `SharedPreferences.getInstance()`, que aquí lanza.
-      final fuente = FuenteMusicaLocalAutoImpl();
-
-      await expectLater(
-        fuente.estadoCarpeta(),
-        completion(EstadoCarpetaLocal.noConfigurada),
-      );
-    });
-
-    test('ese fallo NO se reporta como canalNoDisponible, que es la única '
-        'respuesta que significa «hay carpeta pero no puedo comprobar el '
-        'permiso»', () async {
-      final fuente = FuenteMusicaLocalAutoImpl();
-
-      final estado = await fuente.estadoCarpeta();
-
-      expect(
-        estado,
-        isNot(EstadoCarpetaLocal.canalNoDisponible),
-        reason:
-            'el fallo de prefs es una MissingPluginException igual que la '
-            'del canal `pluriwave/file_actions`, así que un único try que '
-            'las capturase juntas borraría la distinción de 3 valores: el '
-            'árbol mostraría «Música Local» con un subárbol que explica un '
-            'problema de canal inexistente',
-      );
-    });
-  });
-}

test/servicios/musica_local_auto_test.dart

@@ -163,132 +163,6 @@ void main() {
       },
     );
   });
-  /// fix/android-auto-musica-local — «Muchísimas veces (la mayoría) no
-  /// aparece la opción de reproducir música local, no aparece ni el menú».
-  ///
-  /// El usuario TIENE la compra PRO, así que no es un problema de
-  /// entitlement. La causa real: `hasPersistedPermission` viaja por
-  /// `MethodChannel('pluriwave/file_actions')`, cuyo ÚNICO registro de
-  /// handler vive en `MainActivity.configureFlutterEngine`. Cuando Android
-  /// Auto levanta el MediaBrowserService sin que la app se haya abierto,
-  /// `audio_service` construye un FlutterEngine SIN Activity, ese método
-  /// nunca corre, el canal se queda sin handler y `invokeMethod` lanza
-  /// `MissingPluginException` — indistinguible hasta ahora de «permiso
-  /// revocado».
-  ///
-  /// Estos tests fijan la distinción: «el canal no está disponible» NO es
-  /// «no hay carpeta».
-  group('FuenteMusicaLocalAutoImpl.estadoCarpeta', () {
-    const canal = MethodChannel('pluriwave/file_actions');
-
-    tearDown(() {
-      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-          .setMockMethodCallHandler(canal, null);
-    });
-
-    test(
-      'con URI persistida y SIN handler nativo (motor headless de Android '
-      'Auto) reporta canalNoDisponible, no noConfigurada',
-      () async {
-        SharedPreferences.setMockInitialValues({
-          'musica_local_uri': 'content://tree/x',
-        });
-        // Sin handler: `invokeMethod` lanza MissingPluginException, que es
-        // exactamente lo que pasa en el motor sin Activity.
-        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(canal, null);
-
-        final fuente = FuenteMusicaLocalAutoImpl(
-          prefs: await SharedPreferences.getInstance(),
-        );
-
-        expect(
-          await fuente.estadoCarpeta(),
-          EstadoCarpetaLocal.canalNoDisponible,
-        );
-      },
-    );
-
-    test(
-      'con URI persistida y handler nativo que responde false (permiso '
-      'revocado de verdad) reporta noConfigurada',
-      () async {
-        SharedPreferences.setMockInitialValues({
-          'musica_local_uri': 'content://tree/x',
-        });
-        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(canal, (call) async {
-          expect(call.method, 'hasPersistedPermission');
-          return false;
-        });
-
-        final fuente = FuenteMusicaLocalAutoImpl(
-          prefs: await SharedPreferences.getInstance(),
-        );
-
-        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
-      },
-    );
-
-    test(
-      'con URI persistida y handler nativo que responde true reporta '
-      'configurada',
-      () async {
-        SharedPreferences.setMockInitialValues({
-          'musica_local_uri': 'content://tree/x',
-        });
-        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(canal, (call) async => true);
-
-        final fuente = FuenteMusicaLocalAutoImpl(
-          prefs: await SharedPreferences.getInstance(),
-        );
-
-        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.configurada);
-      },
-    );
-
-    test(
-      'sin URI persistida reporta noConfigurada sin invocar el canal',
-      () async {
-        SharedPreferences.setMockInitialValues({});
-        var llamadas = 0;
-        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(canal, (call) async {
-          llamadas++;
-          return true;
-        });
-
-        final fuente = FuenteMusicaLocalAutoImpl(
-          prefs: await SharedPreferences.getInstance(),
-        );
-
-        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
-        expect(llamadas, 0);
-      },
-    );
-
-    test(
-      'un PlatformException del canal (el handler SÍ existe, la llamada '
-      'falla) reporta noConfigurada, no canalNoDisponible',
-      () async {
-        SharedPreferences.setMockInitialValues({
-          'musica_local_uri': 'content://tree/x',
-        });
-        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(canal, (call) async {
-          throw PlatformException(code: 'ERROR');
-        });
-
-        final fuente = FuenteMusicaLocalAutoImpl(
-          prefs: await SharedPreferences.getInstance(),
-        );
-
-        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
-      },
-    );
-  });
-
   group('esArchivoAudio', () {
     test('acepta cualquier MIME audio/*, en cualquier capitalización', () {
       expect(esArchivoAudio('audio/mpeg', 'cancion.mp3'), isTrue);

test/servicios/navegacion_auto_destacadas_test.dart

@@ -1,267 +0,0 @@
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
-import 'package:pluriwave/servicios/navegacion_auto.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-/// Free-tier Android Auto surface (fix/auto-quality-guidelines, items 7, 8
-/// and 10).
-///
-/// Google Play returned "Approved with Issues" against the Android for Cars
-/// App Quality Guidelines on version code 157. The free root advertised four
-/// folders that each dead-ended on a single non-playable "Función Premium"
-/// row, and on a cold headless bind every one of the underlying lists is
-/// empty anyway. This suite pins the replacement: ONE browsable folder that
-/// resolves to real, playable stations.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  group('FuenteEmisorasAutoLocal.porUuid — item 7', () {
-    // Cold bind shape: `todas()` is `_snapshotTodas ?? const []`, no
-    // favourites (sqflite is not initialised under `flutter test`, so the
-    // read throws and degrades to `[]`), and a custom-stations path that
-    // does not exist.
-    FuenteEmisorasAutoLocal fuenteFria() => FuenteEmisorasAutoLocal(
-      resolverRutaCustom: () async => 'no/existe/emisoras_custom.json',
-    );
-
-    setUp(() => SharedPreferences.setMockInitialValues({}));
-
-    test('en frío resuelve un uuid destacado (antes devolvía null y la fila '
-        'no hacía nada al tocarla)', () async {
-      final fuente = fuenteFria();
-
-      final resuelta = await fuente.porUuid(emisorasDestacadas.first.uuid);
-
-      expect(resuelta, isNotNull);
-      expect(resuelta!.url, emisorasDestacadas.first.url);
-    });
-
-    test('en frío resuelve la última escuchada persistida', () async {
-      const ultima = Emisora(
-        uuid: 'uuid-ultima',
-        nombre: 'Ultima',
-        url: 'https://ultima.example/stream',
-      );
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora:
-            '{"uuid":"uuid-ultima","nombre":"Ultima",'
-            '"url":"https://ultima.example/stream"}',
-      });
-
-      final resuelta = await fuenteFria().porUuid(ultima.uuid);
-
-      expect(resuelta?.url, ultima.url);
-    });
-
-    test('un uuid desconocido sigue devolviendo null', () async {
-      expect(await fuenteFria().porUuid('uuid-inexistente'), isNull);
-    });
-
-    test('el snapshot vivo gana al set destacado para el MISMO uuid',
-        () async {
-      final fuente = fuenteFria();
-      final delCatalogo = Emisora(
-        uuid: emisorasDestacadas.first.uuid,
-        nombre: 'Version viva',
-        url: 'https://viva.example/stream',
-      );
-      fuente.actualizarSnapshot(todas: [delCatalogo]);
-
-      final resuelta = await fuente.porUuid(delCatalogo.uuid);
-
-      expect(resuelta?.url, 'https://viva.example/stream');
-    });
-  });
-
-  group('raiz(premium:) — item 8', () {
-    test('free: exactamente UNA carpeta navegable, y ninguna de las cuatro '
-        'que morían en la fila premium', () {
-      final constructor = ConstructorArbolAuto();
-
-      // `incluirMusicaLocal: true` a propósito: ni siquiera con carpeta
-      // local configurada puede el tier gratuito ver ese nodo.
-      final libre = constructor.raiz(incluirMusicaLocal: true, premium: false);
-
-      expect(libre, hasLength(1));
-      expect(libre.single.id, ConstructorArbolAuto.idDestacadas);
-      expect(libre.single.playable, isFalse);
-      expect(libre.single.title, isNotEmpty);
-      expect(
-        libre.map((m) => m.id),
-        isNot(
-          anyOf(
-            contains(ConstructorArbolAuto.idFavoritos),
-            contains(ConstructorArbolAuto.idTodas),
-            contains(ConstructorArbolAuto.idMisEmisoras),
-            contains(ConstructorArbolAuto.idMusicaLocal),
-          ),
-        ),
-      );
-    });
-
-    test('premium: el árbol de hoy, sin cambios (guardia de regresión)', () {
-      final constructor = ConstructorArbolAuto();
-
-      expect(
-        constructor
-            .raiz(incluirMusicaLocal: true, premium: true)
-            .map((m) => m.id),
-        [
-          ConstructorArbolAuto.idFavoritos,
-          ConstructorArbolAuto.idTodas,
-          ConstructorArbolAuto.idMisEmisoras,
-          ConstructorArbolAuto.idMusicaLocal,
-        ],
-      );
-      expect(
-        constructor
-            .raiz(incluirMusicaLocal: false, premium: true)
-            .map((m) => m.id),
-        [
-          ConstructorArbolAuto.idFavoritos,
-          ConstructorArbolAuto.idTodas,
-          ConstructorArbolAuto.idMisEmisoras,
-        ],
-      );
-      expect(
-        constructor
-            .raiz(incluirMusicaLocal: true, premium: true)
-            .every((m) => m.playable == false),
-        isTrue,
-      );
-    });
-
-    test('la raíz del tier gratuito SIEMPRE lleva una carpeta navegable: '
-        'audio_service 0.18.18 descarta los rootHints, así que un root de '
-        'un solo item PLAYABLE se renderiza vacío en una unidad que solo '
-        'acepta FLAG_BROWSABLE', () {
-      final libre = ConstructorArbolAuto().raiz(
-        incluirMusicaLocal: false,
-        premium: false,
-      );
-
-      expect(libre.any((m) => m.playable == false), isTrue);
-    });
-
-    test('el titulo de la unica carpeta gratuita lo decide el LLAMANTE, no '
-        'una constante castellana de este archivo (hallazgo 4)', () {
-      final libre = ConstructorArbolAuto().raiz(
-        incluirMusicaLocal: false,
-        premium: false,
-        tituloDestacadas: 'Listen',
-      );
-
-      expect(
-        libre.single.title,
-        'Listen',
-        reason:
-            'this one label is 100% of the browse tree a free-tier (i.e. '
-            'every Play reviewer) driver ever sees; the pure builder stays '
-            'AppLocalizations-free, so the handler has to hand it the string',
-      );
-    });
-  });
-
-  group('hijosDestacadas — item 8/9', () {
-    test('mapea a items PLAYABLE con id emisora:<uuid>', () {
-      final items = ConstructorArbolAuto().hijosDestacadas(emisorasDestacadas);
-
-      expect(items, hasLength(emisorasDestacadas.length));
-      expect(items.every((m) => m.playable == true), isTrue);
-      expect(items.first.id, 'emisora:${emisorasDestacadas.first.uuid}');
-      expect(items.every((m) => m.artUri != null), isTrue);
-    });
-
-    test('lista vacía devuelve lista vacía, nunca lanza', () {
-      expect(ConstructorArbolAuto().hijosDestacadas(const []), isEmpty);
-    });
-  });
-
-  group('respuestaBloqueadaPorEntitlement — item 10', () {
-    List<MediaItem>? gate(String id, {required bool premium}) =>
-        respuestaBloqueadaPorEntitlement(
-          parentMediaId: id,
-          premium: premium,
-          destacadas: emisorasDestacadas,
-        );
-
-    test('premium: nada se bloquea', () {
-      for (final id in [
-        AudioService.browsableRootId,
-        ConstructorArbolAuto.idFavoritos,
-        ConstructorArbolAuto.idTodas,
-        ConstructorArbolAuto.idMisEmisoras,
-        ConstructorArbolAuto.idMusicaLocal,
-        ConstructorArbolAuto.idDestacadas,
-        'emisora:uuid-del-catalogo',
-      ]) {
-        expect(gate(id, premium: true), isNull, reason: id);
-      }
-    });
-
-    test('free: la raíz y el contenido gratuito PASAN', () {
-      expect(gate(AudioService.browsableRootId, premium: false), isNull);
-      expect(gate(ConstructorArbolAuto.idDestacadas, premium: false), isNull);
-      for (final e in emisorasDestacadas) {
-        expect(gate('emisora:${e.uuid}', premium: false), isNull);
-      }
-    });
-
-    test('free: el catálogo premium se bloquea', () {
-      for (final id in [
-        ConstructorArbolAuto.idTodas,
-        ConstructorArbolAuto.idMisEmisoras,
-        ConstructorArbolAuto.idMusicaLocal,
-        ConstructorArbolAuto.idFavoritos,
-        ConstructorArbolAuto.idEcualizador,
-        'grupo:algo',
-        'emisora:uuid-del-catalogo',
-        'pista:doc-id',
-      ]) {
-        expect(gate(id, premium: false), isNotNull, reason: id);
-      }
-    });
-
-    test('la rama bloqueada devuelve el contenido gratuito, NUNCA una fila '
-        'no reproducible: eso es exactamente lo que Play citó', () {
-      final bloqueada = gate(ConstructorArbolAuto.idTodas, premium: false);
-
-      expect(bloqueada, isNotNull);
-      expect(bloqueada, isNotEmpty);
-      expect(
-        bloqueada!.every((m) => m.playable == true),
-        isTrue,
-        reason: 'una fila no reproducible en el árbol es la cita de Play',
-      );
-      expect(bloqueada.map((m) => m.id), [
-        for (final e in emisorasDestacadas) 'emisora:${e.uuid}',
-      ]);
-    });
-
-    test('sin destacadas resolubles la rama bloqueada sigue sin inventar una '
-        'fila muerta', () {
-      final bloqueada = respuestaBloqueadaPorEntitlement(
-        parentMediaId: ConstructorArbolAuto.idTodas,
-        premium: false,
-        destacadas: const [],
-      );
-
-      expect(bloqueada, isEmpty);
-    });
-  });
-
-  test('idPremiumInfo / itemPremiumBloqueado ya no existen — item 10', () {
-    // Guardia estructural: si alguien los reintroduce, este archivo deja de
-    // compilar por el `expect` de abajo, no por un comentario. La única
-    // prueba real es que `ConstructorArbolAuto` no expone ningún item no
-    // reproducible fuera de las carpetas.
-    final libre = ConstructorArbolAuto().raiz(
-      incluirMusicaLocal: true,
-      premium: false,
-    );
-
-    expect(libre.every((m) => m.id != 'premium:info'), isTrue);
-  });
-}

test/servicios/navegacion_auto_gating_test.dart

@@ -1,142 +1,106 @@
 import 'package:audio_service/audio_service.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/modelos/emisora.dart';
 import 'package:pluriwave/servicios/navegacion_auto.dart';
 
-/// Android Auto entitlement gating — the id-shape matrix.
-///
-/// REWRITTEN for fix/auto-quality-guidelines item 10. This suite used to
-/// assert the opposite design: that every non-root id, for a free-tier user,
-/// collapsed to a single non-playable `premium:info` row. Google Play cited
-/// that browse tree against the Android for Cars App Quality Guidelines, so
-/// the contract is now content-scoping — the free tier sees LESS, never a
-/// row that does nothing.
-///
-/// [respuestaBloqueadaPorEntitlement]'s return VALUE is covered in
-/// `navegacion_auto_destacadas_test.dart`; this file pins the decision
-/// surface ([idPermitidoEnFree]) across every id shape the tree can produce,
-/// including the stale/deep-linked ones a head unit's cached tree replays.
+/// Android Auto entitlement gating (android-auto-media spec "Free-Tier
+/// Reduced Root Browse" + "Free-Tier Browse Never Leaks Real Content",
+/// design.md ADR-4). All pure — no handler instantiation needed
+/// (`PluriWaveAudioHandler` cannot be constructed in a unit test).
 void main() {
-  const gratuitas = [
-    Emisora(uuid: 'libre-1', nombre: 'Libre 1', url: 'https://libre1.example'),
-    Emisora(uuid: 'libre-2', nombre: 'Libre 2', url: 'https://libre2.example'),
-  ];
+  group('raiz(premium:) — root keeps its labels for every tier', () {
+    test('premium: identical to today\'s tree (regression guard)', () {
+      final constructor = ConstructorArbolAuto();
 
-  group('idPermitidoEnFree', () {
-    test('la raíz siempre pasa: es lo único que decide qué ve el tier', () {
-      expect(
-        idPermitidoEnFree(
-          AudioService.browsableRootId,
-          destacadas: gratuitas,
-        ),
-        isTrue,
+      final premiumConLocal = constructor.raiz(
+        incluirMusicaLocal: true,
+        premium: true,
       );
-    });
-
-    test('la carpeta gratuita pasa', () {
-      expect(
-        idPermitidoEnFree(
-          ConstructorArbolAuto.idDestacadas,
-          destacadas: gratuitas,
-        ),
-        isTrue,
+      final premiumSinLocal = constructor.raiz(
+        incluirMusicaLocal: false,
+        premium: true,
       );
+
+      expect(premiumConLocal.map((m) => m.id), [
+        ConstructorArbolAuto.idFavoritos,
+        ConstructorArbolAuto.idTodas,
+        ConstructorArbolAuto.idMisEmisoras,
+        ConstructorArbolAuto.idMusicaLocal,
+      ]);
+      expect(premiumConLocal.every((m) => m.playable == false), isTrue);
+      expect(premiumConLocal.every((m) => m.displaySubtitle == null), isTrue);
+      expect(premiumSinLocal.map((m) => m.id), [
+        ConstructorArbolAuto.idFavoritos,
+        ConstructorArbolAuto.idTodas,
+        ConstructorArbolAuto.idMisEmisoras,
+      ]);
     });
 
-    test('un emisora:<uuid> del set gratuito pasa', () {
-      for (final e in gratuitas) {
-        expect(
-          idPermitidoEnFree('emisora:${e.uuid}', destacadas: gratuitas),
-          isTrue,
-          reason: e.uuid,
-        );
-      }
+    test('free: same folder ids/titles, non-blank, never playable', () {
+      final constructor = ConstructorArbolAuto();
+
+      final libre = constructor.raiz(incluirMusicaLocal: true, premium: false);
+
+      expect(libre, isNotEmpty);
+      expect(libre.map((m) => m.id), [
+        ConstructorArbolAuto.idFavoritos,
+        ConstructorArbolAuto.idTodas,
+        ConstructorArbolAuto.idMisEmisoras,
+        ConstructorArbolAuto.idMusicaLocal,
+      ]);
+      expect(libre.every((m) => m.playable == false), isTrue);
+    });
+  });
+
+  test(
+    'itemPremiumBloqueado(): id fijo, no reproducible, etiqueta premium',
+    () {
+      final item = ConstructorArbolAuto().itemPremiumBloqueado();
+
+      expect(item.id, 'premium:info');
+      expect(item.playable, isFalse);
+      expect(item.title, isNotEmpty);
+    },
+  );
+
+  group('respuestaBloqueadaPorEntitlement — backstop de navegacion', () {
+    test('root nunca es bloqueada (root siempre resuelve via raiz)', () {
+      final respuesta = respuestaBloqueadaPorEntitlement(
+        parentMediaId: AudioService.browsableRootId,
+        premium: false,
+      );
+
+      expect(respuesta, isNull);
     });
 
-    test('las carpetas premium NO pasan', () {
+    test('cualquier id no-root, en free, retorna SOLO el item bloqueado', () {
       for (final id in [
         ConstructorArbolAuto.idFavoritos,
         ConstructorArbolAuto.idTodas,
         ConstructorArbolAuto.idMisEmisoras,
         ConstructorArbolAuto.idMusicaLocal,
         ConstructorArbolAuto.idEcualizador,
+        // Stale/deep-linked id from before a downgrade — the backstop must
+        // not special-case known ids (Spec "Stale folder id bypass
+        // attempt").
+        'emisora:algun-uuid-viejo',
+        'grupo:algo',
       ]) {
-        expect(idPermitidoEnFree(id, destacadas: gratuitas), isFalse,
-            reason: id);
-      }
-    });
-
-    test('un id rancio/deep-link de antes de una bajada de tier NO pasa: '
-        'ésa es la propiedad de seguridad que el rediseño tenía que '
-        'conservar', () {
-      for (final id in [
-        'emisora:uuid-del-catalogo',
-        'grupo:algun-grupo',
-        'pista:doc-id',
-        'carpeta_local:doc-id',
-        'carpeta_local_reproducir:doc-id',
-        'carpeta_local_aleatorio:doc-id',
-        'eq_preset:Rock',
-        'premium:info', // la fila muerta que ya no existe
-        '',
-      ]) {
-        expect(idPermitidoEnFree(id, destacadas: gratuitas), isFalse,
-            reason: id);
-      }
-    });
-
-    test('emisora: con uuid vacío NO pasa (id malformado, no comodín)', () {
-      expect(idPermitidoEnFree('emisora:', destacadas: gratuitas), isFalse);
-    });
-
-    test('con el set gratuito vacío solo pasan la raíz y su carpeta', () {
-      expect(
-        idPermitidoEnFree(AudioService.browsableRootId, destacadas: const []),
-        isTrue,
-      );
-      expect(
-        idPermitidoEnFree(
-          ConstructorArbolAuto.idDestacadas,
-          destacadas: const [],
-        ),
-        isTrue,
-      );
-      expect(
-        idPermitidoEnFree('emisora:libre-1', destacadas: const []),
-        isFalse,
-      );
-    });
-  });
-
-  group('respuestaBloqueadaPorEntitlement', () {
-    test('premium: ningún id se bloquea, ni siquiera uno inventado', () {
-      for (final id in [
-        AudioService.browsableRootId,
-        ConstructorArbolAuto.idTodas,
-        'emisora:cualquier-cosa',
-        'basura',
-      ]) {
-        expect(
-          respuestaBloqueadaPorEntitlement(
-            parentMediaId: id,
-            premium: true,
-            destacadas: gratuitas,
-          ),
-          isNull,
-          reason: id,
+        final respuesta = respuestaBloqueadaPorEntitlement(
+          parentMediaId: id,
+          premium: false,
         );
+        expect(respuesta, hasLength(1));
+        expect(respuesta!.single.id, 'premium:info');
       }
     });
 
-    test('free: lo bloqueado NUNCA incluye un item no reproducible', () {
-      final bloqueada = respuestaBloqueadaPorEntitlement(
-        parentMediaId: ConstructorArbolAuto.idMisEmisoras,
-        premium: false,
-        destacadas: gratuitas,
+    test('cualquier id no-root, en premium, no es bloqueada', () {
+      final respuesta = respuestaBloqueadaPorEntitlement(
+        parentMediaId: ConstructorArbolAuto.idFavoritos,
+        premium: true,
       );
 
-      expect(bloqueada, isNotNull);
-      expect(bloqueada!.every((m) => m.playable == true), isTrue);
+      expect(respuesta, isNull);
     });
   });
 }

test/servicios/navegacion_auto_localizacion_test.dart

@@ -1,221 +0,0 @@
-import 'dart:ui' show Locale;
-
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/l10n/gen/app_localizations.dart';
-import 'package:pluriwave/modelos/pista_local.dart';
-import 'package:pluriwave/servicios/musica_local_auto.dart';
-import 'package:pluriwave/servicios/navegacion_auto.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-/// Every user-readable label of the Android Auto browse tree is translated.
-///
-/// The owner's rule, after Play saw a Spanish-only car tree on a head unit
-/// in any of the 13 shipped locales: anything a user can read gets
-/// translated. The two ARB guards (`arb_parity_test`/`arb_anti_copy_test`)
-/// only ever see strings that already entered the ARB system, so neither
-/// could catch a label hardcoded in `navegacion_auto.dart` that never
-/// became a key. This file closes that hole from the CONSUMPTION side
-/// (the tree really renders the injected locale);
-/// `test/l10n/etiquetas_arbol_auto_test.dart` closes it from the SOURCE
-/// side (no new hardcoded label can be added at all).
-Future<Map<String, MetadatosPista>> _sinMetadatos(List<String> ids) async =>
-    const {};
-
-List<NodoLocal> _pistas(int cuantas, {String prefijo = 'cancion'}) =>
-    List.generate(
-      cuantas,
-      (i) => NodoLocal(
-        documentId: 'doc-$prefijo-$i',
-        nombre: '${prefijo}_${i.toString().padLeft(3, '0')}.mp3',
-        esDirectorio: false,
-      ),
-    );
-
-void main() {
-  final ingles = lookupAppLocalizations(const Locale('en'));
-
-  group('EtiquetasArbolAuto desde AppLocalizations', () {
-    test('mapea cada etiqueta del árbol a su clave ARB del locale', () {
-      final etiquetas = etiquetasArbolAutoDesde(ingles);
-
-      expect(etiquetas.escuchar, ingles.autoCarpetaEscuchar);
-      expect(etiquetas.favoritos, ingles.autoCarpetaFavoritos);
-      expect(etiquetas.todasLasEmisoras, ingles.autoCarpetaTodas);
-      expect(etiquetas.misEmisoras, ingles.autoCarpetaMisEmisoras);
-      expect(etiquetas.musicaLocal, ingles.autoCarpetaMusicaLocal);
-      expect(
-        etiquetas.musicaLocalNoDisponible,
-        ingles.autoMusicaLocalNoDisponible,
-      );
-      expect(etiquetas.cargarMas, ingles.autoCargarMas);
-      expect(etiquetas.ordenarPorCalidad, ingles.autoOrdenarPorCalidad);
-      expect(etiquetas.reproducirCarpeta, ingles.autoReproducirCarpeta);
-      expect(etiquetas.reproducirAleatorio, ingles.autoReproducirAleatorio);
-      expect(etiquetas.pistaSinNombre, ingles.autoPistaSinNombre);
-    });
-
-    test('ninguna etiqueta inglesa cae en el castellano de respaldo', () {
-      final etiquetas = etiquetasArbolAutoDesde(ingles);
-      const respaldo = EtiquetasArbolAuto.respaldo;
-
-      expect(etiquetas.favoritos, isNot(respaldo.favoritos));
-      expect(etiquetas.todasLasEmisoras, isNot(respaldo.todasLasEmisoras));
-      expect(etiquetas.misEmisoras, isNot(respaldo.misEmisoras));
-      expect(etiquetas.musicaLocal, isNot(respaldo.musicaLocal));
-      expect(
-        etiquetas.musicaLocalNoDisponible,
-        isNot(respaldo.musicaLocalNoDisponible),
-      );
-      expect(etiquetas.cargarMas, isNot(respaldo.cargarMas));
-      expect(etiquetas.ordenarPorCalidad, isNot(respaldo.ordenarPorCalidad));
-      expect(etiquetas.reproducirCarpeta, isNot(respaldo.reproducirCarpeta));
-      expect(etiquetas.reproducirAleatorio, isNot(respaldo.reproducirAleatorio));
-      expect(etiquetas.pistaSinNombre, isNot(respaldo.pistaSinNombre));
-    });
-  });
-
-  group('ConstructorArbolAuto rotula con las etiquetas inyectadas', () {
-    final constructor = ConstructorArbolAuto(
-      etiquetas: etiquetasArbolAutoDesde(ingles),
-    );
-
-    test('la raíz premium rotula sus cuatro carpetas en el locale', () {
-      final raiz = constructor.raiz(incluirMusicaLocal: true, premium: true);
-
-      expect(raiz.map((i) => i.title).toList(), [
-        ingles.autoCarpetaFavoritos,
-        ingles.autoCarpetaTodas,
-        ingles.autoCarpetaMisEmisoras,
-        ingles.autoCarpetaMusicaLocal,
-      ]);
-    });
-
-    test('la raíz gratuita sigue rotulando Escuchar en el locale', () {
-      final raiz = constructor.raiz(incluirMusicaLocal: false, premium: false);
-
-      expect(raiz.single.title, ingles.autoCarpetaEscuchar);
-    });
-
-    test('el item de música local no disponible va en el locale', () {
-      expect(
-        constructor.itemLocalNoDisponible().title,
-        ingles.autoMusicaLocalNoDisponible,
-      );
-    });
-
-    test('las acciones de carpeta y la entrada de orden van en el '
-        'locale', () async {
-      final items = await constructor.itemsLocales(
-        _pistas(3),
-        documentIdPadre: 'padre',
-        metadatosDe: _sinMetadatos,
-      );
-
-      final titulos = items.map((i) => i.title).toList();
-      expect(titulos, contains(ingles.autoReproducirCarpeta));
-      expect(titulos, contains(ingles.autoReproducirAleatorio));
-      expect(titulos, contains(ingles.autoOrdenarPorCalidad));
-    });
-
-    test('el item "cargar más" de las tres vistas paginadas va en el '
-        'locale', () async {
-      final nodos = _pistas(60);
-
-      final porNombre = await constructor.itemsLocales(
-        nodos,
-        documentIdPadre: 'padre',
-        metadatosDe: _sinMetadatos,
-      );
-      final porCalidad = await constructor.itemsLocalesOrdenCalidad(
-        nodos,
-        documentIdPadre: 'padre',
-        metadatosDe: _sinMetadatos,
-      );
-      final porBucket = await constructor.itemsLocalesBucket(
-        _pistas(60, prefijo: 'apple'),
-        documentIdPadre: 'padre',
-        idxBucket: 0,
-        metadatosDe: _sinMetadatos,
-      );
-
-      expect(porNombre.last.title, ingles.autoCargarMas);
-      expect(porCalidad.last.title, ingles.autoCargarMas);
-      expect(porBucket.last.title, ingles.autoCargarMas);
-    });
-
-    test('un nombre de fichero en blanco cae en la pista sin nombre del '
-        'locale', () async {
-      final items = await constructor.itemsLocales(
-        const [
-          NodoLocal(
-            documentId: 'doc-vacio',
-            nombre: '   ',
-            esDirectorio: false,
-          ),
-        ],
-        documentIdPadre: 'padre',
-        metadatosDe: _sinMetadatos,
-      );
-
-      final pista = items.singleWhere((i) => i.id.startsWith('pista:'));
-      expect(pista.title, ingles.autoPistaSinNombre);
-    });
-
-    test('los rangos alfabéticos NO se traducen: son rangos de letras '
-        'latinas, no prosa', () async {
-      final items = await constructor.itemsLocales(
-        _pistas(60),
-        documentIdPadre: 'padre',
-        metadatosDe: _sinMetadatos,
-      );
-
-      expect(items.map((i) => i.title), containsAll(['A-F', 'G-M']));
-    });
-  });
-
-  group('hijosMusicaLocal propaga las etiquetas', () {
-    test('la carpeta raíz local rotula sus acciones en el locale', () async {
-      final items = await hijosMusicaLocal(
-        ConstructorArbolAuto.idMusicaLocal,
-        fuente: _FuenteLocalFalsa(),
-        etiquetas: etiquetasArbolAutoDesde(ingles),
-      );
-
-      expect(
-        items!.map((i) => i.title),
-        containsAll([
-          ingles.autoReproducirCarpeta,
-          ingles.autoReproducirAleatorio,
-        ]),
-      );
-    });
-  });
-}
-
-/// Minimal in-memory [FuenteMusicaLocalAuto]: one playable track at the
-/// tree root, no metadata, native channel available.
-class _FuenteLocalFalsa implements FuenteMusicaLocalAuto {
-  @override
-  Future<EstadoCarpetaLocal> estadoCarpeta() async =>
-      EstadoCarpetaLocal.configurada;
-
-  @override
-  Future<List<NodoLocal>> hijos(String documentId) async =>
-      documentId.isEmpty
-          ? const [
-            NodoLocal(
-              documentId: 'doc-0',
-              nombre: 'cancion.mp3',
-              esDirectorio: false,
-            ),
-          ]
-          : const [];
-
-  @override
-  Future<Map<String, MetadatosPista>> metadatosDe(List<String> documentIds) =>
-      _sinMetadatos(documentIds);
-
-  @override
-  Future<String?> uriContenidoDePista(String documentId) async =>
-      'content://fake/$documentId';
-}

test/servicios/navegacion_auto_test.dart

@@ -2130,74 +2130,6 @@ void main() {
       expect(await hijosMusicaLocal('grupo:g1', fuente: fuente), isNull);
     });
 
-    /// fix/android-auto-musica-local: la raíz ya no oculta el nodo cuando
-    /// el canal nativo no está disponible, así que el subárbol tiene que
-    /// EXPLICAR el problema en vez de abrirse vacío (una carpeta vacía se
-    /// lee como «no tengo música», que es justo la conclusión equivocada).
-    ///
-    /// La etiqueta sale de `EtiquetasArbolAuto.musicaLocalNoDisponible`,
-    /// como TODAS las etiquetas legibles del árbol del coche: todo lo que
-    /// un usuario lee se traduce. Este test solo comprueba que hay UNA
-    /// etiqueta no vacía; el idioma concreto lo cubre
-    /// `navegacion_auto_localizacion_test.dart`.
-    test('canalNoDisponible y carpeta vacía: la raíz local devuelve un item '
-        'explicativo NO reproducible, no una carpeta vacía', () async {
-      final fuente = _FakeFuenteMusicaLocalAuto(
-        estado: EstadoCarpetaLocal.canalNoDisponible,
-      );
-
-      final items = await hijosMusicaLocal(
-        ConstructorArbolAuto.idMusicaLocal,
-        fuente: fuente,
-      );
-
-      expect(items, isNotNull);
-      expect(items!.map((i) => i.id), [ConstructorArbolAuto.idLocalNoLista]);
-      expect(items.single.playable, isFalse);
-      expect(items.single.title, isNotEmpty);
-    });
-
-    test('canalNoDisponible pero CON pistas resueltas: no se entromete, se '
-        'listan las pistas normalmente', () async {
-      final fuente = _FakeFuenteMusicaLocalAuto(
-        estado: EstadoCarpetaLocal.canalNoDisponible,
-        hijosPorDocId: {
-          '': const [
-            NodoLocal(
-              documentId: 'd1',
-              nombre: 'Cancion.mp3',
-              esDirectorio: false,
-            ),
-          ],
-        },
-      );
-
-      final items = await hijosMusicaLocal(
-        ConstructorArbolAuto.idMusicaLocal,
-        fuente: fuente,
-      );
-
-      expect(items, isNotNull);
-      expect(
-        items!.map((i) => i.id),
-        isNot(contains(ConstructorArbolAuto.idLocalNoLista)),
-      );
-      expect(items.any((i) => i.id == 'pista:d1'), isTrue);
-    });
-
-    test('carpeta genuinamente vacía con el canal SÍ disponible: sigue '
-        'devolviendo lista vacía, sin item explicativo', () async {
-      final fuente = _FakeFuenteMusicaLocalAuto();
-
-      final items = await hijosMusicaLocal(
-        ConstructorArbolAuto.idMusicaLocal,
-        fuente: fuente,
-      );
-
-      expect(items, isNotNull);
-      expect(items, isEmpty);
-    });
-
     test('fuente null (cold-start, nunca registrada) devuelve lista vacía '
         'para un id de música local válido, no null y sin lanzar', () async {
       final resultado = await hijosMusicaLocal(
@@ -3698,7 +3630,7 @@ class _FakeFuenteEmisorasAuto implements FuenteEmisorasAuto {
 
 class _FakeFuenteMusicaLocalAuto implements FuenteMusicaLocalAuto {
   _FakeFuenteMusicaLocalAuto({
-    EstadoCarpetaLocal estado = EstadoCarpetaLocal.configurada,
+    bool configurada = true,
     Map<String, List<NodoLocal>>? hijosPorDocId,
     Map<String, String?>? uriPorDocId,
     Map<String, MetadatosPista>? metadatosPorDocId,
@@ -3706,7 +3638,7 @@ class _FakeFuenteMusicaLocalAuto implements FuenteMusicaLocalAuto {
     Object? errorEnUriContenido,
     Object? errorEnMetadatosDe,
     Set<String>? idsConErrorEnHijos,
-  }) : _estado = estado,
+  }) : _configurada = configurada,
        _hijosPorDocId = hijosPorDocId ?? const {},
        _uriPorDocId = uriPorDocId ?? const {},
        _metadatosPorDocId = metadatosPorDocId ?? const {},
@@ -3715,7 +3647,7 @@ class _FakeFuenteMusicaLocalAuto implements FuenteMusicaLocalAuto {
        _errorEnMetadatosDe = errorEnMetadatosDe,
        _idsConErrorEnHijos = idsConErrorEnHijos ?? const {};
 
-  final EstadoCarpetaLocal _estado;
+  final bool _configurada;
   final Map<String, List<NodoLocal>> _hijosPorDocId;
   final Map<String, String?> _uriPorDocId;
   final Map<String, MetadatosPista> _metadatosPorDocId;
@@ -3734,7 +3666,7 @@ class _FakeFuenteMusicaLocalAuto implements FuenteMusicaLocalAuto {
   final List<List<String>> llamadasMetadatosDe = [];
 
   @override
-  Future<EstadoCarpetaLocal> estadoCarpeta() async => _estado;
+  Future<bool> hayCarpetaConfigurada() async => _configurada;
 
   @override
   Future<List<NodoLocal>> hijos(String documentId) async {

test/servicios/servicio_audio_auto_free_test.dart

@@ -1,679 +0,0 @@
-import 'dart:async';
-import 'dart:ui' show Locale;
-
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart';
-import 'package:pluriwave/l10n/gen/app_localizations.dart';
-import 'package:pluriwave/modelos/pista_local.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
-import 'package:pluriwave/servicios/musica_local_auto.dart';
-import 'package:pluriwave/servicios/navegacion_auto.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// Free-tier Android Auto surface, handler side (fix/auto-quality-guidelines,
-/// items 9, 11, 12, 13, 14).
-///
-/// Every test here runs with `_fuenteNavegacionGlobal` NEVER registered —
-/// this file never calls `registrarFuenteNavegacion`. That is the exact bind
-/// a Play reviewer performs: Android Auto starts the headless engine, and
-/// until (and even after) `main.dart` wires its sources, the car's browse and
-/// play paths must produce real, playable content out of the binary alone.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  late _GuionReproductor guion;
-
-  setUp(() {
-    guion = _GuionReproductor();
-    PluriWaveAudioHandler.fabricaReproductorPrueba =
-        (pipeline, carga) => _ReproductorFalso(guion, pipeline, carga);
-    // Fresh install = free tier: `esPremiumPersistido` is
-    // `getBool('compra_premium_v1') ?? false`, and there is no trial key.
-    SharedPreferences.setMockInitialValues({});
-  });
-
-  tearDown(() {
-    PluriWaveAudioHandler.fabricaReproductorPrueba = null;
-    PluriWaveAudioHandler.lectorLocalePlataforma =
-        PluriWaveAudioHandler.lectorLocalePlataformaPorDefecto;
-  });
-
-  AppLocalizations textos() => lookupAppLocalizations(const Locale('es'));
-
-  group('debeBloquearCambioDeEmisora — item 11', () {
-    test('free + emisora gratuita: NO bloquea', () {
-      expect(
-        debeBloquearCambioDeEmisora(premium: false, esEmisoraGratuita: true),
-        isFalse,
-      );
-    });
-
-    test('free + emisora premium: bloquea (propiedad de seguridad original — '
-        'un emisora:<uuid> rancio de antes de una bajada de tier no puede '
-        'sonar)', () {
-      expect(
-        debeBloquearCambioDeEmisora(premium: false, esEmisoraGratuita: false),
-        isTrue,
-      );
-    });
-
-    test('premium: nunca bloquea', () {
-      expect(
-        debeBloquearCambioDeEmisora(premium: true, esEmisoraGratuita: false),
-        isFalse,
-      );
-      expect(
-        debeBloquearCambioDeEmisora(premium: true, esEmisoraGratuita: true),
-        isFalse,
-      );
-    });
-  });
-
-  group('getChildren — item 9', () {
-    test('sin fuente de navegación registrada, la carpeta gratuita devuelve '
-        '>= 3 items REPRODUCIBLES', () async {
-      final handler = crearHandler();
-
-      final items = await handler.getChildren(
-        ConstructorArbolAuto.idDestacadas,
-      );
-
-      expect(items.length, greaterThanOrEqualTo(3));
-      expect(items.every((m) => m.playable == true), isTrue);
-      expect(items.every((m) => m.id.startsWith('emisora:')), isTrue);
-    });
-
-    test('la raíz gratuita es UNA carpeta y no paga el round trip nativo de '
-        'estadoCarpeta()', () async {
-      final fuenteLocal = _FuenteMusicaLocalEspia();
-      registrarFuenteMusicaLocal(fuenteLocal);
-      final handler = crearHandler();
-
-      final raiz = await handler.getChildren(AudioService.browsableRootId);
-
-      expect(raiz.map((m) => m.id), [ConstructorArbolAuto.idDestacadas]);
-      expect(
-        fuenteLocal.llamadasEstadoCarpeta,
-        0,
-        reason:
-            'estadoCarpeta() viaja por un MethodChannel que NO existe en el '
-            'motor headless; el tier gratuito no puede ver Música Local, así '
-            'que preguntarlo solo añade una vía de fallo en la raíz',
-      );
-    });
-
-    test('una carpeta premium NO devuelve una fila no reproducible: devuelve '
-        'el contenido gratuito', () async {
-      final handler = crearHandler();
-
-      final items = await handler.getChildren(ConstructorArbolAuto.idTodas);
-
-      expect(items, isNotEmpty);
-      expect(items.every((m) => m.playable == true), isTrue);
-      expect(items.every((m) => m.id != 'premium:info'), isTrue);
-    });
-  });
-
-  group('playFromMediaId — item 12', () {
-    test('free + uuid gratuito: SUENA', () async {
-      final handler = crearHandler();
-      final destacada = emisorasDestacadas.first;
-
-      await handler.playFromMediaId('emisora:${destacada.uuid}');
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, contains(destacada.url));
-    });
-
-    test('free + uuid premium: publica error CON errorCode y errorMessage '
-        'localizado, nunca vuelve en silencio', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('en');
-      final handler = crearHandler();
-
-      await handler.playFromMediaId('emisora:uuid-del-catalogo');
-      await pumpEventQueue();
-
-      final estado = handler.playbackState.value;
-      expect(estado.processingState, AudioProcessingState.error);
-      expect(estado.errorCode, isNotNull);
-      expect(
-        estado.errorMessage,
-        lookupAppLocalizations(const Locale('en')).autoErrorEmisoraPremium,
-      );
-      expect(guion.urlsSolicitadas, isEmpty);
-    });
-
-    test('free + pista local: bloqueada, y también publica el error', () async {
-      final handler = crearHandler();
-
-      await handler.playFromMediaId('pista:doc-id');
-      await pumpEventQueue();
-
-      expect(
-        handler.playbackState.value.processingState,
-        AudioProcessingState.error,
-      );
-    });
-
-    test('free + uuid inexistente en NINGÚN sitio: error, no silencio',
-        () async {
-      final handler = crearHandler();
-
-      await handler.playFromMediaId('emisora:');
-      await pumpEventQueue();
-
-      expect(
-        handler.playbackState.value.processingState,
-        AudioProcessingState.error,
-      );
-    });
-  });
-
-  group('playFromSearch — items 12 y 13', () {
-    test('free: una consulta que casa con el set gratuito SUENA', () async {
-      final handler = crearHandler();
-      final destacada = emisorasDestacadas.first;
-
-      await handler.playFromSearch(destacada.nombre);
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, contains(destacada.url));
-    });
-
-    test('free: una consulta sin resultados publica error localizado, nunca '
-        'vuelve en silencio', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('es');
-      final handler = crearHandler();
-
-      await handler.playFromSearch('emisora que no existe en ningun sitio');
-      await pumpEventQueue();
-
-      final estado = handler.playbackState.value;
-      expect(estado.processingState, AudioProcessingState.error);
-      expect(estado.errorCode, isNotNull);
-      expect(estado.errorMessage, textos().autoErrorBusquedaSinResultados);
-    });
-
-    test('consulta VACÍA ("Reproduce PluriWave") arranca algo — free', () async {
-      final handler = crearHandler();
-
-      await handler.playFromSearch('');
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, isNotEmpty);
-    });
-
-    test('consulta VACÍA arranca algo — PREMIUM (antes fallaba incluso para '
-        'un cliente que había pagado)', () async {
-      SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
-      final handler = crearHandler();
-
-      await handler.playFromSearch('   ');
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, isNotEmpty);
-    });
-
-    test('consulta vacía prefiere la ÚLTIMA escuchada', () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora:
-            '{"uuid":"uuid-ultima","nombre":"Ultima",'
-            '"url":"https://ultima.example/stream"}',
-      });
-      final handler = crearHandler();
-
-      await handler.playFromSearch('');
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, ['https://ultima.example/stream']);
-    });
-  });
-
-  group('un rechazo NO destruye una sesion que esta sonando — hallazgo 1', () {
-    /// Puts the handler in the exact state the reviewer reproduces: a free
-    /// station tapped from the browse tree and audibly playing.
-    Future<PluriWaveAudioHandler> sonando() async {
-      final handler = crearHandler();
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-      guion.ultimoReproductor!.emitir(
-        PlayerState(true, ProcessingState.ready),
-      );
-      await pumpEventQueue();
-      expect(
-        handler.playbackState.value.playing,
-        isTrue,
-        reason: 'precondicion: la emisora esta sonando',
-      );
-      return handler;
-    }
-
-    test(
-      'una busqueda por voz fallida deja el estado publicado FUERA de error y '
-      'sigue ofreciendo play/pause/stop',
-      () async {
-        final handler = await sonando();
-
-        // The free candidate set is only the six compiled-in stations, so
-        // almost any spoken station name misses. That must not cost the
-        // driver the whole now-playing screen.
-        await handler.playFromSearch('BBC');
-        await pumpEventQueue();
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.processingState,
-          isNot(AudioProcessingState.error),
-          reason:
-              'AudioService.java:601-611 maps `error` to STATE_ERROR with the '
-              '`playing` flag IGNORED, so publishing it over live audio '
-              'replaces the transport row with an error the session can never '
-              'clear: playerStateStream is .distinct() (nothing more comes '
-              'from a steadily playing ExoPlayer) and _bufferedSub re-asserts '
-              'it ~2x/second through copyWith',
-        );
-        expect(
-          estado.playing,
-          isTrue,
-          reason: 'el audio sigue sonando; el estado tiene que decirlo',
-        );
-        expect(
-          estado.systemActions,
-          containsAll(<MediaAction>[
-            MediaAction.play,
-            MediaAction.pause,
-            MediaAction.stop,
-          ]),
-        );
-        expect(
-          estado.controls.map((c) => c.action),
-          containsAll(<MediaAction>[MediaAction.pause, MediaAction.stop]),
-        );
-      },
-    );
-
-    test('y el motivo del fallo SIGUE llegando al head unit', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('es');
-      final handler = await sonando();
-
-      await handler.playFromSearch('BBC');
-      await pumpEventQueue();
-
-      // AudioService.java:541-544 calls `setErrorMessage` from `setState`
-      // regardless of processingState, so the text still reaches
-      // PlaybackStateCompat without STATE_ERROR.
-      expect(
-        handler.playbackState.value.errorMessage,
-        textos().autoErrorBusquedaSinResultados,
-      );
-      expect(handler.playbackState.value.errorCode, isNotNull);
-    });
-
-    test(
-      'sin sesion viva el rechazo SI es terminal: error explicado (el caso en '
-      'que el coche no tiene nada que perder)',
-      () async {
-        final handler = crearHandler();
-
-        await handler.playFromSearch('BBC');
-        await pumpEventQueue();
-
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.error,
-        );
-        expect(handler.playbackState.value.errorMessage, isNotNull);
-      },
-    );
-
-    /// CONTRACT for an action refusal published over a LIVE session
-    /// (`_publicarErrorAuto`'s non-terminal branch):
-    ///
-    /// 1. the code and the message are published immediately and stand for
-    ///    [PluriWaveAudioHandler.ventanaErrorAccionAuto] (the two tests
-    ///    above pin step 1);
-    /// 2. when that window elapses they are BOTH cleared, and nothing else
-    ///    about the state moves;
-    /// 3. any real player transition arriving first clears them early — a
-    ///    genuine state change supersedes a stale refusal;
-    /// 4. only the fields this refusal published are ever cleared, so a
-    ///    reconnect status message that replaced them survives.
-    ///
-    /// It has to be bounded: `_bufferedSub` republishes
-    /// `playbackState.value.copyWith(...)` ~2x/second and `copyWith` carries
-    /// every omitted field forward (audio_service.dart:400-427), so
-    /// `AudioService.java:541-544` re-calls `setErrorMessage(code, msg)` on
-    /// every one of those pushes. Without a clear, one voice miss makes the
-    /// session advertise an error for the rest of the station's playback,
-    /// over audible healthy audio.
-    group('y el rechazo es TRANSITORIO: nada lo arrastra para siempre', () {
-      setUp(() {
-        PluriWaveAudioHandler.ventanaErrorAccionAuto = const Duration(
-          milliseconds: 80,
-        );
-      });
-
-      tearDown(() {
-        PluriWaveAudioHandler.ventanaErrorAccionAuto =
-            PluriWaveAudioHandler.ventanaErrorAccionAutoPorDefecto;
-      });
-
-      test('al pasar la ventana, codigo y mensaje desaparecen', () async {
-        final handler = await sonando();
-
-        await handler.playFromSearch('BBC');
-        await pumpEventQueue();
-        expect(
-          handler.playbackState.value.errorCode,
-          isNotNull,
-          reason: 'precondicion: el rechazo se publico',
-        );
-
-        await Future<void>.delayed(const Duration(milliseconds: 250));
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.errorCode,
-          isNull,
-          reason:
-              'every later push carries the code forward through copyWith, so '
-              'the session would keep telling the head unit it is in error '
-              'while the station plays perfectly',
-        );
-        expect(estado.errorMessage, isNull);
-        expect(
-          estado.playing,
-          isTrue,
-          reason: 'clearing the refusal must not touch the session itself',
-        );
-        expect(
-          estado.processingState,
-          isNot(AudioProcessingState.error),
-          reason: 'nor its processing state',
-        );
-      });
-
-      test(
-        'y un cambio de estado real del reproductor los limpia antes',
-        () async {
-          final handler = await sonando();
-
-          await handler.playFromSearch('BBC');
-          await pumpEventQueue();
-          expect(handler.playbackState.value.errorMessage, isNotNull);
-
-          // The driver pauses: a genuine transition. `manejarEstadoPlayer`
-          // omitted both fields, so `copyWith` carried the refusal into the
-          // paused state and every state after it.
-          handler.manejarEstadoPlayer(
-            PlayerState(false, ProcessingState.ready),
-          );
-          await pumpEventQueue();
-
-          final estado = handler.playbackState.value;
-          expect(estado.errorCode, isNull);
-          expect(estado.errorMessage, isNull);
-        },
-      );
-
-      test('y stop() limpia el codigo, no solo el mensaje', () async {
-        final handler = await sonando();
-
-        await handler.playFromSearch('BBC');
-        await pumpEventQueue();
-        expect(handler.playbackState.value.errorCode, isNotNull);
-
-        await handler.stop();
-        await pumpEventQueue();
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.errorCode,
-          isNull,
-          reason:
-              'stop() cleared errorMessage but omitted errorCode, so the idle '
-              'it publishes shipped a stale ERROR_CODE_PREMIUM_ACCOUNT_'
-              'REQUIRED (4) with no message to explain it',
-        );
-        expect(estado.errorMessage, isNull);
-      });
-    });
-  });
-
-  group('errorCode se limpia en un cambio de fuente — item 6', () {
-    test('un rechazo premium seguido de una emisora gratuita NO arrastra el '
-        'codigo de error', () async {
-      final handler = crearHandler();
-
-      await handler.playFromMediaId('emisora:uuid-del-catalogo');
-      await pumpEventQueue();
-      expect(
-        handler.playbackState.value.errorCode,
-        isNotNull,
-        reason: 'precondicion: el rechazo publico un codigo',
-      );
-
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-
-      expect(
-        handler.playbackState.value.errorCode,
-        isNull,
-        reason:
-            '`_cambiarFuente` cleared errorMessage but omitted errorCode, and '
-            'copyWith carries an omitted field forward, so a stale code rode '
-            'along indefinitely',
-      );
-      expect(handler.playbackState.value.errorMessage, isNull);
-    });
-  });
-
-  group('getChildren(recentRootId) — reanudacion del head unit', () {
-    test('con una ultima emisora persistida devuelve EXACTAMENTE un item '
-        'reproducible', () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora:
-            '{"uuid":"uuid-ultima","nombre":"Ultima",'
-            '"url":"https://ultima.example/stream"}',
-      });
-      final handler = crearHandler();
-
-      final items = await handler.getChildren(AudioService.recentRootId);
-
-      expect(
-        items,
-        hasLength(1),
-        reason:
-            'onGetRoot (AudioService.java:817-821) answers "recent" whenever '
-            'the head unit sends EXTRA_RECENT, which Android Auto does on '
-            'reconnect, and the platform expects exactly one resume item — '
-            'free tier used to fall through and return all six stations',
-      );
-      expect(items.single.playable, isTrue);
-      expect(items.single.id, 'emisora:uuid-ultima');
-    });
-
-    test('sin ultima emisora devuelve lista vacia y no lanza', () async {
-      final handler = crearHandler();
-
-      expect(await handler.getChildren(AudioService.recentRootId), isEmpty);
-    });
-
-    test('premium tambien obtiene su tile de reanudacion, no una lista '
-        'vacia', () async {
-      SharedPreferences.setMockInitialValues({
-        'compra_premium_v1': true,
-        claveUltimaEmisora:
-            '{"uuid":"uuid-premium","nombre":"Premium",'
-            '"url":"https://premium.example/stream"}',
-      });
-      final handler = crearHandler();
-
-      final items = await handler.getChildren(AudioService.recentRootId);
-
-      expect(items, hasLength(1));
-      expect(items.single.id, 'emisora:uuid-premium');
-    });
-  });
-
-  group('la raiz gratuita esta LOCALIZADA — hallazgo 4', () {
-    test('en un motor headless en ingles la unica carpeta que un revisor de '
-        'Play ve NO sale en castellano', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('en');
-      final handler = crearHandler();
-
-      final raiz = await handler.getChildren(AudioService.browsableRootId);
-
-      expect(raiz, hasLength(1));
-      expect(
-        raiz.single.title,
-        lookupAppLocalizations(const Locale('en')).autoCarpetaEscuchar,
-        reason:
-            'raiz(premium: false) is 100% of the browse tree a Play reviewer '
-            'ever sees, on a device in any of the 13 shipped locales — the '
-            'hardcoded-Spanish car-label convention stops being defensible '
-            'once one label IS the whole free root',
-      );
-      expect(raiz.single.title, isNot('Escuchar'));
-    });
-
-    test('en castellano sigue diciendo Escuchar', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('es');
-      final handler = crearHandler();
-
-      final raiz = await handler.getChildren(AudioService.browsableRootId);
-
-      expect(raiz.single.title, 'Escuchar');
-    });
-  });
-
-  group('botones de salto — item 14', () {
-    test('free: el salto CICLA dentro del set gratuito en vez de no hacer '
-        'nada', () async {
-      final handler = crearHandler();
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, emisorasDestacadas[1].url);
-    });
-
-    test('free: el salto hacia atrás envuelve al final del set', () async {
-      final handler = crearHandler();
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-
-      await handler.skipToPrevious();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, emisorasDestacadas.last.url);
-    });
-
-    test('free: los botones se SIGUEN anunciando (un boton que funciona es '
-        'mejor UX que un hueco, y controls/systemActions se construyen en un '
-        'listener sincrono que no puede await-ear prefs)', () async {
-      final handler = crearHandler();
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-      // `controls`/`systemActions` are only rebuilt from a real player event,
-      // so the double has to emit one for this assertion to mean anything.
-      guion.ultimoReproductor!.emitir(
-        PlayerState(true, ProcessingState.ready),
-      );
-      await pumpEventQueue();
-
-      final estado = handler.playbackState.value;
-      expect(estado.systemActions, contains(MediaAction.skipToNext));
-      expect(estado.systemActions, contains(MediaAction.skipToPrevious));
-    });
-  });
-}
-
-/// Cuenta los round trips nativos que la raíz del árbol dispara.
-class _FuenteMusicaLocalEspia implements FuenteMusicaLocalAuto {
-  int llamadasEstadoCarpeta = 0;
-
-  @override
-  Future<EstadoCarpetaLocal> estadoCarpeta() async {
-    llamadasEstadoCarpeta++;
-    return EstadoCarpetaLocal.configurada;
-  }
-
-  @override
-  Future<List<NodoLocal>> hijos(String documentId) async => const [];
-
-  @override
-  Future<String?> uriContenidoDePista(String documentId) async => null;
-
-  @override
-  Future<Map<String, MetadatosPista>> metadatosDe(
-    List<String> documentIds,
-  ) async => const {};
-}
-
-/// Misma forma que el doble de `servicio_audio_transporte_test.dart`.
-class _GuionReproductor {
-  int llamadasPlay = 0;
-  final urlsSolicitadas = <String>[];
-
-  /// The handler rebuilds its player on every source change, so a test that
-  /// needs to drive player events has to reach the LATEST instance.
-  _ReproductorFalso? ultimoReproductor;
-}
-
-class _ReproductorFalso extends AudioPlayer {
-  _ReproductorFalso(
-    this._guion,
-    AudioPipeline pipeline,
-    AudioLoadConfiguration carga,
-  ) : super(audioPipeline: pipeline, audioLoadConfiguration: carga) {
-    _guion.ultimoReproductor = this;
-  }
-
-  final _GuionReproductor _guion;
-  final _estados = StreamController<PlayerState>.broadcast();
-
-  void emitir(PlayerState estado) => _estados.add(estado);
-
-  @override
-  Stream<PlayerState> get playerStateStream => _estados.stream;
-
-  @override
-  Future<Duration?> setUrl(
-    String url, {
-    Map<String, String>? headers,
-    Duration? initialPosition,
-    bool preload = true,
-    dynamic tag,
-  }) async {
-    _guion.urlsSolicitadas.add(url);
-    return null;
-  }
-
-  @override
-  Future<void> play() async {
-    _guion.llamadasPlay++;
-  }
-
-  @override
-  Future<void> pause() async {}
-
-  @override
-  Future<void> stop() async {}
-
-  @override
-  Future<void> setVolume(double volume) async {}
-
-  @override
-  Future<void> dispose() async {
-    await _estados.close();
-  }
-}

test/servicios/servicio_audio_contexto_salto_test.dart

@@ -1,618 +0,0 @@
-import 'dart:async';
-import 'dart:ui' show Locale;
-
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart';
-import 'package:pluriwave/l10n/gen/app_localizations.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/modelos/grupo_favoritos.dart';
-import 'package:pluriwave/servicios/contexto_reproduccion.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
-import 'package:pluriwave/servicios/navegacion_auto.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// Contexto de reproducción en el HANDLER — «al conectar el coche, siguiente/
-/// anterior ya no recuerdan en qué lista estaba».
-///
-/// El handler es el único que existe en los dos motores (el del móvil y el
-/// headless que levanta Android Auto sin Activity), así que es él quien tiene
-/// que escribir y leer el contexto. Lo hace por un PUERTO inyectado en
-/// `registrarHandler`, exactamente igual que el flag on/off del ecualizador:
-/// `servicio_audio.dart` no importa `shared_preferences` ni conoce
-/// `EstadoRadio`, que en el coche no llega a construirse nunca.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  late _GuionReproductor guion;
-  late _PuertoContexto puerto;
-
-  setUp(() {
-    guion = _GuionReproductor();
-    puerto = _PuertoContexto();
-    PluriWaveAudioHandler.fabricaReproductorPrueba =
-        (pipeline, carga) => _ReproductorFalso(guion, pipeline, carga);
-    SharedPreferences.setMockInitialValues({});
-  });
-
-  tearDown(() {
-    PluriWaveAudioHandler.fabricaReproductorPrueba = null;
-    // `_fuenteNavegacionGlobal` es global de módulo: se deja siempre en una
-    // fuente vacía para que un test no herede las listas del anterior.
-    registrarFuenteNavegacion(_FuenteFalsa());
-  });
-
-  AppLocalizations textos() => lookupAppLocalizations(const Locale('es'));
-
-  Emisora favorita(String uuid, String grupo) => Emisora(
-    uuid: uuid,
-    nombre: uuid,
-    url: 'https://example.com/$uuid',
-    grupoFavoritosId: grupo,
-  );
-
-  final rock1 = favorita('rock1', 'g-rock');
-  final rock2 = favorita('rock2', 'g-rock');
-  final rock3 = favorita('rock3', 'g-rock');
-  final jazz1 = favorita('jazz1', 'g-jazz');
-  final jazz2 = favorita('jazz2', 'g-jazz');
-  const gruposVivos = [
-    GrupoFavoritos(id: 'g-rock', nombre: 'Rock', orden: 1),
-    GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-  ];
-
-  PluriWaveAudioHandler handlerConPuerto() {
-    final handler = crearHandler();
-    registrarHandler(
-      handler,
-      leerContextoSalto: puerto.leer,
-      guardarContextoSalto: puerto.guardar,
-    );
-    return handler;
-  }
-
-  Future<void> premium() async {
-    SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
-  }
-
-  group('escritura — el contexto se fija en TODO camino que arranca una '
-      'emisora, no solo en el del árbol del coche', () {
-    setUp(premium);
-
-    test('playFromMediaId (toque en el árbol del coche)', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playFromMediaId('emisora:rock1');
-      await pumpEventQueue();
-
-      expect(puerto.guardados.last, const ContextoSalto.grupo('g-rock'));
-    });
-
-    test('playFromSearch (voz)', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playFromSearch('jazz1');
-      await pumpEventQueue();
-
-      expect(puerto.guardados.last, const ContextoSalto.favoritos());
-    });
-
-    test('playMediaItem (el camino del móvil: ServicioAudio.reproducir)',
-        () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock2, l10n: textos()));
-      await pumpEventQueue();
-
-      expect(puerto.guardados.last, const ContextoSalto.grupo('g-rock'));
-    });
-
-    test('una PISTA LOCAL no escribe contexto de emisora: su cola es otra '
-        'cosa y pisarlo dejaría la radio recorriendo una lista ajena',
-        () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(
-        const MediaItem(
-          id: 'content://media/documents/pista-1',
-          title: 'Pista local',
-        ),
-      );
-      await pumpEventQueue();
-
-      expect(puerto.guardados, isEmpty);
-    });
-  });
-
-  group('lectura — el contexto recordado sobrevive al reinicio del proceso',
-      () {
-    setUp(premium);
-
-    test('la fuente aún no está registrada cuando arranca la emisora (carrera '
-        'real del bind en frío): el salto usa el contexto de la sesión '
-        'anterior en vez de morir', () async {
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      // Bind en frío: `main.dart` todavía no ha llamado a
-      // registrarFuenteNavegacion cuando el coche pide reproducir.
-      registrarFuenteNavegacion(_FuenteFalsa());
-      final handler = handlerConPuerto();
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-
-      // La fuente llega después, ya con las listas cargadas.
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, rock2.url);
-      expect(puerto.lecturas, greaterThan(0));
-    });
-
-    test('el contexto recordado MANDA sobre la rederivación: el registro de '
-        'favoritos perdió el grupo, y aun así se recorre el grupo', () async {
-      // Escenario real: el snapshot que empuja el móvil llega antes de que
-      // los grupos estén cargados, así que `favoritos()` reporta
-      // «sin asignar» un rato. Sin memoria, el salto se ensancha a todos los
-      // favoritos justo en mitad del trayecto.
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, rock2.url);
-    });
-  });
-
-  group('degradación del contexto recordado', () {
-    setUp(premium);
-
-    test('el grupo recordado fue BORRADO -> se recorren todos los favoritos',
-        () async {
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      registrarFuenteNavegacion(
-        _FuenteFalsa(
-          favoritos: [
-            favorita('rock1', GrupoFavoritos.sinAsignarId),
-            jazz1,
-            jazz2,
-          ],
-          grupos: const [
-            GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-          ],
-        ),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, jazz1.url);
-    });
-
-    test('el grupo SIGUE VIVO pero la emisora se salió de él -> se PERMANECE '
-        'en el grupo y suena su PRIMERA emisora', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, rock2, jazz1], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      expect(puerto.guardados.last, const ContextoSalto.grupo('g-rock'));
-      guion.urlsSolicitadas.clear();
-
-      // El móvil saca rock1 del grupo a media marcha: g-rock sigue existiendo
-      // y sigue teniendo emisoras, solo que ya no la que suena.
-      registrarFuenteNavegacion(
-        _FuenteFalsa(
-          // jazz1 va DELANTE de rock2 a propósito: si el contexto se
-          // ensanchara a todos los favoritos, «siguiente» sonaría jazz1.
-          favoritos: [
-            favorita('rock1', GrupoFavoritos.sinAsignarId),
-            jazz1,
-            rock2,
-            rock3,
-          ],
-          grupos: gruposVivos,
-        ),
-      );
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, rock2.url);
-      expect(
-        puerto.persistido,
-        const ContextoSalto.grupo('g-rock'),
-        reason: 'el grupo sobrevive, así que el contexto no se rederiva',
-      );
-    });
-
-    test('el grupo sigue vivo con UNA sola emisora -> el salto NO se ensancha '
-        'a todos los favoritos: se queda donde está', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(
-          favoritos: [rock1, rock2, jazz1, jazz2],
-          grupos: gruposVivos,
-        ),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-
-      // rock2 sale del grupo: g-rock se queda solo con la emisora que suena.
-      registrarFuenteNavegacion(
-        _FuenteFalsa(
-          favoritos: [
-            rock1,
-            favorita('rock2', GrupoFavoritos.sinAsignarId),
-            jazz1,
-            jazz2,
-          ],
-          grupos: gruposVivos,
-        ),
-      );
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, isEmpty);
-      expect(puerto.persistido, const ContextoSalto.grupo('g-rock'));
-    });
-
-    test('el grupo fue BORRADO y la emisora ya NO es favorita -> suena la '
-        'PRIMERA de los favoritos que queden', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-
-      registrarFuenteNavegacion(
-        _FuenteFalsa(
-          favoritos: [jazz1, jazz2],
-          grupos: const [
-            GrupoFavoritos(id: 'g-jazz', nombre: 'Jazz', orden: 2),
-          ],
-        ),
-      );
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, jazz1.url);
-    });
-
-    test('no queda ningún favorito y la emisora no está en ninguna lista -> '
-        'no-op silencioso, nunca un salto arbitrario', () async {
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      registrarFuenteNavegacion(_FuenteFalsa(grupos: gruposVivos));
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, isEmpty);
-    });
-  });
-
-  group('tier gratuito', () {
-    test('la lista de salto queda CONGELADA en el orden curado: que cambie '
-        '`ultima_emisora_v1` a media marcha no reordena el recorrido, así '
-        'que «anterior» vuelve a deshacer «siguiente»', () async {
-      // `resolverEmisorasDestacadas` se recompone como
-      // `[última reproducida, ...curadas]`, así que la lista SE REORDENA SOLA
-      // según suena cada emisora. Recorrerla en vivo hacía que «anterior»
-      // dejara de ser el inverso de «siguiente» a mitad de trayecto.
-      final kexp = emisorasDestacadas[3];
-      final siguienteCurada = emisorasDestacadas[4];
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora:
-            '{"uuid":"${kexp.uuid}","nombre":"${kexp.nombre}",'
-            '"url":"${kexp.url}"}',
-      });
-      final handler = handlerConPuerto();
-
-      // Fija la divergencia: la lista VIVA con `ultima` = KEXP empieza por
-      // KEXP, así que recorrerla daría la primera curada. Sin esta línea el
-      // test de abajo pasaría también con el comportamiento antiguo.
-      final enVivo = await resolverEmisorasDestacadas();
-      expect(
-        emisoraVecina(kexp, enVivo, haciaAtras: false)?.url,
-        emisorasDestacadas.first.url,
-      );
-
-      await handler.playFromMediaId('emisora:${kexp.uuid}');
-      await pumpEventQueue();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(
-        guion.urlsSolicitadas.last,
-        siguienteCurada.url,
-        reason:
-            'en vivo la lista sería [KEXP, ...resto], y «siguiente» se iría a '
-            'la primera curada en vez de a la que va detrás de KEXP',
-      );
-
-      // El móvil (vivo) persiste la emisora que acaba de sonar.
-      final prefs = await SharedPreferences.getInstance();
-      await prefs.setString(
-        claveUltimaEmisora,
-        '{"uuid":"${siguienteCurada.uuid}",'
-        '"nombre":"${siguienteCurada.nombre}",'
-        '"url":"${siguienteCurada.url}"}',
-      );
-
-      await handler.skipToPrevious();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, kexp.url);
-    });
-
-    test('una emisora ajena al set curado se ANTEPONE al recorrido congelado, '
-        'para que ningún botón quede muerto', () async {
-      SharedPreferences.setMockInitialValues({
-        claveUltimaEmisora:
-            '{"uuid":"ajena","nombre":"Ajena",'
-            '"url":"https://example.com/ajena"}',
-      });
-      final handler = handlerConPuerto();
-
-      await handler.playFromMediaId('emisora:ajena');
-      await pumpEventQueue();
-
-      expect(
-        puerto.guardados.last,
-        ContextoSalto.destacadas([
-          'ajena',
-          ...emisorasDestacadas.map((e) => e.uuid),
-        ]),
-      );
-
-      await handler.skipToPrevious();
-      await pumpEventQueue();
-      expect(guion.urlsSolicitadas.last, emisorasDestacadas.last.url);
-    });
-
-    test('un contexto PREMIUM recordado NO se camina en tier gratuito: una '
-        'cuenta degradada no sigue recorriendo el catálogo', () async {
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, emisorasDestacadas[1].url);
-      expect(
-        puerto.guardados.last.tipo,
-        TipoContextoSalto.destacadas,
-        reason: 'el contexto de un usuario free es SIEMPRE el set gratuito',
-      );
-    });
-
-    test('free: aunque el grupo de favoritos siga VIVO, el recorrido no entra '
-        'en él tampoco en el segundo salto', () async {
-      // La nueva caída «grupo vivo -> su primera emisora» no puede convertirse
-      // en una puerta trasera al contenido de pago.
-      puerto.persistido = const ContextoSalto.grupo('g-rock');
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, rock2, rock3], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playFromMediaId('emisora:${emisorasDestacadas.first.uuid}');
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas, [
-        emisorasDestacadas[1].url,
-        emisorasDestacadas[2].url,
-      ]);
-    });
-  });
-
-  group('robustez del puerto', () {
-    setUp(premium);
-
-    test('sin puerto registrado el salto sigue funcionando por rederivación '
-        '(un test de widgets, o el arranque antes de main.dart)', () async {
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, rock2.url);
-    });
-
-    test('un puerto que revienta degrada a rederivación en vez de dejar al '
-        'conductor sin botones', () async {
-      puerto.explota = true;
-      registrarFuenteNavegacion(
-        _FuenteFalsa(favoritos: [rock1, jazz1, rock2], grupos: gruposVivos),
-      );
-      final handler = handlerConPuerto();
-
-      await handler.playMediaItem(mediaItemParaEmisora(rock1, l10n: textos()));
-      await pumpEventQueue();
-      guion.urlsSolicitadas.clear();
-      await handler.skipToNext();
-      await pumpEventQueue();
-
-      expect(guion.urlsSolicitadas.last, rock2.url);
-    });
-  });
-}
-
-/// Doble del puerto de persistencia que `main.dart` ata a
-/// `contexto_reproduccion.dart`.
-class _PuertoContexto {
-  ContextoSalto? persistido;
-  final guardados = <ContextoSalto>[];
-  int lecturas = 0;
-  bool explota = false;
-
-  Future<ContextoSalto?> leer() async {
-    lecturas++;
-    if (explota) throw StateError('disco ilegible');
-    return persistido;
-  }
-
-  Future<void> guardar(ContextoSalto contexto) async {
-    if (explota) throw StateError('disco de solo lectura');
-    guardados.add(contexto);
-    persistido = contexto;
-  }
-}
-
-class _FuenteFalsa implements FuenteEmisorasAuto {
-  _FuenteFalsa({
-    List<Emisora>? favoritos,
-    List<Emisora>? misEmisoras,
-    List<Emisora>? todas,
-    List<GrupoFavoritos>? grupos,
-  }) : _favoritos = favoritos ?? const [],
-       _misEmisoras = misEmisoras ?? const [],
-       _todas = todas ?? const [],
-       _grupos = grupos ?? const [];
-
-  final List<Emisora> _favoritos;
-  final List<Emisora> _misEmisoras;
-  final List<Emisora> _todas;
-  final List<GrupoFavoritos> _grupos;
-
-  @override
-  Future<List<Emisora>> favoritos() async => _favoritos;
-
-  @override
-  Future<List<Emisora>> misEmisoras() async => _misEmisoras;
-
-  @override
-  Future<List<Emisora>> todas() async => _todas;
-
-  @override
-  Future<List<GrupoFavoritos>> grupos() async => _grupos;
-
-  @override
-  Future<Emisora?> porUuid(String uuid) async {
-    for (final lista in [_favoritos, _misEmisoras, _todas]) {
-      for (final e in lista) {
-        if (e.uuid == uuid) return e;
-      }
-    }
-    for (final e in await resolverEmisorasDestacadas()) {
-      if (e.uuid == uuid) return e;
-    }
-    return null;
-  }
-
-  @override
-  void actualizarSnapshot({
-    List<Emisora>? favoritos,
-    List<Emisora>? misEmisoras,
-    List<Emisora>? todas,
-    List<GrupoFavoritos>? grupos,
-  }) {}
-}
-
-/// Misma forma que el doble de `servicio_audio_auto_free_test.dart`.
-class _GuionReproductor {
-  final urlsSolicitadas = <String>[];
-  _ReproductorFalso? ultimoReproductor;
-}
-
-class _ReproductorFalso extends AudioPlayer {
-  _ReproductorFalso(
-    this._guion,
-    AudioPipeline pipeline,
-    AudioLoadConfiguration carga,
-  ) : super(audioPipeline: pipeline, audioLoadConfiguration: carga) {
-    _guion.ultimoReproductor = this;
-  }
-
-  final _GuionReproductor _guion;
-  final _estados = StreamController<PlayerState>.broadcast();
-
-  @override
-  Stream<PlayerState> get playerStateStream => _estados.stream;
-
-  @override
-  Future<Duration?> setUrl(
-    String url, {
-    Map<String, String>? headers,
-    Duration? initialPosition,
-    bool preload = true,
-    dynamic tag,
-  }) async {
-    _guion.urlsSolicitadas.add(url);
-    return null;
-  }
-
-  @override
-  Future<void> play() async {}
-
-  @override
-  Future<void> pause() async {}
-
-  @override
-  Future<void> stop() async {}
-
-  @override
-  Future<void> setVolume(double volume) async {}
-
-  @override
-  Future<void> dispose() async {
-    await _estados.close();
-  }
-}

test/servicios/servicio_audio_eq_auto_test.dart

@@ -1,374 +0,0 @@
-import 'dart:async';
-
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart';
-import 'package:pluriwave/modelos/preset_ecualizador.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// eq-coche — the equalizer toggle pressed FROM ANDROID AUTO.
-///
-/// Reported by the owner: the toggle behaves correctly from the phone screen
-/// but from the car it «sometimes sounds like a doubled equalization and
-/// sometimes does nothing».
-///
-/// Three independent causes, one per group below:
-///
-///  A. The handler's `_presetActual` was hardcoded to `PresetEcualizador.flat`
-///     and had NO disk seam. The on/off flag got one (`leerEqActivoPersistido`,
-///     `eq-estado-unico` item A); the preset never did. On a headless Android
-///     Auto engine — no Activity, no Provider tree, so no `EstadoEcualizador`
-///     to push the real preset — enabling the equalizer from the car applied
-///     FLAT.
-///
-///  B. `_aplicarEcualizadorActivo` called `setEnabled(activo)` BEFORE pushing
-///     the preset's gains, so the native effect was re-activated carrying
-///     whatever band levels the previous preset had left in it and only
-///     afterwards were the intended ones written, band by band. That audible
-///     gap is the «doubled equalization».
-///
-///  C. `_recrearPlayer` dropped `_eqDisponible` to `false` on EVERY station
-///     change and never restored it until the fresh player attached. Every
-///     native EQ path is gated on that flag, so a car toggle landing inside
-///     the window flipped the icon and the flag but never touched the audio —
-///     the «does nothing» — and the EQ button itself vanished from the car's
-///     now-playing screen (`controlesEcualizadorPersonalizados` returns
-///     `const []` when unavailable) and came back seconds later.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  late _GuionReproductorEq guion;
-
-  setUp(() {
-    guion = _GuionReproductorEq();
-    PluriWaveAudioHandler.fabricaReproductorPrueba =
-        (pipeline, carga) => _ReproductorFalsoEq(guion, pipeline, carga);
-  });
-
-  tearDown(() {
-    PluriWaveAudioHandler.fabricaReproductorPrueba = null;
-    PluriWaveAudioHandler.fabricaEcualizadorPrueba = null;
-  });
-
-  group('A — the preset is seeded from disk on a headless engine', () {
-    test('registrarHandler consults the injected preset port exactly once '
-        'and seeds the handler with it, with no widget tree', () async {
-      final handler = crearHandler();
-      var lecturas = 0;
-
-      registrarHandler(
-        handler,
-        leerPresetPersistido: () async {
-          lecturas++;
-          return PresetEcualizador.jazz;
-        },
-      );
-      await pumpEventQueue();
-
-      expect(lecturas, 1, reason: 'exactly one disk read per engine start');
-      expect(
-        handler.presetActual,
-        PresetEcualizador.jazz,
-        reason:
-            'from the car the handler is the ONLY owner of the preset — '
-            'nothing else ever pushes one on a headless engine',
-      );
-    });
-
-    test('a read failure leaves the historical default instead of '
-        'propagating', () async {
-      final handler = crearHandler();
-
-      registrarHandler(
-        handler,
-        leerPresetPersistido: () async => throw StateError('sin disco'),
-      );
-      await pumpEventQueue();
-
-      expect(handler.presetActual, PresetEcualizador.flat);
-    });
-
-    test('without a preset port the handler is left untouched (widget tests, '
-        'fakes)', () async {
-      final handler = crearHandler();
-      await handler.aplicarPreset(PresetEcualizador.rock);
-
-      registrarHandler(handler);
-      await pumpEventQueue();
-
-      expect(handler.presetActual, PresetEcualizador.rock);
-    });
-
-    test('a preset already chosen while the disk read was in flight WINS — '
-        'seeding never clobbers a live choice', () async {
-      final handler = crearHandler();
-      final lectura = Completer<PresetEcualizador?>();
-
-      registrarHandler(handler, leerPresetPersistido: () => lectura.future);
-      // The phone UI (`EstadoEcualizador`) resolves a per-station preset and
-      // pushes it while the seed's disk read is still pending.
-      await handler.aplicarPreset(PresetEcualizador.pop);
-      lectura.complete(PresetEcualizador.jazz);
-      await pumpEventQueue();
-
-      expect(
-        handler.presetActual,
-        PresetEcualizador.pop,
-        reason:
-            'the seed exists to fill a VOID, not to overrule the richer '
-            'per-station/per-device preset the phone UI resolves',
-      );
-    });
-  });
-
-  group('B — the preset is pushed BEFORE the effect is enabled', () {
-    test('enabling applies the gains first and only then flips the native '
-        'effect on', () {
-      expect(
-        PluriWaveAudioHandler.pasosEcualizador(activo: true),
-        [PasoEcualizador.ganancias, PasoEcualizador.habilitacion],
-        reason:
-            'enabling first would re-activate the native Equalizer carrying '
-            'the PREVIOUS preset gains, which is the doubled equalization '
-            'the owner hears',
-      );
-    });
-
-    test('disabling only flips the effect off — the band gains are NOT '
-        'reset', () {
-      expect(
-        PluriWaveAudioHandler.pasosEcualizador(activo: false),
-        [PasoEcualizador.habilitacion],
-        reason:
-            'android.media.audiofx.AudioEffect.setEnabled(false) bypasses '
-            'the effect and RETAINS its band levels, and the enable path '
-            'rewrites them before re-enabling anyway — zeroing them would be '
-            'one native round trip per band for no audible difference',
-      );
-    });
-
-    test('the real toggle path executes those steps IN THAT ORDER', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      await handler.setEcualizadorActivo(true);
-
-      expect(
-        handler.pasosEcualizadorEjecutados,
-        [PasoEcualizador.ganancias, PasoEcualizador.habilitacion],
-        reason:
-            'the ORDER is the fix; asserting only that both happened would '
-            'stay green against the exact bug being fixed',
-      );
-    });
-
-    test('the real disable path executes only the habilitacion step', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      await handler.setEcualizadorActivo(false);
-
-      expect(handler.pasosEcualizadorEjecutados, [
-        PasoEcualizador.habilitacion,
-      ]);
-    });
-  });
-
-  group('C — a station change no longer drops the equalizer', () {
-    test('once the EQ was available, no state published across a station '
-        'change and a car toggle has zero custom actions', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-      // The EQ action is on the car's now-playing screen before the station
-      // changes — that is the state the driver is looking at.
-      await handler.setEcualizadorActivo(true);
-
-      final acciones = <int>[];
-      final sub = handler.playbackState.listen(
-        (estado) => acciones.add(
-          estado.controls.where((c) => c.customAction != null).length,
-        ),
-      );
-
-      await handler.playMediaItem(
-        const MediaItem(id: 'https://a', title: 'A'),
-      );
-      await pumpEventQueue();
-      // The car tap that used to land inside the window `_recrearPlayer`
-      // opened. It republishes the controls from `_eqDisponible`, so a flag
-      // reset to `false` shows up here as an EQ button that disappeared.
-      await handler.customAction(accionEqToggle);
-      await sub.cancel();
-
-      expect(
-        acciones,
-        isNotEmpty,
-        reason: 'the station change must publish at least one state',
-      );
-      expect(
-        acciones.every((n) => n > 0),
-        isTrue,
-        reason:
-            'the EQ button vanished and reappeared on every station change '
-            'because `_recrearPlayer` reset `_eqDisponible`; availability is '
-            'a DEVICE property and does not change with the station. Got '
-            '$acciones',
-      );
-    });
-
-    test('the availability flag survives the player rebuild, so a car toggle '
-        'inside the window still reaches the native effect', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      await handler.playMediaItem(
-        const MediaItem(id: 'https://a', title: 'A'),
-      );
-      await pumpEventQueue();
-
-      expect(
-        handler.ecualizadorDisponible,
-        isTrue,
-        reason:
-            'this is the flag every native EQ path is gated on; false here '
-            'is exactly the reported «does nothing»',
-      );
-    });
-  });
-
-  group('D — a failed native call is traced and never lies', () {
-    test('a throwing setEnabled is traced instead of swallowed', () async {
-      PluriWaveAudioHandler.fabricaEcualizadorPrueba =
-          () => _EcualizadorQueFalla();
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      await handler.setEcualizadorActivo(true);
-
-      expect(
-        handler.fallosNativosEcualizador,
-        greaterThan(0),
-        reason:
-            'the silent `catch (_) {}` made a dead native equalizer '
-            'indistinguishable from a working one in a car logcat',
-      );
-    });
-
-    test('a failed on/off call leaves the published state honest instead of '
-        'claiming a state the audio does not have', () async {
-      PluriWaveAudioHandler.fabricaEcualizadorPrueba =
-          () => _EcualizadorQueFalla();
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-      await handler.sembrarEcualizadorActivo(false);
-
-      await handler.setEcualizadorActivo(true);
-
-      expect(
-        handler.ecualizadorActivo,
-        isFalse,
-        reason:
-            'the native effect refused, so the car icon must not read "on" '
-            'over audio that is not equalized',
-      );
-    });
-
-    test('a failed on/off call is not persisted', () async {
-      PluriWaveAudioHandler.fabricaEcualizadorPrueba =
-          () => _EcualizadorQueFalla();
-      final handler = crearHandler();
-      final escrituras = <bool>[];
-      registrarHandler(
-        handler,
-        guardarEqActivoPersistido: (activo) async => escrituras.add(activo),
-      );
-      handler.simularEcualizadorDisponible(true);
-      await handler.sembrarEcualizadorActivo(false);
-
-      await handler.setEcualizadorActivo(true);
-
-      expect(
-        escrituras,
-        isEmpty,
-        reason:
-            'persisting a state the device rejected would resurrect it on '
-            'the next engine start',
-      );
-    });
-  });
-}
-
-/// An `AndroidEqualizer` whose `setEnabled` always throws, standing in for a
-/// device whose native `Equalizer` effect refuses the call. Nothing else is
-/// overridden, so the rest of the handler runs unchanged.
-class _EcualizadorQueFalla extends AndroidEqualizer {
-  @override
-  Future<void> setEnabled(bool enabled) async {
-    throw StateError('el efecto nativo rechazo la llamada');
-  }
-}
-
-/// Minimal script/observation record shared by every [_ReproductorFalsoEq]
-/// the handler builds (it rebuilds its player on every source change).
-class _GuionReproductorEq {
-  int llamadasSetUrl = 0;
-  _ReproductorFalsoEq? ultimoReproductor;
-}
-
-/// An [AudioPlayer] whose platform-touching methods are replaced, so a real
-/// station change can be driven under `flutter test`. Mirrors the double in
-/// `servicio_audio_transporte_test.dart`.
-class _ReproductorFalsoEq extends AudioPlayer {
-  _ReproductorFalsoEq(
-    this._guion,
-    AudioPipeline pipeline,
-    AudioLoadConfiguration carga,
-  ) : super(audioPipeline: pipeline, audioLoadConfiguration: carga) {
-    _guion.ultimoReproductor = this;
-  }
-
-  final _GuionReproductorEq _guion;
-  final _estados = StreamController<PlayerState>.broadcast();
-
-  @override
-  Stream<PlayerState> get playerStateStream => _estados.stream;
-
-  @override
-  Future<Duration?> setUrl(
-    String url, {
-    Map<String, String>? headers,
-    Duration? initialPosition,
-    bool preload = true,
-    dynamic tag,
-  }) async {
-    _guion.llamadasSetUrl++;
-    return null;
-  }
-
-  @override
-  Future<void> play() async {}
-
-  @override
-  Future<void> pause() async {}
-
-  @override
-  Future<void> stop() async {}
-
-  @override
-  Future<void> setVolume(double volume) async {}
-
-  @override
-  Future<void> dispose() async {
-    await _estados.close();
-  }
-}

test/servicios/servicio_audio_eq_estado_unico_test.dart

@@ -1,478 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart' show PlayerState, ProcessingState;
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// eq-estado-unico — the equalizer's on/off flag gets a SINGLE owner.
-///
-/// Reported bug: «alguna emisora parece que esta con la ecualizacion activada
-/// (suena muy alto) pero con el boton desactivado», and «pulsando sobre el
-/// boton de ecualizar en Android Auto tampoco activaba ni desactivaba».
-///
-/// The flag used to live in three independent copies — the handler's
-/// hardcoded `_ecualizadorActivo = true`, `EstadoEcualizador._activo`, and
-/// SharedPreferences — and the persisted value only ever reached the handler
-/// through `EstadoEcualizador.cargarPersistido()`, which a headless Android
-/// Auto engine (no Activity, no Provider tree, no `EstadoRadio._init`) never
-/// runs. So in the car the handler played with the equalizer forced ON while
-/// disk and the phone UI both said OFF.
-///
-/// NOTE on testability: the long-standing comment in `servicio_audio.dart`
-/// claiming `PluriWaveAudioHandler` "cannot be instantiated in a unit test
-/// (a real just_audio.AudioPlayer needs platform MethodChannels)" is WRONG
-/// as of just_audio 0.9.46 — `AudioPlayer`'s constructor resolves its
-/// platform lazily and never becomes active without a `setUrl`, so the
-/// handler constructs fine here and every EQ path that does not touch the
-/// native effect is directly exercisable. That is what the dispatch tests
-/// below rely on; only the native `setEnabled`/`setGain` calls stay out of
-/// reach (they sit behind `_eqDisponible`, which is `false` off-device).
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  group('estadoEqInicial (A — seed the handler from disk on every engine)', () {
-    test('adopts the persisted value when there is one', () {
-      expect(estadoEqInicial(persistido: false), isFalse);
-      expect(estadoEqInicial(persistido: true), isTrue);
-    });
-
-    test('defaults to ON only when nothing was ever persisted', () {
-      expect(
-        estadoEqInicial(persistido: null),
-        isTrue,
-        reason: 'a first install keeps the historical default (EQ on)',
-      );
-    });
-  });
-
-  group('registrarHandler (A — seeding)', () {
-    test('consults the injected read port exactly once and seeds the handler '
-        'with the persisted value', () async {
-      final handler = crearHandler();
-      var lecturas = 0;
-
-      registrarHandler(
-        handler,
-        leerEqActivoPersistido: () async {
-          lecturas++;
-          return false;
-        },
-      );
-      await Future<void>.delayed(Duration.zero);
-
-      expect(lecturas, 1, reason: 'exactly one disk read per engine start');
-      expect(
-        handler.ecualizadorActivo,
-        isFalse,
-        reason: 'the handler must adopt what the phone UI persisted',
-      );
-    });
-
-    test('a read failure leaves the handler on the safe default instead of '
-        'propagating', () async {
-      final handler = crearHandler();
-
-      registrarHandler(
-        handler,
-        leerEqActivoPersistido: () async => throw StateError('sin disco'),
-      );
-      await Future<void>.delayed(Duration.zero);
-
-      expect(handler.ecualizadorActivo, isTrue);
-    });
-
-    test('without a read port the handler is left untouched (widget tests, '
-        'fakes)', () async {
-      final handler = crearHandler();
-      await handler.setEcualizadorActivo(false);
-
-      registrarHandler(handler);
-      await Future<void>.delayed(Duration.zero);
-
-      expect(handler.ecualizadorActivo, isFalse);
-    });
-  });
-
-  /// A, CONSTRUCTION-WINDOW half. `_eqActivoPersistido` (the module-level
-  /// cache behind `_ecualizadorActivo = estadoEqInicial(persistido: ...)`)
-  /// had zero coverage on BOTH sides: replacing that initialiser with the old
-  /// hardcoded `= true` left the suite green, and so did deleting the
-  /// `_eqActivoPersistido = activo` write in `_aplicarEcualizadorActivo`.
-  ///
-  /// The window it closes is real: `AudioService.init` builds the handler
-  /// through its `builder` callback and only AFTER that future resolves does
-  /// `main.dart` reach `registrarHandler`. A car tap landing inside that
-  /// window would otherwise hit a handler whose flag had never seen disk.
-  group('A (construction window) — a handler built after a disk read', () {
-    test('a handler constructed AFTER a read port has already answered '
-        'starts from the persisted value, not from a hardcoded default',
-        () async {
-      // One engine does the read `registrarHandler` performs in main.dart.
-      final primero = crearHandler();
-
-      // Pin the module cache to the OPPOSITE value first. Without this the
-      // test passes for the wrong reason: whatever ran before may already
-      // have left the cache on `false`, so deleting the disk→cache write in
-      // `_sembrarEcualizadorDesdeDisco` would still leave this green. Seeding
-      // does NOT write the cache (`_aplicarEcualizadorActivo` returns before
-      // it when `persistir: false`), so after this pin that write is the only
-      // path that can bring the cache back down to `false`.
-      await primero.setEcualizadorActivo(true);
-
-      registrarHandler(primero, leerEqActivoPersistido: () async => false);
-      await Future<void>.delayed(Duration.zero);
-      expect(primero.ecualizadorActivo, isFalse);
-
-      // Now the construction window: a handler built by `AudioService.init`'s
-      // builder, with no port of its own yet.
-      final segundo = crearHandler();
-
-      expect(
-        segundo.ecualizadorActivo,
-        isFalse,
-        reason:
-            'a car tap landing before registrarHandler must not find the '
-            'equalizer forced on while disk says off',
-      );
-    });
-
-    test('the cache follows what the handler itself writes, in both '
-        'directions', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      await handler.setEcualizadorActivo(false);
-      expect(
-        crearHandler().ecualizadorActivo,
-        isFalse,
-        reason:
-            'the write side of the cache: a toggle must be visible to the '
-            'next handler built on this engine',
-      );
-
-      await handler.setEcualizadorActivo(true);
-      expect(crearHandler().ecualizadorActivo, isTrue);
-    });
-  });
-
-  group('B — the handler persists its OWN toggle', () {
-    test('an eq toggle writes through the injected port even with no '
-        'EstadoEcualizador in play', () async {
-      final handler = crearHandler();
-      final escrituras = <bool>[];
-
-      registrarHandler(
-        handler,
-        guardarEqActivoPersistido: (activo) async => escrituras.add(activo),
-      );
-
-      await handler.setEcualizadorActivo(false);
-      await handler.setEcualizadorActivo(true);
-
-      expect(
-        escrituras,
-        [false, true],
-        reason:
-            'a car/notification toggle must survive a process restart '
-            'without any UI object existing',
-      );
-    });
-
-    test('seeding from disk does NOT write back to disk', () async {
-      final handler = crearHandler();
-      final escrituras = <bool>[];
-
-      registrarHandler(
-        handler,
-        leerEqActivoPersistido: () async => false,
-        guardarEqActivoPersistido: (activo) async => escrituras.add(activo),
-      );
-      await Future<void>.delayed(Duration.zero);
-
-      expect(handler.ecualizadorActivo, isFalse);
-      expect(escrituras, isEmpty);
-    });
-
-    test('a failing write port never breaks the toggle', () async {
-      final handler = crearHandler();
-
-      registrarHandler(
-        handler,
-        guardarEqActivoPersistido: (_) async => throw StateError('disco lleno'),
-      );
-
-      await handler.setEcualizadorActivo(false);
-
-      expect(handler.ecualizadorActivo, isFalse);
-    });
-  });
-
-  group('decidirToggleEq (C — the customAction decision)', () {
-    test('flips the current value', () {
-      expect(
-        decidirToggleEq(activoActual: true, eqDisponible: true).nuevoActivo,
-        isFalse,
-      );
-      expect(
-        decidirToggleEq(activoActual: false, eqDisponible: true).nuevoActivo,
-        isTrue,
-      );
-    });
-
-    test('a native call is required only when the effect is attached', () {
-      expect(
-        decidirToggleEq(
-          activoActual: true,
-          eqDisponible: true,
-        ).requiereLlamadaNativa,
-        isTrue,
-      );
-      expect(
-        decidirToggleEq(
-          activoActual: true,
-          eqDisponible: false,
-        ).requiereLlamadaNativa,
-        isFalse,
-        reason:
-            'with no native Equalizer effect the flag still flips, but '
-            'nothing is pushed to the platform',
-      );
-    });
-
-    test('the flag still flips with no native effect — the car button must '
-        'never look inert', () {
-      expect(
-        decidirToggleEq(activoActual: false, eqDisponible: false).nuevoActivo,
-        isTrue,
-      );
-    });
-  });
-
-  group('customAction dispatch (C — zero coverage before this)', () {
-    test('the accionEqToggle literal routes through decidirToggleEq', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      await handler.setEcualizadorActivo(true);
-
-      await handler.customAction(accionEqToggle);
-      expect(handler.ecualizadorActivo, isFalse);
-
-      await handler.customAction(accionEqToggle);
-      expect(handler.ecualizadorActivo, isTrue);
-    });
-
-    test('a car toggle persists through the same write port as a phone '
-        'toggle', () async {
-      final handler = crearHandler();
-      final escrituras = <bool>[];
-      registrarHandler(
-        handler,
-        guardarEqActivoPersistido: (activo) async => escrituras.add(activo),
-      );
-      // Explicit starting state. A fresh handler seeds `_ecualizadorActivo`
-      // from the module-level `_eqActivoPersistido` cache, which any earlier
-      // test in this file leaves at whatever it last wrote. This assertion
-      // is about what the TOGGLE does, not about what the previous test
-      // happened to leave behind — without these two lines, simply
-      // reordering the tests silently flips the expectation to `[true]`.
-      await handler.setEcualizadorActivo(true);
-      escrituras.clear();
-
-      await handler.customAction(accionEqToggle);
-
-      expect(escrituras, [false]);
-    });
-
-    test('an unknown custom action is a silent no-op', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      final antes = handler.ecualizadorActivo;
-
-      await handler.customAction('accion.inexistente');
-
-      expect(handler.ecualizadorActivo, antes);
-    });
-  });
-
-  group('debeReasertarEcualizadorNativo (D — re-assert on activation)', () {
-    test('an idle -> active transition with the effect attached re-asserts', () {
-      expect(
-        PluriWaveAudioHandler.debeReasertarEcualizadorNativo(
-          estado: ProcessingState.ready,
-          reproductorActivoAntes: false,
-          eqDisponible: true,
-        ),
-        isTrue,
-        reason:
-            "just_audio's AudioEffect.setEnabled only reaches the platform "
-            'while the player is active, so a toggle made while stopped '
-            'never landed natively',
-      );
-    });
-
-    test('staying active does not re-assert on every event', () {
-      expect(
-        PluriWaveAudioHandler.debeReasertarEcualizadorNativo(
-          estado: ProcessingState.ready,
-          reproductorActivoAntes: true,
-          eqDisponible: true,
-        ),
-        isFalse,
-      );
-    });
-
-    test('going idle does not re-assert', () {
-      expect(
-        PluriWaveAudioHandler.debeReasertarEcualizadorNativo(
-          estado: ProcessingState.idle,
-          reproductorActivoAntes: true,
-          eqDisponible: true,
-        ),
-        isFalse,
-      );
-    });
-
-    test('no attached effect never re-asserts', () {
-      expect(
-        PluriWaveAudioHandler.debeReasertarEcualizadorNativo(
-          estado: ProcessingState.ready,
-          reproductorActivoAntes: false,
-          eqDisponible: false,
-        ),
-        isFalse,
-      );
-    });
-
-    test('buffering/loading/completed already count as active', () {
-      for (final estado in [
-        ProcessingState.loading,
-        ProcessingState.buffering,
-        ProcessingState.completed,
-      ]) {
-        expect(
-          PluriWaveAudioHandler.debeReasertarEcualizadorNativo(
-            estado: estado,
-            reproductorActivoAntes: false,
-            eqDisponible: true,
-          ),
-          isTrue,
-          reason:
-              '$estado is a non-idle state, i.e. the platform player is '
-              'attached and accepts effect calls',
-        );
-      }
-    });
-  });
-
-  /// D, WIRING half. Everything above this group tests the pure
-  /// [PluriWaveAudioHandler.debeReasertarEcualizadorNativo] predicate and
-  /// nothing else: deleting the `playerStateStream` listener's whole re-assert
-  /// block — the `if (debeReasertar...) unawaited(_reasertarEcualizadorNativo())`
-  /// call, the `_reproductorActivo = proc != ProcessingState.idle` edge
-  /// tracking — left the suite green. That is the SAME producer-only hole that
-  /// let a dead Android Auto EQ button ship, so it gets closed here rather than
-  /// re-tested at the predicate.
-  ///
-  /// [PluriWaveAudioHandler.manejarEstadoPlayer] IS the listener body — the
-  /// same method `playerStateStream.listen` is subscribed to — so these
-  /// drive the real handler through real player-state transitions.
-  group('D (wiring) — the playerState idle -> active edge', () {
-    PlayerState estado(ProcessingState proc, {bool playing = false}) =>
-        PlayerState(playing, proc);
-
-    test('the first non-idle event re-asserts the native effect exactly '
-        'once, and staying active never re-asserts again', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      expect(handler.reasercionesEcualizador, 0);
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.loading));
-      expect(
-        handler.reasercionesEcualizador,
-        1,
-        reason:
-            "just_audio's AudioEffect.setEnabled is a no-op while the "
-            'platform player is detached, so a toggle made while stopped '
-            'only lands on this edge',
-      );
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.buffering));
-      handler.manejarEstadoPlayer(estado(ProcessingState.ready, playing: true));
-      handler.manejarEstadoPlayer(estado(ProcessingState.completed));
-      expect(
-        handler.reasercionesEcualizador,
-        1,
-        reason:
-            'the player emits many events while active; re-asserting on '
-            'each one would be a native call storm',
-      );
-    });
-
-    test('going idle re-arms the edge, so stop + play re-asserts again — '
-        'this is the `_reproductorActivo = proc != idle` line', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.simularEcualizadorDisponible(true);
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.ready, playing: true));
-      expect(handler.reasercionesEcualizador, 1);
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.idle));
-      expect(
-        handler.reasercionesEcualizador,
-        1,
-        reason: 'going idle itself never re-asserts',
-      );
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.ready, playing: true));
-      expect(
-        handler.reasercionesEcualizador,
-        2,
-        reason:
-            'without the edge-tracking assignment the flag would stay true '
-            'and the toggle made while stopped would never land natively',
-      );
-    });
-
-    test('with no native effect attached nothing is ever re-asserted', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      // `_eqDisponible` is false off-device, which is also the real
-      // "device has no Equalizer effect" case.
-
-      handler.manejarEstadoPlayer(estado(ProcessingState.ready, playing: true));
-      handler.manejarEstadoPlayer(estado(ProcessingState.idle));
-      handler.manejarEstadoPlayer(estado(ProcessingState.ready, playing: true));
-
-      expect(handler.reasercionesEcualizador, 0);
-    });
-  });
-
-  group('F — the EQ re-push must not rewind the car progress bar', () {
-    test('the EQ controls re-push refreshes updatePosition from the '
-        'player', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-      handler.playbackState.add(
-        handler.playbackState.value.copyWith(
-          updatePosition: const Duration(minutes: 3),
-        ),
-      );
-
-      await handler.setEcualizadorActivo(false);
-
-      expect(
-        handler.playbackState.value.updatePosition,
-        handler.posicionActual,
-        reason:
-            'copyWith stamps a fresh updateTime but keeps the OLD '
-            'updatePosition, so an EQ tap told the car "you are at 3:00, as '
-            'of right now" and the bar snapped backwards',
-      );
-    });
-  });
-}

test/servicios/servicio_audio_eq_ganancia_test.dart

@@ -1,201 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-/// `mapearGananciaNativa` — the hand-off from the app's ±12 dB slider to the
-/// device's native `Equalizer`, whose capability is reported as
-/// `AndroidEqualizerParameters.min/maxDecibels`
-/// (`Equalizer.getBandLevelRange()` in millibels, divided by 1000).
-///
-/// WHY THIS CONTRACT CHANGED — the previous one stretched each side of the
-/// slider against its own end of the native range, so `+6` on a device
-/// reporting `[-12, +20]` was delivered as `+10`. Both sides of the mapping
-/// are already the SAME unit, so that multiplication was a unit error:
-///
-///   * `just_audio` documents `setGain` as "Sets the gain for this band in
-///     decibels", and its Android bridge does `setBandLevel(band,
-///     round(gain * 1000.0))` — plain dB to millibels, no normalisation.
-///     `min/maxDecibels` are the device's absolute CAPABILITY in dB, i.e. a
-///     bound on the control, not a scale to normalise into.
-///   * The app makes the user a decibel promise in three places at once: the
-///     slider is hard-coded `min: -12.0, max: 12.0`, the label under each
-///     band prints `'${banda.toStringAsFixed(1)}dB'`, and TalkBack reads out
-///     `equalizerBandValue` = "{value} decibels". Stretching made that label
-///     a lie on every device whose range is not exactly ±12.
-///   * Presets are persisted and EXPORTED as those same raw slider dB
-///     (`PresetEcualizador.toJson`), so under the old mapping a backup
-///     restored on a wider-range phone showed identical numbers and played
-///     louder — and on the common asymmetric shape `[-12, +19]` boosts were
-///     multiplied by 1.58 while cuts were not, deforming the preset's SHAPE
-///     rather than merely its depth.
-///
-/// So: the number the user reads is the number the device is asked for. The
-/// native range only CLAMPS it.
-///
-/// What this deliberately KEEPS from the previous contract — every invariant
-/// the «suena muy alto» fix actually earned. 0 dB is always exactly 0 (a
-/// naive `db.clamp(minDecibels, maxDecibels)` would regress that on a wholly
-/// positive reported range, turning a FLAT preset into a boost again), the
-/// sign of the user's intent is never inverted, the result never escapes the
-/// native range, a device with no headroom above unity can never boost, and a
-/// zero-width range collapses to 0.
-void main() {
-  group('mapearGananciaNativa — 0 dB is always exactly 0', () {
-    test('symmetric range (the common case) is unchanged', () {
-      expect(
-        mapearGananciaNativa(0, minDecibels: -15, maxDecibels: 15),
-        0,
-      );
-    });
-
-    test('asymmetric range no longer boosts a FLAT preset', () {
-      // The reported symptom: on a device reporting [-12, +19] the old
-      // midpoint mapping turned every 0 dB band into +3.5 dB of real boost.
-      expect(
-        mapearGananciaNativa(0, minDecibels: -12, maxDecibels: 19),
-        0,
-        reason: 'a FLAT preset must be inaudible, on every device',
-      );
-    });
-
-    test('a wholly positive range still cannot boost a FLAT preset', () {
-      // This is precisely why the mapping cannot be a plain
-      // `db.clamp(minDecibels, maxDecibels)`: that would answer +3 here and
-      // bring the «suena muy alto» bug straight back. The clamp window has
-      // to be widened so that it always contains 0.
-      expect(mapearGananciaNativa(0, minDecibels: 3, maxDecibels: 19), 0);
-    });
-
-    test('a wholly negative range still cannot cut a FLAT preset', () {
-      expect(mapearGananciaNativa(0, minDecibels: -19, maxDecibels: -3), 0);
-    });
-  });
-
-  group('mapearGananciaNativa — the slider dB reach the device literally', () {
-    test('+12 dB is delivered as +12 dB, not stretched to the native max', () {
-      // CONTRACT CHANGE: this used to assert 19, i.e. the whole of the
-      // device's headroom. The slider says "12.0dB" and the accessibility
-      // label says "12.0 decibels", so 12 dB is what the device must be
-      // asked for. The 7 dB of extra hardware headroom is unreachable by
-      // design until the slider itself is widened and says so.
-      expect(mapearGananciaNativa(12, minDecibels: -12, maxDecibels: 19), 12);
-    });
-
-    test('-12 dB is delivered as -12 dB', () {
-      expect(mapearGananciaNativa(-12, minDecibels: -12, maxDecibels: 19), -12);
-    });
-
-    test('values beyond the slider scale clamp to the slider limit', () {
-      // CONTRACT CHANGE: these used to answer the NATIVE extremes (±15).
-      // The slider scale is the first bound; the device range is the second.
-      expect(mapearGananciaNativa(40, minDecibels: -15, maxDecibels: 15), 12);
-      expect(mapearGananciaNativa(-40, minDecibels: -15, maxDecibels: 15), -12);
-    });
-  });
-
-  group('mapearGananciaNativa — the label is the value the device gets', () {
-    test('+6 dB on a wide-range device is +6 dB, never 10', () {
-      // CONTRACT CHANGE: this used to assert closeTo(10) — "half boost is
-      // half of the positive headroom". A slider reading "6.0dB" that
-      // produced +10 dB of real boost is exactly what made a restored backup
-      // sound different on a different phone.
-      expect(
-        mapearGananciaNativa(6, minDecibels: -12, maxDecibels: 20),
-        closeTo(6, 1e-9),
-      );
-    });
-
-    test('-6 dB on that same device is -6 dB', () {
-      expect(
-        mapearGananciaNativa(-6, minDecibels: -12, maxDecibels: 20),
-        closeTo(-6, 1e-9),
-      );
-    });
-
-    test('the six factory presets keep their shape on an asymmetric device', () {
-      // Jazz, authored in true dB before any scaling existed. Under the old
-      // mapping [-12, +19] delivered it as [4.75, -1, -1.5, 3.17, 6.33]: a
-      // different tonal curve, not merely a louder one.
-      const jazz = [3.0, -1.0, -1.5, 2.0, 4.0];
-      final entregado = jazz
-          .map(
-            (db) =>
-                mapearGananciaNativa(db, minDecibels: -12, maxDecibels: 19),
-          )
-          .toList();
-      expect(entregado, jazz);
-    });
-
-    test('the sign of the user intent is never inverted', () {
-      for (final db in [-12.0, -6.0, -1.0, 1.0, 6.0, 12.0]) {
-        final nativo = mapearGananciaNativa(
-          db,
-          minDecibels: -12,
-          maxDecibels: 19,
-        );
-        expect(
-          nativo.sign,
-          db.sign,
-          reason: 'a cut must never become a boost ($db dB -> $nativo)',
-        );
-      }
-    });
-  });
-
-  group('mapearGananciaNativa — a device narrower than the slider', () {
-    test('a request that fits is still delivered literally', () {
-      // CONTRACT CHANGE: the old mapping shrank this to (3/12)*6 = 1.5 dB,
-      // so a modest device silently under-delivered every request too.
-      expect(mapearGananciaNativa(3, minDecibels: -6, maxDecibels: 6), 3);
-      expect(mapearGananciaNativa(-3, minDecibels: -6, maxDecibels: 6), -3);
-    });
-
-    test('a request beyond the device range clamps to the device limit', () {
-      expect(mapearGananciaNativa(12, minDecibels: -6, maxDecibels: 6), 6);
-      expect(mapearGananciaNativa(-12, minDecibels: -6, maxDecibels: 6), -6);
-    });
-
-    test('a very narrow device still gets a sane, in-range value', () {
-      for (final db in [-12.0, -5.0, 0.0, 5.0, 12.0]) {
-        final nativo = mapearGananciaNativa(
-          db,
-          minDecibels: -1.5,
-          maxDecibels: 1.5,
-        );
-        expect(nativo, greaterThanOrEqualTo(-1.5));
-        expect(nativo, lessThanOrEqualTo(1.5));
-        expect(nativo.sign, db.sign);
-      }
-    });
-  });
-
-  group('mapearGananciaNativa — degenerate ranges reported by the device', () {
-    test('a device with no headroom above unity can never boost', () {
-      expect(mapearGananciaNativa(12, minDecibels: -15, maxDecibels: 0), 0);
-      expect(mapearGananciaNativa(6, minDecibels: -15, maxDecibels: 0), 0);
-    });
-
-    test('a cut the device could honour exactly is not over-delivered', () {
-      // CONTRACT CHANGE: this used to answer -15, spending the device's whole
-      // range on a request for -12 dB. The user asked for -12; -12 is
-      // representable here, so -12 is what is sent.
-      expect(mapearGananciaNativa(-12, minDecibels: -15, maxDecibels: 0), -12);
-    });
-
-    test('a zero-width range collapses everything to 0', () {
-      expect(mapearGananciaNativa(12, minDecibels: 0, maxDecibels: 0), 0);
-      expect(mapearGananciaNativa(-12, minDecibels: 0, maxDecibels: 0), 0);
-    });
-
-    test('the result never escapes the native range', () {
-      for (final db in [-12.0, -3.0, 0.0, 3.0, 12.0]) {
-        final nativo = mapearGananciaNativa(
-          db,
-          minDecibels: -3,
-          maxDecibels: 19,
-        );
-        expect(nativo, greaterThanOrEqualTo(-3));
-        expect(nativo, lessThanOrEqualTo(19));
-      }
-    });
-  });
-}

test/servicios/servicio_audio_gating_test.dart

@@ -1,12 +1,5 @@
-import 'package:audio_service/audio_service.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:pluriwave/modelos/pista_local.dart';
-import 'package:pluriwave/servicios/musica_local_auto.dart';
-import 'package:pluriwave/servicios/navegacion_auto.dart';
 import 'package:pluriwave/servicios/servicio_audio.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/handlers_audio.dart';
 
 /// Android Auto play-path backstop (design.md ADR-4, android-auto-media
 /// spec "Free-Tier Browse Never Leaks Real Content" + "Current-Station
@@ -20,204 +13,26 @@ import '../helpers/handlers_audio.dart';
 /// handler's dispatch methods delegate to (mirrors `mapearEstadoProceso`
 /// and every other pure helper in this file).
 void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  // fix/auto-quality-guidelines item 11: the gate is CONTENT-scoped now.
-  // Blocking every switch for the free tier is what made the car surface
-  // useless for the only tier a Play reviewer can be in.
-  test('free tier: bloquea una emisora del catálogo premium', () {
-    expect(
-      debeBloquearCambioDeEmisora(premium: false, esEmisoraGratuita: false),
-      isTrue,
-    );
-  });
-
-  test('free tier: NO bloquea una emisora del set gratuito', () {
-    expect(
-      debeBloquearCambioDeEmisora(premium: false, esEmisoraGratuita: true),
-      isFalse,
-    );
+  test('free tier: bloquea cualquier cambio de emisora/salto', () {
+    expect(debeBloquearCambioDeEmisora(premium: false), isTrue);
   });
 
   test('premium: nunca bloquea', () {
-    expect(
-      debeBloquearCambioDeEmisora(premium: true, esEmisoraGratuita: false),
-      isFalse,
-    );
+    expect(debeBloquearCambioDeEmisora(premium: true), isFalse);
   });
 
-  /// fix/android-auto-musica-local, item 4: el hook dejó de ser «solo la
-  /// transición free -> premium». Android Auto cachea la raíz, así que
-  /// CUALQUIER momento en el que el árbol pasa a poder mostrar algo que
-  /// antes no podía tiene que invalidarla — muy en particular, que aparezca
-  /// por fin una Activity (y con ella el handler nativo del canal
-  /// `pluriwave/file_actions`) o que el usuario acabe de elegir carpeta.
-  /// De ahí el nombre neutro.
-  group('invalidarArbolAuto / registrarInvalidacionArbolAuto', () {
+  group('notificarDesbloqueoAuto / registrarNotificacionDesbloqueoAuto', () {
     test('sin hook registrado, es un no-op seguro', () {
-      expect(() => invalidarArbolAuto(), returnsNormally);
+      expect(() => notificarDesbloqueoAuto(), returnsNormally);
     });
 
     test('invoca el hook registrado exactamente una vez por llamada', () {
       var llamadas = 0;
-      registrarInvalidacionArbolAuto(() => llamadas++);
+      registrarNotificacionDesbloqueoAuto(() => llamadas++);
 
-      invalidarArbolAuto();
+      notificarDesbloqueoAuto();
 
       expect(llamadas, 1);
     });
-
-    test('registrarHandler conecta la invalidación al handler: una llamada '
-        'notifica la raíz Y Música Local', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      final raiz = <Map<String, dynamic>>[];
-      final local = <Map<String, dynamic>>[];
-      final subRaiz = handler
-          .subscribeToChildren(AudioService.browsableRootId)
-          .listen(raiz.add);
-      final subLocal = handler
-          .subscribeToChildren(ConstructorArbolAuto.idMusicaLocal)
-          .listen(local.add);
-
-      invalidarArbolAuto();
-      await Future<void>.delayed(Duration.zero);
-      await subRaiz.cancel();
-      await subLocal.cancel();
-
-      expect(raiz, hasLength(1));
-      expect(local, hasLength(1));
-    });
-  });
-
-  /// fix/android-auto-musica-local, item 5.
-  ///
-  /// `subscribeToChildren` sembraba el `BehaviorSubject` con un mapa vacío.
-  /// El listener interno de `audio_service` se suscribe en cuanto el head
-  /// unit navega un id, recibe ESE valor semilla de inmediato y lo reenvía
-  /// como `notifyChildrenChanged` — o sea, el primer browse de cada id
-  /// provocaba un segundo `getChildren` espurio. En la raíz eso era un
-  /// SEGUNDO round trip de permisos justo en la ruta que ya estaba
-  /// fallando. Sin semilla no hay valor que reenviar, y la invalidación
-  /// explícita (`notificarHijosCambiaron`) sigue funcionando igual.
-  group('subscribeToChildren', () {
-    test('el sujeto arranca SIN valor: nada que reenviar en la primera '
-        'suscripción, así que no hay notifyChildrenChanged espurio', () {
-      final handler = crearHandler();
-
-      expect(handler.subscribeToChildren('musica_local').hasValue, isFalse);
-    });
-
-    test('memoiza por id: dos llamadas devuelven el MISMO stream', () {
-      final handler = crearHandler();
-
-      expect(
-        identical(
-          handler.subscribeToChildren('musica_local'),
-          handler.subscribeToChildren('musica_local'),
-        ),
-        isTrue,
-      );
-      expect(
-        identical(
-          handler.subscribeToChildren('musica_local'),
-          handler.subscribeToChildren('favoritos'),
-        ),
-        isFalse,
-      );
-    });
-
-    test('notificarHijosCambiaron sí empuja un valor al sujeto ya suscrito',
-        () async {
-      final handler = crearHandler();
-      final stream = handler.subscribeToChildren('musica_local');
-      final recibidos = <Map<String, dynamic>>[];
-      final sub = stream.listen(recibidos.add);
-
-      handler.notificarHijosCambiaron('musica_local');
-      await Future<void>.delayed(Duration.zero);
-      await sub.cancel();
-
-      expect(recibidos, hasLength(1));
-    });
-  });
-
-  /// fix/android-auto-musica-local — «no aparece la opción de reproducir
-  /// música local, no aparece ni el menú», con la compra PRO hecha.
-  ///
-  /// La raíz decidía la existencia del nodo con un round trip de permisos
-  /// por `MethodChannel`. En el motor headless que Android Auto levanta sin
-  /// Activity ese canal no tiene handler, la llamada lanzaba
-  /// `MissingPluginException` y el nodo se omitía — y Android Auto CACHEA
-  /// la raíz, así que se quedaba fuera toda la sesión.
-  ///
-  /// La pertenencia a la raíz ya no depende de poder contestar esa
-  /// pregunta: basta con que el estado NO sea [EstadoCarpetaLocal.noConfigurada].
-  group('getChildren(root): pertenencia de Música Local', () {
-    setUp(() {
-      SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
-    });
-
-    Future<List<String>> idsRaizCon(EstadoCarpetaLocal estado) async {
-      registrarFuenteMusicaLocal(_FakeFuenteMusicaLocalGating(estado));
-      final handler = crearHandler();
-      final items = await handler.getChildren(AudioService.browsableRootId);
-      return items.map((i) => i.id).toList();
-    }
-
-    test(
-      'canalNoDisponible (motor sin Activity, pero el usuario SÍ eligió '
-      'carpeta): la raíz sigue ofreciendo Música Local',
-      () async {
-        expect(
-          await idsRaizCon(EstadoCarpetaLocal.canalNoDisponible),
-          contains(ConstructorArbolAuto.idMusicaLocal),
-        );
-      },
-    );
-
-    test('configurada: la raíz ofrece Música Local', () async {
-      expect(
-        await idsRaizCon(EstadoCarpetaLocal.configurada),
-        contains(ConstructorArbolAuto.idMusicaLocal),
-      );
-    });
-
-    test(
-      'noConfigurada (nunca se eligió carpeta, o el permiso está revocado '
-      'de verdad): la raíz sigue omitiendo Música Local',
-      () async {
-        expect(
-          await idsRaizCon(EstadoCarpetaLocal.noConfigurada),
-          isNot(contains(ConstructorArbolAuto.idMusicaLocal)),
-        );
-      },
-    );
   });
 }
-
-/// Misma forma que `_FakeFuenteMusicaLocalAuto` en
-/// `navegacion_auto_test.dart`, reducida a lo que esta suite necesita: solo
-/// el estado de la carpeta decide la raíz.
-class _FakeFuenteMusicaLocalGating implements FuenteMusicaLocalAuto {
-  _FakeFuenteMusicaLocalGating(this._estado);
-
-  final EstadoCarpetaLocal _estado;
-
-  @override
-  Future<EstadoCarpetaLocal> estadoCarpeta() async => _estado;
-
-  @override
-  Future<List<NodoLocal>> hijos(String documentId) async => const [];
-
-  @override
-  Future<String?> uriContenidoDePista(String documentId) async => null;
-
-  @override
-  Future<Map<String, MetadatosPista>> metadatosDe(
-    List<String> documentIds,
-  ) async => const {};
-}

test/servicios/servicio_audio_transporte_test.dart

@@ -1,736 +0,0 @@
-import 'dart:async';
-import 'dart:ui' show Locale;
-
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart';
-import 'package:pluriwave/l10n/gen/app_localizations.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// Android for Cars App Quality Guidelines — transport state machine.
-///
-/// Google Play returned "Approved with Issues" against version code 157:
-/// «clicking on stop button makes the entire app useless». These tests drive
-/// the REAL [PluriWaveAudioHandler] against a scripted [AudioPlayer] double
-/// (installed through [PluriWaveAudioHandler.fabricaReproductorPrueba]) so
-/// the published `playbackState` sequence — the only thing Android Auto ever
-/// sees — can be asserted end to end.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  late _GuionReproductor guion;
-
-  setUp(() {
-    guion = _GuionReproductor();
-    PluriWaveAudioHandler.fabricaReproductorPrueba =
-        (pipeline, carga) => _ReproductorFalso(guion, pipeline, carga);
-  });
-
-  tearDown(() {
-    PluriWaveAudioHandler.fabricaReproductorPrueba = null;
-  });
-
-  group('stop() durante cambios de fuente en vuelo (P0 — botón Stop)', () {
-    test(
-      'dos cambios encolados y un stop: el ultimo estado publicado es idle, '
-      'nunca vuelve a loading',
-      () async {
-        final handler = crearHandler();
-        final publicados = <AudioProcessingState>[];
-        final sub = handler.playbackState.listen(
-          (estado) => publicados.add(estado.processingState),
-        );
-
-        unawaited(
-          handler
-              .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-              .catchError((_) {}),
-        );
-        unawaited(
-          handler
-              .playMediaItem(const MediaItem(id: 'https://b', title: 'B'))
-              .catchError((_) {}),
-        );
-
-        await handler.stop();
-        // Drain both queued source changes: they must discover the stale
-        // revision WITHOUT ever publishing again.
-        await pumpEventQueue();
-        await sub.cancel();
-
-        expect(
-          publicados.last,
-          AudioProcessingState.idle,
-          reason:
-              'a stale queued source change must never rewrite `loading` over '
-              'the `idle` that stop() published — that is what leaves Android '
-              'Auto spinning forever on a dead session. Secuencia: $publicados',
-        );
-      },
-    );
-  });
-
-  group('pause() durante un cambio de fuente en vuelo (P0 — botón Pausa)', () {
-    test('la emisora NO arranca: _player.play() nunca se invoca', () async {
-      guion.completerSetUrl = Completer<Duration?>();
-      final handler = crearHandler();
-
-      unawaited(
-        handler
-            .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-            .catchError((_) {}),
-      );
-      await pumpEventQueue();
-      expect(
-        guion.llamadasSetUrl,
-        1,
-        reason: 'precondicion: el cambio de fuente esta en vuelo',
-      );
-
-      await handler.pause();
-      guion.completerSetUrl!.complete(null);
-      await pumpEventQueue();
-
-      expect(
-        guion.llamadasPlay,
-        0,
-        reason:
-            'the user pressed Pause while the station was loading — the load '
-            'finishing afterwards must never start playback behind their back',
-      );
-    });
-
-    test(
-      'y el coche no se queda en el spinner: el estado publicado sale de '
-      'loading',
-      () async {
-        guion.completerSetUrl = Completer<Duration?>();
-        final handler = crearHandler();
-
-        unawaited(
-          handler
-              .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-              .catchError((_) {}),
-        );
-        await pumpEventQueue();
-
-        await handler.pause();
-        guion.completerSetUrl!.complete(null);
-        await pumpEventQueue();
-
-        expect(
-          handler.playbackState.value.processingState,
-          isNot(AudioProcessingState.loading),
-          reason:
-              'withholding the play() must not leave the car showing the '
-              'spinner the load started with — nothing else will publish, '
-              'because the player never transitions',
-        );
-        expect(handler.playbackState.value.playing, isFalse);
-      },
-    );
-  });
-
-  group('Suelo de estado terminal (P0 — nunca un spinner eterno)', () {
-    setUp(() {
-      PluriWaveAudioHandler.vigilanciaTransitoria = const Duration(
-        milliseconds: 60,
-      );
-    });
-
-    tearDown(() {
-      PluriWaveAudioHandler.vigilanciaTransitoria =
-          PluriWaveAudioHandler.vigilanciaTransitoriaPorDefecto;
-    });
-
-    test(
-      'un buffering publicado SIN carga viva cae a un estado terminal dentro '
-      'de la ventana',
-      () async {
-        final handler = crearHandler();
-
-        handler.manejarEstadoPlayer(
-          PlayerState(false, ProcessingState.buffering),
-        );
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.buffering,
-          reason: 'precondicion: el coche esta viendo el spinner',
-        );
-
-        await Future<void>.delayed(const Duration(milliseconds: 250));
-
-        expect(
-          handler.playbackState.value.processingState,
-          isIn(const [
-            AudioProcessingState.ready,
-            AudioProcessingState.idle,
-            AudioProcessingState.error,
-          ]),
-          reason:
-              'the only exits from loading/buffering are player events that '
-              '.distinct() can swallow — without a floor the car spins '
-              'forever over a session nobody is driving',
-        );
-      },
-    );
-
-    test('una carga LEGITIMA en vuelo no se interrumpe', () async {
-      guion.completerSetUrl = Completer<Duration?>();
-      final handler = crearHandler();
-
-      unawaited(
-        handler
-            .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-            .catchError((_) {}),
-      );
-      await pumpEventQueue();
-
-      await Future<void>.delayed(const Duration(milliseconds: 250));
-
-      expect(
-        handler.playbackState.value.processingState,
-        AudioProcessingState.loading,
-        reason:
-            'the watchdog is a floor for a STALLED state machine, not a cap '
-            'on how long a slow station may take to open',
-      );
-    });
-
-    test(
-      'un mount estancado NO cae en un idle mudo: publica un motivo legible '
-      '(hallazgo 3)',
-      () async {
-        final handler = crearHandler();
-
-        // Exact shape of a stalled icecast mount: the socket opens, `setUrl`
-        // returns inside the timeout (so no TimeoutException and no
-        // PlayerException — `_esErrorDeRed` never fires and the reconnect
-        // machine is never entered), and then no data ever arrives. State
-        // sits at buffering with `_cambiosEnVuelo` already back to 0.
-        handler.manejarEstadoPlayer(
-          PlayerState(false, ProcessingState.buffering),
-        );
-
-        await Future<void>.delayed(const Duration(milliseconds: 250));
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.processingState,
-          AudioProcessingState.error,
-          reason:
-              'a bare `idle` routes straight into `AudioService._stop()` '
-              '(audio_service.dart:1131-1135), so the driver got silence, a '
-              'dead session and no explanation. `error` keeps the session '
-              'alive and carries a message',
-        );
-        expect(
-          estado.errorMessage,
-          isNotNull,
-          reason:
-              'the floor must say something the driver can read and act on',
-        );
-      },
-    );
-
-    test(
-      'un rebuffer normal a mitad de emision NO se convierte en error '
-      '(regresion: el suelo miraba solo processingState)',
-      () async {
-        final handler = crearHandler();
-
-        // Established playback: the stream delivered audio and ExoPlayer
-        // reached `ready` while playing. This is what separates a re-buffer
-        // from a mount that never produced a byte.
-        handler.manejarEstadoPlayer(PlayerState(true, ProcessingState.ready));
-        // Ordinary mid-stream re-buffer: `bufferForPlaybackAfterRebuffer` is
-        // 5 s, so a tunnel or an LTE handover routinely holds this state for
-        // longer than the floor's window. ExoPlayer raised no error, so
-        // `_intentarReconexion` never ran and `reintentoPendiente` is false;
-        // `_cambiosEnVuelo` is already 0 because the non-blocking
-        // `_iniciarPlaySinBloquear` returned long ago.
-        handler.manejarEstadoPlayer(
-          PlayerState(true, ProcessingState.buffering),
-        );
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.buffering,
-          reason: 'precondicion: el reproductor esta rellenando el buffer',
-        );
-
-        await Future<void>.delayed(const Duration(milliseconds: 250));
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.processingState,
-          isNot(AudioProcessingState.error),
-          reason:
-              'a self-recovering re-buffer over live audio must never be '
-              'converted into a hard STATE_ERROR: the driver is in a tunnel, '
-              'not on a dead mount, and `_errorTerminal` latches so nothing '
-              'the player emits afterwards could undo it',
-        );
-        expect(
-          estado.playing,
-          isTrue,
-          reason:
-              'the player still owns the timeline — publishing `playing: '
-              'false` over it desynchronises the head unit transport row',
-        );
-        expect(
-          estado.errorMessage,
-          isNull,
-          reason: 'nothing failed, so there is nothing to tell the driver',
-        );
-      },
-    );
-
-    test(
-      'un mount que NUNCA entrego audio sigue cayendo al suelo aunque el '
-      'reproductor diga playing: true',
-      () async {
-        final handler = crearHandler();
-
-        // `just_audio`'s `playing` is the play-when-ready intent flag: it
-        // flips to true the moment `play()` is called, whether or not a
-        // single byte ever arrives. So the stalled icecast mount the floor
-        // exists for reports `playing: true` too — `playing` alone can never
-        // be the discriminator.
-        handler.manejarEstadoPlayer(
-          PlayerState(true, ProcessingState.buffering),
-        );
-
-        await Future<void>.delayed(const Duration(milliseconds: 250));
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.processingState,
-          AudioProcessingState.error,
-          reason:
-              'no `ready` was ever reached on this run, so nothing is '
-              're-buffering: the driver is staring at a spinner and the floor '
-              'is the only exit',
-        );
-        expect(estado.errorMessage, isNotNull);
-      },
-    );
-
-    test(
-      'la ventana del suelo respeta el presupuesto de diez segundos hasta el '
-      'primer mensaje',
-      () {
-        expect(
-          PluriWaveAudioHandler.vigilanciaTransitoriaPorDefecto,
-          lessThanOrEqualTo(const Duration(seconds: 10)),
-          reason:
-              'the floor is the ONLY exit for a stalled mount, so its window '
-              'IS the time-to-first-message for that failure mode; twenty '
-              "seconds was double the code's own cited budget",
-        );
-      },
-    );
-  });
-
-  group('Error terminal de reproduccion: la sesion sobrevive (hallazgo 2)', () {
-    test(
-      'el ultimo estado publicado es error CON mensaje, y no lo sigue un idle',
-      () async {
-        // A non-network failure: `_esErrorDeRed` is false, so this goes
-        // straight down the terminal path instead of the reconnect machine.
-        guion.errorSetUrl = Exception('mount muerto');
-        final handler = crearHandler();
-        final publicados = <AudioProcessingState>[];
-        final sub = handler.playbackState.listen(
-          (estado) => publicados.add(estado.processingState),
-        );
-
-        await handler
-            .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-            .catchError((_) {});
-        await pumpEventQueue();
-
-        // What `_player.stop()` really does: just_audio.dart:1016-1025
-        // switches to the idle dummy platform, so `playerStateStream` emits a
-        // distinct (playing:false, idle). The double cannot do that on its
-        // own, so the test drives the exact event the real player would.
-        guion.ultimoReproductor!.emitir(
-          PlayerState(false, ProcessingState.idle),
-        );
-        await pumpEventQueue();
-        await sub.cancel();
-
-        final estado = handler.playbackState.value;
-        expect(
-          estado.processingState,
-          AudioProcessingState.error,
-          reason:
-              'forwarding that idle makes audio_service call '
-              'AudioService._stop() -> deactivateMediaSession() + stopSelf(), '
-              'so PluriWave dropped off the Android Auto playback surface a '
-              'single event-loop turn after showing the error',
-        );
-        expect(estado.errorMessage, isNotNull);
-        expect(
-          publicados.last,
-          isNot(AudioProcessingState.idle),
-          reason: 'secuencia publicada: $publicados',
-        );
-        expect(
-          handler.mediaItem.value,
-          isNotNull,
-          reason:
-              'Android Auto drops a session with no metadata to show, so '
-              'nulling the media item on the error path makes the app vanish '
-              'from the car pane even when the state itself survives — the '
-              'station that failed has to keep its name on screen',
-        );
-      },
-    );
-
-    test(
-      'un stop() del usuario DESPUES del error sigue produciendo un idle real '
-      '(la sesion tiene que poder morir cuando el conductor lo pide)',
-      () async {
-        guion.errorSetUrl = Exception('mount muerto');
-        final handler = crearHandler();
-
-        await handler
-            .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-            .catchError((_) {});
-        await pumpEventQueue();
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.error,
-          reason: 'precondicion',
-        );
-
-        await handler.stop();
-        await pumpEventQueue();
-
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.idle,
-          reason:
-              'suppressing the error-driven idle must NEVER make the Stop '
-              'button unkillable — that is the original citation',
-        );
-      },
-    );
-  });
-
-  group('Presupuesto de tiempo hasta el primer mensaje (<= 10 s)', () {
-    tearDown(() {
-      PluriWaveAudioHandler.timeoutCambioFuente =
-          PluriWaveAudioHandler.timeoutCambioFuentePorDefecto;
-    });
-
-    test('el timeout por defecto deja el primer mensaje dentro de 10 s', () {
-      expect(
-        PluriWaveAudioHandler.timeoutCambioFuentePorDefecto,
-        lessThanOrEqualTo(const Duration(seconds: 10)),
-        reason:
-            'Android for Cars App Quality Guidelines allow ten seconds before '
-            'the driver must be told something; the first attempt alone used '
-            'to burn twelve',
-      );
-    });
-
-    test(
-      'una fuente que nunca responde publica un mensaje visible al agotar el '
-      'primer intento',
-      () async {
-        PluriWaveAudioHandler.timeoutCambioFuente = const Duration(
-          milliseconds: 100,
-        );
-        guion.setUrlCuelga = true;
-        final handler = crearHandler();
-
-        unawaited(
-          handler
-              .playMediaItem(const MediaItem(id: 'https://muerta', title: 'X'))
-              .catchError((_) {}),
-        );
-        await Future<void>.delayed(const Duration(milliseconds: 300));
-
-        expect(
-          handler.playbackState.value.errorMessage,
-          isNotNull,
-          reason:
-              'the backoff used to publish `buffering` with errorMessage: '
-              'null, so the car showed a silent spinner for the whole ~100 s '
-              'reconnect window',
-        );
-        expect(
-          handler.playbackState.value.processingState,
-          AudioProcessingState.buffering,
-          reason: 'still retrying — the message rides ON TOP of the retry',
-        );
-      },
-    );
-
-    test('los reintentos siguen DETRAS del mensaje', () async {
-      PluriWaveAudioHandler.timeoutCambioFuente = const Duration(
-        milliseconds: 100,
-      );
-      guion.setUrlCuelga = true;
-      final handler = crearHandler();
-
-      unawaited(
-        handler
-            .playMediaItem(const MediaItem(id: 'https://muerta', title: 'X'))
-            .catchError((_) {}),
-      );
-      // First backoff delay is 1 s (ControladorReconexion default).
-      await Future<void>.delayed(const Duration(milliseconds: 1300));
-
-      expect(
-        guion.llamadasSetUrl,
-        greaterThanOrEqualTo(2),
-        reason: 'the reconnect machine keeps working after the first message',
-      );
-      expect(
-        handler.playbackState.value.errorMessage,
-        isNotNull,
-        reason:
-            'and the message survives the retry: re-entering `_cambiarFuente` '
-            'must not blank the car screen back to a silent spinner',
-      );
-    });
-  });
-
-  /// A handler nobody released goes on running: its terminal-state floor
-  /// timer, its `ControladorReconexion` backoff (1/2/4/8/16 s, which easily
-  /// outlives the test that armed it) and whatever is still queued on
-  /// `_colaCambioFuente`. When one of those finally performs a source change
-  /// it calls `_crearPlayer()`, which reads the CURRENT static
-  /// `fabricaReproductorPrueba` — so it builds a double bound to a LATER
-  /// test's script and increments that test's counters for work it never
-  /// asked for. A suite that passes under those conditions passes by luck.
-  group('Liberacion del handler: nada sobrevive al test que lo creo', () {
-    tearDown(() {
-      PluriWaveAudioHandler.timeoutCambioFuente =
-          PluriWaveAudioHandler.timeoutCambioFuentePorDefecto;
-    });
-
-    test(
-      'un handler liberado NO vuelve a construir un reproductor contra la '
-      'fabrica del test siguiente',
-      () async {
-        PluriWaveAudioHandler.timeoutCambioFuente = const Duration(
-          milliseconds: 60,
-        );
-        guion.setUrlCuelga = true;
-        final handler = crearHandler();
-
-        unawaited(
-          handler
-              .playMediaItem(const MediaItem(id: 'https://muerta', title: 'X'))
-              .catchError((_) {}),
-        );
-        // Long enough for the source-change timeout to fire and the reconnect
-        // machine to arm its first backoff retry (1 s).
-        await Future<void>.delayed(const Duration(milliseconds: 200));
-        expect(
-          guion.llamadasSetUrl,
-          1,
-          reason: 'precondicion: hay un reintento armado detras',
-        );
-
-        await handler.liberar();
-
-        // Exactly what the framework does between tests: a brand-new script
-        // and a factory bound to it. Nothing from the previous test may
-        // reach this.
-        final guionSiguiente = _GuionReproductor();
-        PluriWaveAudioHandler.fabricaReproductorPrueba = (pipeline, carga) =>
-            _ReproductorFalso(guionSiguiente, pipeline, carga);
-
-        await Future<void>.delayed(const Duration(milliseconds: 1400));
-
-        expect(
-          guionSiguiente.llamadasSetUrl,
-          0,
-          reason:
-              'the leaked backoff retry re-enters `_cambiarFuente`, which '
-              'calls `_crearPlayer()` and therefore reads whatever factory is '
-              'installed NOW — attributing a dead handler s work to the test '
-              'that happens to be running',
-        );
-        expect(
-          guionSiguiente.ultimoReproductor,
-          isNull,
-          reason: 'no player at all may be built against the new script',
-        );
-      },
-    );
-
-    test('liberar() es idempotente', () async {
-      final handler = crearHandler();
-
-      await handler.liberar();
-      await handler.liberar();
-    });
-  });
-
-  group('Idioma de la superficie del coche (motor sin Activity)', () {
-    tearDown(() {
-      PluriWaveAudioHandler.lectorLocalePlataforma =
-          PluriWaveAudioHandler.lectorLocalePlataformaPorDefecto;
-    });
-
-    /// Drives a NON-network failure through the real source-change path so the
-    /// terminal error message published to the car can be read back.
-    Future<String?> mensajeDeError(PluriWaveAudioHandler handler) async {
-      guion.errorSetUrl = Exception('boom');
-      await handler
-          .playMediaItem(const MediaItem(id: 'https://a', title: 'A'))
-          .catchError((_) {});
-      await pumpEventQueue();
-      return handler.playbackState.value.errorMessage;
-    }
-
-    test(
-      'sin configurarLocalizaciones, los mensajes salen en el locale de la '
-      'plataforma, no en es',
-      () async {
-        PluriWaveAudioHandler.lectorLocalePlataforma = () =>
-            const Locale('en');
-        final handler = crearHandler();
-
-        final mensaje = await mensajeDeError(handler);
-
-        expect(
-          mensaje,
-          lookupAppLocalizations(const Locale('en')).audioErrorUnexpectedPlayback,
-          reason:
-              '`configurarLocalizaciones` only ever runs from '
-              '`mini_reproductor.dart` didChangeDependencies. The headless '
-              'Android Auto engine has no Activity and no widget tree, so it '
-              'never ran there and every car message came out in Spanish',
-        );
-        expect(
-          mensaje,
-          isNot(
-            lookupAppLocalizations(
-              const Locale('es'),
-            ).audioErrorUnexpectedPlayback,
-          ),
-        );
-      },
-    );
-
-    test('un locale de plataforma no soportado conserva el respaldo es', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('sw');
-      final handler = crearHandler();
-
-      expect(
-        await mensajeDeError(handler),
-        lookupAppLocalizations(const Locale('es')).audioErrorUnexpectedPlayback,
-        reason: 'the existing fallback must survive an unresolvable locale',
-      );
-    });
-
-    test('configurarLocalizaciones sigue teniendo prioridad', () async {
-      PluriWaveAudioHandler.lectorLocalePlataforma = () => const Locale('en');
-      final handler = crearHandler();
-      handler.configurarLocalizaciones(
-        lookupAppLocalizations(const Locale('fr')),
-      );
-
-      expect(
-        await mensajeDeError(handler),
-        lookupAppLocalizations(const Locale('fr')).audioErrorUnexpectedPlayback,
-        reason: 'the phone UI still owns the locale once a widget tree exists',
-      );
-    });
-  });
-}
-
-/// Shared script/observation record for every [_ReproductorFalso] the handler
-/// builds (it rebuilds its player on every source change, so counters cannot
-/// live on the instance).
-class _GuionReproductor {
-  int llamadasPlay = 0;
-  int llamadasSetUrl = 0;
-  final urlsSolicitadas = <String>[];
-
-  /// When set, `setUrl` completes with this error instead of succeeding.
-  Object? errorSetUrl;
-
-  /// When true, `setUrl` never completes (simulates a dead stream that only
-  /// the source-change timeout can end).
-  bool setUrlCuelga = false;
-
-  /// When set, `setUrl` returns this completer's future, so a test can hold a
-  /// source change mid-flight and release it after acting on the handler.
-  Completer<Duration?>? completerSetUrl;
-
-  /// The handler rebuilds its player on every source change, so a test that
-  /// needs to drive a player event has to reach the LATEST instance.
-  _ReproductorFalso? ultimoReproductor;
-}
-
-/// A [AudioPlayer] whose platform-touching methods are replaced by the script
-/// above. Everything else (the rx subjects the constructor wires up) is the
-/// real thing, so the handler's stream plumbing is exercised unchanged.
-class _ReproductorFalso extends AudioPlayer {
-  _ReproductorFalso(
-    this._guion,
-    AudioPipeline pipeline,
-    AudioLoadConfiguration carga,
-  ) : super(audioPipeline: pipeline, audioLoadConfiguration: carga) {
-    _guion.ultimoReproductor = this;
-  }
-
-  final _GuionReproductor _guion;
-  final _estados = StreamController<PlayerState>.broadcast();
-
-  /// Drives the exact `playerStateStream` event the real player would emit.
-  void emitir(PlayerState estado) {
-    if (!_estados.isClosed) _estados.add(estado);
-  }
-
-  @override
-  Stream<PlayerState> get playerStateStream => _estados.stream;
-
-  @override
-  Future<Duration?> setUrl(
-    String url, {
-    Map<String, String>? headers,
-    Duration? initialPosition,
-    bool preload = true,
-    dynamic tag,
-  }) {
-    _guion.llamadasSetUrl++;
-    _guion.urlsSolicitadas.add(url);
-    if (_guion.setUrlCuelga) return Completer<Duration?>().future;
-    final pendiente = _guion.completerSetUrl;
-    if (pendiente != null) return pendiente.future;
-    final error = _guion.errorSetUrl;
-    if (error != null) return Future<Duration?>.error(error);
-    return Future<Duration?>.value(null);
-  }
-
-  @override
-  Future<void> play() async {
-    _guion.llamadasPlay++;
-  }
-
-  @override
-  Future<void> pause() async {}
-
-  @override
-  Future<void> stop() async {}
-
-  @override
-  Future<void> setVolume(double volume) async {}
-
-  @override
-  Future<void> dispose() async {
-    await _estados.close();
-  }
-}

test/servicios/servicio_audio_ultima_emisora_test.dart

@@ -1,507 +0,0 @@
-import 'dart:async';
-
-import 'package:audio_service/audio_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:just_audio/just_audio.dart';
-import 'package:pluriwave/modelos/emisora.dart';
-import 'package:pluriwave/servicios/emisoras_destacadas.dart';
-import 'package:pluriwave/servicios/servicio_audio.dart';
-import 'package:shared_preferences/shared_preferences.dart';
-
-import '../helpers/handlers_audio.dart';
-
-/// Resuming the last station in Android Auto — the three defects that made a
-/// car-only session unable to remember, restart or even NAME what it was
-/// playing.
-///
-/// Every test here runs with NO widget tree and NO browse source registered:
-/// that is the engine Android Auto actually starts
-/// (`AudioServicePlugin.java:75-111` builds `new FlutterEngine(context)` with
-/// no Activity), so `EstadoRadio` — the only thing that used to write
-/// `ultima_emisora_v1` — is never constructed there.
-///
-///  A1. The last station was written EXCLUSIVELY by `EstadoRadio`, so a
-///      session that happened only in the car never updated the key and the
-///      head unit was offered the station from the last time the PHONE was
-///      used. The same key feeds `resolverEmisorasDestacadas`, so the free
-///      tier's featured folder was stale too.
-///
-///  A2. `play()` with no source called `_player.play()`, and
-///      `just_audio.dart:937-967` publishes `_playingSubject.add(true)`
-///      BEFORE the `_audioSource != null` gate — so the platform was never
-///      touched, the returned Future never completed, and `playing: true`
-///      was forwarded over `processingState: idle`.
-///      `AudioService.java:559-560` then runs `enterPlayingState()` while
-///      `getPlaybackState()` is `STATE_NONE`: a notification with a pause
-///      button, no audio, no title and no artwork (or a
-///      `ForegroundServiceStartNotAllowedException` on API 31+).
-///
-///  A3. `mediaItem` was null on a cold start — the only `mediaItem.add` sites
-///      are the duration update, `_cambiarFuente` and `stop` — so
-///      `audio_service.dart:1029-1033` returned before `setMediaItem` and the
-///      native side got no metadata at all.
-void main() {
-  TestWidgetsFlutterBinding.ensureInitialized();
-
-  final crearHandler = registrarHandlersLiberables();
-
-  late _GuionReproductor guion;
-
-  /// The free set's first station: resolvable from the binary alone, so it
-  /// works on a bind where no browse source was ever registered — which is
-  /// the whole point of these tests.
-  const emisoraFip = Emisora(
-    uuid: 'pw-destacada-fip',
-    nombre: 'FIP',
-    url: 'https://icecast.radiofrance.fr/fip-midfi.mp3',
-    pais: 'France',
-    codigoPais: 'FR',
-    idioma: 'french',
-  );
-
-  setUp(() {
-    guion = _GuionReproductor();
-    PluriWaveAudioHandler.fabricaReproductorPrueba =
-        (pipeline, carga) => _ReproductorFalso(guion, pipeline, carga);
-    // Fresh install = free tier (`esPremiumPersistido` is `getBool(...) ??
-    // false`) and no `ultima_emisora_v1`.
-    SharedPreferences.setMockInitialValues({});
-  });
-
-  tearDown(() {
-    PluriWaveAudioHandler.fabricaReproductorPrueba = null;
-  });
-
-  group('A1 — el coche escribe la ultima emisora', () {
-    test(
-      'playFromMediaId desde el coche persiste ESA emisora por el puerto '
-      'inyectado, sin arbol de widgets',
-      () async {
-        final prefs = await SharedPreferences.getInstance();
-        final handler = crearHandler();
-        final guardadas = <Emisora>[];
-        registrarHandler(
-          handler,
-          guardarUltimaEmisora: (emisora) async {
-            guardadas.add(emisora);
-            await guardarUltimaEmisoraPersistida(emisora, prefs: prefs);
-          },
-        );
-
-        await handler.playFromMediaId('emisora:${emisoraFip.uuid}');
-        await pumpEventQueue();
-
-        expect(
-          guardadas.map((e) => e.uuid),
-          [emisoraFip.uuid],
-          reason:
-              'a car-only session must update `ultima_emisora_v1` itself — '
-              '`EstadoRadio` is never built on a headless engine',
-        );
-        final persistida = await ultimaEmisoraPersistida(prefs: prefs);
-        expect(persistida?.uuid, emisoraFip.uuid);
-        expect(
-          persistida?.url,
-          emisoraFip.url,
-          reason:
-              'the record has to be PLAYABLE: it is what the recent root and '
-              '`resolverEmisorasDestacadas` hand back to the head unit',
-        );
-      },
-    );
-
-    test('playMediaItem directo (voz, telefono) persiste igual', () async {
-      final handler = crearHandler();
-      final guardadas = <Emisora>[];
-      registrarHandler(
-        handler,
-        guardarUltimaEmisora: (emisora) async => guardadas.add(emisora),
-      );
-
-      await handler.playMediaItem(
-        const MediaItem(
-          id: 'https://ejemplo/stream',
-          title: 'Ejemplo',
-          extras: {'uuid': 'uuid-ejemplo'},
-        ),
-      );
-      await pumpEventQueue();
-
-      expect(guardadas.map((e) => e.uuid), ['uuid-ejemplo']);
-      expect(guardadas.single.url, 'https://ejemplo/stream');
-    });
-
-    test(
-      'una pista local NO se persiste como ultima emisora',
-      () async {
-        final handler = crearHandler();
-        final guardadas = <Emisora>[];
-        registrarHandler(
-          handler,
-          guardarUltimaEmisora: (emisora) async => guardadas.add(emisora),
-        );
-
-        await handler.playMediaItem(
-          const MediaItem(
-            id: 'content://media/audio/7',
-            title: 'Pista local',
-            extras: {'documentId': 'doc-7'},
-          ),
-        );
-        await pumpEventQueue();
-
-        expect(
-          guardadas,
-          isEmpty,
-          reason:
-              '`ultima_emisora_v1` feeds the recent root and the featured '
-              'folder as an `emisora:<uuid>` row — a `content://` track '
-              'there is a row that does nothing when tapped',
-        );
-      },
-    );
-
-    test('un fallo del puerto se traza y NUNCA propaga', () async {
-      final handler = crearHandler();
-      registrarHandler(
-        handler,
-        guardarUltimaEmisora: (_) async => throw StateError('sin disco'),
-      );
-
-      await expectLater(
-        handler.playMediaItem(
-          const MediaItem(
-            id: 'https://ejemplo/stream',
-            title: 'Ejemplo',
-            extras: {'uuid': 'uuid-ejemplo'},
-          ),
-        ),
-        completes,
-      );
-      await pumpEventQueue();
-    });
-
-    test('sin puerto (tests de widget, fakes) no pasa nada', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      await expectLater(
-        handler.playMediaItem(
-          const MediaItem(
-            id: 'https://ejemplo/stream',
-            title: 'Ejemplo',
-            extras: {'uuid': 'uuid-ejemplo'},
-          ),
-        ),
-        completes,
-      );
-    });
-  });
-
-  group('A2 — play() sin fuente no publica una sesion fantasma', () {
-    test(
-      'con una emisora persistida, play() resuelve y arranca ESA emisora: el '
-      'reproductor recibe su url',
-      () async {
-        final handler = crearHandler();
-        registrarHandler(
-          handler,
-          leerUltimaEmisora: () async => emisoraFip,
-        );
-        await pumpEventQueue();
-
-        unawaited(handler.play().catchError((_) {}));
-        await pumpEventQueue();
-
-        expect(
-          guion.urlsSolicitadas,
-          contains(emisoraFip.url),
-          reason:
-              '`AudioService.java:920` routes the car KEYCODE_MEDIA_PLAY '
-              'straight into play(); on a cold engine there is no source, so '
-              'it has to resolve the persisted station instead',
-        );
-      },
-    );
-
-    test(
-      'y NINGUN estado publicado lleva playing:true sobre processingState '
-      'idle',
-      () async {
-        final handler = crearHandler();
-        registrarHandler(
-          handler,
-          leerUltimaEmisora: () async => emisoraFip,
-        );
-        await pumpEventQueue();
-
-        final fantasmas = <PlaybackState>[];
-        final sub = handler.playbackState.listen((estado) {
-          if (estado.playing &&
-              estado.processingState == AudioProcessingState.idle) {
-            fantasmas.add(estado);
-          }
-        });
-
-        unawaited(handler.play().catchError((_) {}));
-        await pumpEventQueue();
-        await sub.cancel();
-
-        expect(
-          fantasmas,
-          isEmpty,
-          reason:
-              'playing:true over idle is what makes `AudioService.java:559` '
-              'call enterPlayingState() with STATE_NONE — a PluriWave '
-              'notification with a pause button, no audio and no title',
-        );
-      },
-    );
-
-    test(
-      'sin nada persistido: no se toca el reproductor, no hay estado '
-      'fantasma y play() no se queda colgado',
-      () async {
-        final handler = crearHandler();
-        registrarHandler(handler, leerUltimaEmisora: () async => null);
-        await pumpEventQueue();
-
-        final fantasmas = <PlaybackState>[];
-        final sub = handler.playbackState.listen((estado) {
-          if (estado.playing &&
-              estado.processingState == AudioProcessingState.idle) {
-            fantasmas.add(estado);
-          }
-        });
-
-        await expectLater(
-          handler.play().timeout(const Duration(seconds: 2)),
-          completes,
-        );
-        await pumpEventQueue();
-        await sub.cancel();
-
-        expect(
-          guion.llamadasPlay,
-          0,
-          reason:
-              'with nothing to restore the player must not be touched at '
-              'all: `just_audio` publishes playing:true before its source '
-              'gate and never completes the future it returns',
-        );
-        expect(guion.llamadasSetUrl, 0);
-        expect(fantasmas, isEmpty);
-      },
-    );
-
-    test(
-      'con una fuente ya abierta, play() sigue siendo la reanudacion de '
-      'siempre (pausa -> play no reabre nada)',
-      () async {
-        final handler = crearHandler();
-        registrarHandler(
-          handler,
-          leerUltimaEmisora: () async => emisoraFip,
-        );
-        await handler.playMediaItem(
-          const MediaItem(
-            id: 'https://ejemplo/stream',
-            title: 'Ejemplo',
-            extras: {'uuid': 'uuid-ejemplo'},
-          ),
-        );
-        await pumpEventQueue();
-        await handler.pause();
-        final urlsAntes = List<String>.from(guion.urlsSolicitadas);
-
-        await handler.play();
-        await pumpEventQueue();
-
-        expect(
-          guion.urlsSolicitadas,
-          urlsAntes,
-          reason:
-              'a resume must NOT re-open the source, and must never replace '
-              'the live station with the persisted one',
-        );
-        expect(handler.intencionReproducir, isTrue);
-      },
-    );
-  });
-
-  group('A3 — arranque en frio: el coche recibe metadatos', () {
-    test(
-      'con una emisora persistida se publica su mediaItem SIN arrancar '
-      'reproduccion',
-      () async {
-        final handler = crearHandler();
-
-        registrarHandler(
-          handler,
-          leerUltimaEmisora: () async => emisoraFip,
-        );
-        await pumpEventQueue();
-
-        expect(
-          handler.mediaItem.value,
-          isNotNull,
-          reason:
-              '`audio_service.dart:1029-1033` returns before setMediaItem '
-              'when mediaItem is null, so a cold engine sent the head unit '
-              'no metadata whatsoever',
-        );
-        expect(handler.mediaItem.value?.id, emisoraFip.url);
-        expect(handler.playbackState.value.playing, isFalse);
-        expect(
-          guion.llamadasSetUrl,
-          0,
-          reason:
-              'publishing metadata must not open a stream: a cold bind '
-              'happens on every reconnect and must stay silent',
-        );
-      },
-    );
-
-    test('sin nada persistido el mediaItem sigue vacio', () async {
-      final handler = crearHandler();
-
-      registrarHandler(handler, leerUltimaEmisora: () async => null);
-      await pumpEventQueue();
-
-      expect(handler.mediaItem.value, isNull);
-    });
-
-    test(
-      'una emisora que ya empezo a sonar NO es pisada por la siembra',
-      () async {
-        final handler = crearHandler();
-        final lectura = Completer<Emisora?>();
-
-        registrarHandler(handler, leerUltimaEmisora: () => lectura.future);
-        await handler.playMediaItem(
-          const MediaItem(
-            id: 'https://enVivo/stream',
-            title: 'En vivo',
-            extras: {'uuid': 'uuid-en-vivo'},
-          ),
-        );
-        lectura.complete(emisoraFip);
-        await pumpEventQueue();
-
-        expect(
-          handler.mediaItem.value?.id,
-          'https://enVivo/stream',
-          reason:
-              'the seed exists to fill a VOID; clobbering the live station '
-              'would rename what the driver is listening to',
-        );
-      },
-    );
-  });
-
-  group('getMediaItem resuelve tambien el set destacado', () {
-    test(
-      'sin fuente de navegacion registrada, una emisora destacada resuelve',
-      () async {
-        final handler = crearHandler();
-        registrarHandler(handler);
-
-        final item = await handler.getMediaItem('emisora:${emisoraFip.uuid}');
-
-        expect(
-          item,
-          isNotNull,
-          reason:
-              '`porUuid` already falls back to the featured set, so the car '
-              'could BROWSE a featured station and not resolve its media '
-              'item — the asymmetry is the bug',
-        );
-        expect(item?.id, 'emisora:${emisoraFip.uuid}');
-        expect(item?.title, emisoraFip.nombre);
-      },
-    );
-
-    test('un id que no es de emisora sigue devolviendo null', () async {
-      final handler = crearHandler();
-      registrarHandler(handler);
-
-      expect(await handler.getMediaItem('pista:doc-1'), isNull);
-      expect(await handler.getMediaItem('emisora:'), isNull);
-    });
-  });
-}
-
-/// Shared script/observation record for every [_ReproductorFalso] the handler
-/// builds (it rebuilds its player on every source change, so counters cannot
-/// live on the instance).
-class _GuionReproductor {
-  int llamadasPlay = 0;
-  int llamadasSetUrl = 0;
-  final urlsSolicitadas = <String>[];
-}
-
-/// An [AudioPlayer] double that reproduces the ONE `just_audio` behaviour
-/// defect A2 is about: `play()` (`just_audio.dart:937-967`) publishes
-/// `playing: true` BEFORE the `_audioSource != null` gate, and with no source
-/// it never touches the platform and never completes the future it returned.
-class _ReproductorFalso extends AudioPlayer {
-  _ReproductorFalso(
-    this._guion,
-    AudioPipeline pipeline,
-    AudioLoadConfiguration carga,
-  ) : super(audioPipeline: pipeline, audioLoadConfiguration: carga);
-
-  final _GuionReproductor _guion;
-  final _estados = StreamController<PlayerState>.broadcast();
-
-  /// A fresh player has no source, exactly like the real one.
-  bool _fuenteCargada = false;
-
-  @override
-  Stream<PlayerState> get playerStateStream => _estados.stream;
-
-  @override
-  Future<Duration?> setUrl(
-    String url, {
-    Map<String, String>? headers,
-    Duration? initialPosition,
-    bool preload = true,
-    dynamic tag,
-  }) async {
-    _guion.llamadasSetUrl++;
-    _guion.urlsSolicitadas.add(url);
-    _fuenteCargada = true;
-    return null;
-  }
-
-  @override
-  Future<void> play() {
-    _guion.llamadasPlay++;
-    if (!_estados.isClosed) {
-      _estados.add(
-        PlayerState(
-          true,
-          _fuenteCargada ? ProcessingState.ready : ProcessingState.idle,
-        ),
-      );
-    }
-    // The dangling future: with no source, upstream `play()` awaits a
-    // `_playingSubject` transition the platform will never produce.
-    if (!_fuenteCargada) return Completer<void>().future;
-    return Future<void>.value();
-  }
-
-  @override
-  Future<void> pause() async {}
-
-  @override
-  Future<void> stop() async {}
-
-  @override
-  Future<void> setVolume(double volume) async {}
-
-  @override
-  Future<void> dispose() async {
-    await _estados.close();
-  }
-}

test/servicios/servicio_compras_test.dart

@@ -1,57 +1,14 @@
-import 'dart:async';
-
 import 'package:flutter_test/flutter_test.dart';
 import 'package:in_app_purchase/in_app_purchase.dart';
 import 'package:pluriwave/servicios/servicio_compras.dart';
 
-/// Port-boundary tests (Design ADR-2 "keeps Strict TDD viable with zero
-/// plugin channels in unit tests"): [eventoDesdeEstadoCompra] es la parte
-/// pura, y [ServicioComprasPlayBilling] se ejercita inyectando
-/// [_InAppPurchaseFalso] — sin ningún platform channel real.
-/// `EstadoEntitlement` se prueba aparte con un `PuertoCompras` falso
+/// Pure port-boundary tests (Design ADR-2 "keeps Strict TDD viable with zero
+/// plugin channels in unit tests"): [eventoDesdeEstadoCompra] is the ONLY
+/// piece of `ServicioComprasPlayBilling` that is unit-testable without a
+/// real `in_app_purchase` platform channel — [ServicioComprasPlayBilling]
+/// itself is the sole call site (Design ADR-2), exercised instead through
+/// `EstadoEntitlement` + a fake `PuertoCompras`
 /// (`estado_entitlement_test.dart`).
-
-/// Fake [InAppPurchase]: deja que cada test empuje lotes por
-/// [purchaseStream] a mano. `noSuchMethod` cubre el resto de la API del
-/// plugin, que estos tests no ejercitan.
-class _InAppPurchaseFalso implements InAppPurchase {
-  final _compras = StreamController<List<PurchaseDetails>>.broadcast();
-  int restauracionesPedidas = 0;
-  final completadas = <PurchaseDetails>[];
-
-  @override
-  Stream<List<PurchaseDetails>> get purchaseStream => _compras.stream;
-
-  @override
-  Future<void> restorePurchases({String? applicationUserName}) async {
-    restauracionesPedidas++;
-  }
-
-  @override
-  Future<void> completePurchase(PurchaseDetails purchase) async {
-    completadas.add(purchase);
-  }
-
-  void emitir(List<PurchaseDetails> compras) => _compras.add(compras);
-
-  Future<void> dispose() => _compras.close();
-
-  @override
-  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
-PurchaseDetails _compraFalsa(PurchaseStatus status) => PurchaseDetails(
-  purchaseID: 'compra-1',
-  productID: ServicioComprasPlayBilling.idProducto,
-  verificationData: PurchaseVerificationData(
-    localVerificationData: 'local',
-    serverVerificationData: 'server',
-    source: 'google_play',
-  ),
-  transactionDate: null,
-  status: status,
-);
-
 void main() {
   group('eventoDesdeEstadoCompra', () {
     test('purchased -> comprada', () {
@@ -93,59 +50,6 @@ void main() {
     });
   });
 
-  group('ServicioComprasPlayBilling.purchaseStream', () {
-    test('un lote vacio emite noEncontrada (restaurar sin compras)', () async {
-      final iap = _InAppPurchaseFalso();
-      addTearDown(iap.dispose);
-      final servicio = ServicioComprasPlayBilling(inAppPurchase: iap);
-      addTearDown(servicio.dispose);
-
-      final tipos = <TipoEventoCompra>[];
-      final sub = servicio.eventos.listen((e) => tipos.add(e.tipo));
-      addTearDown(sub.cancel);
-
-      await servicio.restaurar();
-      iap.emitir(const <PurchaseDetails>[]);
-      await Future<void>.delayed(Duration.zero);
-
-      // Sin este evento `EstadoEntitlement._compraEnCurso` se queda en `true`
-      // para siempre y `hoja_premium.dart` deshabilita AMBOS botones
-      // (comprar y restaurar): el usuario no puede pagar.
-      expect(tipos, <TipoEventoCompra>[TipoEventoCompra.noEncontrada]);
-      expect(iap.restauracionesPedidas, 1);
-    });
-
-    test('un lote con compras NO emite noEncontrada', () async {
-      final iap = _InAppPurchaseFalso();
-      addTearDown(iap.dispose);
-      final servicio = ServicioComprasPlayBilling(inAppPurchase: iap);
-      addTearDown(servicio.dispose);
-
-      final tipos = <TipoEventoCompra>[];
-      final sub = servicio.eventos.listen((e) => tipos.add(e.tipo));
-      addTearDown(sub.cancel);
-
-      iap.emitir(<PurchaseDetails>[_compraFalsa(PurchaseStatus.restored)]);
-      await Future<void>.delayed(Duration.zero);
-
-      expect(tipos, <TipoEventoCompra>[TipoEventoCompra.restaurada]);
-    });
-
-    test('completa las compras pendientes de confirmar', () async {
-      final iap = _InAppPurchaseFalso();
-      addTearDown(iap.dispose);
-      final servicio = ServicioComprasPlayBilling(inAppPurchase: iap);
-      addTearDown(servicio.dispose);
-
-      final compra =
-          _compraFalsa(PurchaseStatus.purchased)..pendingCompletePurchase = true;
-      iap.emitir(<PurchaseDetails>[compra]);
-      await Future<void>.delayed(Duration.zero);
-
-      expect(iap.completadas, <PurchaseDetails>[compra]);
-    });
-  });
-
   test('idProducto es el identificador unico no-consumible', () {
     expect(ServicioComprasPlayBilling.idProducto, 'pluriwave_premium');
   });

test/servicios/servicio_export_import_test.dart

@@ -232,107 +232,4 @@ void main() {
       },
     );
   });
-
-  group('ServicioExportImport v4 — equalizer on/off toggle', () {
-    test('v4 export includes ecualizadorActivo=true and schemaVersion 4', () {
-      final config = servicio.construirExportacion(
-        gruposFavoritos: gruposFavoritosFixture,
-        favoritos: favoritosFixture,
-        emisorasCustom: emisorasCustomFixture,
-        presetPrincipal: PresetEcualizador.flat,
-        presetsPorEmisora: {},
-        alarmas: null,
-        emisoraPreferidaUuid: null,
-        ordenListas: 'calidad',
-        timerSuenoPresetsSegundos: const [300],
-        eqMultiDeviceEnabled: false,
-        ecualizadorActivo: true,
-      );
-
-      expect(config['version'], 4);
-      expect(config['ecualizadorActivo'], isTrue);
-    });
-
-    test('v4 export includes ecualizadorActivo=false and schemaVersion 4', () {
-      final config = servicio.construirExportacion(
-        gruposFavoritos: gruposFavoritosFixture,
-        favoritos: favoritosFixture,
-        emisorasCustom: emisorasCustomFixture,
-        presetPrincipal: PresetEcualizador.flat,
-        presetsPorEmisora: {},
-        alarmas: null,
-        emisoraPreferidaUuid: null,
-        ordenListas: 'calidad',
-        timerSuenoPresetsSegundos: const [300],
-        eqMultiDeviceEnabled: false,
-        ecualizadorActivo: false,
-      );
-
-      expect(config['version'], 4);
-      expect(config['ecualizadorActivo'], isFalse);
-    });
-
-    test('v4 round-trip preserves the equalizer toggle exactly', () {
-      final config = servicio.construirExportacion(
-        gruposFavoritos: gruposFavoritosFixture,
-        favoritos: favoritosFixture,
-        emisorasCustom: emisorasCustomFixture,
-        presetPrincipal: PresetEcualizador.jazz,
-        presetsPorEmisora: {'fav-1': PresetEcualizador.rock},
-        alarmas: alarmasFixture,
-        emisoraPreferidaUuid: 'fav-1',
-        ordenListas: 'calidad',
-        timerSuenoPresetsSegundos: const [300, 1800],
-        eqMultiDeviceEnabled: true,
-        ecualizadorActivo: false,
-      );
-
-      final json = servicio.exportar(config);
-      final importado = servicio.importar(json);
-
-      expect(importado, isNotNull);
-      expect(importado!['version'], 4);
-      expect(importado['ecualizadorActivo'], isFalse);
-    });
-
-    test('omitting ecualizadorActivo keeps the export at v3 (backward compat) '
-        'and no key is written', () {
-      final config = servicio.construirExportacion(
-        gruposFavoritos: gruposFavoritosFixture,
-        favoritos: favoritosFixture,
-        emisorasCustom: emisorasCustomFixture,
-        presetPrincipal: PresetEcualizador.flat,
-        presetsPorEmisora: {},
-        alarmas: null,
-        emisoraPreferidaUuid: null,
-        ordenListas: 'calidad',
-        timerSuenoPresetsSegundos: const [300],
-        eqMultiDeviceEnabled: true,
-        // ecualizadorActivo omitted — emulates a v3 export.
-      );
-
-      expect(config['version'], 3);
-      expect(config.containsKey('ecualizadorActivo'), isFalse);
-    });
-
-    test('omitting every v3/v4 extension keeps the export at v2 (backward '
-        'compat)', () {
-      final config = servicio.construirExportacion(
-        gruposFavoritos: gruposFavoritosFixture,
-        favoritos: favoritosFixture,
-        emisorasCustom: emisorasCustomFixture,
-        presetPrincipal: PresetEcualizador.flat,
-        presetsPorEmisora: {},
-        alarmas: null,
-        emisoraPreferidaUuid: null,
-        ordenListas: 'calidad',
-        timerSuenoPresetsSegundos: const [300],
-        // No v3/v4 extensions at all.
-      );
-
-      expect(config['version'], 2);
-      expect(config.containsKey('ecualizadorActivo'), isFalse);
-      expect(config.containsKey('eqMultiDeviceEnabled'), isFalse);
-    });
-  });
 }

test/servicios/servicio_favoritos_sqlite_test.dart

@@ -105,80 +105,6 @@ void main() {
     expect(favoritos.single.grupoFavoritosId, GrupoFavoritos.sinAsignarId);
     expect(grupos.any((g) => g.id == grupo.id), isFalse);
   });
-
-  // ── Primitivas de restauración (importarConfig) ────────────────────────────
-  //
-  // `agregar` es la primitiva de "marcar como favorita": fuerza `sin_asignar`
-  // y un `orden` nuevo a propósito, porque una emisora recién marcada no
-  // pertenece a ningún grupo. Reusarla para RESTAURAR una copia de seguridad
-  // destruía justo los dos campos que la copia traía. `restaurarFavorito` es
-  // la primitiva que faltaba.
-
-  test('restaurarFavorito preserva el grupo y el orden de la copia', () async {
-    final servicio = crearServicio();
-    addTearDown(servicio.cerrar);
-
-    await servicio.restaurarGrupo(
-      const GrupoFavoritos(id: 'grupo-rock', nombre: 'Rock', orden: 7),
-    );
-
-    await servicio.restaurarFavorito(
-      _emisora(
-        'radio-1',
-        'Radio Uno',
-      ).copyWith(orden: 42, grupoFavoritosId: 'grupo-rock'),
-    );
-
-    final favoritos = await servicio.obtenerTodos();
-    expect(favoritos.single.grupoFavoritosId, 'grupo-rock');
-    expect(favoritos.single.orden, 42);
-  });
-
-  test('restaurarFavorito cae a Sin asignar cuando el grupo de la copia no '
-      'existe (copia editada a mano o restauración parcial)', () async {
-    final servicio = crearServicio();
-    addTearDown(servicio.cerrar);
-
-    await servicio.restaurarFavorito(
-      _emisora(
-        'radio-1',
-        'Radio Uno',
-      ).copyWith(orden: 3, grupoFavoritosId: 'grupo-fantasma'),
-    );
-
-    final favoritos = await servicio.obtenerTodos();
-    expect(favoritos.single.grupoFavoritosId, GrupoFavoritos.sinAsignarId);
-    expect(favoritos.single.orden, 3);
-  });
-
-  test('restaurarGrupo hace upsert preservando id, nombre y orden, y NUNCA '
-      'duplica el grupo protegido', () async {
-    final servicio = crearServicio();
-    addTearDown(servicio.cerrar);
-
-    await servicio.restaurarGrupo(
-      const GrupoFavoritos(id: 'grupo-jazz', nombre: 'Jazz', orden: 5),
-    );
-    // Segunda pasada (reimportar la misma copia): upsert, no duplicado.
-    await servicio.restaurarGrupo(
-      const GrupoFavoritos(id: 'grupo-jazz', nombre: 'Jazz renombrado', orden: 5),
-    );
-    await servicio.restaurarGrupo(
-      const GrupoFavoritos(
-        id: GrupoFavoritos.sinAsignarId,
-        nombre: 'Unassigned',
-        orden: 0,
-        protegido: true,
-      ),
-    );
-
-    final grupos = await servicio.obtenerGrupos();
-    final jazz = grupos.singleWhere((g) => g.id == 'grupo-jazz');
-    expect(jazz.nombre, 'Jazz renombrado');
-    expect(jazz.orden, 5);
-    // El protegido conserva su nombre local: no se importa desde la copia.
-    expect(grupos.singleWhere((g) => g.esSinAsignar).nombre, 'Sin asignar');
-  });
 }
 
 Emisora _emisora(String uuid, String nombre) {

test/widgets/hoja_premium_test.dart

@@ -2,7 +2,6 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:in_app_purchase/in_app_purchase.dart';
 import 'package:pluriwave/estado/estado_entitlement.dart';
 import 'package:pluriwave/l10n/gen/app_localizations.dart';
 import 'package:pluriwave/servicios/servicio_compras.dart';
@@ -10,12 +9,6 @@ import 'package:pluriwave/widgets/hoja_premium.dart';
 import 'package:provider/provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
-/// fix/import-alarmas-y-paywall: a purchase sheet the user cannot escape is
-/// a dark pattern and a Play policy risk. These cover the dismiss
-/// affordance, the honest/concrete feature list, and the equalizer guard
-/// (the phone equalizer is free for everyone and must never be presented as
-/// a premium feature — this has regressed conceptually before).
-
 /// Fake [PuertoCompras] (mirrors `app_test.dart`'s own fake): lets a test
 /// drive [EstadoEntitlement]'s purchase-stream events without touching
 /// `in_app_purchase`.
@@ -36,28 +29,6 @@ class _PuertoComprasFalso implements PuertoCompras {
   Future<void> dispose() => _eventos.close();
 }
 
-/// Fake [InAppPurchase]: permite montar el paywall sobre el
-/// `ServicioComprasPlayBilling` REAL (no un `PuertoCompras` falso) para cubrir
-/// el bloqueo del paywall de extremo a extremo. `noSuchMethod` cubre el resto
-/// de la API del plugin, que este test no ejercita.
-class _InAppPurchaseFalso implements InAppPurchase {
-  final _compras = StreamController<List<PurchaseDetails>>.broadcast();
-
-  @override
-  Stream<List<PurchaseDetails>> get purchaseStream => _compras.stream;
-
-  @override
-  Future<void> restorePurchases({String? applicationUserName}) async {
-    // Play Billing publica un lote VACÍO cuando no hay nada que restaurar.
-    _compras.add(const <PurchaseDetails>[]);
-  }
-
-  Future<void> dispose() => _compras.close();
-
-  @override
-  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
 /// FIX 3 / FIX 9 (code review): the paywall must show localized feedback for
 /// a failed purchase/restore, a distinct non-error confirmation when a
 /// restore finds nothing, and its own dedicated "premium active" string
@@ -97,150 +68,6 @@ void main() {
     return estado;
   }
 
-  /// Presents `HojaPremium` through the REAL `mostrarHojaPremium` modal
-  /// route (unlike [bombear], which embeds it directly with no route to
-  /// pop) so the dismiss controls can be exercised end-to-end exactly as a
-  /// user would encounter them.
-  Future<void> bombearComoHoja(
-    WidgetTester tester, {
-    required _PuertoComprasFalso compras,
-  }) async {
-    await tester.pumpWidget(
-      MultiProvider(
-        providers: [
-          ChangeNotifierProvider<EstadoEntitlement>(
-            create: (_) => EstadoEntitlement(prefs: null, compras: compras),
-          ),
-        ],
-        child: MaterialApp(
-          locale: const Locale('es'),
-          localizationsDelegates: AppLocalizations.localizationsDelegates,
-          supportedLocales: AppLocalizations.supportedLocales,
-          home: Builder(
-            builder:
-                (context) => Scaffold(
-                  body: TextButton(
-                    onPressed: () => mostrarHojaPremium(context),
-                    child: const Text('abrir'),
-                  ),
-                ),
-          ),
-        ),
-      ),
-    );
-    await tester.pump();
-    await tester.tap(find.text('abrir'));
-    await tester.pumpAndSettle();
-    l10n = AppLocalizations.of(tester.element(find.byType(HojaPremium)));
-  }
-
-  group('fix/import-alarmas-y-paywall — dismissibility', () {
-    testWidgets('the close (X) control closes the sheet without purchasing or '
-        'restoring', (tester) async {
-      final compras = _PuertoComprasFalso();
-      addTearDown(compras.dispose);
-      await bombearComoHoja(tester, compras: compras);
-
-      expect(find.byType(HojaPremium), findsOneWidget);
-
-      await tester.tap(find.byKey(const ValueKey('hoja-premium-cerrar')));
-      await tester.pumpAndSettle();
-
-      expect(find.byType(HojaPremium), findsNothing);
-    });
-
-    testWidgets(
-      'the "not now" secondary action closes the sheet without purchasing '
-      'or restoring',
-      (tester) async {
-        final compras = _PuertoComprasFalso();
-        addTearDown(compras.dispose);
-        await bombearComoHoja(tester, compras: compras);
-
-        expect(find.byType(HojaPremium), findsOneWidget);
-
-        await tester.tap(find.byKey(const ValueKey('hoja-premium-ahora-no')));
-        await tester.pumpAndSettle();
-
-        expect(find.byType(HojaPremium), findsNothing);
-      },
-    );
-
-    testWidgets('the system back gesture also closes the sheet (default '
-        'isDismissible/enableDrag, no PopScope blocking it)', (tester) async {
-      final compras = _PuertoComprasFalso();
-      addTearDown(compras.dispose);
-      await bombearComoHoja(tester, compras: compras);
-
-      expect(find.byType(HojaPremium), findsOneWidget);
-
-      await tester.binding.handlePopRoute();
-      await tester.pumpAndSettle();
-
-      expect(find.byType(HojaPremium), findsNothing);
-    });
-
-    testWidgets(
-      'an already-premium user still gets the close control (no decline '
-      'needed) and no "not now" button',
-      (tester) async {
-        SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
-        final compras = _PuertoComprasFalso();
-        addTearDown(compras.dispose);
-        await bombearComoHoja(tester, compras: compras);
-
-        expect(
-          find.byKey(const ValueKey('hoja-premium-cerrar')),
-          findsOneWidget,
-        );
-        expect(
-          find.byKey(const ValueKey('hoja-premium-ahora-no')),
-          findsNothing,
-        );
-      },
-    );
-  });
-
-  group('fix/import-alarmas-y-paywall — honest, concrete copy', () {
-    testWidgets('lists the 5 features premium actually unlocks', (
-      tester,
-    ) async {
-      final compras = _PuertoComprasFalso();
-      addTearDown(compras.dispose);
-      await bombear(tester, compras: compras);
-
-      expect(find.text(l10n.premiumBeneficioSinAnuncios), findsOneWidget);
-      expect(find.text(l10n.premiumBeneficioAndroidAuto), findsOneWidget);
-      expect(find.text(l10n.premiumBeneficioGrabacion), findsOneWidget);
-      expect(find.text(l10n.premiumBeneficioVacaciones), findsOneWidget);
-      expect(find.text(l10n.premiumBeneficioAlarmasIlimitadas), findsOneWidget);
-    });
-
-    testWidgets('states this is a one-time purchase, not a subscription', (
-      tester,
-    ) async {
-      final compras = _PuertoComprasFalso();
-      addTearDown(compras.dispose);
-      await bombear(tester, compras: compras);
-
-      expect(find.text(l10n.premiumPagoUnico), findsOneWidget);
-    });
-
-    testWidgets(
-      'GUARD: the phone equalizer is never presented as a premium feature',
-      (tester) async {
-        final compras = _PuertoComprasFalso();
-        addTearDown(compras.dispose);
-        await bombear(tester, compras: compras);
-
-        expect(find.text(l10n.equalizerTitle), findsNothing);
-        expect(find.text(l10n.equalizerActive), findsNothing);
-        expect(find.textContaining('cualizador'), findsNothing);
-        expect(find.textContaining('qualizer'), findsNothing);
-      },
-    );
-  });
-
   group(
     'FIX 9 — la etiqueta de premium activo es propia, no la del ecualizador',
     () {
@@ -321,54 +148,4 @@ void main() {
       },
     );
   });
-
-  group('bloqueo del paywall — "Restaurar compras" sin compras previas', () {
-    testWidgets('extremo a extremo (ServicioComprasPlayBilling real): un lote '
-        'vacío reactiva AMBOS botones, comprar y restaurar', (tester) async {
-      final iap = _InAppPurchaseFalso();
-      addTearDown(iap.dispose);
-      final servicio = ServicioComprasPlayBilling(inAppPurchase: iap);
-      addTearDown(servicio.dispose);
-
-      await tester.pumpWidget(
-        MultiProvider(
-          providers: [
-            ChangeNotifierProvider<EstadoEntitlement>(
-              create:
-                  (_) => EstadoEntitlement(prefs: null, compras: servicio),
-            ),
-          ],
-          child: MaterialApp(
-            locale: const Locale('es'),
-            localizationsDelegates: AppLocalizations.localizationsDelegates,
-            supportedLocales: AppLocalizations.supportedLocales,
-            home: const Scaffold(body: HojaPremium()),
-          ),
-        ),
-      );
-      await tester.pump();
-      l10n = AppLocalizations.of(tester.element(find.byType(HojaPremium)));
-
-      final restaurar = find.byKey(const ValueKey('hoja-premium-restaurar'));
-      final comprar = find.byKey(const ValueKey('hoja-premium-comprar'));
-
-      await tester.tap(restaurar);
-      await tester.pump();
-      await tester.pump();
-
-      // El botón sigue vivo: si `noEncontrada` nunca llega, `compraEnCurso`
-      // se queda en `true` y el usuario no puede pagar nunca más.
-      expect(
-        tester.widget<OutlinedButton>(restaurar).onPressed,
-        isNotNull,
-        reason: 'restaurar debe volver a estar habilitado',
-      );
-      expect(
-        tester.widget<FilledButton>(comprar).onPressed,
-        isNotNull,
-        reason: 'comprar debe volver a estar habilitado',
-      );
-      expect(find.text(l10n.restauracionSinCompras), findsOneWidget);
-    });
-  });
 }