397 lines
13 KiB
Dart
397 lines
13 KiB
Dart
import 'dart:async';
|
|
import 'dart:io' show File, Platform;
|
|
|
|
import 'package:dio/dio.dart';
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:just_audio/just_audio.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
import '../../../core/services/api_service.dart';
|
|
import '../../../l10n/app_localizations.dart';
|
|
import '../../../shared/theme/theme_extensions.dart';
|
|
|
|
/// A dialog for playing audio files.
|
|
class AudioPlayerDialog extends StatefulWidget {
|
|
/// The file ID for downloading.
|
|
final String fileId;
|
|
|
|
/// The API service for authenticated requests.
|
|
final ApiService api;
|
|
|
|
/// The file name to display.
|
|
final String fileName;
|
|
|
|
const AudioPlayerDialog({
|
|
super.key,
|
|
required this.fileId,
|
|
required this.api,
|
|
required this.fileName,
|
|
});
|
|
|
|
/// Shows the audio player dialog.
|
|
static Future<void> show(
|
|
BuildContext context, {
|
|
required String fileId,
|
|
required ApiService api,
|
|
required String fileName,
|
|
}) {
|
|
return showDialog(
|
|
context: context,
|
|
builder: (context) => AudioPlayerDialog(
|
|
fileId: fileId,
|
|
api: api,
|
|
fileName: fileName,
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
State<AudioPlayerDialog> createState() => _AudioPlayerDialogState();
|
|
}
|
|
|
|
class _AudioPlayerDialogState extends State<AudioPlayerDialog> {
|
|
final AudioPlayer _player = AudioPlayer();
|
|
|
|
bool _isPlaying = false;
|
|
bool _isLoading = true;
|
|
bool _hasError = false;
|
|
Duration _position = Duration.zero;
|
|
Duration _duration = Duration.zero;
|
|
File? _tempFile;
|
|
|
|
StreamSubscription<PlayerState>? _stateSub;
|
|
StreamSubscription<Duration>? _positionSub;
|
|
StreamSubscription<Duration?>? _durationSub;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_setupPlayer();
|
|
}
|
|
|
|
Future<void> _setupPlayer() async {
|
|
try {
|
|
// Get file info first to determine the correct extension
|
|
final fileInfo = await widget.api.getFileInfo(widget.fileId);
|
|
final filename = fileInfo['filename'] as String? ?? 'audio.m4a';
|
|
final contentType = (fileInfo['meta'] as Map<String, dynamic>?)?['content_type'] as String?;
|
|
|
|
debugPrint('AudioPlayerDialog: filename=$filename, contentType=$contentType');
|
|
debugPrint('AudioPlayerDialog: fileInfo=$fileInfo');
|
|
|
|
// Extract extension from filename
|
|
final extension = filename.contains('.')
|
|
? filename.substring(filename.lastIndexOf('.'))
|
|
: '.m4a';
|
|
|
|
// Download the file (requires authentication)
|
|
// Use timestamp suffix to prevent conflicts if same file opened multiple times
|
|
final tempDir = await getTemporaryDirectory();
|
|
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
|
final tempPath = '${tempDir.path}/audio_${widget.fileId}_$timestamp$extension';
|
|
_tempFile = File(tempPath);
|
|
|
|
// Fetch file content through API (authenticated)
|
|
final response = await widget.api.dio.get(
|
|
'/api/v1/files/${widget.fileId}/content',
|
|
options: Options(responseType: ResponseType.bytes),
|
|
);
|
|
|
|
final responseData = response.data;
|
|
if (responseData is! List<int>) {
|
|
throw Exception('Unexpected response type: ${responseData.runtimeType}');
|
|
}
|
|
final bytes = responseData;
|
|
debugPrint('AudioPlayerDialog: Downloaded ${bytes.length} bytes');
|
|
debugPrint('AudioPlayerDialog: First 20 bytes: ${bytes.take(20).toList()}');
|
|
debugPrint('AudioPlayerDialog: Response content-type: ${response.headers.value('content-type')}');
|
|
|
|
await _tempFile!.writeAsBytes(bytes);
|
|
debugPrint('AudioPlayerDialog: Saved to $tempPath');
|
|
|
|
// Setup player state listeners
|
|
_stateSub = _player.playerStateStream.listen((state) {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_isPlaying = state.playing;
|
|
if (state.processingState == ProcessingState.completed) {
|
|
_isPlaying = false;
|
|
_position = _duration;
|
|
}
|
|
});
|
|
});
|
|
|
|
_positionSub = _player.positionStream.listen((pos) {
|
|
if (!mounted) return;
|
|
setState(() => _position = pos);
|
|
});
|
|
|
|
_durationSub = _player.durationStream.listen((dur) {
|
|
if (!mounted) return;
|
|
if (dur != null) {
|
|
setState(() {
|
|
_duration = dur;
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
});
|
|
|
|
// Load and play the file
|
|
await _player.setFilePath(_tempFile!.path);
|
|
|
|
if (mounted) {
|
|
setState(() => _isLoading = false);
|
|
}
|
|
|
|
await _player.play();
|
|
} catch (e) {
|
|
debugPrint('AudioPlayerDialog: Error loading audio: $e');
|
|
// Clean up temp file on error to avoid orphaned files
|
|
_tempFile?.delete().then((_) {
|
|
debugPrint('AudioPlayerDialog: Cleaned up temp file after error');
|
|
}).catchError((e) {
|
|
debugPrint('AudioPlayerDialog: Failed to clean up temp file after error: $e');
|
|
});
|
|
_tempFile = null;
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_hasError = true;
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
Future<void> _togglePlayPause() async {
|
|
if (_isPlaying) {
|
|
await _player.pause();
|
|
} else {
|
|
// If at end, restart from beginning
|
|
if (_position >= _duration && _duration > Duration.zero) {
|
|
await _player.seek(Duration.zero);
|
|
}
|
|
await _player.play();
|
|
}
|
|
}
|
|
|
|
Future<void> _seekTo(double value) async {
|
|
final position = Duration(milliseconds: (value * _duration.inMilliseconds).round());
|
|
await _player.seek(position);
|
|
}
|
|
|
|
String _formatDuration(Duration duration) {
|
|
final minutes = duration.inMinutes.toString().padLeft(2, '0');
|
|
final seconds = (duration.inSeconds % 60).toString().padLeft(2, '0');
|
|
return '$minutes:$seconds';
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_stateSub?.cancel();
|
|
_positionSub?.cancel();
|
|
_durationSub?.cancel();
|
|
// AudioPlayer.dispose() is async but Flutter's dispose() is sync.
|
|
// Fire-and-forget is acceptable here as just_audio handles cleanup internally.
|
|
unawaited(_player.dispose());
|
|
// Clean up temp file (fire and forget, log errors for debugging)
|
|
_tempFile?.delete().then((_) {
|
|
debugPrint('AudioPlayerDialog: Cleaned up temp file');
|
|
}).catchError((e) {
|
|
debugPrint('AudioPlayerDialog: Failed to clean up temp file: $e');
|
|
});
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = context.conduitTheme;
|
|
final l10n = AppLocalizations.of(context)!;
|
|
|
|
final progress = _duration.inMilliseconds > 0
|
|
? (_position.inMilliseconds / _duration.inMilliseconds).clamp(0.0, 1.0)
|
|
: 0.0;
|
|
|
|
return Dialog(
|
|
backgroundColor: theme.surfaceContainer,
|
|
shape: RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.circular(AppBorderRadius.lg),
|
|
),
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(Spacing.lg),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
// Header
|
|
Row(
|
|
children: [
|
|
Container(
|
|
width: 48,
|
|
height: 48,
|
|
decoration: BoxDecoration(
|
|
color: Colors.orange.withValues(alpha: 0.15),
|
|
borderRadius: BorderRadius.circular(AppBorderRadius.md),
|
|
),
|
|
child: Icon(
|
|
Platform.isIOS
|
|
? CupertinoIcons.waveform
|
|
: Icons.audio_file_rounded,
|
|
color: Colors.orange,
|
|
size: IconSize.lg,
|
|
),
|
|
),
|
|
const SizedBox(width: Spacing.md),
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
widget.fileName,
|
|
style: AppTypography.bodyMediumStyle.copyWith(
|
|
color: theme.textPrimary,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
maxLines: 2,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
Text(
|
|
l10n.audioAttachment,
|
|
style: AppTypography.captionStyle.copyWith(
|
|
color: theme.textSecondary,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
IconButton(
|
|
icon: Icon(
|
|
Platform.isIOS ? CupertinoIcons.xmark : Icons.close,
|
|
color: theme.textSecondary,
|
|
),
|
|
onPressed: () => Navigator.pop(context),
|
|
),
|
|
],
|
|
),
|
|
|
|
const SizedBox(height: Spacing.xl),
|
|
|
|
// Error state
|
|
if (_hasError)
|
|
Column(
|
|
children: [
|
|
Icon(
|
|
Platform.isIOS
|
|
? CupertinoIcons.exclamationmark_circle
|
|
: Icons.error_outline,
|
|
color: theme.error,
|
|
size: 48,
|
|
),
|
|
const SizedBox(height: Spacing.md),
|
|
Text(
|
|
l10n.failedToLoadAudio,
|
|
style: AppTypography.bodyMediumStyle.copyWith(
|
|
color: theme.error,
|
|
),
|
|
),
|
|
],
|
|
)
|
|
// Loading state
|
|
else if (_isLoading)
|
|
Column(
|
|
children: [
|
|
SizedBox(
|
|
width: 48,
|
|
height: 48,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 3,
|
|
valueColor: AlwaysStoppedAnimation(theme.buttonPrimary),
|
|
),
|
|
),
|
|
const SizedBox(height: Spacing.md),
|
|
Text(
|
|
l10n.loadingAudio,
|
|
style: AppTypography.bodyMediumStyle.copyWith(
|
|
color: theme.textSecondary,
|
|
),
|
|
),
|
|
],
|
|
)
|
|
// Player controls
|
|
else ...[
|
|
// Progress slider
|
|
SliderTheme(
|
|
data: SliderThemeData(
|
|
trackHeight: 4,
|
|
thumbShape: const RoundSliderThumbShape(enabledThumbRadius: 6),
|
|
activeTrackColor: Colors.orange,
|
|
inactiveTrackColor: theme.surfaceContainerHighest,
|
|
thumbColor: Colors.orange,
|
|
overlayColor: Colors.orange.withValues(alpha: 0.2),
|
|
),
|
|
child: Slider(
|
|
value: progress,
|
|
onChanged: _seekTo,
|
|
),
|
|
),
|
|
|
|
// Time display
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: Spacing.sm),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Text(
|
|
_formatDuration(_position),
|
|
style: AppTypography.captionStyle.copyWith(
|
|
color: theme.textSecondary,
|
|
),
|
|
),
|
|
Text(
|
|
_formatDuration(_duration),
|
|
style: AppTypography.captionStyle.copyWith(
|
|
color: theme.textSecondary,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
|
|
const SizedBox(height: Spacing.md),
|
|
|
|
// Play/Pause button
|
|
GestureDetector(
|
|
onTap: _togglePlayPause,
|
|
child: Container(
|
|
width: 64,
|
|
height: 64,
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
color: Colors.orange,
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: Colors.orange.withValues(alpha: 0.3),
|
|
blurRadius: 12,
|
|
spreadRadius: 2,
|
|
),
|
|
],
|
|
),
|
|
child: Icon(
|
|
_isPlaying
|
|
? (Platform.isIOS
|
|
? CupertinoIcons.pause_fill
|
|
: Icons.pause_rounded)
|
|
: (Platform.isIOS
|
|
? CupertinoIcons.play_fill
|
|
: Icons.play_arrow_rounded),
|
|
color: Colors.white,
|
|
size: 32,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|