dustin/Melo
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Equalizer (nativ), Dolby-Atmos-Zugang und Auto-Wiedergabe bei Kopfhoerern

Browse Source 
- Native Bruecke AudioEffectsBridge.kt: Equalizer + BassBoost + Virtualizer
  auf der Audio-Session des Players, inkl. System-Klangeffekt-Panel
- Dart-Seite AudioEffects: Presets, Baender, Bass/Immersiv, persistiert
- EqualizerScreen nach Vorlage inkl. Drehregler (CustomPainter)
- Auto-Wiedergabe bei verbundenen Kopfhoerern (Klinke + Bluetooth)
- MODIFY_AUDIO_SETTINGS im Manifest
- Einstellungen: neuer Bereich "Ton"

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011snPXPafPC5i87o68H14W7
This commit is contained in:
dustin
2026-08-20 18:35:06 +02:00
co-authored by Claude Opus 5
parent 7aa98864aa
commit 1325badf90
13 changed files with 1020 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/main.dart
+15
View File
@@ -10,6 +10,7 @@ import 'library/library_service.dart';
import 'library/my_music_screen.dart';
import 'library/playlist_service.dart';
import 'library/search_screen.dart';
import 'player/audio_effects.dart';
import 'player/audio_handler.dart';
import 'player/mini_player.dart';
import 'services/logger_service.dart';
@@ -24,6 +25,7 @@ late final PlaylistService _playlists;
late final OfflineMode _offlineMode;
late final CategoryService _categories;
late final AppSettings _settings;
late final AudioEffects _effects;
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
@@ -45,6 +47,18 @@ Future<void> main() async {
androidShowNotificationBadge: true,
),
);
_effects = AudioEffects();
await _effects.init();
// Die Audio-Session steht erst beim Abspielen fest und kann wechseln —
// die Klangeffekte müssen dann neu daran gehängt werden.
_handler.androidAudioSessionIdStream.listen((id) {
if (id != null) _effects.attach(id);
});
_handler.autoPlayOnHeadphones = _settings.autoPlayOnHeadphones;
_settings.addListener(
() => _handler.autoPlayOnHeadphones = _settings.autoPlayOnHeadphones,
);
runApp(const MeloApp());
}
@@ -62,6 +76,7 @@ class MeloApp extends StatelessWidget {
ChangeNotifierProvider<OfflineMode>.value(value: _offlineMode),
ChangeNotifierProvider<CategoryService>.value(value: _categories),
ChangeNotifierProvider<AppSettings>.value(value: _settings),
ChangeNotifierProvider<AudioEffects>.value(value: _effects),
],
child: MaterialApp(
title: 'Melo',
lib/player/audio_effects.dart
+198
View File
@@ -0,0 +1,198 @@
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:shared_preferences/shared_preferences.dart';
/// Ein Equalizer-Band, wie es das Gerät meldet.
class EqBand {
const EqBand({required this.index, required this.centerHz, required this.level});
final int index;
/// Mittenfrequenz in Hz (Android liefert Milli-Hertz).
final int centerHz;
/// Pegel in Millibel.
final int level;
EqBand withLevel(int newLevel) =>
EqBand(index: index, centerHz: centerHz, level: newLevel);
/// "60Hz" bzw. "14.0kHz" — wie in der Vorlage.
String get label => centerHz >= 1000
? '${(centerHz / 1000).toStringAsFixed(1)}kHz'
: '${centerHz}Hz';
}
/// Steuert die nativen Android-Klangeffekte (Equalizer, Bass, Immersives
/// Audio) und merkt sich die Einstellungen über Neustarts hinweg.
///
/// Die Effekte hängen an der Audio-Session des Players. Die meldet just_audio
/// erst beim Abspielen und bei jedem Wechsel neu — deshalb [attach].
class AudioEffects extends ChangeNotifier {
AudioEffects({MethodChannel? channel})
: _channel = channel ?? const MethodChannel('de.baka.melo/audio_effects');
final MethodChannel _channel;
static const _keyEnabled = 'eq_aktiv';
static const _keyLevels = 'eq_pegel';
static const _keyBass = 'eq_bass';
static const _keyVirtualizer = 'eq_immersiv';
bool _enabled = false;
bool _available = false;
List<EqBand> _bands = const [];
List<String> _presets = const [];
int _minLevel = -1500;
int _maxLevel = 1500;
int _bass = 0;
int _virtualizer = 0;
bool _bassSupported = false;
bool _virtualizerSupported = false;
String? _error;
bool get enabled => _enabled;
/// Ob das Gerät die Effekte überhaupt bereitgestellt hat.
bool get available => _available;
List<EqBand> get bands => _bands;
List<String> get presets => _presets;
int get minLevel => _minLevel;
int get maxLevel => _maxLevel;
/// Bass-Stärke 0–1000 (Android-Skala).
int get bass => _bass;
/// Virtualizer-Stärke 0–1000 ("Immersives Audio").
int get virtualizer => _virtualizer;
bool get bassSupported => _bassSupported;
bool get virtualizerSupported => _virtualizerSupported;
String? get error => _error;
/// Lädt die gespeicherten Werte. Angewendet werden sie, sobald über
/// [attach] eine Audio-Session bekannt ist.
Future<void> init() async {
final prefs = await SharedPreferences.getInstance();
_enabled = prefs.getBool(_keyEnabled) ?? false;
_bass = prefs.getInt(_keyBass) ?? 0;
_virtualizer = prefs.getInt(_keyVirtualizer) ?? 0;
notifyListeners();
}
/// Verbindet die Effekte mit der Audio-Session [sessionId] und stellt die
/// gespeicherten Werte wieder her.
Future<void> attach(int sessionId) async {
try {
final config = await _channel
.invokeMapMethod<String, dynamic>('attach', {'sessionId': sessionId});
if (config == null) return;
_bands = [
for (final raw in (config['bands'] as List).cast<Map>())
EqBand(
index: raw['index'] as int,
// Android liefert Milli-Hertz.
centerHz: (raw['centerFrequencyMilliHz'] as int) ~/ 1000,
level: raw['level'] as int,
),
];
_presets = (config['presets'] as List).cast<String>();
_minLevel = config['minLevel'] as int;
_maxLevel = config['maxLevel'] as int;
_bassSupported = config['bassSupported'] as bool? ?? false;
_virtualizerSupported = config['virtualizerSupported'] as bool? ?? false;
_available = true;
_error = null;
await _restoreSavedLevels();
await setEnabled(_enabled);
await setBass(_bass);
await setVirtualizer(_virtualizer);
} on PlatformException catch (e) {
_available = false;
_error = e.message;
}
notifyListeners();
}
Future<void> setEnabled(bool value) async {
_enabled = value;
notifyListeners();
await _invoke('setEnabled', {'enabled': value});
final prefs = await SharedPreferences.getInstance();
await prefs.setBool(_keyEnabled, value);
}
Future<void> setBandLevel(int index, int level) async {
final clamped = level.clamp(_minLevel, _maxLevel);
_bands = [
for (final band in _bands)
band.index == index ? band.withLevel(clamped) : band,
];
notifyListeners();
await _invoke('setBandLevel', {'band': index, 'level': clamped});
await _saveLevels();
}
Future<void> usePreset(int preset) async {
final levels = await _invoke<List<Object?>>('usePreset', {'preset': preset});
if (levels != null && levels.length == _bands.length) {
_bands = [
for (var i = 0; i < _bands.length; i++)
_bands[i].withLevel(levels[i] as int),
];
notifyListeners();
await _saveLevels();
}
}
Future<void> setBass(int strength) async {
_bass = strength.clamp(0, 1000);
notifyListeners();
await _invoke('setBassStrength', {'strength': _bass});
final prefs = await SharedPreferences.getInstance();
await prefs.setInt(_keyBass, _bass);
}
Future<void> setVirtualizer(int strength) async {
_virtualizer = strength.clamp(0, 1000);
notifyListeners();
await _invoke('setVirtualizerStrength', {'strength': _virtualizer});
final prefs = await SharedPreferences.getInstance();
await prefs.setInt(_keyVirtualizer, _virtualizer);
}
/// Öffnet die Klangeffekte des Systems (auf POCO/Xiaomi Dolby Atmos).
/// Gibt false zurück, wenn das Gerät keine solche Oberfläche anbietet.
Future<bool> openSystemPanel() async {
return await _invoke<bool>('openSystemPanel', null) ?? false;
}
Future<void> _restoreSavedLevels() async {
final prefs = await SharedPreferences.getInstance();
final saved = prefs.getStringList(_keyLevels);
if (saved == null || saved.length != _bands.length) return;
for (var i = 0; i < _bands.length; i++) {
final level = int.tryParse(saved[i]);
if (level == null) continue;
_bands[i] = _bands[i].withLevel(level);
await _invoke('setBandLevel', {'band': _bands[i].index, 'level': level});
}
}
Future<void> _saveLevels() async {
final prefs = await SharedPreferences.getInstance();
await prefs.setStringList(
_keyLevels, [for (final b in _bands) b.level.toString()]);
}
Future<T?> _invoke<T>(String method, Map<String, dynamic>? args) async {
try {
return await _channel.invokeMethod<T>(method, args);
} on PlatformException catch (e) {
_error = e.message;
notifyListeners();
return null;
} on MissingPluginException {
// Kein Android (Tests, Desktop): Effekte gibt es dort nicht.
return null;
}
}
}
lib/player/audio_handler.dart
+29
View File
@@ -1,10 +1,12 @@
import 'dart:async';
import 'package:audio_service/audio_service.dart';
import 'package:audio_session/audio_session.dart';
import 'package:just_audio/just_audio.dart';
import '../library/database.dart';
import '../services/cache_manager.dart';
import '../services/navidrome_service.dart';
import 'headphone_autoplay.dart';
import 'sleep_timer.dart';
/// Entscheidet, ob eine gespeicherte Wiedergabeposition beim Laden
@@ -37,6 +39,10 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
final NavidromeService _nav = NavidromeService();
int? _lastCountedIndex;
/// Wiedergabe automatisch starten, sobald Kopfhörer verbunden werden.
/// Wird von den App-Einstellungen gesetzt.
bool autoPlayOnHeadphones = false;
MeloAudioHandler({required this.db}) {
_cache = CacheManager();
_cache.init();
@@ -71,6 +77,8 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
}
});
_watchHeadphones();
// Ermittelte Dauer nachtragen
_player.durationStream.listen((duration) {
final item = mediaItem.value;
@@ -80,6 +88,27 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
});
}
/// Startet die Wiedergabe, wenn Kopfhörer verbunden werden und der Nutzer
/// das in den Einstellungen erlaubt hat.
Future<void> _watchHeadphones() async {
final session = await AudioSession.instance;
session.devicesChangedEventStream.listen((event) {
final added = event.devicesAdded.map((d) => d.type).toSet();
if (shouldAutoPlay(
added: added,
enabled: autoPlayOnHeadphones,
hasQueue: queue.value.isNotEmpty,
playing: _player.playing,
)) {
play();
}
});
}
/// Audio-Session des Players — die Klangeffekte hängen daran.
Stream<int?> get androidAudioSessionIdStream =>
_player.androidAudioSessionIdStream;
/// Ersetzt die Warteschlange und startet ab [startIndex].
/// Auto-Caching: Streame von Server + speichere lokal gleichzeitig.
Future<void> loadPlaylist(List<MediaItem> items, {int startIndex = 0}) async {
lib/player/headphone_autoplay.dart
+22
View File
@@ -0,0 +1,22 @@
import 'package:audio_session/audio_session.dart';
/// Gerätetypen, die als "Kopfhörer" gelten — Klinke wie Bluetooth.
const _headphoneTypes = {
AudioDeviceType.wiredHeadset,
AudioDeviceType.wiredHeadphones,
AudioDeviceType.bluetoothA2dp,
AudioDeviceType.bluetoothSco,
};
/// Entscheidet, ob nach dem Verbinden von [added] automatisch abgespielt wird.
/// Nur wenn die Einstellung aktiv ist, etwas in der Warteschlange steht und
/// gerade nichts läuft — eine laufende Wiedergabe wird nie unterbrochen.
bool shouldAutoPlay({
required Set<AudioDeviceType> added,
required bool enabled,
required bool hasQueue,
required bool playing,
}) {
if (!enabled || !hasQueue || playing) return false;
return added.any(_headphoneTypes.contains);
}
lib/settings/equalizer_screen.dart
+313
View File
@@ -0,0 +1,313 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../player/audio_effects.dart';
import '../shared/theme.dart';
/// Equalizer-Bildschirm: Klangprofile, manuelle Bänder und die beiden
/// Drehregler für Bass und Immersives Audio.
class EqualizerScreen extends StatelessWidget {
const EqualizerScreen({super.key});
@override
Widget build(BuildContext context) {
final effects = context.watch<AudioEffects>();
return Scaffold(
appBar: AppBar(
title: const Text('Equalizer'),
actions: [
Padding(
padding: const EdgeInsets.only(right: 12),
child: Switch(
value: effects.enabled,
onChanged: effects.available ? effects.setEnabled : null,
),
),
],
),
body: !effects.available
? _NotAvailable(error: effects.error)
: Opacity(
opacity: effects.enabled ? 1 : 0.4,
child: IgnorePointer(
ignoring: !effects.enabled,
child: ListView(
padding: const EdgeInsets.fromLTRB(16, 8, 16, 32),
children: [
_Presets(effects: effects),
const SizedBox(height: 24),
const _SectionTitle('Manuelle Anpassung'),
const SizedBox(height: 8),
_Bands(effects: effects),
const SizedBox(height: 28),
const _SectionTitle('Sound verbessern'),
const Padding(
padding: EdgeInsets.only(top: 4, bottom: 12),
child: Row(
children: [
Icon(Icons.headphones, size: 14, color: Colors.white38),
SizedBox(width: 6),
Expanded(
child: Text(
'Kopfhörer aufsetzen, bevor du die Soundeffekte '
'einstellst',
style: TextStyle(
color: Colors.white38, fontSize: 12),
),
),
],
),
),
_Enhancers(effects: effects),
],
),
),
),
);
}
}
class _NotAvailable extends StatelessWidget {
const _NotAvailable({this.error});
final String? error;
@override
Widget build(BuildContext context) {
return Center(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 32),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
const Icon(Icons.graphic_eq, size: 64, color: Colors.white24),
const SizedBox(height: 12),
const Text(
'Der Equalizer ist erst verfügbar, wenn Musik läuft',
textAlign: TextAlign.center,
style: TextStyle(color: Colors.white54),
),
if (error != null) ...[
const SizedBox(height: 8),
Text(error!,
textAlign: TextAlign.center,
style: const TextStyle(color: Colors.white24, fontSize: 12)),
],
],
),
),
);
}
}
class _SectionTitle extends StatelessWidget {
const _SectionTitle(this.text);
final String text;
@override
Widget build(BuildContext context) {
return Text(text,
style: const TextStyle(fontSize: 20, fontWeight: FontWeight.w700));
}
}
class _Presets extends StatelessWidget {
const _Presets({required this.effects});
final AudioEffects effects;
@override
Widget build(BuildContext context) {
return Wrap(
spacing: 10,
runSpacing: 10,
children: [
for (var i = 0; i < effects.presets.length; i++)
SizedBox(
width: (MediaQuery.of(context).size.width - 32 - 20) / 3,
height: 64,
child: Material(
color: MeloTheme.surfaceHigh,
borderRadius: BorderRadius.circular(10),
child: InkWell(
borderRadius: BorderRadius.circular(10),
onTap: () => effects.usePreset(i),
child: Center(
child: Text(effects.presets[i],
textAlign: TextAlign.center,
maxLines: 2,
overflow: TextOverflow.ellipsis),
),
),
),
),
],
);
}
}
class _Bands extends StatelessWidget {
const _Bands({required this.effects});
final AudioEffects effects;
@override
Widget build(BuildContext context) {
return Row(
crossAxisAlignment: CrossAxisAlignment.end,
children: [
for (final band in effects.bands)
Expanded(
child: Column(
children: [
SizedBox(
height: 200,
child: RotatedBox(
quarterTurns: 3,
child: Slider(
value: band.level
.clamp(effects.minLevel, effects.maxLevel)
.toDouble(),
min: effects.minLevel.toDouble(),
max: effects.maxLevel.toDouble(),
onChanged: (v) =>
effects.setBandLevel(band.index, v.round()),
),
),
),
Text(band.label,
style:
const TextStyle(color: Colors.white54, fontSize: 11)),
Text('${(band.level / 100).round()}',
style:
const TextStyle(color: Colors.white38, fontSize: 11)),
],
),
),
],
);
}
}
class _Enhancers extends StatelessWidget {
const _Enhancers({required this.effects});
final AudioEffects effects;
@override
Widget build(BuildContext context) {
return Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
Knob(
label: 'Bass',
value: effects.bass / 1000,
enabled: effects.bassSupported,
onChanged: (v) => effects.setBass((v * 1000).round()),
),
Knob(
label: 'Immersives Audio',
value: effects.virtualizer / 1000,
enabled: effects.virtualizerSupported,
onChanged: (v) => effects.setVirtualizer((v * 1000).round()),
),
],
);
}
}
/// Drehregler wie in der Vorlage: senkrecht wischen regelt von 0 bis 1.
class Knob extends StatelessWidget {
const Knob({
super.key,
required this.label,
required this.value,
required this.onChanged,
this.enabled = true,
});
final String label;
final double value;
final ValueChanged<double> onChanged;
final bool enabled;
static const _size = 120.0;
@override
Widget build(BuildContext context) {
return Opacity(
opacity: enabled ? 1 : 0.4,
child: Column(
children: [
GestureDetector(
onVerticalDragUpdate: enabled
// Ein voller Ausschlag entspricht ~200 Pixel Wischweg.
? (d) => onChanged((value - d.delta.dy / 200).clamp(0.0, 1.0))
: null,
child: CustomPaint(
size: const Size(_size, _size),
painter: _KnobPainter(value),
),
),
const SizedBox(height: 8),
Text(label,
style: const TextStyle(color: Colors.white54, fontSize: 12)),
Text('${(value * 100).round()}',
style: const TextStyle(color: Colors.white38, fontSize: 11)),
],
),
);
}
}
class _KnobPainter extends CustomPainter {
_KnobPainter(this.value);
final double value;
/// Der Regelbereich läuft von unten links (135°) über 270° nach unten rechts.
static const _start = math.pi * 0.75;
static const _sweep = math.pi * 1.5;
static const _dots = 24;
@override
void paint(Canvas canvas, Size size) {
final center = Offset(size.width / 2, size.height / 2);
final radius = size.width / 2;
for (var i = 0; i < _dots; i++) {
final t = i / (_dots - 1);
final angle = _start + _sweep * t;
final active = t <= value;
canvas.drawCircle(
center + Offset(math.cos(angle), math.sin(angle)) * (radius - 5),
active ? 3.5 : 2.5,
Paint()..color = active ? MeloTheme.red : Colors.white24,
);
}
canvas.drawCircle(
center,
radius - 16,
Paint()..color = MeloTheme.surfaceHigh,
);
canvas.drawCircle(
center,
radius - 16,
Paint()
..style = PaintingStyle.stroke
..strokeWidth = 1
..color = Colors.white12,
);
final pointer = _start + _sweep * value;
canvas.drawLine(
center + Offset(math.cos(pointer), math.sin(pointer)) * (radius - 46),
center + Offset(math.cos(pointer), math.sin(pointer)) * (radius - 22),
Paint()
..color = Colors.white
..strokeWidth = 2
..strokeCap = StrokeCap.round,
);
}
@override
bool shouldRepaint(_KnobPainter oldDelegate) => oldDelegate.value != value;
}
lib/settings/settings_screen.dart
+45
View File
@@ -9,7 +9,9 @@ import '../services/cache_manager.dart';
import '../services/logger_service.dart';
import '../services/navidrome_service.dart';
import '../services/offline_mode.dart';
import '../player/audio_effects.dart';
import 'app_settings.dart';
import 'equalizer_screen.dart';
import 'library_stats.dart';
/// Settings-Tab: Bibliotheks-Statistik, Berechtigungen, Navidrome, Über Melo.
@@ -37,6 +39,21 @@ class _SettingsScreenState extends State<SettingsScreen> {
if (mounted) setState(() => _cacheSize = size);
}
/// Öffnet die Klangeffekt-Oberfläche des Systems (auf POCO/Xiaomi ist das
/// Dolby Atmos). Nicht jedes Gerät bietet sie an.
Future<void> _oeffneSystemKlangeffekte(BuildContext context) async {
final effects = context.read<AudioEffects>();
final messenger = ScaffoldMessenger.of(context);
final geoeffnet = await effects.openSystemPanel();
if (!geoeffnet) {
messenger.showSnackBar(
const SnackBar(
content: Text('Dieses Gerät bietet keine System-Klangeffekte an'),
),
);
}
}
@override
Widget build(BuildContext context) {
final db = context.read<MeloDb>();
@@ -89,6 +106,34 @@ class _SettingsScreenState extends State<SettingsScreen> {
},
),
const Divider(height: 1),
const _SectionLabel('Ton'),
ListTile(
leading: const Icon(Icons.graphic_eq),
title: const Text('Equalizer'),
subtitle: const Text('Klangprofile, Bass und Immersives Audio'),
trailing: const Icon(Icons.chevron_right),
onTap: () => Navigator.of(context).push(
MaterialPageRoute(builder: (_) => const EqualizerScreen()),
),
),
ListTile(
leading: const Icon(Icons.surround_sound),
title: const Text('Dolby Atmos'),
subtitle: const Text('Klangeffekte des Systems öffnen'),
trailing: const Icon(Icons.open_in_new),
onTap: () => _oeffneSystemKlangeffekte(context),
),
Consumer<AppSettings>(
builder: (context, settings, _) => SwitchListTile(
secondary: const Icon(Icons.headset),
title: const Text('Automatische Wiedergabe'),
subtitle: const Text(
'Startet, sobald Kopfhörer verbunden werden (auch Bluetooth)'),
value: settings.autoPlayOnHeadphones,
onChanged: settings.setAutoPlayOnHeadphones,
),
),
const Divider(height: 1),
const _SectionLabel('Darstellung'),
Consumer<AppSettings>(
builder: (context, settings, _) => SwitchListTile(