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)
-                    const Chip(
-                      label: Text('Se guarda aunque no esté activo'),
-                      visualDensity: VisualDensity.compact,
+                  Chip(
+                    label: Text(
+                      estado.ecualizadorActivo ? 'Activo' : 'Desactivado',
                     ),
+                    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 =>
-      _handler.androidAudioSessionIdStream;
+  Stream<int?> get androidAudioSessionIdStream async* {
+    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(
-            Map<String, dynamic>.from(preset as Map),
-          ),
+          PresetEcualizador.desdeJson(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) {
-        setState(() => _ondaReal = const []);
-      }
+      _ultimaOndaReal = null;
       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(),
         ),