car-interface-android/lib/features/home/system_controller.dart

import 'dart:async';

import 'package:flutter/foundation.dart';

import '../../data/models/system_status.dart';
import '../../data/services/native_bridge.dart';

/// Polls the system for battery, Wi-Fi, media volume and media activity.
///
/// Polling keeps the app free of long-lived broadcast receivers and works
/// identically on Android 10 and 15. Timers are stopped while the launcher is
/// in the background.
class SystemController extends ChangeNotifier {
  SystemController(this._platform);

  final LauncherPlatform _platform;

  SystemStatus _status = const SystemStatus();
  VolumeInfo _volume = const VolumeInfo();
  Timer? _volumeTimer;
  Timer? _statusTimer;
  bool _active = false;
  bool _volumeBusy = false;
  bool _statusBusy = false;
  bool _musicBusy = false;
  bool _musicPlaying = false;
  bool _disposed = false;
  int _lastNonZeroVolume = 0;

  SystemStatus get status => _status;
  VolumeInfo get volume => _volume;
  int get volumePercent => _volume.percent;
  bool get isMuted => _volume.index <= 0;
  bool get isMusicPlaying => _musicPlaying;

  Future<void> start() async {
    if (_active) return;
    _active = true;
    await refreshAll();
    _volumeTimer = Timer.periodic(const Duration(milliseconds: 900), (_) {
      _pollVolume();
      _pollMusic();
    });
    _statusTimer = Timer.periodic(
      const Duration(seconds: 20),
      (_) => _pollStatus(),
    );
  }

  void stop() {
    _active = false;
    _volumeTimer?.cancel();
    _volumeTimer = null;
    _statusTimer?.cancel();
    _statusTimer = null;
  }

  Future<void> refreshAll() async {
    await Future.wait([_pollVolume(), _pollStatus(), _pollMusic()]);
  }

  Future<void> _pollVolume() async {
    if (_volumeBusy || !_active) return;
    _volumeBusy = true;
    try {
      final next = await _platform.getVolume();
      if (next.index != _volume.index || next.max != _volume.max) {
        _volume = next;
        if (next.index > 0) _lastNonZeroVolume = next.index;
        _notify();
      }
    } finally {
      _volumeBusy = false;
    }
  }

  Future<void> _pollMusic() async {
    if (_musicBusy || !_active) return;
    _musicBusy = true;
    try {
      final playing = await _platform.isMusicPlaying();
      if (playing != _musicPlaying) {
        _musicPlaying = playing;
        _notify();
      }
    } finally {
      _musicBusy = false;
    }
  }

  Future<void> _pollStatus() async {
    if (_statusBusy) return;
    _statusBusy = true;
    try {
      final next = await _platform.getStatus();
      if (next.batteryLevel != _status.batteryLevel ||
          next.charging != _status.charging ||
          next.wifi != _status.wifi) {
        _status = next;
        _notify();
      }
    } finally {
      _statusBusy = false;
    }
  }

  Future<void> setVolume(int index) async {
    final max = _volume.max <= 0 ? 15 : _volume.max;
    final clamped = index.clamp(0, max);
    _volume = VolumeInfo(index: clamped, max: max);
    if (clamped > 0) _lastNonZeroVolume = clamped;
    _notify();
    await _platform.setVolume(clamped);
  }

  Future<void> adjustVolume(int delta) => setVolume(_volume.index + delta);

  Future<void> toggleMute() async {
    if (_volume.index > 0) {
      _lastNonZeroVolume = _volume.index;
      await setVolume(0);
    } else {
      final restore = _lastNonZeroVolume > 0
          ? _lastNonZeroVolume
          : (_volume.max <= 0
                ? 1
                : (_volume.max / 2).round().clamp(1, _volume.max));
      await setVolume(restore);
    }
  }

  void _notify() {
    if (!_disposed) notifyListeners();
  }

  @override
  void dispose() {
    _disposed = true;
    stop();
    super.dispose();
  }
}