fix(player): stabilize equalizer and visualizer

lib/estado/estado_radio.dart

@@ -69,6 +69,7 @@ class EstadoRadio extends ChangeNotifier {
   final Map<String, PresetEcualizador> _presetsEmisoraMap = {};
   PresetEcualizador _presetPrincipal = PresetEcualizador.flat;
   PresetEcualizador _presetActual = PresetEcualizador.flat;
+  bool _ecualizadorActivo = true;
 
   bool _cargandoPopulares = false;
   bool _cargandoBusqueda = false;
@@ -102,6 +103,7 @@ class EstadoRadio extends ChangeNotifier {
   Stream<EstadoReproduccion> get estadoStream => audio.estadoStream;
   PresetEcualizador get presetEcualizador => _presetActual;
   PresetEcualizador get presetPrincipalEcualizador => _presetPrincipal;
+  bool get ecualizadorActivo => _ecualizadorActivo;
   bool get ecualizadorDisponible => audio.ecualizadorDisponible;
 
   bool get emisoraActualEsFavorita {
@@ -172,13 +174,16 @@ class EstadoRadio extends ChangeNotifier {
       final config = await servicioEcualizador.cargar();
       _presetPrincipal = config.principal;
       _presetActual = config.principal;
+      _ecualizadorActivo = config.activo;
       _presetsEmisoraMap
         ..clear()
         ..addAll(config.porEmisora);
+      await audio.setEcualizadorActivo(_ecualizadorActivo);
       await audio.aplicarPreset(_presetPrincipal);
     } catch (_) {
       _presetPrincipal = PresetEcualizador.flat;
       _presetActual = PresetEcualizador.flat;
+      _ecualizadorActivo = true;
       _presetsEmisoraMap.clear();
     }
   }
@@ -483,6 +488,16 @@ class EstadoRadio extends ChangeNotifier {
     }
   }
 
+  Future<void> cambiarEcualizadorActivo(bool activo) async {
+    _ecualizadorActivo = activo;
+    await servicioEcualizador.guardarActivo(activo);
+    await audio.setEcualizadorActivo(activo);
+    if (activo) {
+      await audio.aplicarPreset(_presetActual);
+    }
+    notifyListeners();
+  }
+
   Future<void> cambiarPresetEcualizador(
     PresetEcualizador preset, {
     bool guardarPorEmisora = true,
@@ -632,6 +647,7 @@ class EstadoRadio extends ChangeNotifier {
       ConfiguracionEcualizador(
         principal: _presetPrincipal,
         porEmisora: _presetsEmisoraMap,
+        activo: _ecualizadorActivo,
       ),
     );
 

lib/pantallas/pantalla_ajustes.dart

@@ -181,13 +181,26 @@ class _SeccionEcualizador extends StatelessWidget {
                     style: Theme.of(ctx).textTheme.titleMedium,
                   ),
                   const Spacer(),
-                  if (!disponible)
+                  Chip(
-                    const Chip(
+                    label: Text(
-                      label: Text('Se guarda aunque no esté activo'),
+                      estado.ecualizadorActivo ? 'Activo' : 'Desactivado',
-                      visualDensity: VisualDensity.compact,
                     ),
+                    visualDensity: VisualDensity.compact,
+                  ),
                 ],
               ),
+              const SizedBox(height: 8),
+              SwitchListTile.adaptive(
+                contentPadding: EdgeInsets.zero,
+                title: const Text('Activar ecualizador'),
+                subtitle: Text(
+                  disponible
+                      ? 'Los cambios se aplican en tiempo real a la emisora actual.'
+                      : 'Se guardan los cambios y se aplicarán cuando Android habilite el efecto.',
+                ),
+                value: estado.ecualizadorActivo,
+                onChanged: estado.cambiarEcualizadorActivo,
+              ),
               if (mostrarModoPorEmisora) ...[
                 const SizedBox(height: 8),
                 SwitchListTile.adaptive(

lib/pantallas/pantalla_reproductor.dart

@@ -90,6 +90,21 @@ class _PantallaReproductorState extends State<PantallaReproductor>
           onPressed: () => Navigator.pop(context),
         ),
         actions: [
+          IconButton(
+            icon: Icon(
+              estado.ecualizadorActivo
+                  ? Icons.equalizer_rounded
+                  : Icons.equalizer_outlined,
+              color: estado.ecualizadorActivo ? tokens.warmCoral : null,
+            ),
+            tooltip:
+                estado.ecualizadorActivo
+                    ? 'Desactivar ecualizador'
+                    : 'Activar ecualizador',
+            onPressed:
+                () =>
+                    estado.cambiarEcualizadorActivo(!estado.ecualizadorActivo),
+          ),
           IconButton(
             icon: Icon(
               esFavorito

lib/servicios/servicio_audio.dart

@@ -77,8 +77,11 @@ class ServicioAudio {
   Future<void> setVolumen(double vol) => _handler.setVolumen(vol);
   double get volumen => _handler.volumen;
   bool get estaSonando => _handler.playbackState.value.playing;
-  Stream<int?> get androidAudioSessionIdStream =>
+  Stream<int?> get androidAudioSessionIdStream async* {
-      _handler.androidAudioSessionIdStream;
+    yield _handler.androidAudioSessionId;
+    yield* _handler.androidAudioSessionIdStream;
+  }
+
   Future<void> dispose() async {}
 
   // ── Ecualizador ───────────────────────────────────────────────────────────
@@ -88,6 +91,8 @@ class ServicioAudio {
 
   Future<void> aplicarPreset(PresetEcualizador preset) =>
       _handler.aplicarPreset(preset);
+  Future<void> setEcualizadorActivo(bool activo) =>
+      _handler.setEcualizadorActivo(activo);
 
   Future<void> setBanda(int index, double db) => _handler.setBanda(index, db);
 }
@@ -106,6 +111,7 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
   StreamSubscription<PlaybackEvent>? _eventosSub;
   StreamSubscription<int?>? _androidAudioSessionIdSub;
   final _androidAudioSessionIdController = StreamController<int?>.broadcast();
+  int? _androidAudioSessionId;
   Future<void> _colaCambioFuente = Future<void>.value();
   int _revisionFuente = 0;
 
@@ -116,9 +122,12 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
   AndroidEqualizer? get ecualizador => _eq;
   bool _eqDisponible = false;
   bool get ecualizadorDisponible => _eqDisponible;
+  bool _ecualizadorActivo = true;
+  bool get ecualizadorActivo => _ecualizadorActivo;
 
   PresetEcualizador _presetActual = PresetEcualizador.flat;
   PresetEcualizador get presetActual => _presetActual;
+  int? get androidAudioSessionId => _androidAudioSessionId;
   Stream<int?> get androidAudioSessionIdStream =>
       _androidAudioSessionIdController.stream;
 
@@ -166,6 +175,7 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
     _androidAudioSessionIdSub = _player.androidAudioSessionIdStream.listen((
       sessionId,
     ) {
+      _androidAudioSessionId = sessionId;
       if (!_androidAudioSessionIdController.isClosed) {
         _androidAudioSessionIdController.add(sessionId);
       }
@@ -316,6 +326,7 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
 
     _eq = AndroidEqualizer();
     _eqDisponible = false;
+    _androidAudioSessionId = null;
     _player = _crearPlayer();
     await _player.setVolume(_volumen);
     _conectarStreamsPlayer();
@@ -342,7 +353,7 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
       final params = await _eq.parameters;
       _eqDisponible = params.bands.isNotEmpty;
       if (_eqDisponible) {
-        await _eq.setEnabled(true);
+        await _eq.setEnabled(_ecualizadorActivo);
         await aplicarPreset(_presetActual);
       }
     } catch (_) {
@@ -355,6 +366,8 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
     _presetActual = preset;
     if (!_eqDisponible) return;
     try {
+      await _eq.setEnabled(_ecualizadorActivo);
+      if (!_ecualizadorActivo) return;
       final params = await _eq.parameters;
       for (
         int i = 0;
@@ -368,12 +381,12 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
 
   /// Ajusta una banda individual.
   Future<void> setBanda(int index, double db) async {
-    if (!_eqDisponible) return;
     final bandas = List<double>.from(_presetActual.bandas);
     if (index >= 0 && index < bandas.length) {
       bandas[index] = db;
       _presetActual = _presetActual.copyWithBandas(bandas);
     }
+    if (!_eqDisponible || !_ecualizadorActivo) return;
     try {
       final params = await _eq.parameters;
       if (index < params.bands.length) {
@@ -382,6 +395,17 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
     } catch (_) {}
   }
 
+  Future<void> setEcualizadorActivo(bool activo) async {
+    _ecualizadorActivo = activo;
+    if (!_eqDisponible) return;
+    try {
+      await _eq.setEnabled(activo);
+      if (activo) {
+        await aplicarPreset(_presetActual);
+      }
+    } catch (_) {}
+  }
+
   Future<void> setVolumen(double vol) async {
     _volumen = vol.clamp(0.0, 1.0);
     await _player.setVolume(_volumen);

lib/servicios/servicio_ecualizador.dart

@@ -8,15 +8,18 @@ class ConfiguracionEcualizador {
   const ConfiguracionEcualizador({
     required this.principal,
     required this.porEmisora,
+    this.activo = true,
   });
 
   final PresetEcualizador principal;
   final Map<String, PresetEcualizador> porEmisora;
+  final bool activo;
 }
 
 class ServicioEcualizador {
   static const _keyPresetPrincipal = 'eq_preset_principal_v1';
   static const _keyPresetsPorEmisora = 'eq_presets_por_emisora_v1';
+  static const _keyActivo = 'eq_activo_v1';
 
   Future<ConfiguracionEcualizador> cargar() async {
     final prefs = await SharedPreferences.getInstance();
@@ -25,6 +28,7 @@ class ServicioEcualizador {
     return ConfiguracionEcualizador(
       principal: principal,
       porEmisora: porEmisora,
+      activo: prefs.getBool(_keyActivo) ?? true,
     );
   }
 
@@ -40,6 +44,11 @@ class ServicioEcualizador {
     await _guardarPresetsPorEmisora(prefs, mapa);
   }
 
+  Future<void> guardarActivo(bool activo) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyActivo, activo);
+  }
+
   Future<void> eliminarPorEmisora(String uuid) async {
     final prefs = await SharedPreferences.getInstance();
     final mapa = _leerPresetsPorEmisora(prefs);
@@ -54,6 +63,7 @@ class ServicioEcualizador {
       jsonEncode(config.principal.toJson()),
     );
     await _guardarPresetsPorEmisora(prefs, config.porEmisora);
+    await prefs.setBool(_keyActivo, config.activo);
   }
 
   PresetEcualizador _leerPresetPrincipal(SharedPreferences prefs) {
@@ -82,9 +92,7 @@ class ServicioEcualizador {
       return data.map(
         (uuid, preset) => MapEntry(
           uuid,
-          PresetEcualizador.desdeJson(
+          PresetEcualizador.desdeJson(Map<String, dynamic>.from(preset as Map)),
-            Map<String, dynamic>.from(preset as Map),
-          ),
         ),
       );
     } catch (_) {

lib/widgets/visualizador_audio.dart

@@ -40,7 +40,9 @@ class _VisualizadorAudioState extends State<VisualizadorAudio>
   late final AnimationController _controller;
   bool _activo = false;
   int? _sessionId;
-  List<double> _ondaReal = const [];
+  List<double> _ondaObjetivo = const [];
+  List<double> _ondaVisual = const [];
+  DateTime? _ultimaOndaReal;
   StreamSubscription<EstadoReproduccion>? _estadoSubscription;
   StreamSubscription<int?>? _sessionSubscription;
   StreamSubscription<dynamic>? _ondaSubscription;
@@ -52,7 +54,10 @@ class _VisualizadorAudioState extends State<VisualizadorAudio>
       vsync: this,
       duration: const Duration(seconds: 2),
     )..addListener(() {
-      if (mounted) setState(() {});
+      if (mounted) {
+        _actualizarOndaVisual();
+        setState(() {});
+      }
     });
     _estadoSubscription = widget.estadoStream.listen(_onEstado);
     _sessionSubscription = widget.androidAudioSessionIdStream?.listen(
@@ -87,9 +92,7 @@ class _VisualizadorAudioState extends State<VisualizadorAudio>
     if (!puedeCapturar) {
       unawaited(_ondaSubscription?.cancel());
       _ondaSubscription = null;
-      if (_ondaReal.isNotEmpty && mounted) {
+      _ultimaOndaReal = null;
-        setState(() => _ondaReal = const []);
-      }
       return;
     }
 
@@ -107,18 +110,66 @@ class _VisualizadorAudioState extends State<VisualizadorAudio>
                 .map((v) => v.toDouble().clamp(0.0, 1.0))
                 .toList(growable: false);
             if (muestras.isNotEmpty) {
-              setState(() => _ondaReal = muestras);
+              _ultimaOndaReal = DateTime.now();
+              _ondaObjetivo = _normalizar(muestras);
             }
           },
           onError: (_) {
             unawaited(_ondaSubscription?.cancel());
             _ondaSubscription = null;
-            if (mounted) setState(() => _ondaReal = const []);
+            _ultimaOndaReal = null;
           },
           cancelOnError: false,
         );
   }
 
+  void _actualizarOndaVisual() {
+    final objetivo = _objetivoActual();
+    if (_ondaVisual.length != objetivo.length) {
+      _ondaVisual = List<double>.from(objetivo);
+      return;
+    }
+    _ondaVisual = List<double>.generate(objetivo.length, (i) {
+      final suavizado = _ondaVisual[i] + (objetivo[i] - _ondaVisual[i]) * 0.16;
+      return suavizado.clamp(0.0, 1.0);
+    }, growable: false);
+  }
+
+  List<double> _objetivoActual() {
+    final ahora = DateTime.now();
+    final tieneReal =
+        _ultimaOndaReal != null &&
+        ahora.difference(_ultimaOndaReal!) <
+            const Duration(milliseconds: 900) &&
+        _ondaObjetivo.isNotEmpty;
+    if (tieneReal) return _ondaObjetivo;
+    return _ondaOrganica();
+  }
+
+  List<double> _ondaOrganica() {
+    final count = widget.barras.clamp(8, 96);
+    final phase = _controller.value * pi * 2;
+    final intensidad = _activo ? 1.0 : 0.18;
+    return List<double>.generate(count, (i) {
+      final p = count <= 1 ? 0.0 : i / (count - 1);
+      final envelope = sin(pi * p).clamp(0.10, 1.0);
+      final flow =
+          sin(phase + p * pi * 2.2) * 0.24 +
+          sin(phase * 0.63 - p * pi * 5.1) * 0.18 +
+          sin(phase * 1.37 + p * pi * 9.0) * 0.08;
+      final value = 0.5 + flow * envelope * intensidad;
+      return value.clamp(0.12, 0.88);
+    }, growable: false);
+  }
+
+  List<double> _normalizar(List<double> muestras) {
+    final maximo = muestras.fold<double>(0, (max, v) => v > max ? v : max);
+    if (maximo <= 0.001) return muestras;
+    return muestras
+        .map((v) => (0.08 + (v / maximo) * 0.84).clamp(0.0, 1.0))
+        .toList(growable: false);
+  }
+
   @override
   void dispose() {
     _estadoSubscription?.cancel();
@@ -141,7 +192,7 @@ class _VisualizadorAudioState extends State<VisualizadorAudio>
             color: color,
             phase: t,
             active: _activo,
-            waveform: _ondaReal,
+            waveform: _ondaVisual,
           ),
           child: const SizedBox.expand(),
         ),

test/estado/estado_radio_test.dart

@@ -35,223 +35,269 @@ void main() {
       );
     });
 
-    test('carga EQ principal persistido antes de decidir EQ de reproducción',
+    test(
-        () async {
+      'carga EQ principal persistido antes de decidir EQ de reproducción',
-      final audio = FakeServicioAudio();
+      () async {
-      final principal = PresetEcualizador.rock;
+        final audio = FakeServicioAudio();
-      final emisora = emisoraDemo(uuid: 'api-1', nombre: 'API Uno');
+        final principal = PresetEcualizador.rock;
-      final estado = EstadoRadio(
+        final emisora = emisoraDemo(uuid: 'api-1', nombre: 'API Uno');
-        audio: audio,
+        final estado = EstadoRadio(
-        favoritos: FakeServicioFavoritos(),
+          audio: audio,
-        radio: FakeServicioRadio(populares: [emisora]),
+          favoritos: FakeServicioFavoritos(),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
+          radio: FakeServicioRadio(populares: [emisora]),
-        resolverArchivoCustom: _archivoCustomVacio,
+          servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        iniciarAutomaticamente: false,
+          resolverArchivoCustom: _archivoCustomVacio,
-      );
+          iniciarAutomaticamente: false,
+        );
 
-      await estado.inicializar();
+        await estado.inicializar();
-      await estado.reproducir(emisora);
+        await estado.reproducir(emisora);
 
-      expect(estado.presetEcualizador, principal);
+        expect(estado.presetEcualizador, principal);
-      expect(audio.presetsAplicados.first, principal);
+        expect(audio.presetsAplicados.first, principal);
-      expect(audio.presetsAplicados.last, 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,
-      );
-    });
 
     test(
-        'inicializar deja error tras fallo y cargarPopulares manual recupera estaciones',
+      'mantiene EQ persistido aunque el ecualizador nativo no esté disponible',
-        () async {
+      () async {
-      final radio = FakeServicioRadio(
+        final principal = PresetEcualizador.jazz;
-        erroresPopularesPorLlamada: [Exception('sin red')],
+        final porEmisora = {'fav-1': PresetEcualizador.rock};
-        popularesPorLlamada: [
+        final estado = EstadoRadio(
-          const [],
+          audio: FakeServicioAudio(ecualizadorActivo: false),
-          [emisoraDemo(uuid: 'api-ok', nombre: 'API Recuperada')],
+          favoritos: FakeServicioFavoritos(),
-        ],
+          radio: FakeServicioRadio(),
-        tendenciasPorLlamada: [
+          servicioEcualizador: FakeServicioEcualizador(
-          const [],
+            principal: principal,
-          [emisoraDemo(uuid: 'trend-ok', nombre: 'Trend Recuperada')],
+            porEmisora: porEmisora,
-        ],
+          ),
-      );
+          resolverArchivoCustom: _archivoCustomVacio,
-      final estado = EstadoRadio(
+          iniciarAutomaticamente: false,
-        audio: FakeServicioAudio(),
+        );
-        favoritos: FakeServicioFavoritos(),
-        radio: radio,
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
 
-      await estado.inicializar();
+        await estado.inicializar();
-      expect(estado.error, 'Sin conexión a la API de radio');
 
-      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);
+    test(
-      expect(estado.populares.map((e) => e.uuid), contains('api-ok'));
+      'inicializar deja error tras fallo y cargarPopulares manual recupera estaciones',
-      expect(estado.tendencias.map((e) => e.uuid), contains('trend-ok'));
+      () async {
-      expect(radio.obtenerPopularesCalls, 2);
+        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',
+        await estado.inicializar();
-        () async {
+        expect(estado.error, 'Sin conexión a la API de radio');
-      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);
 
-      final estado = EstadoRadio(
+        await estado.cargarPopulares();
-        audio: audio,
-        favoritos: favoritos,
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
 
-      await estado.inicializar();
+        expect(estado.error, isNull);
-      await estado.cargarFavoritos();
+        expect(estado.populares.map((e) => e.uuid), contains('api-ok'));
-      await estado.guardarPresetEcualizadorPorEmisora(emisora.uuid, propio);
+        expect(estado.tendencias.map((e) => e.uuid), contains('trend-ok'));
+        expect(radio.obtenerPopularesCalls, 2);
+      },
+    );
 
-      await estado.reproducir(emisora);
+    test(
-      expect(estado.presetEcualizador, propio);
+      'EQ propio por emisora pisa al principal y puede volver a fallback',
-      expect(audio.presetsAplicados.last, propio);
+      () 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);
+        final estado = EstadoRadio(
-      await estado.reproducir(emisora);
+          audio: audio,
-      expect(estado.presetEcualizador, principal);
+          favoritos: favoritos,
-      expect(audio.presetsAplicados.last, principal);
+          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 {
+        await estado.inicializar();
-      final audio = FakeServicioAudio();
+        await estado.cargarFavoritos();
-      final favoritos = FakeServicioFavoritos();
+        await estado.guardarPresetEcualizadorPorEmisora(emisora.uuid, propio);
-      final emisora = emisoraDemo(uuid: 'fav-main', nombre: 'Favorita Main');
-      final principal = PresetEcualizador.voz;
-      await favoritos.agregar(emisora);
 
-      final estado = EstadoRadio(
+        await estado.reproducir(emisora);
-        audio: audio,
+        expect(estado.presetEcualizador, propio);
-        favoritos: favoritos,
+        expect(audio.presetsAplicados.last, propio);
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(principal: principal),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
 
-      await estado.inicializar();
+        await estado.deshabilitarPresetEcualizadorPorEmisora(emisora.uuid);
-      await estado.cargarFavoritos();
+        await estado.reproducir(emisora);
-      await estado.reproducir(emisora);
+        expect(estado.presetEcualizador, principal);
+        expect(audio.presetsAplicados.last, principal);
+      },
+    );
 
-      expect(estado.tienePresetEcualizadorPorEmisora(emisora.uuid), isFalse);
+    test(
-      expect(estado.presetEcualizador, principal);
+      'favorita sin EQ propio usa EQ principal desde el primer play',
-      expect(audio.presetsAplicados.last, principal);
+      () 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 {
+        expect(estado.tienePresetEcualizadorPorEmisora(emisora.uuid), isFalse);
-      final audio = FakeServicioAudio();
+        expect(estado.presetEcualizador, principal);
-      final emisora = emisoraDemo(uuid: 'play-1', nombre: 'Primera');
+        expect(audio.presetsAplicados.last, principal);
-      final estado = EstadoRadio(
+      },
-        audio: audio,
+    );
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
-      var notificaciones = 0;
-      estado.addListener(() => notificaciones++);
 
-      await estado.inicializar();
+    test(
-      final antes = notificaciones;
+      'permite activar y desactivar el ecualizador de forma persistente',
-      audio.emitirEstado(EstadoReproduccion.cargando);
+      () async {
-      await Future<void>.delayed(Duration.zero);
+        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 {
+        await estado.cambiarEcualizadorActivo(false);
-      final audio = FakeServicioAudio();
+        expect(estado.ecualizadorActivo, isFalse);
-      final emisora = emisoraDemo(uuid: 'same-1', nombre: 'Misma');
+        expect(servicioEcualizador.config.activo, isFalse);
-      final estado = EstadoRadio(
+        expect(audio.cambiosEcualizadorActivo.last, isFalse);
-        audio: audio,
-        favoritos: FakeServicioFavoritos(),
-        radio: FakeServicioRadio(populares: [emisora]),
-        servicioEcualizador: FakeServicioEcualizador(),
-        resolverArchivoCustom: _archivoCustomVacio,
-        iniciarAutomaticamente: false,
-      );
 
-      await estado.inicializar();
+        await estado.cambiarEcualizadorActivo(true);
-      await estado.reproducir(emisora);
+        expect(estado.ecualizadorActivo, isTrue);
-      await estado.reproducir(emisora);
+        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 {
+        await estado.inicializar();
-      final audio = _AudioControlado();
+        final antes = notificaciones;
-      final radio = FakeServicioRadio();
+        audio.emitirEstado(EstadoReproduccion.cargando);
-      final primera = emisoraDemo(uuid: 'slow-1', nombre: 'Lenta');
+        await Future<void>.delayed(Duration.zero);
-      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();
+        expect(notificaciones, greaterThan(antes));
-      await estado.guardarPresetEcualizadorPorEmisora(
+      },
-        primera.uuid,
+    );
-        PresetEcualizador.rock,
-      );
-      await estado.guardarPresetEcualizadorPorEmisora(
-        segunda.uuid,
-        PresetEcualizador.jazz,
-      );
 
-      final primeraFuture = estado.reproducir(primera);
+    test(
-      final segundaFuture = estado.reproducir(segunda);
+      'reproducir la misma emisora mientras suena fuerza recarga del stream',
-      audio.completar(segunda.uuid);
+      () async {
-      await segundaFuture;
+        final audio = FakeServicioAudio();
-      audio.completar(primera.uuid);
+        final emisora = emisoraDemo(uuid: 'same-1', nombre: 'Misma');
-      await primeraFuture;
+        final estado = EstadoRadio(
+          audio: audio,
+          favoritos: FakeServicioFavoritos(),
+          radio: FakeServicioRadio(populares: [emisora]),
+          servicioEcualizador: FakeServicioEcualizador(),
+          resolverArchivoCustom: _archivoCustomVacio,
+          iniciarAutomaticamente: false,
+        );
 
-      expect(estado.presetEcualizador, PresetEcualizador.jazz);
+        await estado.inicializar();
-      expect(radio.ultimoUuidClick, segunda.uuid);
+        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 ?? [],
+  }) : _populares = populares ?? [],
-        _tendencias = tendencias ?? [],
+       _tendencias = tendencias ?? [],
-        _busqueda = busqueda ?? [],
+       _busqueda = busqueda ?? [],
-        _popularesPorLlamada = popularesPorLlamada ?? const [],
+       _popularesPorLlamada = popularesPorLlamada ?? const [],
-        _tendenciasPorLlamada = tendenciasPorLlamada ?? const [],
+       _tendenciasPorLlamada = tendenciasPorLlamada ?? const [],
-        _erroresPopularesPorLlamada = erroresPopularesPorLlamada ?? const [],
+       _erroresPopularesPorLlamada = erroresPopularesPorLlamada ?? const [],
-        _erroresTendenciasPorLlamada = erroresTendenciasPorLlamada ?? 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
+    final data =
-        ? _popularesPorLlamada[llamada]
+        llamada < _popularesPorLlamada.length
-        : _populares;
+            ? _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
+    final data =
-        ? _tendenciasPorLlamada[llamada]
+        llamada < _tendenciasPorLlamada.length
-        : _tendencias;
+            ? _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,
+         principal: principal ?? PresetEcualizador.flat,
-          porEmisora: porEmisora ?? {},
+         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,
     );
   }
 }