FreeTLab
3449e2cb79
Tres fallos reportados en uso real, con sus causas raiz verificadas en codigo.
1. Ecualizador: el estado no tenia dueño unico
El handler arrancaba con `_ecualizadorActivo = true` a fuego. El valor
persistido solo llegaba por EstadoEcualizador.cargarPersistido(), alcanzable
unicamente desde el arbol de widgets, que un arranque headless de Android Auto
nunca construye. Resultado: el coche reproducia con el EQ forzado a ON mientras
disco e interfaz decian OFF.
Ahora registrarHandler siembra el flag desde disco en todos los motores y
setEcualizadorActivo persiste por su cuenta, asi que un toggle desde el coche o
la notificacion sobrevive sin EstadoEcualizador. _resincronizarConHandler pasa
a ser adopcion pura de interfaz.
Ademas mapearGananciaNativa enviaba 0 dB al punto MEDIO del rango nativo. Con
un getBandLevelRange() asimetrico, un preset plano metia varios dB de boost
real: la causa del "suena muy alto con el boton apagado". Reescrito para
escalar cada lado contra su propio extremo, de modo que 0 dB es siempre 0.
El dispatch de customAction no tenia ningun test. Se extrae decidirToggleEq y
se cubre contra el handler real. El efecto nativo se re-asierta al reactivarse
el reproductor, porque AudioEffect.setEnabled de just_audio es un no-op
mientras la plataforma esta desacoplada.
2. Musica Local no aparecia en el arbol de Android Auto
hayCarpetaConfigurada() consultaba MethodChannel('pluriwave/file_actions'),
registrado solo en MainActivity.configureFlutterEngine. Sin Activity no hay
handler, invokeMethod lanza MissingPluginException y el catch la confundia con
"permiso revocado", omitiendo el nodo. No dependia del entitlement.
La logica SAF sale a packages/pluriwave_file_actions, un paquete plugin local.
El motor headless que crea audio_service ejecuta GeneratedPluginRegistrant en
su constructor, asi que el canal queda registrado en ambos motores. Repuntar el
manifest a una subclase de AudioService no era viable: AudioServicePlugin
enlaza por ComponentName explicito y la app perderia el audio.
EstadoCarpetaLocal de tres valores separa "sin carpeta" de "canal no
disponible"; la raiz decide por la URI persistida y el subarbol muestra un item
explicativo en vez de una carpeta vacia. La invalidacion del arbol cacheado se
dispara al reanudar con el coche ya suscrito; el guardia anterior miraba
View.maybeOf, que bajo runApp siempre existe, por lo que se gastaba en el
arranque headless y no volvia a dispararse.
3. El paywall bloqueaba las compras
restorePurchases() de in_app_purchase_android emite siempre, y con lista vacia
si no hay nada que restaurar. El `if (compras.isEmpty) return;` se la tragaba,
noEncontrada nunca se emitia y la rama que limpia _compraEnCurso estaba muerta
en produccion. Como comprar y restaurar comparten ese flag, un usuario sin
compras que pulsaba restaurar se quedaba sin poder comprar.
Suite completa: 1366 pasan, 2 omitidos. 17 tests nuevos, todos nacidos rojos y
verificados por mutacion. flutter analyze mantiene los 5 avisos preexistentes.
1981 lines
71 KiB
Dart
1981 lines
71 KiB
Dart
import 'dart:async';
|
||
|
||
import 'package:flutter_test/flutter_test.dart';
|
||
import 'package:pluriwave/estado/estado_ecualizador.dart';
|
||
import 'package:pluriwave/estado/estado_radio.dart';
|
||
import 'package:pluriwave/modelos/dispositivo_audio.dart';
|
||
import 'package:pluriwave/modelos/preset_ecualizador.dart';
|
||
|
||
import '../helpers/fakes.dart';
|
||
|
||
void main() {
|
||
group('EstadoEcualizador (S4-R1)', () {
|
||
test(
|
||
'cambiarPreset notifies EstadoEcualizador listeners (S4-R1-A)',
|
||
() async {
|
||
final audio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: audio,
|
||
servicio: FakeServicioEcualizador(),
|
||
);
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
|
||
await eq.cambiarPreset(PresetEcualizador.jazz);
|
||
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
expect(eq.presetActual, PresetEcualizador.jazz);
|
||
expect(audio.presetsAplicados, contains(PresetEcualizador.jazz));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test('EQ preset change does NOT rebuild EstadoRadio listeners '
|
||
'(S4-R1-A, S4-R5)', () async {
|
||
final estado = EstadoRadio(
|
||
esPremium: () => true,
|
||
audio: FakeServicioAudio(),
|
||
favoritos: FakeServicioFavoritos(),
|
||
radio: FakeServicioRadio(),
|
||
servicioEcualizador: FakeServicioEcualizador(),
|
||
iniciarAutomaticamente: false,
|
||
);
|
||
var avisosRadio = 0;
|
||
var avisosEq = 0;
|
||
estado.addListener(() => avisosRadio++);
|
||
estado.ecualizador.addListener(() => avisosEq++);
|
||
|
||
await estado.ecualizador.cambiarPreset(PresetEcualizador.jazz);
|
||
|
||
expect(avisosEq, greaterThanOrEqualTo(1));
|
||
expect(avisosRadio, 0);
|
||
estado.dispose();
|
||
});
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase 5: 4-level resolution hierarchy
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — 4-level resolution (Phase 5)', () {
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
const stationUuid = 'station-uuid-123';
|
||
|
||
EstadoEcualizador buildEq({
|
||
FakeServicioEcualizador? servicio,
|
||
FakeServicioDispositivoAudio? dispositivoAudio,
|
||
bool multiDeviceEnabled = true,
|
||
String? emisoraActualUuid,
|
||
}) {
|
||
return EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio:
|
||
servicio ??
|
||
FakeServicioEcualizador(eqMultiDeviceEnabled: multiDeviceEnabled),
|
||
dispositivoAudio: dispositivoAudio ?? FakeServicioDispositivoAudio(),
|
||
emisoraActualUuid: () => emisoraActualUuid,
|
||
);
|
||
}
|
||
|
||
// 5.1a — matrix entry wins over all others
|
||
test(
|
||
'5.1a matrix entry (stationUuid:deviceId) wins top priority',
|
||
() async {
|
||
final matrizPreset = PresetEcualizador.bassBoost;
|
||
final stationPreset = PresetEcualizador.rock;
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
final globalPreset = PresetEcualizador.pop;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: globalPreset,
|
||
porEmisora: {stationUuid: stationPreset},
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
presetsMatriz: {'$stationUuid:${btDevice.id}': matrizPreset},
|
||
),
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(matrizPreset),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
// 5.1b — falls back to station when no matrix entry
|
||
test('5.1b falls back to station preset when no matrix entry', () async {
|
||
final stationPreset = PresetEcualizador.rock;
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
final globalPreset = PresetEcualizador.pop;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: globalPreset,
|
||
porEmisora: {stationUuid: stationPreset},
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
presetsMatriz: {},
|
||
),
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(stationPreset),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
// 5.1c — falls back to device when no station preset
|
||
test(
|
||
'5.1c falls back to device preset when no station or matrix entry',
|
||
() async {
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
final globalPreset = PresetEcualizador.pop;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: globalPreset,
|
||
porEmisora: {},
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
presetsMatriz: {},
|
||
),
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(devicePreset),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
// 5.1d — falls back to global when nothing else matches
|
||
test(
|
||
'5.1d falls back to global preset when no matrix, station, or device',
|
||
() async {
|
||
final globalPreset = PresetEcualizador.pop;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: globalPreset,
|
||
porEmisora: {},
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {},
|
||
presetsMatriz: {},
|
||
),
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(globalPreset),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
// 5.1e — toggle off collapses to 2-level
|
||
test(
|
||
'5.1e toggle off: presetEfectivo uses only station → global',
|
||
() async {
|
||
final stationPreset = PresetEcualizador.rock;
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
final matrizPreset = PresetEcualizador.bassBoost;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {stationUuid: stationPreset},
|
||
eqMultiDeviceEnabled: false,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
presetsMatriz: {'$stationUuid:${btDevice.id}': matrizPreset},
|
||
),
|
||
multiDeviceEnabled: false,
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// When toggle is off, device and matrix entries must be ignored
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(stationPreset),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
// 5.1f — toggle off with no station falls back to global
|
||
test('5.1f toggle off with no station: falls back to global', () async {
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
|
||
final eq = buildEq(
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {},
|
||
eqMultiDeviceEnabled: false,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
presetsMatriz: {},
|
||
),
|
||
multiDeviceEnabled: false,
|
||
emisoraActualUuid: stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(PresetEcualizador.flat),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase 5.3: Device stream subscription triggers re-resolution
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — device stream subscription (Phase 5.3–5.4)', () {
|
||
const stationUuid = 'station-uuid-stream';
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
test('5.3a device change emits notifyListeners', () async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.jazz},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
// Wait for async processing
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'5.3b device change re-applies resolved preset to audio engine',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final btPreset = PresetEcualizador.jazz;
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: btPreset},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
final initialCount = fakeAudio.presetsAplicados.length;
|
||
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(fakeAudio.presetsAplicados.length, greaterThan(initialCount));
|
||
expect(fakeAudio.presetsAplicados.last, equals(btPreset));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'5.3c toggle off: device stream events do NOT trigger any action',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: false),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
final initialCount = fakeAudio.presetsAplicados.length;
|
||
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(avisos, equals(0));
|
||
expect(fakeAudio.presetsAplicados.length, equals(initialCount));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase D: device disconnect / cold-start revert
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('device disconnect / cold-start revert (Phase D)', () {
|
||
const stationUuid = 'station-uuid-disconnect';
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
const builtinSpeaker = DispositivoAudio(
|
||
id: 'builtin_speaker',
|
||
tipo: TipoDispositivo.altavozInterno,
|
||
nombre: 'Speaker',
|
||
);
|
||
|
||
test(
|
||
'D.1 disconnect resolves and applies the base (builtin_speaker) preset',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.bassBoost},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Connect BT first — active device now resolves to its own preset.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
expect(eq.presetActual, equals(PresetEcualizador.bassBoost));
|
||
|
||
// Disconnect: platform emits the fallback device (builtin_speaker).
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// builtin_speaker has no station/matrix/device entry -> global (flat).
|
||
expect(eq.presetActual, equals(PresetEcualizador.flat));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.flat));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'D.2 disconnect-created builtin_speaker entry must not mask a later '
|
||
'global preset change (bootstrap-skip proof, not a value tautology)',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.jazz},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// BT active with its own preset (jazz).
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Disconnect to builtin_speaker (never seen before): first-seen
|
||
// bootstrap must NOT persist an entry for it, so a subsequent global
|
||
// change is never masked by a stale L3 copy.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Change the global preset after the disconnect.
|
||
await eq.cambiarPresetPrincipal(PresetEcualizador.pop);
|
||
|
||
// Re-trigger resolution for builtin_speaker (e.g. another
|
||
// disconnect/device-changed event). If bootstrap wrote an entry on
|
||
// the first emit above, this second emit would resolve the STALE
|
||
// value (rock) instead of the fresh global (pop) — proving the
|
||
// masking bug. This assertion only passes when no L3 entry for
|
||
// builtin_speaker was ever created.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.presetsDispositivo.containsKey('builtin_speaker'), isFalse);
|
||
expect(eq.presetActual, equals(PresetEcualizador.pop));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.pop));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'D.3 cold start with no device connected applies base resolution, '
|
||
'never a stale persisted device preset',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
// No emitirDispositivo call: obtenerDispositivoActual() defaults to
|
||
// builtin_speaker, simulating a cold start with nothing connected.
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
// Stale entry for a BT device that is NOT currently connected.
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.jazz},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
|
||
await eq.cargarPersistido();
|
||
|
||
expect(eq.dispositivoActualId, equals('builtin_speaker'));
|
||
expect(eq.presetActual, equals(PresetEcualizador.rock));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.rock));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'D.4 connect -> disconnect -> reconnect cycle lands on the correct '
|
||
'preset at each step and never corrupts the device entry',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsMatriz: {'$stationUuid:${btDevice.id}': PresetEcualizador.bassBoost},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Connect: matrix override wins. BT is never-seen, so its own
|
||
// first-seen bootstrap fires here too (unrelated to this change --
|
||
// only builtin_speaker is excluded from bootstrap).
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
expect(eq.presetActual, equals(PresetEcualizador.bassBoost));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.bassBoost));
|
||
final btPresetTrasConectar = eq.presetsDispositivo[btDevice.id];
|
||
expect(btPresetTrasConectar, isNotNull);
|
||
|
||
// Disconnect: builtin_speaker has no matrix/station/device entry -> global.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
expect(eq.presetActual, equals(PresetEcualizador.flat));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.flat));
|
||
|
||
// Reconnect: matrix override wins again.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
expect(eq.presetActual, equals(PresetEcualizador.bassBoost));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.bassBoost));
|
||
|
||
// The disconnect step must never have touched the BT device's own
|
||
// entry (locks existing test 5.5b: reconnect must not overwrite it).
|
||
expect(
|
||
eq.presetsDispositivo[btDevice.id],
|
||
equals(btPresetTrasConectar),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'D.5 station override still wins over global on disconnect-to-base',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {stationUuid: PresetEcualizador.rock},
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.jazz},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// BT active. Note the station override (Level 2) already applies to
|
||
// every device on this station, including BT -- resolution is rock
|
||
// regardless of BT's own Level-3 entry, which is expected hierarchy
|
||
// behavior (Level 2 beats Level 3) and not itself under test here.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Disconnect to builtin_speaker: station override (Level 2) must
|
||
// still beat global (Level 4) -- deterministic revert, not a flatten
|
||
// to global.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.presetActual, equals(PresetEcualizador.rock));
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.rock));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase 5.5–5.6: First-seen device copies current preset
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group(
|
||
'EstadoEcualizador — first-seen device initialization (Phase 5.5–5.6)',
|
||
() {
|
||
const stationUuid = 'station-uuid-first-seen';
|
||
const newDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:NEW:DE:VI:CE:00:00',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'New BT Device',
|
||
);
|
||
|
||
test('5.5a new device gets copy of current resolved preset', () async {
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {},
|
||
);
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(newDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// The device should now have a preset saved equal to the resolved preset
|
||
// at the time of first connection (rock — global fallback)
|
||
expect(
|
||
eq.presetsDispositivo[newDevice.id],
|
||
equals(PresetEcualizador.rock),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'5.5b subsequent reconnection does NOT overwrite user-saved preset',
|
||
() async {
|
||
final userSavedPreset = PresetEcualizador.jazz;
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {newDevice.id: userSavedPreset},
|
||
);
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(newDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Preset must remain the user-saved one, not overwritten with rock
|
||
expect(eq.presetsDispositivo[newDevice.id], equals(userSavedPreset));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
},
|
||
);
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase 5.7–5.8: Toggle-off path uses only 2-level resolution
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — toggle-off path (Phase 5.7–5.8)', () {
|
||
const stationUuid = 'station-toggle-off';
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
test(
|
||
'5.7a cargarPersistido with toggle off applies 2-level resolution',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final stationPreset = PresetEcualizador.rock;
|
||
final devicePreset = PresetEcualizador.jazz;
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {stationUuid: stationPreset},
|
||
eqMultiDeviceEnabled: false,
|
||
presetsDispositivo: {btDevice.id: devicePreset},
|
||
),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// With toggle off, no device subscription, direct 2-level on presetEfectivo
|
||
expect(
|
||
eq.presetEfectivo(stationUuid: stationUuid, deviceId: btDevice.id),
|
||
equals(stationPreset),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test('5.8a eqMultiDeviceEnabled getter reflects loaded value', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.eqMultiDeviceEnabled, isTrue);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('5.8b toggle defaults to false and eq behaves as before', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: false),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.eqMultiDeviceEnabled, isFalse);
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'5.8c cambiarMultiDeviceEnabled persists toggle and notifies',
|
||
() async {
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: false,
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.cambiarMultiDeviceEnabled(true);
|
||
|
||
expect(eq.eqMultiDeviceEnabled, isTrue);
|
||
expect(fakeServicio.config.eqMultiDeviceEnabled, isTrue);
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Phase 5.9: REFACTOR — aplicarPresetActivo path applies device-resolved preset
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group(
|
||
'EstadoEcualizador — aplicarPresetActivo uses device resolution (5.9)',
|
||
() {
|
||
const stationUuid = 'station-refactor';
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
test(
|
||
'5.9a aplicarPresetEmisoraActual uses device-resolved preset when toggle on',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo =
|
||
FakeServicioDispositivoAudio()..emitirDispositivo(btDevice);
|
||
final matrizPreset = PresetEcualizador.bassBoost;
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsMatriz: {'$stationUuid:${btDevice.id}': matrizPreset},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Clear application history from init; emit device to trigger re-apply
|
||
fakeAudio.presetsAplicados.clear();
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(fakeAudio.presetsAplicados.last, equals(matrizPreset));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
},
|
||
);
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// eq-device-autoswitch-ux Phase 2: startup seeding + rename API
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — startup device seeding (eq-device-autoswitch-ux Phase 2)', () {
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
// 2.1 RED — after cargarPersistido with multiDevice ON, dispositivoActualId is seeded
|
||
test('2.1 cargarPersistido seeds dispositivoActualId from obtenerDispositivoActual', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio()
|
||
..emitirDispositivo(btDevice); // sets _dispositivoActual
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(eq.dispositivoActualId, equals('bt_a2dp:AA:BB'));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.2 RED — first-seen device is bootstrapped from resolved preset at startup
|
||
test('2.2 first-seen device is bootstrapped at startup with resolved preset', () async {
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {},
|
||
);
|
||
final fakeDispositivo = FakeServicioDispositivoAudio()
|
||
..emitirDispositivo(btDevice);
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.presetsDispositivo[btDevice.id],
|
||
equals(PresetEcualizador.rock),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.3 RED — obtenerDispositivoActual throws → fallback to 'builtin_speaker'
|
||
test('2.3 obtenerDispositivoActual throws → dispositivoActualId falls back to builtin_speaker', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudioThrows();
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
);
|
||
await eq.cargarPersistido(); // must not throw
|
||
|
||
expect(eq.dispositivoActualId, equals('builtin_speaker'));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.4 RED — toggle off → obtenerDispositivoActual is never called
|
||
test('2.4 eqMultiDeviceEnabled=false → obtenerDispositivoActual NOT called', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudioThrows();
|
||
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: false),
|
||
dispositivoAudio: fakeDispositivo,
|
||
);
|
||
// If obtenerDispositivoActual were called it would throw → test would fail
|
||
await expectLater(eq.cargarPersistido(), completes);
|
||
expect(eq.dispositivoActualId, isNull);
|
||
eq.dispose();
|
||
});
|
||
});
|
||
|
||
group('EstadoEcualizador — rename API (eq-device-autoswitch-ux Phase 2)', () {
|
||
// 2.6 RED — renombrarDispositivo writes to _nombresDispositivos and notifies
|
||
test('2.6a renombrarDispositivo stores name and notifyListeners', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'Living Room BT');
|
||
|
||
expect(eq.obtenerNombreDispositivo('bt_a2dp:AA:BB'), equals('Living Room BT'));
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.6 RED — empty name is no-op (preserves existing name)
|
||
test('2.6b renombrarDispositivo with empty string is no-op', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'My Headset');
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', '');
|
||
|
||
expect(eq.obtenerNombreDispositivo('bt_a2dp:AA:BB'), equals('My Headset'));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.7 RED — obtenerNombreDispositivo returns empty string for unknown device
|
||
test('2.7 obtenerNombreDispositivo returns empty string for unknown device', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.obtenerNombreDispositivo('unknown_device'), equals(''));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.8 RED — nombreVisible fallback chain: custom > platform > id
|
||
test('2.8a nombreVisible returns custom name when available', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'Studio Monitors');
|
||
|
||
expect(
|
||
eq.nombreVisible('bt_a2dp:AA:BB', 'USB Audio'),
|
||
equals('Studio Monitors'),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('2.8b nombreVisible returns platform name when no custom name', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.nombreVisible('bt_a2dp:AA:BB', 'Sony WH-1000XM5'),
|
||
equals('Sony WH-1000XM5'),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('2.8c nombreVisible returns raw deviceId when no custom and no platform name', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(eq.nombreVisible('bt_a2dp:AA:BB', ''), equals('bt_a2dp:AA:BB'));
|
||
eq.dispose();
|
||
});
|
||
|
||
// nombresDispositivos getter
|
||
test('2.9 nombresDispositivos getter returns current map', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'My BT');
|
||
|
||
expect(eq.nombresDispositivos['bt_a2dp:AA:BB'], equals('My BT'));
|
||
eq.dispose();
|
||
});
|
||
|
||
// 2.10 RED — _nombresDispositivos loaded from ConfiguracionEcualizador.nombresDispositivos
|
||
test('2.10 cargarPersistido loads nombresDispositivos from config', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(
|
||
nombresDispositivos: {'bt_a2dp:AA:BB': 'Loaded Name'},
|
||
),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(eq.obtenerNombreDispositivo('bt_a2dp:AA:BB'), equals('Loaded Name'));
|
||
eq.dispose();
|
||
});
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// CRITICAL-1: renombrarDispositivo is a no-op when toggle is OFF
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — renombrarDispositivo toggle guard (CRITICAL-1)', () {
|
||
test(
|
||
'renombrarDispositivo is no-op when eqMultiDeviceEnabled is false',
|
||
() async {
|
||
final fakeServicio = FakeServicioEcualizador(eqMultiDeviceEnabled: false);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'My Device');
|
||
|
||
// No name stored, no listeners notified, service not called
|
||
expect(eq.obtenerNombreDispositivo('bt_a2dp:AA:BB'), equals(''));
|
||
expect(avisos, equals(0));
|
||
expect(fakeServicio.config.nombresDispositivos, isEmpty);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'renombrarDispositivo works normally when eqMultiDeviceEnabled is true',
|
||
() async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.renombrarDispositivo('bt_a2dp:AA:BB', 'My Device');
|
||
|
||
expect(eq.obtenerNombreDispositivo('bt_a2dp:AA:BB'), equals('My Device'));
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// CRITICAL-2: guardarPresetDispositivo method
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — guardarPresetDispositivo (CRITICAL-2)', () {
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
test(
|
||
'guardarPresetDispositivo stores preset and notifies listeners',
|
||
() async {
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.flat},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.guardarPresetDispositivo(btDevice.id, PresetEcualizador.jazz);
|
||
|
||
expect(eq.presetsDispositivo[btDevice.id], equals(PresetEcualizador.jazz));
|
||
expect(fakeServicio.config.presetsDispositivo[btDevice.id], equals(PresetEcualizador.jazz));
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'guardarPresetDispositivo is no-op when toggle is OFF',
|
||
() async {
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: false,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.flat},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
await eq.guardarPresetDispositivo(btDevice.id, PresetEcualizador.jazz);
|
||
|
||
// Preset must remain unchanged
|
||
expect(eq.presetsDispositivo[btDevice.id], equals(PresetEcualizador.flat));
|
||
expect(avisos, equals(0));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'guardarPresetDispositivo triggers re-resolve and apply when device is active',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeDispositivo = FakeServicioDispositivoAudio()
|
||
..emitirDispositivo(btDevice);
|
||
const stationUuid = 'station-save-test';
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {btDevice.id: PresetEcualizador.flat},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
fakeAudio.presetsAplicados.clear();
|
||
await eq.guardarPresetDispositivo(btDevice.id, PresetEcualizador.rock);
|
||
|
||
// Audio was re-applied (re-resolve was triggered)
|
||
expect(fakeAudio.presetsAplicados, isNotEmpty);
|
||
// The resolved preset is the device preset (level 3, no station preset set)
|
||
expect(fakeAudio.presetsAplicados.last, equals(PresetEcualizador.rock));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'guardarPresetDispositivo does NOT re-apply when device is not active',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeServicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {
|
||
btDevice.id: PresetEcualizador.flat,
|
||
'other_device': PresetEcualizador.flat,
|
||
},
|
||
);
|
||
final fakeDispositivo = FakeServicioDispositivoAudio()
|
||
..emitirDispositivo(btDevice);
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: fakeServicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
// Active device is btDevice; save for 'other_device'
|
||
fakeAudio.presetsAplicados.clear();
|
||
await eq.guardarPresetDispositivo('other_device', PresetEcualizador.rock);
|
||
|
||
// Preset saved but audio NOT re-applied since 'other_device' is not active
|
||
expect(eq.presetsDispositivo['other_device'], equals(PresetEcualizador.rock));
|
||
expect(fakeAudio.presetsAplicados, isEmpty);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// WARNING-3: FakeServicioEcualizador preserves nombresDispositivos
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// bt-device-identity Phase 3: platform-name cache + duplicate-entry guard
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — platform-name cache (bt-device-identity Phase 3)', () {
|
||
const stationUuid = 'station-uuid-bt-identity';
|
||
|
||
test('3.1 platform name is cached from a device-change event', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
),
|
||
);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(
|
||
eq.nombrePlataforma('bt_a2dp:AA:BB:CC:DD:EE:FF'),
|
||
equals('AirPods Pro'),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'3.4 composite-placeholder sentinel does not create device-list entry',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: 'bt_a2dp:name:AirPods-Pro',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
),
|
||
);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(
|
||
eq.presetsDispositivo.containsKey('bt_a2dp:name:AirPods-Pro'),
|
||
isFalse,
|
||
);
|
||
expect(
|
||
eq.nombrePlataforma('bt_a2dp:name:AirPods-Pro'),
|
||
equals('AirPods Pro'),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test('3.6 multiple denied-permission devices do not collide', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
final baseline = eq.presetsDispositivo.length;
|
||
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: 'bt_a2dp:name:AirPods-Pro',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
),
|
||
);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: 'bt_a2dp:name:Sony-WH-1000XM5',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'Sony WH-1000XM5',
|
||
),
|
||
);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(
|
||
eq.nombrePlataforma('bt_a2dp:name:AirPods-Pro'),
|
||
equals('AirPods Pro'),
|
||
);
|
||
expect(
|
||
eq.nombrePlataforma('bt_a2dp:name:Sony-WH-1000XM5'),
|
||
equals('Sony WH-1000XM5'),
|
||
);
|
||
expect(eq.presetsDispositivo.length, equals(baseline));
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'3.7 repeated event for known id is a no-op on preset creation '
|
||
'(regression-lock)',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
const device = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(device);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
final presetTrasPrimerEvento = eq.presetsDispositivo[device.id];
|
||
final cantidadTrasPrimerEvento = eq.presetsDispositivo.length;
|
||
expect(presetTrasPrimerEvento, isNotNull);
|
||
|
||
fakeDispositivo.emitirDispositivo(device);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(
|
||
eq.presetsDispositivo[device.id],
|
||
equals(presetTrasPrimerEvento),
|
||
);
|
||
expect(eq.presetsDispositivo.length, equals(cantidadTrasPrimerEvento));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'3.8 transient non-BT id during pairing handshake does not corrupt '
|
||
'the BT entry (regression-lock)',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
);
|
||
const builtinSpeaker = DispositivoAudio(
|
||
id: 'builtin_speaker',
|
||
tipo: TipoDispositivo.altavozInterno,
|
||
nombre: 'Speaker',
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(
|
||
principal: PresetEcualizador.rock,
|
||
eqMultiDeviceEnabled: true,
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Transient builtin_speaker report mid-handshake.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Final BT event once the A2DP profile attaches.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.presetsDispositivo.containsKey(btDevice.id), isTrue);
|
||
expect(eq.presetsDispositivo.containsKey('builtin_speaker'), isFalse);
|
||
expect(
|
||
eq.presetsDispositivo[btDevice.id],
|
||
equals(PresetEcualizador.rock),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'3.10 rename persists after re-pair — composed regression '
|
||
'(closes bt-device-identity CRITICAL-1)',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'AirPods Pro',
|
||
);
|
||
const builtinSpeaker = DispositivoAudio(
|
||
id: 'builtin_speaker',
|
||
tipo: TipoDispositivo.altavozInterno,
|
||
nombre: 'Speaker',
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Connect: real-MAC id, first-seen bootstrap creates a preset entry.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
final presetTrasConectar = eq.presetsDispositivo[btDevice.id];
|
||
expect(presetTrasConectar, isNotNull);
|
||
|
||
// Rename the device via the in-app edit dialog path.
|
||
await eq.renombrarDispositivo(btDevice.id, 'My Headphones');
|
||
expect(
|
||
eq.nombreVisible(btDevice.id, eq.nombrePlataforma(btDevice.id)),
|
||
equals('My Headphones'),
|
||
);
|
||
final cantidadTrasRenombrar = eq.presetsDispositivo.length;
|
||
|
||
// Disconnect: platform reports the transient builtin_speaker fallback.
|
||
fakeDispositivo.emitirDispositivo(builtinSpeaker);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// Re-pair: same physical device reconnects, reporting the SAME MAC.
|
||
fakeDispositivo.emitirDispositivo(btDevice);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// No duplicate entry: presetsDispositivo did not grow.
|
||
expect(eq.presetsDispositivo.length, equals(cantidadTrasRenombrar));
|
||
// The device's own preset entry survives untouched (not overwritten).
|
||
expect(eq.presetsDispositivo[btDevice.id], equals(presetTrasConectar));
|
||
// Custom rename still wins over the re-cached platform name.
|
||
expect(
|
||
eq.nombreVisible(btDevice.id, eq.nombrePlataforma(btDevice.id)),
|
||
equals('My Headphones'),
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
group('FakeServicioEcualizador — nombresDispositivos preservation (WARNING-3)', () {
|
||
test(
|
||
'guardarPrincipal preserves nombresDispositivos',
|
||
() async {
|
||
final fake = FakeServicioEcualizador(
|
||
nombresDispositivos: {'dev1': 'My Speaker'},
|
||
);
|
||
await fake.guardarPrincipal(PresetEcualizador.jazz);
|
||
expect(fake.config.nombresDispositivos['dev1'], equals('My Speaker'));
|
||
},
|
||
);
|
||
|
||
test(
|
||
'guardarActivo preserves nombresDispositivos',
|
||
() async {
|
||
final fake = FakeServicioEcualizador(
|
||
nombresDispositivos: {'dev1': 'My Speaker'},
|
||
);
|
||
await fake.guardarActivo(false);
|
||
expect(fake.config.nombresDispositivos['dev1'], equals('My Speaker'));
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Fix: robust active-device detection (stale green dot)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador.refrescarDispositivoActual', () {
|
||
const btDevice = DispositivoAudio(
|
||
id: 'bt_a2dp:AA:BB:CC:DD:EE:FF',
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'BT Speaker',
|
||
);
|
||
|
||
test(
|
||
'resubscribes the event channel and re-seeds the id from a fresh '
|
||
'device query',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.dispositivoActualId, equals('builtin_speaker'));
|
||
|
||
// The native side changed device but the stale subscription lost the
|
||
// event (activity recreation): only the fake's cached value moved.
|
||
fakeDispositivo.establecerDispositivoSinEvento(btDevice);
|
||
|
||
await eq.refrescarDispositivoActual();
|
||
|
||
expect(fakeDispositivo.resubscribirLlamadas, equals(1));
|
||
expect(eq.dispositivoActualId, equals(btDevice.id));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test('is a no-op when the multi-device toggle is off', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: false),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
await eq.refrescarDispositivoActual();
|
||
|
||
expect(fakeDispositivo.resubscribirLlamadas, equals(0));
|
||
expect(eq.dispositivoActualId, isNull);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('is a no-op when no device service is injected', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Must not throw despite the missing service.
|
||
await eq.refrescarDispositivoActual();
|
||
|
||
expect(eq.dispositivoActualId, isNull);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('is safe to call repeatedly', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
fakeDispositivo.establecerDispositivoSinEvento(btDevice);
|
||
|
||
await eq.refrescarDispositivoActual();
|
||
await eq.refrescarDispositivoActual();
|
||
await eq.refrescarDispositivoActual();
|
||
|
||
expect(fakeDispositivo.resubscribirLlamadas, equals(3));
|
||
expect(eq.dispositivoActualId, equals(btDevice.id));
|
||
eq.dispose();
|
||
});
|
||
|
||
test(
|
||
'a failing resubscribe still falls back to builtin_speaker via the '
|
||
'seeding error path instead of throwing',
|
||
() async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudioThrows();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
await eq.refrescarDispositivoActual();
|
||
|
||
expect(fakeDispositivo.resubscribirLlamadas, equals(1));
|
||
expect(eq.dispositivoActualId, equals('builtin_speaker'));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'overlapping calls share one in-flight refresh (single resubscribe)',
|
||
() async {
|
||
final fakeDispositivo = _FakeDispositivoAudioResubscribirLento();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// Second call lands while the first is still awaiting resubscribir.
|
||
final primero = eq.refrescarDispositivoActual();
|
||
final segundo = eq.refrescarDispositivoActual();
|
||
fakeDispositivo.completarResubscribir();
|
||
await Future.wait([primero, segundo]);
|
||
|
||
expect(fakeDispositivo.resubscribirLlamadas, equals(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// builtin_speaker id collision + device removal
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — cambiarActivo bajo toques rápidos', () {
|
||
test('el motor acaba en el estado que muestra la UI', () async {
|
||
// cambiarActivo persists BEFORE telling the engine, so two quick taps
|
||
// race on a disk write: if the first write resolves last, the engine
|
||
// receives the FIRST tap's value after the second one — the checkbox
|
||
// says on while the sound is off.
|
||
final servicio = _FakeEcualizadorGuardadoLento();
|
||
final audio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(audio: audio, servicio: servicio);
|
||
await eq.cargarPersistido();
|
||
audio.cambiosEcualizadorActivo.clear();
|
||
|
||
final primero = eq.cambiarActivo(false);
|
||
final segundo = eq.cambiarActivo(true);
|
||
await Future.wait([primero, segundo]);
|
||
|
||
expect(eq.activo, isTrue);
|
||
expect(
|
||
audio.cambiosEcualizadorActivo.last,
|
||
isTrue,
|
||
reason: 'the engine must end matching the state the UI shows',
|
||
);
|
||
});
|
||
});
|
||
|
||
group(
|
||
'EstadoEcualizador — importarConfiguracion(activo:) '
|
||
'(equalizer on/off export/import gap)',
|
||
() {
|
||
test(
|
||
'activo: false turns the equalizer off — persisted AND pushed to '
|
||
'the live audio engine (reuses cambiarActivo, not a bare field set)',
|
||
() async {
|
||
final servicio = FakeServicioEcualizador(activo: true);
|
||
final audio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(audio: audio, servicio: servicio);
|
||
await eq.cargarPersistido();
|
||
audio.cambiosEcualizadorActivo.clear();
|
||
|
||
await eq.importarConfiguracion(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {},
|
||
activo: false,
|
||
);
|
||
|
||
expect(eq.activo, isFalse);
|
||
expect(audio.cambiosEcualizadorActivo, contains(false));
|
||
expect(servicio.config.activo, isFalse);
|
||
expect(servicio.guardarActivoLlamadas, 1);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'activo: true turns the equalizer on — persisted AND pushed to '
|
||
'the live audio engine',
|
||
() async {
|
||
final servicio = FakeServicioEcualizador(activo: false);
|
||
final audio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(audio: audio, servicio: servicio);
|
||
await eq.cargarPersistido();
|
||
audio.cambiosEcualizadorActivo.clear();
|
||
|
||
await eq.importarConfiguracion(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {},
|
||
activo: true,
|
||
);
|
||
|
||
expect(eq.activo, isTrue);
|
||
expect(audio.cambiosEcualizadorActivo, contains(true));
|
||
expect(servicio.config.activo, isTrue);
|
||
expect(servicio.guardarActivoLlamadas, 1);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'activo: null (old backup, no field) leaves the current toggle '
|
||
'untouched and does not persist anything for it',
|
||
() async {
|
||
final servicio = FakeServicioEcualizador(activo: false);
|
||
final audio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(audio: audio, servicio: servicio);
|
||
await eq.cargarPersistido();
|
||
audio.cambiosEcualizadorActivo.clear();
|
||
|
||
await eq.importarConfiguracion(
|
||
principal: PresetEcualizador.flat,
|
||
porEmisora: {},
|
||
// activo omitted — simulates a pre-v4 backup.
|
||
);
|
||
|
||
expect(eq.activo, isFalse);
|
||
expect(audio.cambiosEcualizadorActivo, isEmpty);
|
||
expect(servicio.guardarActivoLlamadas, 0);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
},
|
||
);
|
||
|
||
group('EstadoEcualizador — bonded Bluetooth names', () {
|
||
const deviceId = 'bt_a2dp:AA:BB:CC:DD:EE:FF';
|
||
|
||
test('a paired but disconnected device resolves its system name', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio(
|
||
nombresEmparejados: {'AA:BB:CC:DD:EE:FF': 'Omoda'},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {deviceId: PresetEcualizador.rock},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
|
||
await eq.cargarPersistido();
|
||
|
||
// The device was never seen on the stream this session, so the only
|
||
// possible source is the system's bonded-device list.
|
||
expect(eq.nombrePlataforma(deviceId), equals('Omoda'));
|
||
eq.dispose();
|
||
});
|
||
|
||
test('a live enumeration name wins over the bonded one', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio(
|
||
nombresEmparejados: {'AA:BB:CC:DD:EE:FF': 'Stale pairing name'},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: deviceId,
|
||
tipo: TipoDispositivo.bluetoothA2dp,
|
||
nombre: 'Omoda',
|
||
),
|
||
);
|
||
await Future<void>.delayed(Duration.zero);
|
||
|
||
expect(eq.nombrePlataforma(deviceId), equals('Omoda'));
|
||
eq.dispose();
|
||
});
|
||
|
||
test('a custom name still beats the bonded one', () async {
|
||
final fakeDispositivo = FakeServicioDispositivoAudio(
|
||
nombresEmparejados: {'AA:BB:CC:DD:EE:FF': 'OMODA 5'},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
nombresDispositivos: {deviceId: 'Coche'},
|
||
),
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
expect(
|
||
eq.nombreVisible(deviceId, eq.nombrePlataforma(deviceId)),
|
||
equals('Coche'),
|
||
);
|
||
eq.dispose();
|
||
});
|
||
|
||
test('a failing bonded-name lookup never breaks startup', () async {
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: FakeServicioEcualizador(eqMultiDeviceEnabled: true),
|
||
dispositivoAudio: FakeServicioDispositivoAudioThrows(),
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
|
||
await eq.cargarPersistido();
|
||
|
||
expect(eq.nombrePlataforma('bt_a2dp:AA:BB'), isEmpty);
|
||
eq.dispose();
|
||
});
|
||
});
|
||
|
||
group('EstadoEcualizador — builtin_speaker collision guard', () {
|
||
test(
|
||
'an unknown-type device reported under the base id creates no entry',
|
||
() async {
|
||
final servicio = FakeServicioEcualizador(eqMultiDeviceEnabled: true);
|
||
final fakeDispositivo = FakeServicioDispositivoAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: servicio,
|
||
dispositivoAudio: fakeDispositivo,
|
||
emisoraActualUuid: () => null,
|
||
);
|
||
await eq.cargarPersistido();
|
||
|
||
// What the old native else-branch emitted for an LE Audio car stereo:
|
||
// the phone-speaker id carrying a type Dart maps to `desconocido`.
|
||
fakeDispositivo.emitirDispositivo(
|
||
const DispositivoAudio(
|
||
id: 'builtin_speaker',
|
||
tipo: TipoDispositivo.desconocido,
|
||
nombre: 'Omoda',
|
||
),
|
||
);
|
||
await Future<void>.delayed(Duration.zero);
|
||
|
||
expect(eq.presetsDispositivo.containsKey('builtin_speaker'), isFalse);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test('eliminarDispositivo clears preset, name and matrix entries', () async {
|
||
const deviceId = 'bt_a2dp:AA:BB:CC:DD:EE:FF';
|
||
const stationUuid = 'station-uuid-123';
|
||
const otroId = 'bt_a2dp:11:22:33:44:55:66';
|
||
final servicio = FakeServicioEcualizador(
|
||
eqMultiDeviceEnabled: true,
|
||
presetsDispositivo: {
|
||
deviceId: PresetEcualizador.jazz,
|
||
otroId: PresetEcualizador.rock,
|
||
},
|
||
presetsMatriz: {
|
||
'$stationUuid:$deviceId': PresetEcualizador.bassBoost,
|
||
'$stationUuid:$otroId': PresetEcualizador.pop,
|
||
},
|
||
nombresDispositivos: {deviceId: 'Omoda', otroId: 'Travel headphones'},
|
||
);
|
||
final eq = EstadoEcualizador(
|
||
audio: FakeServicioAudio(),
|
||
servicio: servicio,
|
||
dispositivoAudio: FakeServicioDispositivoAudio(),
|
||
emisoraActualUuid: () => stationUuid,
|
||
);
|
||
await eq.cargarPersistido();
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
|
||
await eq.eliminarDispositivo(deviceId);
|
||
|
||
expect(eq.presetsDispositivo.containsKey(deviceId), isFalse);
|
||
expect(eq.nombresDispositivos.containsKey(deviceId), isFalse);
|
||
expect(eq.presetsMatriz.containsKey('$stationUuid:$deviceId'), isFalse);
|
||
// Sibling device untouched.
|
||
expect(eq.presetsDispositivo[otroId], equals(PresetEcualizador.rock));
|
||
expect(eq.nombresDispositivos[otroId], equals('Travel headphones'));
|
||
expect(
|
||
eq.presetsMatriz['$stationUuid:$otroId'],
|
||
equals(PresetEcualizador.pop),
|
||
);
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
});
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// eq-sync-superficies: car/notification-initiated EQ changes must reach
|
||
// EstadoEcualizador (and persist through ServicioEcualizador), not just
|
||
// the audio handler.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
group('EstadoEcualizador — resync with handler-initiated EQ changes '
|
||
'(eq-sync-superficies)', () {
|
||
test(
|
||
'a handler-initiated toggle (car/notification) syncs activo and '
|
||
'notifies listeners',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(activo: true),
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.activo, isTrue);
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
|
||
// Simulates `accionEqToggle` calling
|
||
// `PluriWaveAudioHandler.setEcualizadorActivo` directly, bypassing
|
||
// `ServicioAudio`/`EstadoEcualizador` entirely.
|
||
fakeAudio.simularCambioEqDesdeHandler(activo: false);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.activo, isFalse);
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'a handler-initiated preset change (Android Auto) syncs presetActual '
|
||
'and notifies listeners',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(principal: PresetEcualizador.flat),
|
||
);
|
||
await eq.cargarPersistido();
|
||
expect(eq.presetActual, equals(PresetEcualizador.flat));
|
||
|
||
var avisos = 0;
|
||
eq.addListener(() => avisos++);
|
||
|
||
// Simulates `seleccionarPresetEqPorMediaId` calling
|
||
// `PluriWaveAudioHandler.aplicarPreset` directly.
|
||
fakeAudio.simularCambioEqDesdeHandler(preset: PresetEcualizador.jazz);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.presetActual, equals(PresetEcualizador.jazz));
|
||
expect(avisos, greaterThanOrEqualTo(1));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'a handler-initiated toggle is ADOPTED for display and NOT written '
|
||
'again from here (eq-estado-unico: the handler owns the write)',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeServicio = FakeServicioEcualizador(activo: true);
|
||
final eq = EstadoEcualizador(audio: fakeAudio, servicio: fakeServicio);
|
||
await eq.cargarPersistido();
|
||
|
||
fakeAudio.simularCambioEqDesdeHandler(activo: false);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(
|
||
eq.activo,
|
||
isFalse,
|
||
reason: 'the phone toggle must show what the engine is really doing',
|
||
);
|
||
expect(
|
||
fakeServicio.guardarActivoLlamadas,
|
||
equals(0),
|
||
reason:
|
||
'persistence moved to PluriWaveAudioHandler itself, because '
|
||
'this resync only exists while an EstadoEcualizador does — and '
|
||
'on the headless Android Auto engine that produced the bug, '
|
||
'none ever does. A second write from here would be a second '
|
||
'owner of the same fact.',
|
||
);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'resync does not cause an extra handler write (no feedback loop)',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final eq = EstadoEcualizador(
|
||
audio: fakeAudio,
|
||
servicio: FakeServicioEcualizador(activo: true),
|
||
);
|
||
await eq.cargarPersistido();
|
||
fakeAudio.cambiosEcualizadorActivo.clear();
|
||
fakeAudio.presetsAplicados.clear();
|
||
|
||
fakeAudio.simularCambioEqDesdeHandler(activo: false);
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
// The resync must only read from `audio` and write to `servicio` —
|
||
// never write BACK into `audio`, or a handler write would trigger
|
||
// another stream tick, which would resync again, forever.
|
||
expect(fakeAudio.cambiosEcualizadorActivo, isEmpty);
|
||
expect(fakeAudio.presetsAplicados, isEmpty);
|
||
eq.dispose();
|
||
},
|
||
);
|
||
|
||
test(
|
||
'a UI-initiated toggle still works exactly as before and persists '
|
||
'exactly once (regression)',
|
||
() async {
|
||
final fakeAudio = FakeServicioAudio();
|
||
final fakeServicio = FakeServicioEcualizador(activo: true);
|
||
final eq = EstadoEcualizador(audio: fakeAudio, servicio: fakeServicio);
|
||
await eq.cargarPersistido();
|
||
fakeAudio.cambiosEcualizadorActivo.clear();
|
||
|
||
await eq.cambiarActivo(false);
|
||
// Give any (harmless, no-op) resync tick a chance to run too.
|
||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||
|
||
expect(eq.activo, isFalse);
|
||
expect(fakeServicio.config.activo, isFalse);
|
||
expect(fakeServicio.guardarActivoLlamadas, equals(1));
|
||
expect(fakeAudio.cambiosEcualizadorActivo, equals([false]));
|
||
eq.dispose();
|
||
},
|
||
);
|
||
});
|
||
}
|
||
|
||
/// Fake whose [guardarActivo] stays pending until released, and releases the
|
||
/// pending writes in REVERSE order — reproducing a disk write that resolves
|
||
/// out of order between two quick taps.
|
||
class _FakeEcualizadorGuardadoLento extends FakeServicioEcualizador {
|
||
int _llamadas = 0;
|
||
|
||
@override
|
||
Future<void> guardarActivo(bool activo) async {
|
||
// The FIRST write is the slow one: that is the ordering hazard, since an
|
||
// unserialized second tap overtakes it and the slow write's engine call
|
||
// lands last.
|
||
await Future<void>.delayed(
|
||
_llamadas++ == 0 ? const Duration(milliseconds: 20) : Duration.zero,
|
||
);
|
||
await super.guardarActivo(activo);
|
||
}
|
||
}
|
||
|
||
/// Fake whose [resubscribir] stays pending until [completarResubscribir]
|
||
/// runs — creates the overlap window for the in-flight-guard test above.
|
||
class _FakeDispositivoAudioResubscribirLento
|
||
extends FakeServicioDispositivoAudio {
|
||
final _resubscribir = Completer<void>();
|
||
|
||
void completarResubscribir() => _resubscribir.complete();
|
||
|
||
@override
|
||
Future<void> resubscribir() async {
|
||
resubscribirLlamadas++;
|
||
await _resubscribir.future;
|
||
}
|
||
}
|