fix(player): stabilize equalizer and visualizer

test/estado/estado_radio_test.dart

@@ -35,223 +35,269 @@ void main() {
       );
     });
 
-    test('carga EQ principal persistido antes de decidir EQ de reproducción',
-        () async {
-      final audio = FakeServicioAudio();
-      final principal = PresetEcualizador.rock;
-      final emisora = emisoraDemo(uuid: 'api-1', nombre: 'API Uno');
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+    test(
+      'carga EQ principal persistido antes de decidir EQ de reproducción',
+      () async {
+        final audio = FakeServicioAudio();
+        final principal = PresetEcualizador.rock;
+        final emisora = emisoraDemo(uuid: 'api-1', nombre: 'API Uno');
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(principal: principal),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-      await estado.inicializar();
-      await estado.reproducir(emisora);
+        await estado.inicializar();
+        await estado.reproducir(emisora);
 
-      expect(estado.presetEcualizador, principal);
-      expect(audio.presetsAplicados.first, principal);
-      expect(audio.presetsAplicados.last, principal);
-    });
-
-    test('mantiene EQ persistido aunque el ecualizador nativo no esté disponible',
-        () async {
-      final principal = PresetEcualizador.jazz;
-      final porEmisora = {'fav-1': PresetEcualizador.rock};
-      final estado = EstadoRadio(
-        audio: FakeServicioAudio(ecualizadorActivo: false),
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(),
-        servicioEcualizador: FakeServicioEcualizador(
-          principal: principal,
-          porEmisora: porEmisora,
-        ),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
-
-      await estado.inicializar();
-
-      expect(estado.ecualizadorDisponible, isFalse);
-      expect(estado.presetEcualizador, principal);
-      expect(estado.presetPrincipalEcualizador, principal);
-      expect(
-        estado.presetEcualizadorPorEmisora('fav-1'),
-        PresetEcualizador.rock,
-      );
-    });
+        expect(estado.presetEcualizador, principal);
+        expect(audio.presetsAplicados.first, principal);
+        expect(audio.presetsAplicados.last, principal);
+      },
+    );
 
     test(
-        'inicializar deja error tras fallo y cargarPopulares manual recupera estaciones',
-        () async {
-      final radio = FakeServicioRadio(
-        erroresPopularesPorLlamada: [Exception('sin red')],
-        popularesPorLlamada: [
-          const [],
-          [emisoraDemo(uuid: 'api-ok', nombre: 'API Recuperada')],
-        ],
-        tendenciasPorLlamada: [
-          const [],
-          [emisoraDemo(uuid: 'trend-ok', nombre: 'Trend Recuperada')],
-        ],
-      );
-      final estado = EstadoRadio(
-        audio: FakeServicioAudio(),
-        favoritos: FakeServicioFavoritos(),
-        radio: radio,
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+      'mantiene EQ persistido aunque el ecualizador nativo no esté disponible',
+      () async {
+        final principal = PresetEcualizador.jazz;
+        final porEmisora = {'fav-1': PresetEcualizador.rock};
+        final estado = EstadoRadio(
+          audio: FakeServicioAudio(ecualizadorActivo: false),
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(),
+          servicioEcualizador: FakeServicioEcualizador(
+            principal: principal,
+            porEmisora: porEmisora,
+          ),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-      await estado.inicializar();
-      expect(estado.error, 'Sin conexión a la API de radio');
+        await estado.inicializar();
 
-      await estado.cargarPopulares();
+        expect(estado.ecualizadorDisponible, isFalse);
+        expect(estado.presetEcualizador, principal);
+        expect(estado.presetPrincipalEcualizador, principal);
+        expect(
+          estado.presetEcualizadorPorEmisora('fav-1'),
+          PresetEcualizador.rock,
+        );
+      },
+    );
 
-      expect(estado.error, isNull);
-      expect(estado.populares.map((e) => e.uuid), contains('api-ok'));
-      expect(estado.tendencias.map((e) => e.uuid), contains('trend-ok'));
-      expect(radio.obtenerPopularesCalls, 2);
-    });
+    test(
+      'inicializar deja error tras fallo y cargarPopulares manual recupera estaciones',
+      () async {
+        final radio = FakeServicioRadio(
+          erroresPopularesPorLlamada: [Exception('sin red')],
+          popularesPorLlamada: [
+            const [],
+            [emisoraDemo(uuid: 'api-ok', nombre: 'API Recuperada')],
+          ],
+          tendenciasPorLlamada: [
+            const [],
+            [emisoraDemo(uuid: 'trend-ok', nombre: 'Trend Recuperada')],
+          ],
+        );
+        final estado = EstadoRadio(
+          audio: FakeServicioAudio(),
+          favoritos: FakeServicioFavoritos(),
+          radio: radio,
+          servicioEcualizador: FakeServicioEcualizador(),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-    test('EQ propio por emisora pisa al principal y puede volver a fallback',
-        () async {
-      final audio = FakeServicioAudio();
-      final favoritos = FakeServicioFavoritos();
-      final emisora = emisoraDemo(uuid: 'fav-1', nombre: 'Favorita');
-      final principal = PresetEcualizador.pop;
-      final propio = PresetEcualizador.jazz;
-      await favoritos.agregar(emisora);
+        await estado.inicializar();
+        expect(estado.error, 'Sin conexión a la API de radio');
 
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: favoritos,
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+        await estado.cargarPopulares();
 
-      await estado.inicializar();
-      await estado.cargarFavoritos();
-      await estado.guardarPresetEcualizadorPorEmisora(emisora.uuid, propio);
+        expect(estado.error, isNull);
+        expect(estado.populares.map((e) => e.uuid), contains('api-ok'));
+        expect(estado.tendencias.map((e) => e.uuid), contains('trend-ok'));
+        expect(radio.obtenerPopularesCalls, 2);
+      },
+    );
 
-      await estado.reproducir(emisora);
-      expect(estado.presetEcualizador, propio);
-      expect(audio.presetsAplicados.last, propio);
+    test(
+      'EQ propio por emisora pisa al principal y puede volver a fallback',
+      () async {
+        final audio = FakeServicioAudio();
+        final favoritos = FakeServicioFavoritos();
+        final emisora = emisoraDemo(uuid: 'fav-1', nombre: 'Favorita');
+        final principal = PresetEcualizador.pop;
+        final propio = PresetEcualizador.jazz;
+        await favoritos.agregar(emisora);
 
-      await estado.deshabilitarPresetEcualizadorPorEmisora(emisora.uuid);
-      await estado.reproducir(emisora);
-      expect(estado.presetEcualizador, principal);
-      expect(audio.presetsAplicados.last, principal);
-    });
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: favoritos,
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(principal: principal),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-    test('favorita sin EQ propio usa EQ principal desde el primer play', () async {
-      final audio = FakeServicioAudio();
-      final favoritos = FakeServicioFavoritos();
-      final emisora = emisoraDemo(uuid: 'fav-main', nombre: 'Favorita Main');
-      final principal = PresetEcualizador.voz;
-      await favoritos.agregar(emisora);
+        await estado.inicializar();
+        await estado.cargarFavoritos();
+        await estado.guardarPresetEcualizadorPorEmisora(emisora.uuid, propio);
 
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: favoritos,
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+        await estado.reproducir(emisora);
+        expect(estado.presetEcualizador, propio);
+        expect(audio.presetsAplicados.last, propio);
 
-      await estado.inicializar();
-      await estado.cargarFavoritos();
-      await estado.reproducir(emisora);
+        await estado.deshabilitarPresetEcualizadorPorEmisora(emisora.uuid);
+        await estado.reproducir(emisora);
+        expect(estado.presetEcualizador, principal);
+        expect(audio.presetsAplicados.last, principal);
+      },
+    );
 
-      expect(estado.tienePresetEcualizadorPorEmisora(emisora.uuid), isFalse);
-      expect(estado.presetEcualizador, principal);
-      expect(audio.presetsAplicados.last, principal);
-    });
+    test(
+      'favorita sin EQ propio usa EQ principal desde el primer play',
+      () async {
+        final audio = FakeServicioAudio();
+        final favoritos = FakeServicioFavoritos();
+        final emisora = emisoraDemo(uuid: 'fav-main', nombre: 'Favorita Main');
+        final principal = PresetEcualizador.voz;
+        await favoritos.agregar(emisora);
 
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: favoritos,
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(principal: principal),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
+        await estado.inicializar();
+        await estado.cargarFavoritos();
+        await estado.reproducir(emisora);
 
-    test('notifica cambios de estado de audio para mostrar reproductor al primer play', () async {
-      final audio = FakeServicioAudio();
-      final emisora = emisoraDemo(uuid: 'play-1', nombre: 'Primera');
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
-      var notificaciones = 0;
-      estado.addListener(() => notificaciones++);
+        expect(estado.tienePresetEcualizadorPorEmisora(emisora.uuid), isFalse);
+        expect(estado.presetEcualizador, principal);
+        expect(audio.presetsAplicados.last, principal);
+      },
+    );
 
-      await estado.inicializar();
-      final antes = notificaciones;
-      audio.emitirEstado(EstadoReproduccion.cargando);
-      await Future<void>.delayed(Duration.zero);
+    test(
+      'permite activar y desactivar el ecualizador de forma persistente',
+      () async {
+        final audio = FakeServicioAudio();
+        final servicioEcualizador = FakeServicioEcualizador();
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(),
+          servicioEcualizador: servicioEcualizador,
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-      expect(notificaciones, greaterThan(antes));
-    });
+        await estado.inicializar();
+        expect(estado.ecualizadorActivo, isTrue);
 
-    test('reproducir la misma emisora mientras suena fuerza recarga del stream', () async {
-      final audio = FakeServicioAudio();
-      final emisora = emisoraDemo(uuid: 'same-1', nombre: 'Misma');
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+        await estado.cambiarEcualizadorActivo(false);
+        expect(estado.ecualizadorActivo, isFalse);
+        expect(servicioEcualizador.config.activo, isFalse);
+        expect(audio.cambiosEcualizadorActivo.last, isFalse);
 
-      await estado.inicializar();
-      await estado.reproducir(emisora);
-      await estado.reproducir(emisora);
+        await estado.cambiarEcualizadorActivo(true);
+        expect(estado.ecualizadorActivo, isTrue);
+        expect(servicioEcualizador.config.activo, isTrue);
+        expect(audio.cambiosEcualizadorActivo.last, isTrue);
+      },
+    );
 
-      expect(audio.emisorasReproducidas, hasLength(2));
-    });
+    test(
+      'notifica cambios de estado de audio para mostrar reproductor al primer play',
+      () async {
+        final audio = FakeServicioAudio();
+        final emisora = emisoraDemo(uuid: 'play-1', nombre: 'Primera');
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
+        var notificaciones = 0;
+        estado.addListener(() => notificaciones++);
 
-    test('ignora finalizaciones stale cuando se cambia de emisora rapido', () async {
-      final audio = _AudioControlado();
-      final radio = FakeServicioRadio();
-      final primera = emisoraDemo(uuid: 'slow-1', nombre: 'Lenta');
-      final segunda = emisoraDemo(uuid: 'fast-2', nombre: 'Rapida');
-      final estado = EstadoRadio(
-        audio: audio,
-        favoritos: FakeServicioFavoritos(),
-        radio: radio,
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
+        await estado.inicializar();
+        final antes = notificaciones;
+        audio.emitirEstado(EstadoReproduccion.cargando);
+        await Future<void>.delayed(Duration.zero);
 
-      await estado.inicializar();
-      await estado.guardarPresetEcualizadorPorEmisora(
-        primera.uuid,
-        PresetEcualizador.rock,
-      );
-      await estado.guardarPresetEcualizadorPorEmisora(
-        segunda.uuid,
-        PresetEcualizador.jazz,
-      );
+        expect(notificaciones, greaterThan(antes));
+      },
+    );
 
-      final primeraFuture = estado.reproducir(primera);
-      final segundaFuture = estado.reproducir(segunda);
-      audio.completar(segunda.uuid);
-      await segundaFuture;
-      audio.completar(primera.uuid);
-      await primeraFuture;
+    test(
+      'reproducir la misma emisora mientras suena fuerza recarga del stream',
+      () async {
+        final audio = FakeServicioAudio();
+        final emisora = emisoraDemo(uuid: 'same-1', nombre: 'Misma');
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-      expect(estado.presetEcualizador, PresetEcualizador.jazz);
-      expect(radio.ultimoUuidClick, segunda.uuid);
-    });
+        await estado.inicializar();
+        await estado.reproducir(emisora);
+        await estado.reproducir(emisora);
+
+        expect(audio.emisorasReproducidas, hasLength(2));
+      },
+    );
+
+    test(
+      'ignora finalizaciones stale cuando se cambia de emisora rapido',
+      () async {
+        final audio = _AudioControlado();
+        final radio = FakeServicioRadio();
+        final primera = emisoraDemo(uuid: 'slow-1', nombre: 'Lenta');
+        final segunda = emisoraDemo(uuid: 'fast-2', nombre: 'Rapida');
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: radio,
+          servicioEcualizador: FakeServicioEcualizador(),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
+
+        await estado.inicializar();
+        await estado.guardarPresetEcualizadorPorEmisora(
+          primera.uuid,
+          PresetEcualizador.rock,
+        );
+        await estado.guardarPresetEcualizadorPorEmisora(
+          segunda.uuid,
+          PresetEcualizador.jazz,
+        );
+
+        final primeraFuture = estado.reproducir(primera);
+        final segundaFuture = estado.reproducir(segunda);
+        audio.completar(segunda.uuid);
+        await segundaFuture;
+        audio.completar(primera.uuid);
+        await primeraFuture;
+
+        expect(estado.presetEcualizador, PresetEcualizador.jazz);
+        expect(radio.ultimoUuidClick, segunda.uuid);
+      },
+    );
 
     test('reordenar favoritos reindexa de forma determinística', () async {
       final favoritos = FakeServicioFavoritos();
@@ -266,8 +312,6 @@ void main() {
       expect(lista.map((e) => e.orden).toList(), equals([0, 1, 2]));
     });
 
-
-
     test('cargarMasBusqueda pagina resultados y acota memoria', () async {
       final emisoras = List.generate(
         70,
@@ -358,6 +402,8 @@ Future<File> _archivoCustomVacio() async => _crearArchivoCustom(const []);
 Future<File> _crearArchivoCustom(List<dynamic> emisoras) async {
   final dir = await Directory.systemTemp.createTemp('pluriwave-test-');
   final archivo = File('${dir.path}/emisoras_custom.json');
-  await archivo.writeAsString(jsonEncode(emisoras.map((e) => e.toMap()).toList()));
+  await archivo.writeAsString(
+    jsonEncode(emisoras.map((e) => e.toMap()).toList()),
+  );
   return archivo;
 }

test/helpers/fakes.dart

@@ -16,6 +16,7 @@ class FakeServicioAudio extends ServicioAudio {
   final _estadoController = StreamController<EstadoReproduccion>.broadcast();
   final List<PresetEcualizador> presetsAplicados = [];
   final List<Emisora> emisorasReproducidas = [];
+  final List<bool> cambiosEcualizadorActivo = [];
   Emisora? _emisoraActual;
   EstadoReproduccion _estadoActual = EstadoReproduccion.detenido;
 
@@ -57,6 +58,11 @@ class FakeServicioAudio extends ServicioAudio {
   @override
   Future<void> setBanda(int index, double db) async {}
 
+  @override
+  Future<void> setEcualizadorActivo(bool activo) async {
+    cambiosEcualizadorActivo.add(activo);
+  }
+
   @override
   Future<void> dispose() async {
     await _estadoController.close();
@@ -122,13 +128,13 @@ class FakeServicioRadio extends ServicioRadio {
     List<List<Emisora>>? tendenciasPorLlamada,
     List<Object>? erroresPopularesPorLlamada,
     List<Object>? erroresTendenciasPorLlamada,
-  })  : _populares = populares ?? [],
-        _tendencias = tendencias ?? [],
-        _busqueda = busqueda ?? [],
-        _popularesPorLlamada = popularesPorLlamada ?? const [],
-        _tendenciasPorLlamada = tendenciasPorLlamada ?? const [],
-        _erroresPopularesPorLlamada = erroresPopularesPorLlamada ?? const [],
-        _erroresTendenciasPorLlamada = erroresTendenciasPorLlamada ?? const [];
+  }) : _populares = populares ?? [],
+       _tendencias = tendencias ?? [],
+       _busqueda = busqueda ?? [],
+       _popularesPorLlamada = popularesPorLlamada ?? const [],
+       _tendenciasPorLlamada = tendenciasPorLlamada ?? const [],
+       _erroresPopularesPorLlamada = erroresPopularesPorLlamada ?? const [],
+       _erroresTendenciasPorLlamada = erroresTendenciasPorLlamada ?? const [];
 
   final List<Emisora> _populares;
   final List<Emisora> _tendencias;
@@ -147,14 +153,18 @@ class FakeServicioRadio extends ServicioRadio {
       error is Exception ? error : Exception(error.toString());
 
   @override
-  Future<List<Emisora>> obtenerPopulares({int limit = 30, int offset = 0}) async {
+  Future<List<Emisora>> obtenerPopulares({
+    int limit = 30,
+    int offset = 0,
+  }) async {
     final llamada = obtenerPopularesCalls++;
     if (llamada < _erroresPopularesPorLlamada.length) {
       throw _normalizarError(_erroresPopularesPorLlamada[llamada]);
     }
-    final data = llamada < _popularesPorLlamada.length
-        ? _popularesPorLlamada[llamada]
-        : _populares;
+    final data =
+        llamada < _popularesPorLlamada.length
+            ? _popularesPorLlamada[llamada]
+            : _populares;
     return data.take(limit).toList();
   }
 
@@ -164,9 +174,10 @@ class FakeServicioRadio extends ServicioRadio {
     if (llamada < _erroresTendenciasPorLlamada.length) {
       throw _normalizarError(_erroresTendenciasPorLlamada[llamada]);
     }
-    final data = llamada < _tendenciasPorLlamada.length
-        ? _tendenciasPorLlamada[llamada]
-        : _tendencias;
+    final data =
+        llamada < _tendenciasPorLlamada.length
+            ? _tendenciasPorLlamada[llamada]
+            : _tendencias;
     return data.take(limit).toList();
   }
 
@@ -193,12 +204,15 @@ class FakeServicioEcualizador extends ServicioEcualizador {
   FakeServicioEcualizador({
     PresetEcualizador? principal,
     Map<String, PresetEcualizador>? porEmisora,
+    bool activo = true,
   }) : _config = ConfiguracionEcualizador(
-          principal: principal ?? PresetEcualizador.flat,
-          porEmisora: porEmisora ?? {},
-        );
+         principal: principal ?? PresetEcualizador.flat,
+         porEmisora: porEmisora ?? {},
+         activo: activo,
+       );
 
   ConfiguracionEcualizador _config;
+  ConfiguracionEcualizador get config => _config;
 
   @override
   Future<ConfiguracionEcualizador> cargar() async => _config;
@@ -208,6 +222,16 @@ class FakeServicioEcualizador extends ServicioEcualizador {
     _config = ConfiguracionEcualizador(
       principal: preset,
       porEmisora: _config.porEmisora,
+      activo: _config.activo,
+    );
+  }
+
+  @override
+  Future<void> guardarActivo(bool activo) async {
+    _config = ConfiguracionEcualizador(
+      principal: _config.principal,
+      porEmisora: _config.porEmisora,
+      activo: activo,
     );
   }
 
@@ -218,6 +242,7 @@ class FakeServicioEcualizador extends ServicioEcualizador {
     _config = ConfiguracionEcualizador(
       principal: _config.principal,
       porEmisora: mapa,
+      activo: _config.activo,
     );
   }
 
@@ -228,6 +253,7 @@ class FakeServicioEcualizador extends ServicioEcualizador {
     _config = ConfiguracionEcualizador(
       principal: _config.principal,
       porEmisora: mapa,
+      activo: _config.activo,
     );
   }
 }