car-interface-android/test/system_controller_test.dart

import 'package:cardash_launcher/data/models/app_entry.dart';
import 'package:cardash_launcher/data/models/media_playback.dart';
import 'package:cardash_launcher/data/models/update_info.dart';
import 'package:cardash_launcher/data/models/system_status.dart';
import 'package:cardash_launcher/data/services/native_bridge.dart';
import 'package:cardash_launcher/features/home/system_controller.dart';
import 'package:flutter_test/flutter_test.dart';

class _MediaPlatform implements LauncherPlatform {
  bool playing = false;
  bool applyWrites = false;
  MediaPlayback media = const MediaPlayback();
  VolumeInfo volume = const VolumeInfo(index: 8, max: 15);
  final List<String> keys = [];
  final List<int> volumeWrites = [];

  @override
  Future<List<AppEntry>> listApps() async => const [];

  @override
  Future<void> launchApp({
    required String packageName,
    required String activityName,
  }) async {}

  @override
  Future<bool> isDefaultHome() async => true;

  @override
  Future<bool> requestDefaultHome() async => true;

  @override
  Future<SystemStatus> getStatus() async => const SystemStatus();

  @override
  Future<VolumeInfo> getVolume() async => volume;

  @override
  Future<void> setVolume(int index) async {
    volumeWrites.add(index);
    if (applyWrites) {
      volume = volume.copyWith(index: index);
    }
  }

  @override
  Future<bool> isMusicPlaying() async => playing;

  @override
  Future<bool> sendMediaKey(String action) async {
    keys.add(action);
    if (action == 'play') playing = true;
    if (action == 'pause') playing = false;
    return true;
  }

  @override
  Future<MediaPlayback> getMediaState() async => media;

  @override
  Future<bool> openNotificationAccessSettings() async => true;

  @override
  Future<void> setKeepScreenOn(bool enabled) async {}

  @override
  Future<bool> openUrl(String url) async => true;

  @override
  Future<UpdateInstallResult> downloadAndInstallUpdate(String url) async {
    return const UpdateInstallResult(
      started: false,
      permissionRequired: false,
      message: 'not started',
    );
  }
}

void main() {
  test('pause sends the pause key and clears playing state', () async {
    final platform = _MediaPlatform()..playing = true;
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    expect(controller.isMusicPlaying, isTrue);
    await controller.pauseMusic();
    expect(platform.keys, contains('pause'));
    expect(controller.isMusicPlaying, isFalse);
    controller.stop();
  });

  test('media state supplies the title, progress and playing flag', () async {
    final platform = _MediaPlatform()
      ..media = const MediaPlayback(
        hasAccess: true,
        hasSession: true,
        playing: true,
        title: 'Night Drive',
        artist: 'The Dashboard',
        durationMs: 240000,
        positionMs: 60000,
      );
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    expect(controller.hasMediaAccess, isTrue);
    expect(controller.media.displayTitle, 'Night Drive — The Dashboard');
    expect(controller.media.progress, 0.25);
    expect(controller.isMusicPlaying, isTrue);
    controller.stop();
  });

  test('play resumes and reports whether audio started', () async {
    final platform = _MediaPlatform();
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    expect(controller.isMusicPlaying, isFalse);
    expect(await controller.playMusic(), isTrue);
    expect(platform.keys, contains('play'));
    expect(controller.isMusicPlaying, isTrue);
    controller.stop();
  });

  test('fixed car volume ignores software volume changes', () async {
    final platform = _MediaPlatform()
      ..volume = const VolumeInfo(index: 100, max: 100, fixed: true);
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    expect(controller.isVolumeFixed, isTrue);
    await controller.setVolume(25);
    await controller.toggleMute();

    expect(platform.volumeWrites, isEmpty);
    expect(controller.volume.index, 100);
    controller.stop();
  });

  test('a rejected volume write keeps the requested level', () async {
    final platform = _MediaPlatform()
      ..volume = const VolumeInfo(
        index: 100,
        max: 100,
        streams: {'music': 100, 'system': 8},
      );
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    await controller.setVolume(25);

    expect(platform.volumeWrites, contains(25));
    expect(controller.volume.index, 25);
    expect(controller.volumeUnconfirmed, isFalse);

    controller.toggleVolumeDiagnostics();
    expect(controller.volumeDiagnostics, contains('25 -> 100'));
    expect(controller.volumeDiagnostics, contains('music 100'));

    controller.toggleVolumeDiagnostics();
    expect(controller.volumeDiagnostics, isNull);
    controller.stop();
  });

  test('a confirmed volume write adopts the car level', () async {
    final platform = _MediaPlatform()
      ..applyWrites = true
      ..volume = const VolumeInfo(index: 8, max: 15);
    final controller = SystemController(platform);
    await controller.start();
    addTearDown(controller.dispose);

    await controller.setVolume(3);

    expect(platform.volumeWrites, contains(3));
    expect(controller.volume.index, 3);
    expect(controller.volumeUnconfirmed, isFalse);
    controller.stop();
  });
}