feat(client): 对接详情/播放/进度续看/收藏(K1 看剧闭环)+ 三态 UI

后端接口从 6 个扩到 13 个,全部走真数据:

- 新增 api:playback_api(/app/episodes/{id}/play)、watch_api(/app/watch/*)、
  library_api(/app/favorites*);票据从 CatalogApi 搬到 PlaybackApi
- 新增 repository:PlaybackRepository(含票据 TTL 缓存,默认 10 分钟,时钟可注入)、
  FavoriteRepository、WatchHistoryRepository 换成服务端模型(每剧一条续看记录,删掉 demoProfileId)
- PlayerLogic:起播前取票(拿不到给三态 UI,失败可重试);accessType 驱动锁定文案,
  不在前端猜;签名地址原样交给播放器(只补 host,不动 path/query);
  进度上报节流 5s → 10s,切集/退出/切后台各补一次,播完带 finished
- 续看定位:服务端记录里的那一集才 seek(其它集从头播),续看位置进详情/播放页时读一次
- FavoriteController:收藏以服务端为准,乐观更新 + 失败回滚;退出登录清空
- UI 三态:详情页(加载/失败可重试/空剧集 + 续看进度条 + 收藏按钮)、
  播放页(票据加载中/失败可重试/后端判定不可播)、我的页(续看失败可重试、收藏三态、最近观看)
- l10n 新增 8 个键(en/zh/id 三份):网络/进度/收藏失败、锁定提示、续看文案等

测试:flutter test 188 全过(存量 27 个测试文件未跑红);新增票据过期重取、进度节流、
续看定位、收藏回滚、签名 query 原样保留、真实后端端到端联调(live_watch_flow)
This commit is contained in:
Vicky committed 2026-10-16 17:39:05 +08:00
1 parent 94ff9f1177
commit d7eff4ca59
48 files changed
+2411 -377

No files matched your search

@@ -0,0 +1,120 @@
// Author: fruit.com.cn
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:fruitshorts/core/data/models/drama.dart';
import 'package:fruitshorts/core/data/remote/api_client.dart';
import 'package:fruitshorts/core/data/remote/playback_api.dart';
import 'package:fruitshorts/core/data/repositories/playback_repository.dart';
import 'package:fruitshorts/core/data/services/video_player_port.dart';
import '../support/fake_http_adapter.dart';
/// 播放票据有有效期(契约 §1.4:签名默认 15 分钟):
/// 缓存期内不重复取,过期或显式强刷必须重新取,且**签名地址原样使用**。
void main() {
String envelope(String playUrl) => jsonEncode({
'code': 0,
'message': 'ok',
'data': {
'episodeId': '11',
'dramaId': '5',
'number': 1,
'title': '第 1 集',
'durationSec': 180,
'accessible': true,
'accessType': 'FREE',
'playUrl': playUrl,
'qualities': ['AUTO'],
'unlockCoin': 0,
'previewSeconds': 0,
},
});
_TicketEnv build() {
var now = DateTime(2026, 10, 16, 12);
final adapter = FakeHttpAdapter(
(_) async => FakeHttpResponse(
envelope('/files/episode/11.mp4?e=1760000000&s=9f2c'),
),
);
final client = ApiClient(baseUrl: 'http://127.0.0.1:8081', adapter: adapter);
final repository = HttpPlaybackRepository(
PlaybackApi(client),
ttl: const Duration(minutes: 10),
clock: () => now,
);
return _TicketEnv(
repository: repository,
adapter: adapter,
advance: (Duration d) => now = now.add(d),
);
}
test('should_reuse_ticket_when_cache_is_still_fresh', () async {
final env = build();
await env.repository.ticketFor('11');
env.advance(const Duration(minutes: 9));
await env.repository.ticketFor('11');
expect(env.adapter.requests, hasLength(1));
});
test('should_refetch_ticket_when_cache_expired', () async {
final env = build();
await env.repository.ticketFor('11');
env.advance(const Duration(minutes: 11));
final ticket = await env.repository.ticketFor('11');
expect(env.adapter.requests, hasLength(2));
expect(ticket.playUrl, contains('?e=1760000000&s=9f2c'));
});
test('should_refetch_ticket_when_explicitly_forced', () async {
final env = build();
await env.repository.ticketFor('11');
await env.repository.ticketFor('11', forceRefresh: true);
expect(env.adapter.requests, hasLength(2));
});
test('should_report_freshness_when_asking_before_expiry', () async {
final env = build();
expect(env.repository.isFresh('11'), isFalse);
await env.repository.ticketFor('11');
expect(env.repository.isFresh('11'), isTrue);
env.advance(const Duration(minutes: 11));
expect(env.repository.isFresh('11'), isFalse);
});
test('should_keep_signed_query_verbatim_when_resolving_media_uri', () {
const episode = Episode(
id: '11',
number: 1,
title: '第 1 集',
isFree: true,
videoUrl: '/files/episode/11.mp4?e=1760000000&s=9f2c',
);
final uri = VideoPlayerPort.resolveUri(episode);
// 只补 host,路径与查询串原样保留(签名丢了就等于 403)
expect(uri.path, '/files/episode/11.mp4');
expect(uri.query, 'e=1760000000&s=9f2c');
expect(uri.toString(), endsWith('/files/episode/11.mp4?e=1760000000&s=9f2c'));
});
}
/// 测试用的小环境:仓库 + 假适配器 + 可推进的时钟。
class _TicketEnv {
_TicketEnv({
required this.repository,
required this.adapter,
required this.advance,
});
final HttpPlaybackRepository repository;
final FakeHttpAdapter adapter;
final void Function(Duration) advance;
}
+178
View File
@@ -0,0 +1,178 @@
// Author: fruit.com.cn
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:fruitshorts/core/data/models/drama.dart';
import 'package:fruitshorts/core/data/models/watch_progress.dart';
import 'package:fruitshorts/core/data/services/android_picture_in_picture.dart';
import 'package:fruitshorts/core/data/repositories/playback_repository.dart';
import 'package:fruitshorts/core/data/services/playback_session.dart';
import 'package:fruitshorts/pages/player/player_logic.dart';
import 'package:fruitshorts/pages/player/player_view.dart';
import '../support/fake_watch_history.dart';
import '../support/widget_player.dart';
Drama _drama(String id, {List<int> numbers = const [1, 2, 3]}) => Drama(
id: id,
title: id,
synopsis: 'synopsis',
posterUrl: '/files/poster.png',
episodes: [
for (final number in numbers)
Episode(
id: '$id-$number',
number: number,
title: 'Episode $number',
videoUrl: 'https://example.test/clip.mp4',
isFree: true,
),
],
);
PlayerLogic _logic(FakeWatchHistory history, {Drama? drama}) {
final logic = PlayerLogic(
history: history,
playback: FakePlaybackRepository(),
pictureInPicture: AndroidPictureInPicture(
channel: const MethodChannel('test/progress/pip'),
),
);
if (drama != null) {
logic.attach(
PlayerPage(drama: drama, initialIndex: 0),
isMounted: () => true,
);
logic.start(
factory: (episode) => WidgetPlayer(),
coordinator: PlaybackCoordinator(),
);
}
return logic;
}
/// 排空 session 串行队列,避免测试结束在 dispose 中途。
Future<void> _drain(PlayerLogic logic) async {
for (var attempt = 0; attempt < 4; attempt++) {
await pumpEventQueue();
await logic.session.playbackSettled;
await logic.session.preloadSettled;
}
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('progress throttle', () {
test('should_report_once_per_interval_when_progress_ticks_keep_coming', () {
final logic = _logic(FakeWatchHistory());
final start = DateTime(2026, 10, 16, 12);
logic.lastProgressWrite = start;
// 契约建议每 10 秒一次:3 秒、9 秒都不报,第 10 秒报一次
expect(logic.progressInterval, const Duration(seconds: 10));
expect(logic.shouldReportProgress(start.add(const Duration(seconds: 3))), isFalse);
expect(logic.shouldReportProgress(start.add(const Duration(seconds: 9))), isFalse);
expect(logic.shouldReportProgress(start.add(const Duration(seconds: 10))), isTrue);
// 报过之后节流窗口重新开始
expect(logic.shouldReportProgress(start.add(const Duration(seconds: 15))), isFalse);
expect(logic.shouldReportProgress(start.add(const Duration(seconds: 20))), isTrue);
logic.dispose();
});
test('should_write_immediately_when_saving_on_episode_switch_or_exit', () async {
final history = FakeWatchHistory();
final drama = _drama('signal');
final logic = _logic(history, drama: drama);
// 切集/退出/切后台走 saveCurrentProgress:不受 10 秒节流限制
await logic.queueProgress(
drama,
drama.episodes[0],
const Duration(seconds: 5),
duration: const Duration(minutes: 3),
);
await logic.queueProgress(
drama,
drama.episodes[1],
const Duration(seconds: 6),
duration: const Duration(minutes: 3),
);
expect(history.writes, [
'signal-1|5000|false',
'signal-2|6000|false',
]);
logic.dispose();
});
test('should_report_finished_when_episode_plays_to_the_end', () async {
final history = FakeWatchHistory();
final drama = _drama('signal');
final logic = _logic(history, drama: drama);
await logic.queueProgress(
drama,
drama.episodes[0],
const Duration(minutes: 3),
duration: const Duration(minutes: 3),
finished: true,
);
expect(history.writes, ['signal-1|180000|true']);
logic.dispose();
});
});
group('resume positioning', () {
test('should_take_position_from_server_when_record_matches_the_episode', () async {
final history = FakeWatchHistory(
)..records['signal'] = const WatchProgress(
dramaId: 'signal',
episodeId: 'signal-2',
position: Duration(seconds: 42),
duration: Duration(minutes: 3),
);
final logic = _logic(history, drama: _drama('signal'));
await _drain(logic);
await logic.loadResumePoint();
expect(logic.resumePositionFor('signal-2'), const Duration(seconds: 42));
// 记录里不是这一集:不给定位(从头播,避免"看第 1 集却跳到第 2 集的位置")
expect(logic.resumePositionFor('signal-1'), isNull);
expect(logic.resumePositionFor('signal-3'), isNull);
logic.dispose();
});
test('should_have_no_resume_position_when_server_read_fails', () async {
final history = FakeWatchHistory()..failReads = true;
final logic = _logic(history, drama: _drama('signal'));
await _drain(logic);
await logic.loadResumePoint();
expect(logic.resumePoint, isNull);
expect(logic.resumeLoaded, isTrue);
logic.dispose();
});
test('should_not_seek_when_position_is_zero', () async {
final history = FakeWatchHistory()
..records['signal'] = const WatchProgress(
dramaId: 'signal',
episodeId: 'signal-1',
position: Duration.zero,
duration: Duration(minutes: 3),
);
final logic = _logic(history, drama: _drama('signal'));
await _drain(logic);
await logic.loadResumePoint();
expect(logic.resumePositionFor('signal-1'), isNull);
logic.dispose();
await _drain(logic);
});
});
}
+93 -96
View File
@@ -1,9 +1,11 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:fruitshorts/core/data/models/drama.dart';
import 'package:fruitshorts/core/data/repositories/watch_history_repository.dart';
import 'package:shared_preferences_platform_interface/in_memory_shared_preferences_async.dart';
import 'package:shared_preferences_platform_interface/shared_preferences_async_platform_interface.dart';
// Author: fruit.com.cn
import 'package:flutter_test/flutter_test.dart';
import 'package:fruitshorts/core/data/models/watch_progress.dart';
import 'package:fruitshorts/core/data/repositories/watch_history_repository.dart';
/// 进度仓库从"本地按 profile+剧+集"换成"服务端每剧一条":
/// 这里钉住续看点换算、空记录、字符串数值解析、失败透传与清理。
void main() {
test('should_clamp_invalid_and_completed_values_when_resolving_resume_position', () {
const duration = Duration(seconds: 8);
@@ -25,106 +27,101 @@ void main() {
);
});
test('should_scope_history_by_profile_drama_and_episode_when_saving', () async {
SharedPreferencesAsyncPlatform.instance =
InMemorySharedPreferencesAsync.empty();
final history = SharedPreferencesWatchHistoryRepository();
await history.save(
'profile-a',
'drama-a',
'episode-1',
const Duration(seconds: 3),
);
await history.save(
'profile-a',
'drama-a',
'episode-2',
const Duration(seconds: 5),
);
expect(
await history.positionFor('profile-a', 'drama-a', 'episode-1'),
const Duration(seconds: 3),
);
expect(
await history.positionFor('profile-b', 'drama-a', 'episode-1'),
isNull,
);
expect(await history.lastEpisodeId('profile-a', 'drama-a'), 'episode-2');
expect(await history.lastEpisodeId('profile-a', 'drama-b'), isNull);
});
test('should_prefer_first_loaded_episode_when_resuming', () async {
SharedPreferencesAsyncPlatform.instance =
InMemorySharedPreferencesAsync.empty();
final history = SharedPreferencesWatchHistoryRepository();
await history.save(
'profile-a',
'drama-a',
'episode-1',
const Duration(seconds: 3),
);
await history.save(
'profile-a',
'drama-a',
'episode-2',
const Duration(seconds: 5),
);
final drama = Drama(
id: 'drama-a',
title: 'title',
synopsis: 'synopsis',
posterUrl: '',
episodes: const [
Episode(id: 'episode-1', number: 1, title: 'E1', isFree: true),
Episode(id: 'episode-2', number: 2, title: 'E2', isFree: true),
test('should_return_resume_point_when_server_has_progress', () async {
final history = InMemoryWatchHistoryRepository(
seed: const [
WatchProgress(
dramaId: 'drama-a',
episodeId: 'episode-3',
position: Duration(seconds: 42),
duration: Duration(minutes: 3),
),
],
);
expect(
await history.resumePositionFor('profile-a', drama),
const Duration(seconds: 3),
);
final point = await history.resumePointFor('drama-a');
expect(point?.episodeId, 'episode-3');
expect(point?.position, const Duration(seconds: 42));
});
test('should_fall_back_to_last_watched_episode_when_resuming_a_list_card', () async {
SharedPreferencesAsyncPlatform.instance =
InMemorySharedPreferencesAsync.empty();
final history = SharedPreferencesWatchHistoryRepository();
await history.save(
'profile-a',
'drama-a',
'episode-2',
const Duration(seconds: 5),
);
test('should_return_no_resume_point_when_server_has_no_record', () async {
final history = InMemoryWatchHistoryRepository();
const card = Drama(
id: 'drama-a',
title: 'title',
synopsis: 'synopsis',
posterUrl: '',
totalEpisodes: 12,
);
expect(
await history.resumePositionFor('profile-a', card),
const Duration(seconds: 5),
);
expect(await history.resumePointFor('drama-a'), isNull);
});
test('should_have_no_resume_position_when_list_card_has_no_history', () async {
SharedPreferencesAsyncPlatform.instance =
InMemorySharedPreferencesAsync.empty();
final history = SharedPreferencesWatchHistoryRepository();
const card = Drama(
id: 'drama-b',
title: 'title',
synopsis: 'synopsis',
posterUrl: '',
totalEpisodes: 12,
test('should_return_no_resume_point_when_record_has_no_episode', () async {
final history = InMemoryWatchHistoryRepository(
seed: const [
WatchProgress(
dramaId: 'drama-a',
episodeId: '',
position: Duration(seconds: 5),
duration: Duration(minutes: 3),
),
],
);
expect(await history.resumePositionFor('profile-a', card), isNull);
expect(await history.resumePointFor('drama-a'), isNull);
});
test('should_expose_fraction_when_duration_is_known', () {
const record = WatchProgress(
dramaId: 'd',
episodeId: 'e',
position: Duration(seconds: 30),
duration: Duration(seconds: 120),
);
expect(record.fraction, closeTo(0.25, 0.0001));
expect(record.hasPosition, isTrue);
const unknown = WatchProgress(
dramaId: 'd',
episodeId: 'e',
position: Duration(seconds: 30),
duration: Duration.zero,
);
expect(unknown.fraction, 0);
});
test('should_parse_string_numbers_when_server_sends_ids_and_ms_as_strings', () {
final record = WatchProgress.fromJson({
'dramaId': '2111012753262120962',
'episodeId': '2111012753262120963',
'positionMs': '42000',
'durationMs': '180000',
'finished': false,
'playCount': '2',
});
expect(record.dramaId, '2111012753262120962');
expect(record.episodeId, '2111012753262120963');
expect(record.position, const Duration(seconds: 42));
expect(record.duration, const Duration(seconds: 180));
expect(record.playCount, 2);
});
test('should_throw_when_reading_progress_fails', () async {
final history = InMemoryWatchHistoryRepository()..failReads = 1;
expect(() => history.progressFor('drama-a'), throwsStateError);
});
test('should_drop_record_when_removing_progress', () async {
final history = InMemoryWatchHistoryRepository(
seed: const [
WatchProgress(
dramaId: 'drama-a',
episodeId: 'e1',
position: Duration(seconds: 5),
duration: Duration(minutes: 1),
),
],
);
await history.remove('drama-a');
expect(await history.progressFor('drama-a'), isNull);
});
}