mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-11-21 20:00:49 +01:00
The Save preset button sat in a Flexible beside a Spacer. The two halved the row's free width and the button used only a little of its half, so on a wide page the reset and menu buttons stopped mid-row. The button now takes the room up to them and keeps its own width at the start.
481 lines
17 KiB
Dart
481 lines
17 KiB
Dart
import 'dart:convert';
|
||
|
||
import 'package:material_ui/material_ui.dart';
|
||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||
import 'package:flutter_test/flutter_test.dart';
|
||
import 'package:material_3_expressive/material_3_expressive.dart';
|
||
import 'package:shared_preferences/shared_preferences.dart';
|
||
import 'package:mornye/l10n/l10n.dart';
|
||
import 'package:mornye/models/equalizer_settings.dart';
|
||
import 'package:mornye/providers/equalizer_provider.dart';
|
||
import 'package:mornye/screens/equalizer_screen.dart';
|
||
import 'package:mornye/services/playback_equalizer.dart';
|
||
import 'package:mornye/theme/app_theme.dart';
|
||
import 'package:mornye/theme/mornye_theme.dart';
|
||
import 'package:mornye/widgets/app_menu_button.dart';
|
||
import 'package:mornye/widgets/app_slider.dart';
|
||
import 'package:mornye/widgets/expressive_button.dart';
|
||
import 'package:mornye/widgets/expressive_icon_button.dart';
|
||
import 'package:mornye/widgets/mornye_chrome.dart';
|
||
import 'package:mornye/widgets/mornye_level_slider.dart';
|
||
import 'package:mornye/widgets/slider_value_header.dart';
|
||
|
||
class _CountedSettings extends EqualizerSettings {
|
||
_CountedSettings(double preamp, this.serialized) : super(preamp: preamp);
|
||
|
||
final VoidCallback serialized;
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
serialized();
|
||
return super.toJson();
|
||
}
|
||
}
|
||
|
||
void main() {
|
||
setUp(() {
|
||
SharedPreferences.setMockInitialValues({});
|
||
playbackEqualizer.value = const EqualizerSettings();
|
||
playbackEqualizerError.value = null;
|
||
});
|
||
|
||
testWidgets('slider bursts serialize only the final persisted snapshot', (
|
||
tester,
|
||
) async {
|
||
final container = ProviderContainer();
|
||
final notifier = container.read(equalizerProvider.notifier);
|
||
await tester.pump();
|
||
var serializations = 0;
|
||
final presets = container.read(equalizerProvider).presets;
|
||
for (var i = 0; i < 100; i++) {
|
||
notifier.update(_CountedSettings(-i / 10, () => serializations++));
|
||
}
|
||
expect(serializations, 0);
|
||
expect(container.read(equalizerProvider).presets, same(presets));
|
||
expect(playbackEqualizer.value.preamp, -9.9);
|
||
await tester.pump(const Duration(milliseconds: 350));
|
||
await tester.runAsync(() async => Future<void>.delayed(Duration.zero));
|
||
await tester.pump();
|
||
expect(serializations, 1);
|
||
final prefs = await SharedPreferences.getInstance();
|
||
Object? savedPreamp() {
|
||
final stored =
|
||
jsonDecode(prefs.getString(EqualizerController.storageKey)!)
|
||
as Map<String, dynamic>;
|
||
return (stored['settings'] as Map<String, dynamic>)['preamp'];
|
||
}
|
||
|
||
expect(savedPreamp(), -9.9);
|
||
notifier.update(_CountedSettings(-5, () => serializations++));
|
||
container.dispose();
|
||
await tester.runAsync(() async => Future<void>.delayed(Duration.zero));
|
||
await tester.pump();
|
||
expect(serializations, 2);
|
||
expect(savedPreamp(), -5);
|
||
});
|
||
|
||
for (final mornye in [false, true]) {
|
||
testWidgets(
|
||
'EQ drags retain unrelated controls and current edits ($mornye)',
|
||
(tester) async {
|
||
tester.view.physicalSize = const Size(1200, 3000);
|
||
tester.view.devicePixelRatio = 1;
|
||
addTearDown(tester.view.reset);
|
||
final container = ProviderContainer();
|
||
addTearDown(container.dispose);
|
||
await tester.pumpWidget(
|
||
UncontrolledProviderScope(
|
||
container: container,
|
||
child: MaterialApp(
|
||
theme: mornye
|
||
? MornyeTheme.build(Brightness.dark)
|
||
: AppTheme.light(),
|
||
localizationsDelegates: AppLocalizations.localizationsDelegates,
|
||
supportedLocales: AppLocalizations.supportedLocales,
|
||
home: const EqualizerScreen(),
|
||
),
|
||
),
|
||
);
|
||
await tester.pumpAndSettle();
|
||
final notifier = container.read(equalizerProvider.notifier);
|
||
notifier.update(
|
||
container.read(equalizerProvider).settings.copyWith(preamp: -1),
|
||
);
|
||
await tester.pumpAndSettle();
|
||
final page = tester.widget<Scaffold>(find.byType(Scaffold));
|
||
final picker = find.byType(
|
||
mornye ? MornyeSegmentedControl : M3EButtonGroup,
|
||
);
|
||
final bandPicker = tester.widget(picker);
|
||
Widget bass() => mornye
|
||
? tester
|
||
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
|
||
.firstWhere((slider) => slider.semanticLabel == 'Bass')
|
||
: tester
|
||
.widgetList<AppSlider>(find.byType(AppSlider))
|
||
.firstWhere((slider) => slider.semanticLabel == 'Bass');
|
||
final bassSlider = bass();
|
||
final gainSlider = mornye
|
||
? tester
|
||
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
|
||
.first
|
||
: tester.widgetList<AppSlider>(find.byType(AppSlider)).first;
|
||
for (var i = 1; i <= 20; i++) {
|
||
notifier.update(
|
||
container.read(equalizerProvider).settings.copyWith(preamp: -i / 2),
|
||
);
|
||
await tester.pump(const Duration(milliseconds: 16));
|
||
expect(tester.widget<Scaffold>(find.byType(Scaffold)), same(page));
|
||
expect(tester.widget(picker), same(bandPicker));
|
||
expect(bass(), same(bassSlider));
|
||
}
|
||
if (gainSlider is MornyeLevelSlider) {
|
||
gainSlider.onChanged!(5);
|
||
} else {
|
||
(gainSlider as AppSlider).onChanged!(5);
|
||
}
|
||
await tester.pump();
|
||
if (bassSlider is MornyeLevelSlider) {
|
||
bassSlider.onChanged!(3);
|
||
} else {
|
||
(bassSlider as AppSlider).onChanged!(3);
|
||
}
|
||
await tester.pump();
|
||
final settings = container.read(equalizerProvider).settings;
|
||
expect(settings.preamp, -10);
|
||
expect(settings.gains.first, 5);
|
||
expect(settings.bass, 3);
|
||
expect(playbackEqualizer.value, same(settings));
|
||
notifier.update(const EqualizerSettings());
|
||
await tester.pumpAndSettle();
|
||
notifier.importPreset(
|
||
jsonEncode({
|
||
'format': 'mornye-equalizer',
|
||
'version': 1,
|
||
'name': 'Signed zero',
|
||
'settings': EqualizerSettings(
|
||
gains: List.filled(10, -0.0),
|
||
preamp: -0.0,
|
||
bass: -0.0,
|
||
treble: -0.0,
|
||
balance: -0.0,
|
||
).toJson(),
|
||
}),
|
||
);
|
||
await tester.pumpAndSettle();
|
||
final headers = tester.widgetList<SliderValueHeader>(
|
||
find.byType(SliderValueHeader),
|
||
);
|
||
for (final title in ['Preamp', 'Bass', 'Treble', 'Balance']) {
|
||
expect(
|
||
headers.firstWhere((header) => header.title == title).value,
|
||
title == 'Balance' ? '−0%' : '−0.0 dB',
|
||
);
|
||
}
|
||
final bandValue = mornye
|
||
? tester
|
||
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
|
||
.first
|
||
.value
|
||
: tester.widgetList<AppSlider>(find.byType(AppSlider)).first.value;
|
||
expect(bandValue.isNegative, isTrue);
|
||
expect(tester.takeException(), isNull);
|
||
await tester.pumpWidget(const SizedBox.shrink());
|
||
await tester.pump(const Duration(milliseconds: 350));
|
||
},
|
||
);
|
||
}
|
||
|
||
test('band resampling preserves flat curves and center gains', () {
|
||
for (final count in EqualizerSettings.bandCounts) {
|
||
final settings = const EqualizerSettings().withBandCount(count);
|
||
expect(settings.gains, everyElement(0));
|
||
expect(settings.frequencies.length, count);
|
||
final raised = settings.copyWith(gains: List.filled(count, 6));
|
||
for (final hz in raised.frequencies) {
|
||
expect(raised.gainAt(hz), closeTo(6, 1e-9));
|
||
}
|
||
expect(raised.withBandCount(31).gains, everyElement(closeTo(6, 1e-9)));
|
||
}
|
||
expect(const EqualizerSettings().withBandCount(31).frequencies.take(3), [
|
||
20,
|
||
25,
|
||
31.5,
|
||
]);
|
||
expect(
|
||
() => const EqualizerSettings().withBandCount(32),
|
||
throwsFormatException,
|
||
);
|
||
});
|
||
|
||
test('tone controls and automatic headroom reach the native payload', () {
|
||
const settings = EqualizerSettings(
|
||
enabled: true,
|
||
bass: 6,
|
||
treble: -3,
|
||
preamp: -2,
|
||
);
|
||
final payload = settings.toNative();
|
||
expect(settings.effectiveGains.first, greaterThan(5));
|
||
expect(settings.effectiveGains.last, lessThan(-2));
|
||
expect(payload['inputGain'], lessThan(-7));
|
||
expect(payload['gains'], settings.effectiveGains);
|
||
expect(settings.copyWith(autoHeadroom: false).inputGain, -2);
|
||
});
|
||
|
||
test('presets change the sound but keep output safety choices', () {
|
||
final container = ProviderContainer();
|
||
addTearDown(container.dispose);
|
||
final notifier = container.read(equalizerProvider.notifier);
|
||
notifier.update(
|
||
const EqualizerSettings(
|
||
enabled: true,
|
||
balance: 0.25,
|
||
autoHeadroom: false,
|
||
limiter: false,
|
||
compressor: true,
|
||
ratio: 6,
|
||
),
|
||
);
|
||
final bassBoost = EqualizerPreset.builtIn.firstWhere(
|
||
(preset) => preset.name == 'Bass boost',
|
||
);
|
||
notifier.applyPreset(bassBoost);
|
||
final settings = container.read(equalizerProvider).settings;
|
||
expect(settings.gains, bassBoost.settings.gains);
|
||
expect(settings.enabled, isTrue);
|
||
expect(settings.balance, 0.25);
|
||
expect(settings.autoHeadroom, isFalse);
|
||
expect(settings.limiter, isFalse);
|
||
expect(settings.compressor, isTrue);
|
||
expect(settings.ratio, 6);
|
||
expect(settings.inputGain, 0);
|
||
});
|
||
|
||
test(
|
||
'malformed and nonfinite imports cannot create unsafe native settings',
|
||
() {
|
||
final json = const EqualizerSettings().toJson();
|
||
expect(
|
||
() => EqualizerSettings.fromJson({
|
||
...json,
|
||
'gains': [1, 2],
|
||
}),
|
||
throwsFormatException,
|
||
);
|
||
expect(
|
||
() => EqualizerSettings.fromJson({
|
||
...json,
|
||
'gains': List.filled(10, double.nan),
|
||
}),
|
||
throwsFormatException,
|
||
);
|
||
final bounded = EqualizerSettings.fromJson({
|
||
...json,
|
||
'gains': List.filled(10, 100),
|
||
'preamp': 1000,
|
||
'balance': -100,
|
||
'ratio': double.infinity,
|
||
});
|
||
expect(bounded.gains, everyElement(15));
|
||
expect(bounded.preamp, 12);
|
||
expect(bounded.balance, -1);
|
||
expect(bounded.ratio, 3);
|
||
},
|
||
);
|
||
|
||
testWidgets('presets survive fast edits during startup and reload', (
|
||
tester,
|
||
) async {
|
||
SharedPreferences.setMockInitialValues({
|
||
EqualizerController.storageKey: jsonEncode({
|
||
'settings': const EqualizerSettings(preamp: -4).toJson(),
|
||
'presets': [
|
||
const EqualizerPreset(
|
||
'Headphones',
|
||
EqualizerSettings(bass: 3),
|
||
).toJson(),
|
||
],
|
||
}),
|
||
});
|
||
final container = ProviderContainer();
|
||
container.read(equalizerProvider);
|
||
container
|
||
.read(equalizerProvider.notifier)
|
||
.update(const EqualizerSettings(enabled: true, treble: 2));
|
||
await tester.pump(const Duration(milliseconds: 500));
|
||
await tester.runAsync(() async {
|
||
await Future<void>.delayed(Duration.zero);
|
||
});
|
||
await tester.pump(const Duration(milliseconds: 500));
|
||
expect(container.read(equalizerProvider).settings.treble, 2);
|
||
expect(container.read(equalizerProvider).presets.single.name, 'Headphones');
|
||
final notifier = container.read(equalizerProvider.notifier);
|
||
notifier.savePreset('Desk');
|
||
notifier.update(const EqualizerSettings(enabled: true, preamp: -8));
|
||
final export = notifier.exportPreset('Portable');
|
||
expect(
|
||
(jsonDecode(export) as Map<String, dynamic>)['format'],
|
||
'mornye-equalizer',
|
||
);
|
||
notifier.importPreset(export);
|
||
notifier.importPreset(
|
||
export.replaceFirst('mornye-equalizer', 'spotiflac-equalizer'),
|
||
);
|
||
expect(container.read(equalizerProvider).presets.map((v) => v.name), [
|
||
'Headphones',
|
||
'Desk',
|
||
'Portable',
|
||
]);
|
||
expect(container.read(equalizerProvider).settings.enabled, isTrue);
|
||
expect(() => notifier.importPreset('{}'), throwsFormatException);
|
||
expect(() => notifier.importPreset('x' * 65537), throwsFormatException);
|
||
await tester.pump(const Duration(milliseconds: 500));
|
||
await tester.runAsync(() async {
|
||
await Future<void>.delayed(Duration.zero);
|
||
});
|
||
container.dispose();
|
||
final restored = ProviderContainer();
|
||
addTearDown(restored.dispose);
|
||
restored.read(equalizerProvider);
|
||
await tester.runAsync(() async {
|
||
await Future<void>.delayed(Duration.zero);
|
||
});
|
||
await tester.pump();
|
||
expect(restored.read(equalizerProvider).settings.preamp, -8);
|
||
expect(restored.read(equalizerProvider).presets.length, 3);
|
||
});
|
||
|
||
testWidgets('preset actions end the row on a wide page', (tester) async {
|
||
tester.view.physicalSize = const Size(1200, 3000);
|
||
tester.view.devicePixelRatio = 1;
|
||
addTearDown(tester.view.reset);
|
||
final container = ProviderContainer();
|
||
addTearDown(container.dispose);
|
||
await tester.pumpWidget(
|
||
UncontrolledProviderScope(
|
||
container: container,
|
||
child: MaterialApp(
|
||
theme: AppTheme.light(),
|
||
localizationsDelegates: AppLocalizations.localizationsDelegates,
|
||
supportedLocales: AppLocalizations.supportedLocales,
|
||
home: const EqualizerScreen(),
|
||
),
|
||
),
|
||
);
|
||
await tester.pumpAndSettle();
|
||
|
||
final save = tester.getRect(
|
||
find.ancestor(
|
||
of: find.text('Save preset'),
|
||
matching: find.byType(ExpressiveButton),
|
||
),
|
||
);
|
||
final more = tester.getRect(
|
||
find.byWidgetPredicate(
|
||
(widget) => widget is AppMenuButton && widget.tooltip == 'Presets',
|
||
),
|
||
);
|
||
final reset = tester.getRect(
|
||
find.byWidgetPredicate(
|
||
(widget) => widget is ExpressiveIconButton && widget.tooltip == 'Reset',
|
||
),
|
||
);
|
||
// Save starts the row and the menu ends it, the same distance from
|
||
// their edges of the page.
|
||
expect(1200 - more.right, closeTo(save.left, 0.5));
|
||
expect(reset.right, closeTo(more.left, 0.5));
|
||
expect(save.width, lessThan(300));
|
||
});
|
||
|
||
for (final mornye in [false, true]) {
|
||
testWidgets(
|
||
'EQ editing and dialogs fit a narrow screen with large text ($mornye)',
|
||
(tester) async {
|
||
tester.view.physicalSize = const Size(320, 720);
|
||
tester.view.devicePixelRatio = 1;
|
||
addTearDown(tester.view.reset);
|
||
final container = ProviderContainer();
|
||
addTearDown(container.dispose);
|
||
await tester.pumpWidget(
|
||
UncontrolledProviderScope(
|
||
container: container,
|
||
child: MaterialApp(
|
||
theme: mornye
|
||
? MornyeTheme.build(Brightness.dark)
|
||
: AppTheme.light(),
|
||
localizationsDelegates: AppLocalizations.localizationsDelegates,
|
||
supportedLocales: AppLocalizations.supportedLocales,
|
||
builder: (context, child) => MediaQuery(
|
||
data: MediaQuery.of(
|
||
context,
|
||
).copyWith(textScaler: const TextScaler.linear(1.8)),
|
||
child: child!,
|
||
),
|
||
home: const EqualizerScreen(),
|
||
),
|
||
),
|
||
);
|
||
await tester.pumpAndSettle();
|
||
final picker = find.byType(
|
||
mornye ? MornyeSegmentedControl : M3EButtonGroup,
|
||
);
|
||
await tester.scrollUntilVisible(
|
||
picker,
|
||
150,
|
||
scrollable: find.byType(Scrollable).first,
|
||
);
|
||
await tester.pumpAndSettle();
|
||
// The picker sits on an opaque group card.
|
||
expect(
|
||
find.descendant(of: picker, matching: find.byType(BackdropFilter)),
|
||
findsNothing,
|
||
);
|
||
await tester.tap(
|
||
find.descendant(of: picker, matching: find.text('31')).first,
|
||
);
|
||
await tester.pumpAndSettle();
|
||
expect(container.read(equalizerProvider).settings.gains.length, 31);
|
||
expect(tester.takeException(), isNull);
|
||
// The first slider on the page is the lowest band's fader.
|
||
final onChanged = mornye
|
||
? tester
|
||
.widgetList<MornyeLevelSlider>(find.byType(MornyeLevelSlider))
|
||
.first
|
||
.onChanged
|
||
: tester
|
||
.widgetList<AppSlider>(find.byType(AppSlider))
|
||
.first
|
||
.onChanged;
|
||
onChanged!(5);
|
||
await tester.pump();
|
||
expect(container.read(equalizerProvider).settings.gains.first, 5);
|
||
// Drags over the vertical faders adjust gains instead of scrolling.
|
||
tester
|
||
.state<ScrollableState>(find.byType(Scrollable).first)
|
||
.position
|
||
.jumpTo(0);
|
||
await tester.pumpAndSettle();
|
||
final save = find.text('Save preset');
|
||
await tester.scrollUntilVisible(
|
||
save,
|
||
150,
|
||
scrollable: find.byType(Scrollable).first,
|
||
);
|
||
await tester.pumpAndSettle();
|
||
await tester.tap(save);
|
||
await tester.pumpAndSettle();
|
||
await tester.enterText(find.byType(EditableText), 'My headphones');
|
||
await tester.tap(find.text('Save').last);
|
||
await tester.pumpAndSettle();
|
||
expect(
|
||
container.read(equalizerProvider).presets.single.name,
|
||
'My headphones',
|
||
);
|
||
expect(tester.takeException(), isNull);
|
||
await tester.pumpWidget(const SizedBox.shrink());
|
||
},
|
||
);
|
||
}
|
||
}
|