699 lines
21 KiB
Dart
699 lines
21 KiB
Dart
import 'dart:io';
|
|
|
|
import 'package:cached_network_image/cached_network_image.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
|
import 'package:flutter_lucide/flutter_lucide.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:image_picker/image_picker.dart';
|
|
import 'package:video_player/video_player.dart';
|
|
|
|
import '../../core/auth/auth_service.dart';
|
|
import '../../core/log/app_logger.dart';
|
|
import '../../core/theme/app_colors.dart';
|
|
import '../../core/theme/app_spacing.dart';
|
|
import '../../core/theme/app_typography.dart';
|
|
import '../../core/user/user_state.dart';
|
|
import '../../features/home/models/task_item.dart';
|
|
import '../../shared/widgets/top_nav_bar.dart';
|
|
|
|
import '../../core/api/api_config.dart';
|
|
import '../../core/api/services/image_api.dart';
|
|
import '../../core/api/services/user_api.dart';
|
|
|
|
/// Generate Video screen - matches Pencil mmLB5
|
|
class GenerateVideoScreen extends StatefulWidget {
|
|
const GenerateVideoScreen({super.key, this.task});
|
|
|
|
static final _log = AppLogger('GenerateVideo');
|
|
|
|
final TaskItem? task;
|
|
|
|
@override
|
|
State<GenerateVideoScreen> createState() => _GenerateVideoScreenState();
|
|
}
|
|
|
|
enum _Resolution { p480, p720 }
|
|
|
|
class _GenerateVideoScreenState extends State<GenerateVideoScreen> {
|
|
_Resolution _selectedResolution = _Resolution.p480;
|
|
bool _isGenerating = false;
|
|
|
|
int get _currentCredits {
|
|
final task = widget.task;
|
|
if (task == null) return 50;
|
|
switch (_selectedResolution) {
|
|
case _Resolution.p480:
|
|
return task.credits480p ?? 50;
|
|
case _Resolution.p720:
|
|
return task.credits720p ?? 50;
|
|
}
|
|
}
|
|
|
|
String get _heatmap =>
|
|
_selectedResolution == _Resolution.p480 ? '480p' : '720p';
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
GenerateVideoScreen._log.d('opened with task: ${widget.task}');
|
|
});
|
|
}
|
|
|
|
/// Click flow per docs/generate_video.md: tap Generate Video -> image picker
|
|
/// (camera or gallery) -> after image selected -> proceed to API.
|
|
Future<void> _onGenerateButtonTap() async {
|
|
if (_isGenerating) return;
|
|
|
|
final source = await showModalBottomSheet<ImageSource>(
|
|
context: context,
|
|
builder: (context) => SafeArea(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
ListTile(
|
|
leading: const Icon(LucideIcons.image),
|
|
title: const Text('Choose from gallery'),
|
|
onTap: () => Navigator.pop(context, ImageSource.gallery),
|
|
),
|
|
ListTile(
|
|
leading: const Icon(LucideIcons.camera),
|
|
title: const Text('Take photo'),
|
|
onTap: () => Navigator.pop(context, ImageSource.camera),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
if (source == null || !mounted) return;
|
|
|
|
final picker = ImagePicker();
|
|
final picked = await picker.pickImage(
|
|
source: source,
|
|
imageQuality: 85,
|
|
);
|
|
if (picked == null || !mounted) return;
|
|
|
|
final file = File(picked.path);
|
|
await _runGenerationApi(file);
|
|
}
|
|
|
|
Future<void> _runGenerationApi(File file) async {
|
|
setState(() => _isGenerating = true);
|
|
|
|
try {
|
|
await AuthService.loginComplete;
|
|
|
|
final size = await file.length();
|
|
final ext = file.path.split('.').last.toLowerCase();
|
|
final contentType = ext == 'png'
|
|
? 'image/png'
|
|
: ext == 'gif'
|
|
? 'image/gif'
|
|
: 'image/jpeg';
|
|
final fileName = 'img_${DateTime.now().millisecondsSinceEpoch}.$ext';
|
|
|
|
final presignedRes = await ImageApi.getUploadPresignedUrl(
|
|
fileName1: fileName,
|
|
contentType: contentType,
|
|
expectedSize: size,
|
|
);
|
|
|
|
if (!presignedRes.isSuccess || presignedRes.data == null) {
|
|
throw Exception(presignedRes.msg.isNotEmpty
|
|
? presignedRes.msg
|
|
: 'Failed to get upload URL');
|
|
}
|
|
|
|
final data = presignedRes.data as Map<String, dynamic>;
|
|
final uploadUrl =
|
|
data['bolster'] as String? ?? data['expound'] as String?;
|
|
final filePath = data['recruit'] as String? ?? data['train'] as String?;
|
|
final requiredHeaders = data['remap'] as Map<String, dynamic>?;
|
|
|
|
if (uploadUrl == null ||
|
|
uploadUrl.isEmpty ||
|
|
filePath == null ||
|
|
filePath.isEmpty) {
|
|
throw Exception('Invalid presigned URL response');
|
|
}
|
|
|
|
final headers = <String, String>{};
|
|
if (requiredHeaders != null) {
|
|
for (final e in requiredHeaders.entries) {
|
|
headers[e.key] = e.value?.toString() ?? '';
|
|
}
|
|
}
|
|
if (!headers.containsKey('Content-Type')) {
|
|
headers['Content-Type'] = contentType;
|
|
}
|
|
|
|
final bytes = await file.readAsBytes();
|
|
final uploadResponse = await http.put(
|
|
Uri.parse(uploadUrl),
|
|
headers: headers,
|
|
body: bytes,
|
|
);
|
|
|
|
if (uploadResponse.statusCode < 200 || uploadResponse.statusCode >= 300) {
|
|
throw Exception('Upload failed: ${uploadResponse.statusCode}');
|
|
}
|
|
|
|
final userId = UserState.userId.value;
|
|
if (userId == null || userId.isEmpty) {
|
|
throw Exception('User not logged in');
|
|
}
|
|
|
|
final createRes = await ImageApi.createTask(
|
|
asset: userId,
|
|
guild: filePath,
|
|
allowance: false,
|
|
cipher: widget.task?.taskType ?? '',
|
|
congregation: widget.task?.templateName ?? '',
|
|
heatmap: _heatmap,
|
|
ext: widget.task?.ext,
|
|
);
|
|
|
|
if (!createRes.isSuccess) {
|
|
throw Exception(
|
|
createRes.msg.isNotEmpty ? createRes.msg : 'Failed to create task');
|
|
}
|
|
|
|
final taskData = createRes.data as Map<String, dynamic>?;
|
|
final taskId = taskData?['tree'];
|
|
|
|
// 创建任务成功后刷新用户账户信息（积分等）
|
|
final accountRes = await UserApi.getAccount(
|
|
sentinel: ApiConfig.appId,
|
|
asset: userId,
|
|
);
|
|
if (accountRes.isSuccess && accountRes.data != null) {
|
|
final accountData = accountRes.data as Map<String, dynamic>?;
|
|
final credits = accountData?['reveal'] as int?;
|
|
if (credits != null) {
|
|
UserState.setCredits(credits);
|
|
}
|
|
}
|
|
|
|
if (!mounted) return;
|
|
Navigator.of(context).pushReplacementNamed(
|
|
'/progress',
|
|
arguments: <String, dynamic>{'taskId': taskId, 'imagePath': file.path},
|
|
);
|
|
} catch (e, st) {
|
|
GenerateVideoScreen._log.e('Generate failed', e, st);
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
'Generation failed: ${e.toString().replaceAll('Exception: ', '')}'),
|
|
behavior: SnackBarBehavior.floating,
|
|
),
|
|
);
|
|
}
|
|
} finally {
|
|
if (mounted) {
|
|
setState(() => _isGenerating = false);
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
backgroundColor: AppColors.background,
|
|
appBar: PreferredSize(
|
|
preferredSize: const Size.fromHeight(56),
|
|
child: TopNavBar(
|
|
title: 'Generate Video',
|
|
credits: UserCreditsData.of(context)?.creditsDisplay ?? '--',
|
|
showBackButton: true,
|
|
onBack: () => Navigator.of(context).pop(),
|
|
onCreditsTap: () => Navigator.of(context).pushNamed('/recharge'),
|
|
),
|
|
),
|
|
body: Column(
|
|
children: [
|
|
Expanded(
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.fromLTRB(
|
|
AppSpacing.screenPaddingLarge,
|
|
AppSpacing.screenPaddingLarge,
|
|
AppSpacing.screenPaddingLarge,
|
|
AppSpacing.lg,
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
_CreditsCard(
|
|
credits:
|
|
UserCreditsData.of(context)?.creditsDisplay ?? '--',
|
|
),
|
|
const SizedBox(height: AppSpacing.xxl),
|
|
_VideoPreviewArea(
|
|
videoUrl: widget.task?.previewVideoUrl,
|
|
imageUrl: widget.task?.previewImageUrl,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
SafeArea(
|
|
top: false,
|
|
child: Padding(
|
|
padding: const EdgeInsets.fromLTRB(
|
|
AppSpacing.screenPaddingLarge,
|
|
AppSpacing.lg,
|
|
AppSpacing.screenPaddingLarge,
|
|
AppSpacing.screenPaddingLarge,
|
|
),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
_ResolutionToggle(
|
|
selected: _selectedResolution,
|
|
onChanged: (r) =>
|
|
setState(() => _selectedResolution = r),
|
|
),
|
|
const SizedBox(height: AppSpacing.xxl),
|
|
_GenerateButton(
|
|
onGenerate: _onGenerateButtonTap,
|
|
isLoading: _isGenerating,
|
|
credits: _currentCredits.toString(),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _CreditsCard extends StatelessWidget {
|
|
const _CreditsCard({required this.credits});
|
|
|
|
final String credits;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: AppSpacing.xxl,
|
|
vertical: AppSpacing.xl,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: AppColors.primary,
|
|
borderRadius: BorderRadius.circular(16),
|
|
border: Border.all(
|
|
color: AppColors.primary.withValues(alpha: 0.5),
|
|
),
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: AppColors.primaryShadow.withValues(alpha: 0.25),
|
|
blurRadius: 8,
|
|
offset: const Offset(0, 2),
|
|
),
|
|
],
|
|
),
|
|
child: Row(
|
|
children: [
|
|
Icon(LucideIcons.sparkles, size: 28, color: AppColors.surface),
|
|
const SizedBox(width: AppSpacing.md),
|
|
Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
'Available Credits',
|
|
style: AppTypography.bodyRegular.copyWith(
|
|
color: AppColors.surface.withValues(alpha: 0.8),
|
|
),
|
|
),
|
|
Text(
|
|
credits,
|
|
style: AppTypography.bodyLarge.copyWith(
|
|
fontSize: 32,
|
|
fontWeight: FontWeight.w700,
|
|
color: AppColors.surface,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Video preview area - video URL from card click. Auto-load and play on init.
|
|
/// Video fit: contain (no crop). Loading animation until ready.
|
|
class _VideoPreviewArea extends StatefulWidget {
|
|
const _VideoPreviewArea({
|
|
this.videoUrl,
|
|
this.imageUrl,
|
|
});
|
|
|
|
final String? videoUrl;
|
|
final String? imageUrl;
|
|
|
|
@override
|
|
State<_VideoPreviewArea> createState() => _VideoPreviewAreaState();
|
|
}
|
|
|
|
class _VideoPreviewAreaState extends State<_VideoPreviewArea> {
|
|
VideoPlayerController? _controller;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
if (widget.videoUrl != null && widget.videoUrl!.isNotEmpty) {
|
|
_loadAndPlay();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller?.dispose();
|
|
_controller = null;
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant _VideoPreviewArea oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.videoUrl != widget.videoUrl) {
|
|
_controller?.dispose();
|
|
_controller = null;
|
|
if (widget.videoUrl != null && widget.videoUrl!.isNotEmpty) {
|
|
_loadAndPlay();
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _loadAndPlay() async {
|
|
final url = widget.videoUrl;
|
|
if (url == null || url.isEmpty) return;
|
|
|
|
setState(() {});
|
|
|
|
try {
|
|
final file = await DefaultCacheManager().getSingleFile(url);
|
|
if (!mounted) return;
|
|
final controller = VideoPlayerController.file(file);
|
|
await controller.initialize();
|
|
if (!mounted) return;
|
|
await controller.play();
|
|
controller.setLooping(true);
|
|
if (mounted) {
|
|
setState(() {
|
|
_controller = controller;
|
|
});
|
|
}
|
|
} catch (e) {
|
|
GenerateVideoScreen._log.e('Video load failed', e);
|
|
if (mounted) setState(() {});
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final isReady =
|
|
_controller != null && _controller!.value.isInitialized;
|
|
final hasVideo = widget.videoUrl != null && widget.videoUrl!.isNotEmpty;
|
|
final hasImage =
|
|
widget.imageUrl != null && widget.imageUrl!.isNotEmpty;
|
|
|
|
// Aspect ratio: from video when ready, else 16:9 placeholder
|
|
final aspectRatio = isReady &&
|
|
_controller!.value.size.width > 0 &&
|
|
_controller!.value.size.height > 0
|
|
? _controller!.value.size.width / _controller!.value.size.height
|
|
: 16 / 9;
|
|
|
|
return LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final width = constraints.maxWidth;
|
|
final height = width / aspectRatio;
|
|
|
|
return Container(
|
|
width: width,
|
|
height: height,
|
|
decoration: BoxDecoration(
|
|
color: AppColors.surfaceAlt,
|
|
borderRadius: BorderRadius.circular(16),
|
|
border: Border.all(
|
|
color: AppColors.border,
|
|
width: 1,
|
|
),
|
|
),
|
|
clipBehavior: Clip.antiAlias,
|
|
child: Stack(
|
|
fit: StackFit.expand,
|
|
alignment: Alignment.center,
|
|
children: [
|
|
if (isReady)
|
|
SizedBox.expand(
|
|
child: FittedBox(
|
|
fit: BoxFit.contain,
|
|
child: SizedBox(
|
|
width: _controller!.value.size.width,
|
|
height: _controller!.value.size.height,
|
|
child: VideoPlayer(_controller!),
|
|
),
|
|
),
|
|
)
|
|
else if (hasImage)
|
|
CachedNetworkImage(
|
|
imageUrl: widget.imageUrl!,
|
|
fit: BoxFit.contain,
|
|
width: double.infinity,
|
|
height: double.infinity,
|
|
placeholder: (_, __) => _LoadingOverlay(isLoading: true),
|
|
errorWidget: (_, __, ___) => _LoadingOverlay(isLoading: false),
|
|
)
|
|
else
|
|
_LoadingOverlay(isLoading: false),
|
|
if (hasVideo && !isReady)
|
|
Positioned.fill(
|
|
child: _LoadingOverlay(isLoading: true),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _LoadingOverlay extends StatelessWidget {
|
|
const _LoadingOverlay({this.isLoading = true});
|
|
|
|
final bool isLoading;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
color: AppColors.surfaceAlt,
|
|
alignment: Alignment.center,
|
|
child: isLoading
|
|
? const SizedBox(
|
|
width: 40,
|
|
height: 40,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
color: AppColors.primary,
|
|
),
|
|
)
|
|
: Icon(
|
|
LucideIcons.video,
|
|
size: 48,
|
|
color: AppColors.textMuted,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Resolution row - 1:1 match Pencil oYwsm: label + 480P/720P on same row.
|
|
/// Button: height 36, cornerRadius 18, padding 8x16, gap 12 label-to-btns, gap 8 between btns.
|
|
class _ResolutionToggle extends StatelessWidget {
|
|
const _ResolutionToggle({
|
|
required this.selected,
|
|
required this.onChanged,
|
|
});
|
|
|
|
final _Resolution selected;
|
|
final ValueChanged<_Resolution> onChanged;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return SizedBox(
|
|
height: 44,
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: [
|
|
Text(
|
|
'Resolution',
|
|
style: AppTypography.bodyMedium.copyWith(
|
|
fontSize: 14,
|
|
color: AppColors.textPrimary,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
_ResolutionOption(
|
|
label: '480P',
|
|
isSelected: selected == _Resolution.p480,
|
|
onTap: () => onChanged(_Resolution.p480),
|
|
),
|
|
const SizedBox(width: 8),
|
|
_ResolutionOption(
|
|
label: '720P',
|
|
isSelected: selected == _Resolution.p720,
|
|
onTap: () => onChanged(_Resolution.p720),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _ResolutionOption extends StatelessWidget {
|
|
const _ResolutionOption({
|
|
required this.label,
|
|
required this.isSelected,
|
|
required this.onTap,
|
|
});
|
|
|
|
final String label;
|
|
final bool isSelected;
|
|
final VoidCallback onTap;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return GestureDetector(
|
|
onTap: onTap,
|
|
child: Container(
|
|
height: 36,
|
|
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
|
decoration: BoxDecoration(
|
|
color: isSelected ? AppColors.primary : AppColors.surfaceAlt,
|
|
borderRadius: BorderRadius.circular(18),
|
|
border: isSelected
|
|
? null
|
|
: Border.all(color: AppColors.border, width: 1),
|
|
boxShadow: isSelected
|
|
? [
|
|
BoxShadow(
|
|
color: AppColors.primaryShadow.withValues(alpha: 0.19),
|
|
blurRadius: 4,
|
|
offset: const Offset(0, 2),
|
|
),
|
|
]
|
|
: null,
|
|
),
|
|
alignment: Alignment.center,
|
|
child: Text(
|
|
label,
|
|
style: AppTypography.bodyMedium.copyWith(
|
|
fontSize: 13,
|
|
color: isSelected ? AppColors.surface : AppColors.textSecondary,
|
|
fontWeight: isSelected ? FontWeight.w600 : FontWeight.w500,
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _GenerateButton extends StatelessWidget {
|
|
const _GenerateButton({
|
|
required this.onGenerate,
|
|
this.isLoading = false,
|
|
this.credits = '50',
|
|
});
|
|
|
|
final VoidCallback onGenerate;
|
|
final bool isLoading;
|
|
final String credits;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return GestureDetector(
|
|
onTap: isLoading ? null : onGenerate,
|
|
child: Opacity(
|
|
opacity: isLoading ? 0.6 : 1,
|
|
child: Container(
|
|
height: 56,
|
|
decoration: BoxDecoration(
|
|
color: AppColors.primary,
|
|
borderRadius: BorderRadius.circular(16),
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: AppColors.primaryShadow.withValues(alpha: 0.25),
|
|
blurRadius: 8,
|
|
offset: const Offset(0, 2),
|
|
),
|
|
],
|
|
),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
if (isLoading)
|
|
const SizedBox(
|
|
width: 24,
|
|
height: 24,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
color: AppColors.surface,
|
|
),
|
|
)
|
|
else
|
|
Text(
|
|
'Generate Video',
|
|
style: AppTypography.bodyMedium.copyWith(
|
|
color: AppColors.surface,
|
|
),
|
|
),
|
|
if (!isLoading) ...[
|
|
const SizedBox(width: AppSpacing.md),
|
|
Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 10,
|
|
vertical: AppSpacing.xs,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: AppColors.surface.withValues(alpha: 0.2),
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(
|
|
LucideIcons.sparkles,
|
|
size: 16,
|
|
color: AppColors.surface,
|
|
),
|
|
const SizedBox(width: AppSpacing.xs),
|
|
Text(
|
|
credits,
|
|
style: AppTypography.bodyRegular.copyWith(
|
|
color: AppColors.surface,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|