FreeTLab/pluriwave
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Implement startup retry mechanism for custom stations and equalizer persistence

Browse Source 
- Added state management for startup retry and custom station handling in `EstadoRadio`.
- Created tasks for implementing strict TDD with RED tests for HTTP failure retries and EQ persistence.
- Developed verification report to ensure compliance with TDD practices.
- Introduced fake services for testing, including `FakeServicioAudio`, `FakeServicioFavoritos`, and `FakeServicioRadio`.
- Implemented widget tests for `PantallaInicio` and `PantallaFavoritos` to validate UI behavior with custom stations.
- Enhanced `ServicioRadio` to support host rotation and retry logic for API calls.
- Established a new configuration file to enforce project constraints and testing rules.
This commit is contained in:
Javier Bautista Fernández
2026-04-27 17:34:04 +02:00
parent 922b3b4859
commit d579a0e107
21 changed files with 1902 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

348
lib/estado/estado_radio.dart
View File

@@ -4,50 +4,121 @@ import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:path_provider/path_provider.dart';
import '../modelos/emisora.dart';
import '../modelos/preset_ecualizador.dart';
import '../servicios/servicio_audio.dart';
import '../servicios/servicio_ecualizador.dart';
import '../servicios/servicio_favoritos.dart';
import '../servicios/servicio_radio.dart';
import '../servicios/servicio_timer.dart';
/// Estado global de la app con ChangeNotifier (Provider).
class EstadoRadio extends ChangeNotifier {
final ServicioAudio audio = ServicioAudio();
final ServicioFavoritos favoritos = ServicioFavoritos();
final ServicioRadio radio = ServicioRadio();
late final ServicioTimer timer;
EstadoRadio({
ServicioAudio? audio,
ServicioFavoritos? favoritos,
ServicioRadio? radio,
ServicioEcualizador? servicioEcualizador,
Future<File> Function()? resolverArchivoCustom,
bool iniciarAutomaticamente = true,
}) : audio = audio ?? ServicioAudio(),
favoritos = favoritos ?? ServicioFavoritos(),
radio = radio ?? ServicioRadio(),
servicioEcualizador = servicioEcualizador ?? ServicioEcualizador(),
_resolverArchivoCustom = resolverArchivoCustom {
timer = ServicioTimer(this.audio);
_escucharErroresReproduccion();
if (iniciarAutomaticamente) {
_initFuture = _init();
}
}
// Errores de reproducción → SnackBar
final ServicioAudio audio;
final ServicioFavoritos favoritos;
final ServicioRadio radio;
final ServicioEcualizador servicioEcualizador;
final Future<File> Function()? _resolverArchivoCustom;
late final ServicioTimer timer;
StreamSubscription<EstadoReproduccion>? _suscripcionEstadoAudio;
Future<void>? _initFuture;
// Errores de reproducción → SnackBar.
final _errorController = StreamController<String>.broadcast();
Stream<String> get errorStream => _errorController.stream;
List<Emisora> _populares = [];
List<Emisora> _tendencias = [];
List<Emisora> _resultadosBusqueda = [];
List<Emisora> _listafavoritos = [];
List<Emisora> _listaFavoritos = [];
List<Emisora> _emisorasCustom = [];
// Presets EQ guardados por uuid de emisora
// Presets EQ guardados por uuid de emisora.
final Map<String, PresetEcualizador> _presetsEmisoraMap = {};
PresetEcualizador _presetPrincipal = PresetEcualizador.flat;
PresetEcualizador _presetActual = PresetEcualizador.flat;
bool _cargandoPopulares = false;
bool _cargandoBusqueda = false;
String? _errorCarga;
EstadoRadio() {
timer = ServicioTimer(audio);
_init();
_escucharErroresReproduccion();
List<Emisora> get populares => _populares;
List<Emisora> get tendencias => _tendencias;
List<Emisora> get resultadosBusqueda => _resultadosBusqueda;
List<Emisora> get listaFavoritos => _listaFavoritos;
List<Emisora> get emisorasCustom => _emisorasCustom;
bool get cargandoPopulares => _cargandoPopulares;
bool get cargandoBusqueda => _cargandoBusqueda;
String? get error => _errorCarga;
Emisora? get emisoraActual => audio.emisoraActual;
Stream<EstadoReproduccion> get estadoStream => audio.estadoStream;
PresetEcualizador get presetEcualizador => _presetActual;
PresetEcualizador get presetPrincipalEcualizador => _presetPrincipal;
bool get ecualizadorDisponible => audio.ecualizadorDisponible;
bool get emisoraActualEsFavorita {
final actual = emisoraActual;
if (actual == null) return false;
return _listaFavoritos.any((e) => e.uuid == actual.uuid);
}
/// Escucha el stream de estado del audio y gestiona errores de reproducción
/// de forma centralizada: cancela el timer y notifica al usuario.
bool get emisoraActualTienePresetPropio {
final actual = emisoraActual;
if (actual == null) return false;
return tienePresetEcualizadorPorEmisora(actual.uuid);
}
/// Lista principal (home): custom + populares, sin duplicados.
List<Emisora> get emisorasInicio {
final mapa = <String, Emisora>{};
for (final emisora in _emisorasCustom) {
mapa[emisora.uuid] = emisora;
}
for (final emisora in _populares) {
mapa.putIfAbsent(emisora.uuid, () => emisora);
}
return mapa.values.toList();
}
Future<void> inicializar() {
_initFuture ??= _init();
return _initFuture!;
}
Future<void> _init() async {
await _cargarEcualizadorPersistido();
await Future.wait([
cargarPopulares(),
cargarFavoritos(),
_cargarEmisorasCustom(),
]);
}
/// Escucha el stream de estado del audio y gestiona errores de reproducción.
void _escucharErroresReproduccion() {
audio.estadoStream.listen((estado) {
_suscripcionEstadoAudio = audio.estadoStream.listen((estado) {
if (estado == EstadoReproduccion.error) {
// Cancelar el timer si estaba activo — no debe contar sin audio
if (timer.activo) {
timer.cancelar();
}
@@ -56,25 +127,20 @@ class EstadoRadio extends ChangeNotifier {
});
}
List<Emisora> get populares => _populares;
List<Emisora> get tendencias => _tendencias;
List<Emisora> get resultadosBusqueda => _resultadosBusqueda;
List<Emisora> get listaFavoritos => _listafavoritos;
List<Emisora> get emisorasCustom => _emisorasCustom;
bool get cargandoPopulares => _cargandoPopulares;
bool get cargandoBusqueda => _cargandoBusqueda;
String? get error => _errorCarga;
Emisora? get emisoraActual => audio.emisoraActual;
Stream<EstadoReproduccion> get estadoStream => audio.estadoStream;
PresetEcualizador get presetEcualizador => _presetActual;
bool get ecualizadorDisponible => audio.ecualizadorDisponible;
Future<void> _init() async {
await Future.wait([
cargarPopulares(),
cargarFavoritos(),
_cargarEmisoresCustom(),
]);
Future<void> _cargarEcualizadorPersistido() async {
try {
final config = await servicioEcualizador.cargar();
_presetPrincipal = config.principal;
_presetActual = config.principal;
_presetsEmisoraMap
..clear()
..addAll(config.porEmisora);
await audio.aplicarPreset(_presetPrincipal);
} catch (_) {
_presetPrincipal = PresetEcualizador.flat;
_presetActual = PresetEcualizador.flat;
_presetsEmisoraMap.clear();
}
}
Future<void> cargarPopulares() async {
@@ -88,7 +154,7 @@ class EstadoRadio extends ChangeNotifier {
]);
_populares = results[0];
_tendencias = results[1];
} catch (e) {
} catch (_) {
_errorCarga = 'Sin conexión a la API de radio';
} finally {
_cargandoPopulares = false;
@@ -97,7 +163,7 @@ class EstadoRadio extends ChangeNotifier {
}
Future<void> cargarFavoritos() async {
_listafavoritos = await favoritos.obtenerTodos();
_listaFavoritos = await favoritos.obtenerTodos();
notifyListeners();
}
@@ -117,7 +183,7 @@ class EstadoRadio extends ChangeNotifier {
idioma: idioma,
tag: tag,
);
} catch (e) {
} catch (_) {
_errorController.add('Error en la búsqueda. Comprueba tu conexión.');
} finally {
_cargandoBusqueda = false;
@@ -128,18 +194,13 @@ class EstadoRadio extends ChangeNotifier {
Future<void> reproducir(Emisora emisora) async {
try {
await audio.reproducir(emisora);
radio.registrarClick(emisora.uuid); // fire & forget
// Restaurar preset del ecualizador de esta emisora
final preset = _presetsEmisoraMap[emisora.uuid] ?? PresetEcualizador.flat;
await cambiarPresetEcualizador(preset, guardPorEmisora: false);
unawaited(radio.registrarClick(emisora.uuid));
await _aplicarPresetActivo(_presetParaEmisora(emisora.uuid));
notifyListeners();
} catch (e) {
// La reproducción falló: cancelar el timer para evitar estado inconsistente
// (el timer no debe contar si no hay audio reproduciéndose)
if (timer.activo) {
timer.cancelar();
}
// Emitir mensaje claro al usuario con el nombre de la emisora
final mensajeError = e.toString().replaceFirst('Exception: ', '');
_errorController.add(
mensajeError.isNotEmpty && mensajeError != 'Exception'
@@ -157,6 +218,9 @@ class EstadoRadio extends ChangeNotifier {
Future<bool> toggleFavorito(Emisora emisora) async {
final esFav = await favoritos.toggleFavorito(emisora);
if (!esFav) {
await deshabilitarPresetEcualizadorPorEmisora(emisora.uuid, notificar: false);
}
await cargarFavoritos();
notifyListeners();
return esFav;
@@ -164,43 +228,135 @@ class EstadoRadio extends ChangeNotifier {
Future<bool> esFavorito(String uuid) => favoritos.esFavorito(uuid);
// ── Ecualizador ──────────────────────────────────────────────────────────
// ── Ecualizador ───────────────────────────────────────────────────────────
bool tienePresetEcualizadorPorEmisora(String uuid) =>
_presetsEmisoraMap.containsKey(uuid);
PresetEcualizador? presetEcualizadorPorEmisora(String uuid) =>
_presetsEmisoraMap[uuid];
PresetEcualizador _presetParaEmisora(String uuid) =>
_presetsEmisoraMap[uuid] ?? _presetPrincipal;
Future<void> _aplicarPresetActivo(PresetEcualizador preset) async {
_presetActual = preset;
await audio.aplicarPreset(preset);
}
Future<void> cambiarPresetPrincipalEcualizador(
PresetEcualizador preset, {
bool notificar = true,
}) async {
_presetPrincipal = preset;
await servicioEcualizador.guardarPrincipal(preset);
final actual = emisoraActual;
final puedeAplicarAhora =
actual == null || !_presetsEmisoraMap.containsKey(actual.uuid);
if (puedeAplicarAhora) {
await _aplicarPresetActivo(preset);
}
if (notificar) notifyListeners();
}
Future<void> guardarPresetEcualizadorPorEmisora(
String uuid,
PresetEcualizador preset, {
bool notificar = true,
}) async {
_presetsEmisoraMap[uuid] = preset;
await servicioEcualizador.guardarPorEmisora(uuid, preset);
if (emisoraActual?.uuid == uuid) {
await _aplicarPresetActivo(preset);
}
if (notificar) notifyListeners();
}
Future<void> habilitarPresetEcualizadorPorEmisora(
String uuid, {
PresetEcualizador? base,
bool notificar = true,
}) async {
final presetBase = base ?? _presetsEmisoraMap[uuid] ?? _presetPrincipal;
await guardarPresetEcualizadorPorEmisora(
uuid,
presetBase,
notificar: notificar,
);
}
Future<void> deshabilitarPresetEcualizadorPorEmisora(
String uuid, {
bool notificar = true,
}) async {
_presetsEmisoraMap.remove(uuid);
await servicioEcualizador.eliminarPorEmisora(uuid);
if (emisoraActual?.uuid == uuid) {
await _aplicarPresetActivo(_presetPrincipal);
}
if (notificar) notifyListeners();
}
Future<void> cambiarModoEcualizadorEmisoraActual({required bool usarPropio}) async {
final actual = emisoraActual;
if (actual == null) return;
if (usarPropio) {
await habilitarPresetEcualizadorPorEmisora(actual.uuid);
} else {
await deshabilitarPresetEcualizadorPorEmisora(actual.uuid);
}
}
Future<void> cambiarPresetEcualizador(
PresetEcualizador preset, {
bool guardPorEmisora = true,
bool guardarPorEmisora = true,
}) async {
_presetActual = preset;
await audio.aplicarPreset(preset);
if (guardPorEmisora && emisoraActual != null) {
_presetsEmisoraMap[emisoraActual!.uuid] = preset;
final actual = emisoraActual;
final usarPresetPropio = guardarPorEmisora &&
actual != null &&
_presetsEmisoraMap.containsKey(actual.uuid);
if (usarPresetPropio) {
await guardarPresetEcualizadorPorEmisora(actual.uuid, preset);
return;
}
notifyListeners();
await cambiarPresetPrincipalEcualizador(preset);
}
Future<void> cambiarBandaEcualizador(int index, double db) async {
final bandas = List<double>.from(_presetActual.bandas);
if (index >= 0 && index < bandas.length) bandas[index] = db;
_presetActual = PresetEcualizador(nombre: 'Personalizado', bandas: bandas);
await audio.setBanda(index, db);
if (emisoraActual != null) {
_presetsEmisoraMap[emisoraActual!.uuid] = _presetActual;
}
notifyListeners();
if (index < 0 || index >= bandas.length) return;
bandas[index] = db;
final modificado = PresetEcualizador(
nombre: 'Personalizado',
bandas: bandas,
);
await cambiarPresetEcualizador(modificado);
}
// ── Emisoras personalizadas ───────────────────────────────────────────────
Future<File> _archivoCustom() async {
if (_resolverArchivoCustom != null) {
return _resolverArchivoCustom!();
}
final dir = await getApplicationDocumentsDirectory();
return File('${dir.path}/emisoras_custom.json');
}
Future<void> _cargarEmisoresCustom() async {
Future<void> _cargarEmisorasCustom() async {
try {
final f = await _archivoCustom();
if (!await f.exists()) return;
final data = jsonDecode(await f.readAsString()) as List;
final archivo = await _archivoCustom();
if (!await archivo.exists()) {
_emisorasCustom = [];
notifyListeners();
return;
}
final data = jsonDecode(await archivo.readAsString()) as List;
_emisorasCustom = data
.map((e) => Emisora.fromMap(Map<String, dynamic>.from(e as Map)))
.toList();
@@ -210,24 +366,33 @@ class EstadoRadio extends ChangeNotifier {
notifyListeners();
}
Future<void> _guardarEmisoresCustom() async {
final f = await _archivoCustom();
await f.writeAsString(jsonEncode(_emisorasCustom.map((e) => e.toMap()).toList()));
Future<void> _guardarEmisorasCustom() async {
final archivo = await _archivoCustom();
await archivo.writeAsString(
jsonEncode(_emisorasCustom.map((e) => e.toMap()).toList()),
);
}
Future<void> agregarEmitoraCustom(Emisora emisora) async {
Future<void> agregarEmisoraCustom(Emisora emisora) async {
_emisorasCustom.removeWhere((e) => e.uuid == emisora.uuid);
_emisorasCustom.add(emisora);
await _guardarEmisoresCustom();
await _guardarEmisorasCustom();
notifyListeners();
}
Future<void> eliminarEmitoraCustom(String uuid) async {
// Compatibilidad con el nombre histórico (typo original).
Future<void> agregarEmitoraCustom(Emisora emisora) =>
agregarEmisoraCustom(emisora);
Future<void> eliminarEmisoraCustom(String uuid) async {
_emisorasCustom.removeWhere((e) => e.uuid == uuid);
await _guardarEmisoresCustom();
await _guardarEmisorasCustom();
notifyListeners();
}
// Compatibilidad con el nombre histórico (typo original).
Future<void> eliminarEmitoraCustom(String uuid) => eliminarEmisoraCustom(uuid);
// ── Export / Import ───────────────────────────────────────────────────────
/// Genera el JSON de toda la configuración.
@@ -238,6 +403,7 @@ class EstadoRadio extends ChangeNotifier {
'exportedAt': DateTime.now().toIso8601String(),
'favoritos': favs.map((e) => e.toMap()).toList(),
'emisorasCustom': _emisorasCustom.map((e) => e.toMap()).toList(),
'presetPrincipalEcualizador': _presetPrincipal.toJson(),
'presetsEcualizador': _presetsEmisoraMap.map(
(uuid, preset) => MapEntry(uuid, preset.toJson()),
),
@@ -249,27 +415,52 @@ class EstadoRadio extends ChangeNotifier {
final version = data['version'] as int? ?? 1;
if (version != 1) throw Exception('Versión de configuración no compatible');
// Importar favoritos
final favRaw = data['favoritos'] as List? ?? [];
for (final raw in favRaw) {
final emisora = Emisora.fromMap(Map<String, dynamic>.from(raw as Map));
await favoritos.agregar(emisora);
}
// Importar emisoras custom
final customRaw = data['emisorasCustom'] as List? ?? [];
_emisorasCustom = customRaw
.map((e) => Emisora.fromMap(Map<String, dynamic>.from(e as Map)))
.toList();
await _guardarEmisoresCustom();
await _guardarEmisorasCustom();
final principalRaw = data['presetPrincipalEcualizador'];
if (principalRaw is Map) {
_presetPrincipal = PresetEcualizador.desdeJson(
Map<String, dynamic>.from(principalRaw),
);
} else {
_presetPrincipal = PresetEcualizador.flat;
}
// Importar presets EQ
final presetsRaw = data['presetsEcualizador'] as Map? ?? {};
_presetsEmisoraMap.clear();
presetsRaw.forEach((uuid, presetJson) {
_presetsEmisoraMap[uuid as String] =
PresetEcualizador.desdeJson(Map<String, dynamic>.from(presetJson as Map));
});
_presetsEmisoraMap
..clear()
..addAll(
presetsRaw.map<String, PresetEcualizador>(
(uuid, presetJson) => MapEntry(
uuid as String,
PresetEcualizador.desdeJson(
Map<String, dynamic>.from(presetJson as Map),
),
),
),
);
await servicioEcualizador.guardarConfiguracion(
ConfiguracionEcualizador(
principal: _presetPrincipal,
porEmisora: _presetsEmisoraMap,
),
);
final actual = emisoraActual;
final presetActivo =
actual == null ? _presetPrincipal : _presetParaEmisora(actual.uuid);
await _aplicarPresetActivo(presetActivo);
await cargarFavoritos();
notifyListeners();
@@ -289,6 +480,7 @@ class EstadoRadio extends ChangeNotifier {
@override
void dispose() {
_suscripcionEstadoAudio?.cancel();
_errorController.close();
audio.dispose();
timer.dispose();

16
lib/modelos/preset_ecualizador.dart
View File

@@ -26,4 +26,20 @@ class PresetEcualizador {
PresetEcualizador copyWithBandas(List<double> bandas) =>
PresetEcualizador(nombre: 'Personalizado', bandas: bandas);
@override
bool operator ==(Object other) {
if (identical(this, other)) return true;
if (other is! PresetEcualizador) return false;
if (nombre != other.nombre || bandas.length != other.bandas.length) {
return false;
}
for (int i = 0; i < bandas.length; i++) {
if (bandas[i] != other.bandas[i]) return false;
}
return true;
}
@override
int get hashCode => Object.hash(nombre, Object.hashAll(bandas));
}

45
lib/pantallas/pantalla_ajustes.dart
View File

@@ -44,6 +44,11 @@ class _SeccionEcualizador extends StatelessWidget {
return Consumer<EstadoRadio>(
builder: (ctx, estado, _) {
final disponible = estado.ecualizadorDisponible;
final emisoraActual = estado.emisoraActual;
final mostrarModoPorEmisora =
emisoraActual != null && estado.emisoraActualEsFavorita;
final usandoEqPropio = estado.emisoraActualTienePresetPropio;
return Padding(
padding: const EdgeInsets.all(16),
child: Column(
@@ -57,27 +62,41 @@ class _SeccionEcualizador extends StatelessWidget {
const Spacer(),
if (!disponible)
Chip(
label: const Text('Reproduce una emisora para activar'),
label: const Text('Se guarda aunque no esté activo'),
visualDensity: VisualDensity.compact,
),
],
),
if (disponible) ...[
if (mostrarModoPorEmisora) ...[
const SizedBox(height: 8),
PresetsEcualizadorWidget(
presetActual: estado.presetEcualizador,
onSeleccionar: (p) => estado.cambiarPresetEcualizador(p),
),
const SizedBox(height: 12),
EcualizadorWidget(
preset: estado.presetEcualizador,
onCambio: (p) {
for (int i = 0; i < p.bandas.length; i++) {
estado.cambiarBandaEcualizador(i, p.bandas[i]);
}
SwitchListTile.adaptive(
contentPadding: EdgeInsets.zero,
title: const Text('Usar EQ propio para esta favorita'),
subtitle: Text(
usandoEqPropio
? 'Activo para ${emisoraActual.nombre}'
: 'Usando EQ principal para ${emisoraActual.nombre}',
),
value: usandoEqPropio,
onChanged: (usarPropio) {
estado.cambiarModoEcualizadorEmisoraActual(
usarPropio: usarPropio,
);
},
),
],
const SizedBox(height: 8),
PresetsEcualizadorWidget(
presetActual: estado.presetEcualizador,
onSeleccionar: (p) => estado.cambiarPresetEcualizador(p),
),
const SizedBox(height: 12),
EcualizadorWidget(
preset: estado.presetEcualizador,
onCambio: (p) {
estado.cambiarPresetEcualizador(p);
},
),
],
),
);

2
lib/pantallas/pantalla_inicio.dart
View File

@@ -146,7 +146,7 @@ class _PantallaInicioState extends State<PantallaInicio> {
Widget _gridEmisoras(EstadoRadio estado, ThemeData theme) {
final emisoras = _generoSeleccionado != null
? estado.resultadosBusqueda
: estado.populares;
: estado.emisorasInicio;
final cargando = estado.cargandoPopulares ||
(_generoSeleccionado != null && estado.cargandoBusqueda);

46
lib/servicios/servicio_audio.dart
View File

@@ -2,15 +2,16 @@ import 'dart:developer' as developer;
import 'package:audio_service/audio_service.dart';
import 'package:just_audio/just_audio.dart';
import '../modelos/emisora.dart';
import '../modelos/preset_ecualizador.dart';
/// Estado de reproducción expuesto al UI.
enum EstadoReproduccion { detenido, cargando, reproduciendo, pausado, error }
// ─────────────────────────────────────────────────────────────
// ─────────────────────────────────────────────────────────────────────────────
// Handler global — inicializado en main.dart con AudioService.init
// ─────────────────────────────────────────────────────────────
// ─────────────────────────────────────────────────────────────────────────────
PluriWaveAudioHandler? _handlerGlobal;
void registrarHandler(PluriWaveAudioHandler handler) {
@@ -73,7 +74,7 @@ class ServicioAudio {
bool get estaSonando => _handler.playbackState.value.playing;
Future<void> dispose() async {}
// ── Ecualizador ──────────────────────────────────────────────────────────
// ── Ecualizador ───────────────────────────────────────────────────────────
AndroidEqualizer? get ecualizador => _handler.ecualizador;
bool get ecualizadorDisponible => _handler.ecualizadorDisponible;
PresetEcualizador get presetActual => _handler.presetActual;
@@ -85,9 +86,9 @@ class ServicioAudio {
_handler.setBanda(index, db);
}
// ─────────────────────────────────────────────────────────────
// ─────────────────────────────────────────────────────────────────────────────
// AudioHandler
// ─────────────────────────────────────────────────────────────
// ─────────────────────────────────────────────────────────────────────────────
class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
final AndroidEqualizer _eq = AndroidEqualizer();
@@ -132,9 +133,6 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
playbackState.add(playbackState.value.copyWith(bufferedPosition: pos));
});
// ── Escuchar errores de ExoPlayer ─────────────────────────────────────
// Captura todos los PlaybackException: TYPE_SOURCE (HTTP cleartext,
// certificado inválido, 404), TYPE_UNEXPECTED, timeout de conexión, etc.
_player.playbackEventStream.listen(
(_) {},
onError: (Object error, StackTrace stackTrace) {
@@ -143,8 +141,7 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
);
}
/// Gestiona cualquier error de reproducción de ExoPlayer de forma
/// controlada: emite estado de error al UI y resetea la reproducción.
/// Gestiona cualquier error de reproducción de ExoPlayer.
void _gestionarErrorReproduccion(Object error) {
String mensaje;
String codigoLog;
@@ -160,17 +157,17 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
developer.log(
'[PluriWave] Error reproducción: $codigoLog',
name: 'ServicioAudio',
level: 900, // warning
level: 900,
);
// Emitir estado de error al UI (incluye mensaje legible)
playbackState.add(playbackState.value.copyWith(
processingState: AudioProcessingState.error,
playing: false,
errorMessage: mensaje,
));
emisoraActual = null;
mediaItem.add(null);
// Resetear el player a estado idle limpio (sin lanzar otra excepción)
_player.stop().catchError((_) {});
}
@@ -178,7 +175,6 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
String _mensajeAmigable(PlayerException e) {
final code = e.code;
// ERROR_CODE_IO_* — problemas de red/fuente
if (code >= 2000 && code < 3000) {
if (code == 2001) return 'Sin conexión a internet';
if (code == 2002) return 'La URL de la radio no es válida';
@@ -187,18 +183,14 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
return 'No se puede conectar a la radio';
}
// ERROR_CODE_PARSING_* — formato de stream no soportado
if (code >= 3000 && code < 4000) {
return 'Formato de stream no compatible';
}
// ERROR_CODE_DECODING_* — error de decodificación
if (code >= 4000 && code < 5000) {
return 'Error al decodificar el stream de audio';
}
// TYPE_SOURCE — error en la fuente (HTTP cleartext, cert, etc.)
// En just_audio suele mapearse como code=-1 o message con "Cleartext"
final msg = e.message ?? '';
if (msg.contains('Cleartext') || msg.contains('cleartext')) {
return 'Esta radio usa HTTP sin cifrar (no permitido)';
@@ -227,12 +219,9 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
await _player.stop();
await _player.setUrl(mediaItem.id);
await _player.play();
// Habilitar ecualizador tras reproducir (necesita audio activo)
emisoraActual = _emisoraDesdeMediaItem(mediaItem);
await _activarEcualizador();
} on PlayerException catch (e) {
// El error ya llega por playbackEventStream.onError, pero también
// lo capturamos aquí para asegurarnos de emitir el estado de error
// y propagarlo como excepción (para que EstadoRadio muestre el mensaje).
_gestionarErrorReproduccion(e);
throw Exception(_mensajeAmigable(e));
} on Exception catch (e) {
@@ -246,6 +235,8 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
playing: false,
errorMessage: 'Error inesperado al reproducir',
));
emisoraActual = null;
this.mediaItem.add(null);
rethrow;
}
}
@@ -318,4 +309,15 @@ class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
await stop();
await _player.dispose();
}
Emisora _emisoraDesdeMediaItem(MediaItem mediaItem) {
final uuid = mediaItem.extras?['uuid'] as String? ?? mediaItem.id;
return Emisora(
uuid: uuid,
nombre: mediaItem.title,
url: mediaItem.id,
pais: (mediaItem.artist?.isNotEmpty ?? false) ? mediaItem.artist : null,
favicon: mediaItem.artUri?.toString(),
);
}
}

104
lib/servicios/servicio_ecualizador.dart Normal file
View File

@@ -0,0 +1,104 @@
import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';
import '../modelos/preset_ecualizador.dart';
class ConfiguracionEcualizador {
const ConfiguracionEcualizador({
required this.principal,
required this.porEmisora,
});
final PresetEcualizador principal;
final Map<String, PresetEcualizador> porEmisora;
}
class ServicioEcualizador {
static const _keyPresetPrincipal = 'eq_preset_principal_v1';
static const _keyPresetsPorEmisora = 'eq_presets_por_emisora_v1';
Future<ConfiguracionEcualizador> cargar() async {
final prefs = await SharedPreferences.getInstance();
final principal = _leerPresetPrincipal(prefs);
final porEmisora = _leerPresetsPorEmisora(prefs);
return ConfiguracionEcualizador(
principal: principal,
porEmisora: porEmisora,
);
}
Future<void> guardarPrincipal(PresetEcualizador preset) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString(_keyPresetPrincipal, jsonEncode(preset.toJson()));
}
Future<void> guardarPorEmisora(String uuid, PresetEcualizador preset) async {
final prefs = await SharedPreferences.getInstance();
final mapa = _leerPresetsPorEmisora(prefs);
mapa[uuid] = preset;
await _guardarPresetsPorEmisora(prefs, mapa);
}
Future<void> eliminarPorEmisora(String uuid) async {
final prefs = await SharedPreferences.getInstance();
final mapa = _leerPresetsPorEmisora(prefs);
mapa.remove(uuid);
await _guardarPresetsPorEmisora(prefs, mapa);
}
Future<void> guardarConfiguracion(ConfiguracionEcualizador config) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString(
_keyPresetPrincipal,
jsonEncode(config.principal.toJson()),
);
await _guardarPresetsPorEmisora(prefs, config.porEmisora);
}
PresetEcualizador _leerPresetPrincipal(SharedPreferences prefs) {
final raw = prefs.getString(_keyPresetPrincipal);
if (raw == null || raw.isEmpty) {
return PresetEcualizador.flat;
}
try {
return PresetEcualizador.desdeJson(
Map<String, dynamic>.from(jsonDecode(raw) as Map),
);
} catch (_) {
return PresetEcualizador.flat;
}
}
Map<String, PresetEcualizador> _leerPresetsPorEmisora(
SharedPreferences prefs,
) {
final raw = prefs.getString(_keyPresetsPorEmisora);
if (raw == null || raw.isEmpty) {
return {};
}
try {
final data = Map<String, dynamic>.from(jsonDecode(raw) as Map);
return data.map(
(uuid, preset) => MapEntry(
uuid,
PresetEcualizador.desdeJson(
Map<String, dynamic>.from(preset as Map),
),
),
);
} catch (_) {
return {};
}
}
Future<void> _guardarPresetsPorEmisora(
SharedPreferences prefs,
Map<String, PresetEcualizador> mapa,
) async {
final serializado = mapa.map(
(uuid, preset) => MapEntry(uuid, preset.toJson()),
);
await prefs.setString(_keyPresetsPorEmisora, jsonEncode(serializado));
}
}

122
lib/servicios/servicio_radio.dart
View File

@@ -1,35 +1,58 @@
import 'dart:convert';
import 'dart:math';
import 'package:http/http.dart' as http;
import '../modelos/emisora.dart';
/// Cliente para la Radio Browser API (https://api.radio-browser.info/).
///
/// Selecciona automáticamente un servidor disponible de entre los DNS
/// resueltos para `all.api.radio-browser.info` y rota en caso de error.
///
/// ### Rate limiting
/// La API no tiene límite documentado, pero por cortesía limitamos a
/// peticiones con `?limit` explícito y no hacemos polling automático.
/// Aplica reintentos acotados con rotación de host para tolerar fallos
/// transitorios al iniciar.
class ServicioRadio {
static const _dnsHost = 'all.api.radio-browser.info';
static const _timeout = Duration(seconds: 10);
static const _timeoutPorDefecto = Duration(seconds: 10);
static const _maxIntentosPorDefecto = 3;
static const _retryDelayPorDefecto = Duration(milliseconds: 250);
// Servidores conocidos como fallback si el DNS falla
// Servidores conocidos como fallback si el DNS falla.
static const _servidoresFallback = [
'de1.api.radio-browser.info',
'nl1.api.radio-browser.info',
'at1.api.radio-browser.info',
];
ServicioRadio({
http.Client? cliente,
List<String>? servidores,
int maxIntentos = _maxIntentosPorDefecto,
Duration retryDelay = _retryDelayPorDefecto,
Duration timeout = _timeoutPorDefecto,
}) : _cliente = cliente ?? http.Client(),
_servidores = (servidores == null || servidores.isEmpty)
? List<String>.from(_servidoresFallback)
: List<String>.from(servidores),
_maxIntentos = maxIntentos < 1 ? 1 : maxIntentos,
_retryDelay = retryDelay,
_timeout = timeout;
final http.Client _cliente;
final List<String> _servidores;
final int _maxIntentos;
final Duration _retryDelay;
final Duration _timeout;
String? _servidorActual;
Future<String> _servidor() async {
if (_servidorActual != null) return _servidorActual!;
// Intentar DNS lookup simplificado — usamos fallback directamente
final servidores = List<String>.from(_servidoresFallback)..shuffle(Random());
_servidorActual = servidores.first;
return _servidorActual!;
int _indiceServidorInicial() {
if (_servidorActual == null) {
return 0;
}
final index = _servidores.indexOf(_servidorActual!);
return index >= 0 ? index : 0;
}
String _servidorPorIntento(int indiceBase, int intento) {
final index = (indiceBase + intento) % _servidores.length;
return _servidores[index];
}
Uri _uri(String servidor, String path, Map<String, String> params) {
@@ -40,31 +63,45 @@ class ServicioRadio {
}
Future<List<Emisora>> _get(String path, Map<String, String> params) async {
final servidor = await _servidor();
// lastcheckok=1 filtra emisoras que la API verificó como funcionales
final uri = _uri(servidor, path, {
'lastcheckok': '1',
...params,
});
try {
final resp = await http.get(uri, headers: {
'User-Agent': 'PluriWave/0.1.0 (es.freetimelab.pluriwave)',
}).timeout(_timeout);
Exception? ultimoError;
final indiceBase = _indiceServidorInicial();
final totalIntentos = _maxIntentos;
if (resp.statusCode != 200) {
throw Exception('API error ${resp.statusCode}');
for (int intento = 0; intento < totalIntentos; intento++) {
final servidor = _servidorPorIntento(indiceBase, intento);
final uri = _uri(servidor, path, {
'lastcheckok': '1',
...params,
});
try {
final resp = await _cliente.get(uri, headers: {
'User-Agent': 'PluriWave/0.1.0 (es.freetimelab.pluriwave)',
}).timeout(_timeout);
if (resp.statusCode != 200) {
throw Exception('API error ${resp.statusCode}');
}
final lista = json.decode(resp.body) as List<dynamic>;
_servidorActual = servidor;
return lista
.cast<Map<String, dynamic>>()
.map(Emisora.fromApi)
.where((e) => e.uuid.isNotEmpty && e.url.isNotEmpty)
.toList();
} on Exception catch (e) {
ultimoError = e;
_servidorActual = null;
final ultimoIntento = intento == (totalIntentos - 1);
if (!ultimoIntento && _retryDelay > Duration.zero) {
await Future<void>.delayed(_retryDelay);
}
}
final lista = json.decode(resp.body) as List<dynamic>;
return lista
.cast<Map<String, dynamic>>()
.map(Emisora.fromApi)
.where((e) => e.uuid.isNotEmpty && e.url.isNotEmpty)
.toList();
} catch (e) {
// Rotar servidor en el siguiente intento
_servidorActual = null;
rethrow;
}
throw ultimoError ?? Exception('Error desconocido al consultar la API');
}
/// Emisoras más votadas globalmente.
@@ -133,16 +170,17 @@ class ServicioRadio {
});
}
/// Registrar un click en la API (buenas prácticas de ciudadanía API).
/// Registrar un click en la API (best effort).
Future<void> registrarClick(String uuid) async {
try {
final servidor = await _servidor();
await http.get(
final servidor =
_servidorActual ?? _servidorPorIntento(_indiceServidorInicial(), 0);
await _cliente.get(
Uri.https(servidor, '/json/url/$uuid'),
headers: {'User-Agent': 'PluriWave/0.1.0 (es.freetimelab.pluriwave)'},
).timeout(_timeout);
} catch (_) {
// No crítico — ignorar silenciosamente
// No crítico, ignorar.
}
}
}