Adds Apple airplay/Google cast support to the app

2026-05-14 22:02:37 -07:00
parent 3bb2630e1a
commit c9ef69c8b5
10 changed files with 979 additions and 17 deletions
@@ -1,7 +1,9 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/foundation.dart';
 import 'package:just_audio_background/just_audio_background.dart';
 import 'package:flutter/services.dart';
 import 'app_theme_business_object.dart';
+import 'casting_business_object.dart';
 import 'live_info_business_object.dart';
 import 'live_info_panel.dart';
 import 'streaming_audio_business_object.dart';
@@ -32,9 +34,17 @@ class MyApp extends StatefulWidget {

 class _MyAppState extends State<MyApp> {
  final StreamingAudioBusinessObject _audio = StreamingAudioBusinessObject();
+  final CastingBusinessObject _casting = CastingBusinessObject();
+
+  @override
+  void initState() {
+    super.initState();
+    _casting.initialize();
+  }

  @override
  void dispose() {
+    _casting.dispose();
    _audio.dispose();
    super.dispose();
  }
@@ -46,16 +56,21 @@ class _MyAppState extends State<MyApp> {
      theme: AppThemeBusinessObject.lightTheme(),
      darkTheme: AppThemeBusinessObject.darkTheme(),
      themeMode: ThemeMode.system,
-      home: MainPage(audio: _audio),
+      home: MainPage(audio: _audio, casting: _casting),
      debugShowCheckedModeBanner: false,
    );
  }
 }

 class MainPage extends StatefulWidget {
-  const MainPage({super.key, required this.audio});
+  const MainPage({
+    super.key,
+    required this.audio,
+    required this.casting,
+  });

  final StreamingAudioBusinessObject audio;
+  final CastingBusinessObject casting;

  @override
  State<MainPage> createState() => _MainPageState();
@@ -63,24 +78,61 @@ class MainPage extends StatefulWidget {

 class _MainPageState extends State<MainPage> {
  StreamingAudioBusinessObject get _audio => widget.audio;
+  CastingBusinessObject get _casting => widget.casting;
  final LiveInfoBusinessObject _liveInfo = LiveInfoBusinessObject();
  static const List<int> _intervalOptions = <int>[5, 10, 15, 30, 60];
+  bool _castStreamStartedForActiveSession = false;
+  bool _isStartingCastStream = false;
+  bool _pendingRemotePlay = false;
+
+  bool get _usesExternalCastPlayback =>
+      _casting.isConnected && defaultTargetPlatform == TargetPlatform.android;
+
+  bool get _isIosAirPlay => defaultTargetPlatform == TargetPlatform.iOS;
+
+  bool get _isUsingRemotePlayback => _usesExternalCastPlayback;
+
+  bool get _isPlaybackStopped {
+    if (_isUsingRemotePlayback) {
+      return _casting.isStopped || _casting.playbackStatus == CastingPlaybackStatus.unknown;
+    }
+
+    return _audio.isStopped;
+  }
+
+  bool get _isPlaybackPlaying {
+    if (_isUsingRemotePlayback) {
+      return _casting.isPlaying;
+    }
+
+    return _audio.isPlaying;
+  }
+
+  bool get _isPlaybackBuffering {
+    if (_isUsingRemotePlayback) {
+      return _casting.isBuffering;
+    }
+
+    return _audio.isBuffering;
+  }

  String _playbackStatusLabel() {
-    switch (_audio.playbackStatus) {
-      case StreamingPlaybackStatus.stopped:
-        return 'Stopped';
-      case StreamingPlaybackStatus.buffering:
-        return 'Buffering...';
-      case StreamingPlaybackStatus.playing:
-        return 'Playing';
+    if (_isPlaybackBuffering) {
+      return 'Buffering...';
    }
+
+    if (_isPlaybackPlaying) {
+      return 'Playing';
+    }
+
+    return 'Stopped';
  }

  @override
  void initState() {
    super.initState();
    _audio.addListener(_handleAudioStateChanged);
+    _casting.addListener(_handleCastingStateChanged);
    _liveInfo.addListener(_handleLiveInfoChanged);
    _liveInfo.start();
  }
@@ -105,17 +157,127 @@ class _MainPageState extends State<MainPage> {
    });
  }

+  void _handleCastingStateChanged() {
+    if (
+        _usesExternalCastPlayback &&
+        (!_castStreamStartedForActiveSession || _pendingRemotePlay) &&
+        !_isStartingCastStream) {
+      _startCastingLiveStream();
+    }
+
+    if (!_usesExternalCastPlayback) {
+      _castStreamStartedForActiveSession = false;
+      _isStartingCastStream = false;
+      _pendingRemotePlay = false;
+    }
+
+    if (!mounted) {
+      return;
+    }
+
+    setState(() {
+      // Rebuild when cast state changes from the native platforms.
+    });
+  }
+
+  Future<void> _startCastingLiveStream() async {
+    _isStartingCastStream = true;
+
+    try {
+      await _casting.startCastingLiveStream(
+        streamUrl: _audio.streamUrl,
+        title: 'KRYZ Live Stream',
+        subtitle: 'KRYZ Radio',
+      );
+
+      _castStreamStartedForActiveSession = true;
+      _pendingRemotePlay = false;
+
+      if (_usesExternalCastPlayback && !_audio.isStopped) {
+        await _audio.stop();
+      }
+    } catch (_) {
+      _castStreamStartedForActiveSession = false;
+      // State is already updated by the casting business object.
+    } finally {
+      _isStartingCastStream = false;
+    }
+  }
+
  Future<void> _play() async {
+    if (_usesExternalCastPlayback) {
+      if (_casting.isPlaying || _isStartingCastStream) {
+        return;
+      }
+
+      await _startCastingLiveStream();
+      return;
+    }
+
+    if (_usesExternalCastPlayback && _casting.status == CastingStatus.connecting) {
+      _pendingRemotePlay = true;
+      return;
+    }
+
    await _audio.play();
  }

  Future<void> _stop() async {
+    if (_usesExternalCastPlayback) {
+      await _casting.stopPlayback();
+      return;
+    }
+
    await _audio.stop();
  }

+  Future<void> _toggleCasting() async {
+    if (_casting.isConnected) {
+      await _casting.disconnect();
+      return;
+    }
+
+    await _casting.showDevicePicker();
+  }
+
+  String _castingLabel() {
+    final idleLabel = _isIosAirPlay ? 'AirPlay' : 'Cast';
+    final connectingLabel = _isIosAirPlay ? 'AirPlay...' : 'Casting...';
+    final errorLabel = _isIosAirPlay ? 'AirPlay Error' : 'Cast Error';
+    final unavailableLabel = _isIosAirPlay ? 'No AirPlay' : 'No Cast';
+
+    switch (_casting.status) {
+      case CastingStatus.idle:
+        return idleLabel;
+      case CastingStatus.connecting:
+        return connectingLabel;
+      case CastingStatus.connected:
+        final deviceName = _casting.connectedDeviceName;
+        if (deviceName != null && deviceName.isNotEmpty) {
+          return 'On $deviceName';
+        }
+        return _isIosAirPlay ? 'AirPlaying' : 'Casting';
+      case CastingStatus.error:
+        return errorLabel;
+      case CastingStatus.unavailable:
+        return unavailableLabel;
+    }
+  }
+
+  IconData _castingIcon() {
+    if (_isIosAirPlay) {
+      return Icons.airplay_rounded;
+    }
+
+    return _casting.isConnected
+        ? Icons.cast_connected_rounded
+        : Icons.cast_rounded;
+  }
+
  @override
  void dispose() {
    _audio.removeListener(_handleAudioStateChanged);
+    _casting.removeListener(_handleCastingStateChanged);
    _liveInfo.removeListener(_handleLiveInfoChanged);
    _liveInfo.dispose();
    super.dispose();
@@ -225,15 +387,24 @@ class _MainPageState extends State<MainPage> {
                    runSpacing: 12,
                    children: [
                      ElevatedButton.icon(
-                        onPressed: _audio.isStopped ? _play : null,
+                        onPressed: _isPlaybackStopped ? _play : null,
                        icon: const Icon(Icons.play_arrow_rounded),
                        label: const Text('Play'),
                      ),
                      ElevatedButton.icon(
-                        onPressed: _audio.isStopped ? null : _stop,
+                        onPressed: _isPlaybackStopped ? null : _stop,
                        icon: const Icon(Icons.stop_rounded),
                        label: const Text('Stop'),
                      ),
+                      ElevatedButton.icon(
+                        onPressed:
+                            _casting.status == CastingStatus.connecting ||
+                                _casting.status == CastingStatus.unavailable
+                            ? null
+                            : _toggleCasting,
+                        icon: Icon(_castingIcon()),
+                        label: Text(_castingLabel()),
+                      ),
                      Text(
                        _playbackStatusLabel(),
                        style: theme.textTheme.titleSmall?.copyWith(