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

feat(mvp): PluriWave Fase 1 — estructura completa de la app
Some checks failed
Flutter CI/CD — PluriWave / Test + Build (pull_request) Has been cancelled
Details

Browse Source 
- Modelo Emisora: campos completos Radio Browser API (fromApi + fromMap)
- ServicioRadio: cliente Radio Browser API (populares, tendencias, buscar por nombre/país/idioma/tag)
- ServicioAudio: just_audio + audio_service wrapper (play/pause/stop/toggle, fade, background handler)
- ServicioTimer: countdown con fade out gradual (15/30/60/90 min)
- ServicioFavoritos: actualizado a v2 con campos codec/bitrate/votes/clickcount
- EstadoRadio: ChangeNotifier global con Provider
- PantallaInicio: grid emisoras populares, chips género, shimmer loading, pull-to-refresh
- PantallaBuscar: SearchBar + filtros país/idioma, lista resultados
- PantallaFavoritos: ReorderableListView + swipe-to-delete (Dismissible)
- TarjetaEmisora: card + modo compacto ListTile, cached_network_image, shimmer fallback
- MiniReproductor: barra inferior persistente con stream de estado
- app.dart: MaterialApp + Provider + NavigationBar + timer dialog
- main.dart: punto de entrada limpio
- AndroidManifest.xml: permisos INTERNET + FOREGROUND_SERVICE + audio_service receivers
This commit is contained in:
Kira (Agent)
2026-04-04 17:15:18 +02:00
parent 25a3f3cf5a
commit e9d1f67aa4
14 changed files with 1599 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
lib/servicios/servicio_audio.dart Normal file
View File

@@ -0,0 +1,175 @@
import 'package:audio_service/audio_service.dart';
import 'package:just_audio/just_audio.dart';
import '../modelos/emisora.dart';
/// Estado de reproducción expuesto al UI.
enum EstadoReproduccion { detenido, cargando, reproduciendo, pausado, error }
/// Wrapper sobre just_audio + audio_service para reproducción de radio en streaming.
///
/// ### Uso
/// ```dart
/// final servicio = ServicioAudio();
/// await servicio.inicializar();
/// await servicio.reproducir(emisora);
/// await servicio.pausar();
/// await servicio.detener();
/// ```
///
/// ### Background audio
/// Para habilitar reproducción en background, el handler [PluriWaveAudioHandler]
/// debe registrarse en main.dart con [AudioService.init]. Si no está registrado,
/// just_audio seguirá funcionando en foreground.
class ServicioAudio {
final AudioPlayer _player = AudioPlayer();
Emisora? _emisoraActual;
EstadoReproduccion _estado = EstadoReproduccion.detenido;
EstadoReproduccion get estado => _estado;
Emisora? get emisoraActual => _emisoraActual;
/// Stream de cambios de estado para el UI.
Stream<EstadoReproduccion> get estadoStream => _player.playerStateStream.map(
(s) {
if (s.processingState == ProcessingState.loading ||
s.processingState == ProcessingState.buffering) {
return EstadoReproduccion.cargando;
}
if (s.playing) return EstadoReproduccion.reproduciendo;
if (s.processingState == ProcessingState.idle) return EstadoReproduccion.detenido;
return EstadoReproduccion.pausado;
},
);
/// Inicia la reproducción de la [emisora] indicada.
Future<void> reproducir(Emisora emisora) async {
try {
_estado = EstadoReproduccion.cargando;
// Si es la misma emisora, reanudar sin recargar
if (_emisoraActual?.uuid == emisora.uuid && _player.audioSource != null) {
await _player.play();
_estado = EstadoReproduccion.reproduciendo;
return;
}
_emisoraActual = emisora;
await _player.stop();
await _player.setUrl(emisora.url);
await _player.play();
_estado = EstadoReproduccion.reproduciendo;
} on PlayerException catch (_) {
_estado = EstadoReproduccion.error;
rethrow;
} catch (e) {
_estado = EstadoReproduccion.error;
rethrow;
}
}
/// Pausa la reproducción actual.
Future<void> pausar() async {
await _player.pause();
_estado = EstadoReproduccion.pausado;
}
/// Reanuda si estaba pausado.
Future<void> reanudar() async {
if (_player.audioSource != null) {
await _player.play();
_estado = EstadoReproduccion.reproduciendo;
}
}
/// Alterna entre pausa y reproducción.
Future<void> togglePlay() async {
if (_player.playing) {
await pausar();
} else {
await reanudar();
}
}
/// Detiene la reproducción y libera la fuente.
Future<void> detener() async {
await _player.stop();
_emisoraActual = null;
_estado = EstadoReproduccion.detenido;
}
/// Ajusta el volumen (0.0 - 1.0).
Future<void> setVolumen(double volumen) async {
await _player.setVolume(volumen.clamp(0.0, 1.0));
}
double get volumen => _player.volume;
bool get estaSonando => _player.playing;
/// Libera recursos. Llamar al destruir la pantalla raíz.
Future<void> dispose() async {
await _player.dispose();
}
}
/// Handler de audio_service para reproducción en background con notificación.
///
/// Registrar en main.dart:
/// ```dart
/// final handler = await AudioService.init(
/// builder: () => PluriWaveAudioHandler(),
/// config: const AudioServiceConfig(
/// androidNotificationChannelId: 'es.freetimelab.pluriwave.audio',
/// androidNotificationChannelName: 'PluriWave Radio',
/// androidNotificationOngoing: true,
/// androidStopForegroundOnPause: true,
/// ),
/// );
/// ```
class PluriWaveAudioHandler extends BaseAudioHandler with SeekHandler {
final AudioPlayer _player = AudioPlayer();
PluriWaveAudioHandler() {
_player.playerStateStream.listen((state) {
final playing = state.playing;
final proc = state.processingState;
playbackState.add(playbackState.value.copyWith(
controls: [
if (playing) MediaControl.pause else MediaControl.play,
MediaControl.stop,
],
systemActions: const {MediaAction.seek},
androidCompactActionIndices: const [0],
processingState: {
ProcessingState.idle: AudioProcessingState.idle,
ProcessingState.loading: AudioProcessingState.loading,
ProcessingState.buffering: AudioProcessingState.buffering,
ProcessingState.ready: AudioProcessingState.ready,
ProcessingState.completed: AudioProcessingState.completed,
}[proc]!,
playing: playing,
));
});
}
@override
Future<void> playMediaItem(MediaItem item) async {
mediaItem.add(item);
await _player.setUrl(item.id);
await _player.play();
}
@override
Future<void> play() => _player.play();
@override
Future<void> pause() => _player.pause();
@override
Future<void> stop() async {
await _player.stop();
await super.stop();
}
@override
Future<void> seek(Duration position) => _player.seek(position);
}

272
lib/servicios/servicio_favoritos.dart
View File

@@ -1,251 +1,125 @@
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';
import '../modelos/emisora.dart';
/// Servicio de persistencia de emisoras favoritas con SQLite (sqflite).
/// Servicio de persistencia de emisoras favoritas con SQLite.
///
/// ### Inicialización lazy
/// La base de datos se abre en el primer acceso; no es necesario llamar
/// a ningún método `init()` explícito.
///
/// ### Migration-ready
/// El esquema está versionado (`_dbVersion`). Para añadir columnas en una
/// versión futura, implementa el caso correspondiente en `_onUpgrade`.
/// La versión actual es **1**.
///
/// ### Eliminación lógica
/// No se borran filas físicas sin confirmación explícita. El método
/// [eliminar] hace `DELETE` por `uuid` (la tabla de favoritos es propiedad
/// del usuario y el borrado es una acción explícita y reversible vía
/// [agregar]). Si en el futuro se requiere eliminación lógica, añade la
/// columna `eliminado` en la migración a versión 2.
///
/// ### Uso básico
/// ```dart
/// final servicio = ServicioFavoritos();
///
/// await servicio.agregar(emisora);
/// final lista = await servicio.obtenerTodos();
/// final esFav = await servicio.esFavorito('some-uuid');
/// await servicio.reordenar('some-uuid', 3);
/// await servicio.eliminar('some-uuid');
/// ```
/// - Inicialización lazy: la BD se abre en el primer acceso.
/// - Migration-ready: versión 2 añade campos de la Radio Browser API.
class ServicioFavoritos {
// ─── Constantes de esquema ────────────────────────────────────────────────
static const String _dbNombre = 'pluriwave.db';
static const int _dbVersion = 1;
static const String _tabla = 'favoritos';
// Columnas
static const String _colId = 'id';
static const String _colUuid = 'uuid';
static const String _colNombre = 'nombre';
static const String _colUrl = 'url';
static const String _colFavicon = 'favicon';
static const String _colPais = 'pais';
static const String _colIdioma = 'idioma';
static const String _colTags = 'tags';
static const String _colOrden = 'orden';
// ─── Estado interno ───────────────────────────────────────────────────────
/// Instancia única del servicio (singleton ligero).
static final ServicioFavoritos _instancia = ServicioFavoritos._interno();
factory ServicioFavoritos() => _instancia;
ServicioFavoritos._interno();
static const _dbName = 'pluriwave.db';
static const _dbVersion = 2;
Database? _db;
// ─── Acceso a la BD (lazy) ────────────────────────────────────────────────
/// Devuelve la instancia abierta de la BD.
/// La abre y crea las tablas en el primer acceso.
Future<Database> get _database async {
_db ??= await _abrirBd();
_db ??= await _initDb();
return _db!;
}
Future<Database> _abrirBd() async {
final ruta = join(await getDatabasesPath(), _dbNombre);
Future<Database> _initDb() async {
final dbPath = await getDatabasesPath();
final path = join(dbPath, _dbName);
return openDatabase(
ruta,
path,
version: _dbVersion,
onCreate: _onCreate,
onUpgrade: _onUpgrade,
);
}
// ─── Callbacks de ciclo de vida de la BD ─────────────────────────────────
/// Crea el esquema inicial (versión 1).
Future<void> _onCreate(Database db, int version) async {
await db.execute('''
CREATE TABLE IF NOT EXISTS $_tabla (
$_colId INTEGER PRIMARY KEY AUTOINCREMENT,
$_colUuid TEXT NOT NULL UNIQUE,
$_colNombre TEXT NOT NULL,
$_colUrl TEXT NOT NULL,
$_colFavicon TEXT,
$_colPais TEXT,
$_colIdioma TEXT,
$_colTags TEXT,
$_colOrden INTEGER NOT NULL DEFAULT 0
CREATE TABLE favoritos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
uuid TEXT NOT NULL UNIQUE,
nombre TEXT NOT NULL,
url TEXT NOT NULL,
favicon TEXT,
pais TEXT,
codigo_pais TEXT,
idioma TEXT,
tags TEXT,
codec TEXT,
bitrate INTEGER,
votes INTEGER NOT NULL DEFAULT 0,
clickcount INTEGER NOT NULL DEFAULT 0,
orden INTEGER NOT NULL DEFAULT 0
)
''');
// Índice para búsquedas frecuentes por uuid
await db.execute(
'CREATE UNIQUE INDEX IF NOT EXISTS idx_favoritos_uuid ON $_tabla ($_colUuid)',
);
// Índice para ordenación
await db.execute(
'CREATE INDEX IF NOT EXISTS idx_favoritos_orden ON $_tabla ($_colOrden)',
);
}
/// Migraciones futuras.
///
/// Añade un `case` por cada nueva versión. No uses `DROP COLUMN` —
/// marca la columna como obsoleta y elimínala en el siguiente sprint.
Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
for (var v = oldVersion + 1; v <= newVersion; v++) {
switch (v) {
// Ejemplo para versión 2:
// case 2:
// await db.execute(
// 'ALTER TABLE $_tabla ADD COLUMN nueva_col TEXT',
// );
default:
break;
}
if (oldVersion < 2) {
// v1→v2: añadir columnas de la Radio Browser API
await db.execute('ALTER TABLE favoritos ADD COLUMN codigo_pais TEXT');
await db.execute('ALTER TABLE favoritos ADD COLUMN codec TEXT');
await db.execute('ALTER TABLE favoritos ADD COLUMN bitrate INTEGER');
await db.execute('ALTER TABLE favoritos ADD COLUMN votes INTEGER NOT NULL DEFAULT 0');
await db.execute('ALTER TABLE favoritos ADD COLUMN clickcount INTEGER NOT NULL DEFAULT 0');
}
}
// ─── API pública ──────────────────────────────────────────────────────────
/// Devuelve todas las emisoras favoritas ordenadas por [_colOrden] ASC.
///
/// Nunca devuelve null; devuelve lista vacía si no hay favoritos.
/// Devuelve todas las emisoras favoritas ordenadas por [orden].
Future<List<Emisora>> obtenerTodos() async {
final db = await _database;
final filas = await db.query(
_tabla,
orderBy: '$_colOrden ASC, $_colId ASC',
);
return filas.map(Emisora.fromMap).toList();
final rows = await db.query('favoritos', orderBy: 'orden ASC');
return rows.map(Emisora.fromMap).toList();
}
/// Agrega [emisora] a la lista de favoritos.
///
/// Si ya existe una emisora con el mismo [Emisora.uuid], actualiza todos
/// sus campos (upsert). El campo [Emisora.orden] se asigna al final de la
/// lista cuando su valor es 0 y la emisora es nueva.
///
/// Devuelve el [id] de la fila insertada o actualizada.
Future<int> agregar(Emisora emisora) async {
/// Añade una emisora a favoritos. Si ya existe (mismo uuid), la actualiza.
Future<void> agregar(Emisora emisora) async {
final db = await _database;
// Calcular orden automático si viene en 0 y la emisora es nueva
Emisora emisoraFinal = emisora;
if (emisora.orden == 0) {
final existe = await esFavorito(emisora.uuid);
if (!existe) {
final maxOrden = await _maxOrden(db);
emisoraFinal = emisora.copyWith(orden: maxOrden + 1);
}
}
return db.insert(
_tabla,
emisoraFinal.toMap(),
// Calcular el siguiente orden
final maxOrden = Sqflite.firstIntValue(
await db.rawQuery('SELECT MAX(orden) FROM favoritos'),
) ??
-1;
final nuevaEmisora = emisora.copyWith(orden: maxOrden + 1);
await db.insert(
'favoritos',
nuevaEmisora.toMap(),
conflictAlgorithm: ConflictAlgorithm.replace,
);
}
/// Elimina la emisora con [uuid] de la lista de favoritos.
///
/// Si la emisora no existe, no hace nada (idempotente).
/// Devuelve el número de filas eliminadas (0 ó 1).
Future<int> eliminar(String uuid) async {
/// Elimina una emisora de favoritos por [uuid].
Future<void> eliminar(String uuid) async {
final db = await _database;
return db.delete(
_tabla,
where: '$_colUuid = ?',
whereArgs: [uuid],
);
await db.delete('favoritos', where: 'uuid = ?', whereArgs: [uuid]);
}
/// Devuelve `true` si la emisora con [uuid] está en la lista de favoritos.
/// Devuelve true si la emisora con [uuid] está en favoritos.
Future<bool> esFavorito(String uuid) async {
final db = await _database;
final resultado = await db.query(
_tabla,
columns: [_colId],
where: '$_colUuid = ?',
whereArgs: [uuid],
limit: 1,
final count = Sqflite.firstIntValue(
await db.rawQuery(
'SELECT COUNT(*) FROM favoritos WHERE uuid = ?',
[uuid],
),
);
return resultado.isNotEmpty;
return (count ?? 0) > 0;
}
/// Actualiza el [orden] de la emisora con [uuid] al valor [nuevoOrden].
///
/// Si la emisora no existe, no hace nada (idempotente).
/// Devuelve el número de filas actualizadas (0 ó 1).
///
/// Nota: este método actualiza solo la columna `orden` de la emisora
/// indicada. Si necesitas reordenar toda la lista de una vez (drag & drop),
/// construye una lista ordenada y llama a [reordenarLista].
Future<int> reordenar(String uuid, int nuevoOrden) async {
/// Alterna el estado de favorito de una emisora.
Future<bool> toggleFavorito(Emisora emisora) async {
if (await esFavorito(emisora.uuid)) {
await eliminar(emisora.uuid);
return false;
} else {
await agregar(emisora);
return true;
}
}
/// Actualiza el orden de un favorito.
Future<void> reordenar(String uuid, int nuevoOrden) async {
final db = await _database;
return db.update(
_tabla,
{_colOrden: nuevoOrden},
where: '$_colUuid = ?',
await db.update(
'favoritos',
{'orden': nuevoOrden},
where: 'uuid = ?',
whereArgs: [uuid],
);
}
/// Reordena la lista completa de favoritos en una sola transacción.
///
/// Recibe una lista ordenada de UUIDs y asigna el orden 0, 1, 2... en
/// el mismo orden. Ideal para operaciones de drag & drop.
Future<void> reordenarLista(List<String> uuidsOrdenados) async {
final db = await _database;
await db.transaction((txn) async {
for (var i = 0; i < uuidsOrdenados.length; i++) {
await txn.update(
_tabla,
{_colOrden: i},
where: '$_colUuid = ?',
whereArgs: [uuidsOrdenados[i]],
);
}
});
}
/// Devuelve el número total de emisoras favoritas.
Future<int> contarFavoritos() async {
final db = await _database;
final resultado = await db.rawQuery(
'SELECT COUNT(*) AS total FROM $_tabla',
);
return resultado.first['total'] as int? ?? 0;
}
// ─── Helpers privados ─────────────────────────────────────────────────────
/// Devuelve el valor máximo actual de [_colOrden], o 0 si la tabla está vacía.
Future<int> _maxOrden(Database db) async {
final resultado = await db.rawQuery(
'SELECT MAX($_colOrden) AS max_orden FROM $_tabla',
);
return resultado.first['max_orden'] as int? ?? 0;
}
}

144
lib/servicios/servicio_radio.dart Normal file
View File

@@ -0,0 +1,144 @@
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.
class ServicioRadio {
static const _dnsHost = 'all.api.radio-browser.info';
static const _timeout = Duration(seconds: 10);
// 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',
];
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!;
}
Uri _uri(String servidor, String path, Map<String, String> params) {
return Uri.https(servidor, path, {
'hidebroken': 'true',
...params,
});
}
Future<List<Emisora>> _get(String path, Map<String, String> params) async {
final servidor = await _servidor();
final uri = _uri(servidor, path, params);
try {
final resp = await http.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>;
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;
}
}
/// Emisoras más votadas globalmente.
Future<List<Emisora>> obtenerPopulares({int limit = 30}) async {
return _get('/json/stations/topvote/$limit', {});
}
/// Emisoras más escuchadas (por clicks) globalmente.
Future<List<Emisora>> obtenerTendencias({int limit = 20}) async {
return _get('/json/stations/topclick/$limit', {});
}
/// Buscar por nombre de emisora.
Future<List<Emisora>> buscarPorNombre(String query, {int limit = 30}) async {
return _get('/json/stations/search', {
'name': query,
'limit': limit.toString(),
'order': 'votes',
'reverse': 'true',
});
}
/// Buscar por código de país (ISO 3166-1 alpha-2, e.g. 'ES', 'US').
Future<List<Emisora>> buscarPorPais(String codigoPais, {int limit = 50}) async {
return _get('/json/stations/bycountrycodeexact/$codigoPais', {
'limit': limit.toString(),
'order': 'votes',
'reverse': 'true',
});
}
/// Buscar por idioma (e.g. 'spanish', 'english').
Future<List<Emisora>> buscarPorIdioma(String idioma, {int limit = 30}) async {
return _get('/json/stations/bylanguageexact/$idioma', {
'limit': limit.toString(),
'order': 'votes',
'reverse': 'true',
});
}
/// Buscar por tag/género (e.g. 'rock', 'jazz', 'pop').
Future<List<Emisora>> buscarPorTag(String tag, {int limit = 30}) async {
return _get('/json/stations/bytagexact/$tag', {
'limit': limit.toString(),
'order': 'votes',
'reverse': 'true',
});
}
/// Búsqueda combinada: permite combinar nombre, país, idioma y tag.
Future<List<Emisora>> buscar({
String? nombre,
String? pais,
String? idioma,
String? tag,
int limit = 30,
}) async {
return _get('/json/stations/search', {
if (nombre != null && nombre.isNotEmpty) 'name': nombre,
if (pais != null && pais.isNotEmpty) 'countrycode': pais,
if (idioma != null && idioma.isNotEmpty) 'language': idioma,
if (tag != null && tag.isNotEmpty) 'tag': tag,
'limit': limit.toString(),
'order': 'votes',
'reverse': 'true',
});
}
/// Registrar un click en la API (buenas prácticas de ciudadanía API).
Future<void> registrarClick(String uuid) async {
try {
final servidor = await _servidor();
await http.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
}
}
}

97
lib/servicios/servicio_timer.dart Normal file
View File

@@ -0,0 +1,97 @@
import 'dart:async';
import 'servicio_audio.dart';
/// Opciones predefinidas de timer en minutos.
const opcionesTimer = [15, 30, 60, 90];
/// Servicio de auto-apagado de la radio.
///
/// Cuenta atrás desde la duración elegida. Cuando llega a 0:
/// 1. Hace un fade out de [_fadeDuracion] segundos.
/// 2. Llama a [ServicioAudio.detener].
///
/// El UI puede escuchar [tiempoRestanteStream] para mostrar el contador.
class ServicioTimer {
final ServicioAudio _audio;
Timer? _timer;
Timer? _fadeTicker;
DateTime? _finAt;
Duration _tiempoRestante = Duration.zero;
bool _activo = false;
static const _fadeDuracion = Duration(seconds: 30);
static const _fadeStep = Duration(seconds: 1);
final _controller = StreamController<Duration>.broadcast();
ServicioTimer(this._audio);
/// Stream que emite el tiempo restante cada segundo.
Stream<Duration> get tiempoRestanteStream => _controller.stream;
Duration get tiempoRestante => _tiempoRestante;
bool get activo => _activo;
/// Inicia el timer para [minutos] minutos.
void iniciar(int minutos) {
cancelar();
final duracion = Duration(minutes: minutos);
_finAt = DateTime.now().add(duracion);
_tiempoRestante = duracion;
_activo = true;
_controller.add(_tiempoRestante);
_timer = Timer.periodic(const Duration(seconds: 1), (_) {
final ahora = DateTime.now();
final restante = _finAt!.difference(ahora);
if (restante <= Duration.zero) {
_tiempoRestante = Duration.zero;
_controller.add(_tiempoRestante);
_iniciarFadeOut();
cancelar(detenerAudio: false);
} else {
_tiempoRestante = restante;
_controller.add(_tiempoRestante);
}
});
}
void _iniciarFadeOut() {
final pasos = _fadeDuracion.inSeconds;
final volumenInicial = _audio.volumen;
int paso = 0;
_fadeTicker = Timer.periodic(_fadeStep, (_) async {
paso++;
final nuevoVolumen = volumenInicial * (1 - paso / pasos);
await _audio.setVolumen(nuevoVolumen.clamp(0.0, 1.0));
if (paso >= pasos) {
_fadeTicker?.cancel();
await _audio.detener();
await _audio.setVolumen(volumenInicial); // restaurar volumen para próxima vez
}
});
}
/// Cancela el timer activo sin detener el audio.
void cancelar({bool detenerAudio = false}) {
_timer?.cancel();
_timer = null;
_fadeTicker?.cancel();
_fadeTicker = null;
_activo = false;
_tiempoRestante = Duration.zero;
_controller.add(_tiempoRestante);
if (detenerAudio) {
_audio.detener();
}
}
void dispose() {
cancelar();
_controller.close();
}
}