431 lines
14 KiB
Dart
431 lines
14 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_screenutil/flutter_screenutil.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:yumi/app/constants/sc_room_msg_type.dart';
|
|
import 'package:yumi/services/audio/rtc_manager.dart';
|
|
import 'package:yumi/services/audio/rtm_manager.dart';
|
|
import 'package:yumi/ui_kit/components/sc_debounce_widget.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/music/room_music_floating_entry.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/red_packet/room_red_packet_models.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/red_packet/room_red_packet_open_dialog.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/red_packet/room_red_packet_pending_cache.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/room_banner_view.dart';
|
|
import 'package:yumi/ui_kit/widgets/room/room_game_bottom_sheet.dart';
|
|
|
|
class RoomPlayWidget extends StatefulWidget {
|
|
const RoomPlayWidget({super.key});
|
|
|
|
@override
|
|
State<RoomPlayWidget> createState() => _RoomPlayWidgetState();
|
|
}
|
|
|
|
class _RoomPlayWidgetState extends State<RoomPlayWidget> {
|
|
static const double _rightActionDownShift = 24;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return SizedBox.expand(
|
|
child: Stack(
|
|
children: [
|
|
PositionedDirectional(
|
|
end: 15.w,
|
|
bottom: (150 - _rightActionDownShift).w,
|
|
child: const RoomMusicFloatingEntry(),
|
|
),
|
|
PositionedDirectional(
|
|
end: 15.w,
|
|
bottom: (200 - _rightActionDownShift).w,
|
|
child: const _RoomRedPacketFloatingEntry(),
|
|
),
|
|
PositionedDirectional(
|
|
end: 15.w,
|
|
bottom: (100 - _rightActionDownShift).w,
|
|
child: const RoomGameEntryButton(),
|
|
),
|
|
PositionedDirectional(
|
|
end: 10.w,
|
|
bottom: 15.w,
|
|
child: SizedBox(width: 46.w, child: RoomBannerView()),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _RoomRedPacketFloatingEntry extends StatefulWidget {
|
|
const _RoomRedPacketFloatingEntry();
|
|
|
|
@override
|
|
State<_RoomRedPacketFloatingEntry> createState() =>
|
|
_RoomRedPacketFloatingEntryState();
|
|
}
|
|
|
|
class _RoomRedPacketFloatingEntryState
|
|
extends State<_RoomRedPacketFloatingEntry> {
|
|
static const int _listRefreshIntervalSeconds = 5;
|
|
|
|
Timer? _entryRefreshTimer;
|
|
bool _refreshingList = false;
|
|
int _elapsedSeconds = 0;
|
|
String _observedRoomId = '';
|
|
String _verifiedRoomId = '';
|
|
int _verifiedRoomRefreshCount = 0;
|
|
Set<String> _verifiedKnownPacketIds = const <String>{};
|
|
Set<String> _verifiedVisiblePacketIds = const <String>{};
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_entryRefreshTimer = Timer.periodic(
|
|
const Duration(seconds: 1),
|
|
(_) => _onEntryTimerTick(),
|
|
);
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (mounted) {
|
|
_refreshRoomRedPacketList();
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_entryRefreshTimer?.cancel();
|
|
super.dispose();
|
|
}
|
|
|
|
void _onEntryTimerTick() {
|
|
RoomRedPacketPendingCache.instance.pruneExpired();
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
_refreshRoomRedPacketListIfRoomChanged();
|
|
setState(() {});
|
|
_elapsedSeconds++;
|
|
if (_elapsedSeconds % _listRefreshIntervalSeconds == 0) {
|
|
_refreshRoomRedPacketList();
|
|
}
|
|
}
|
|
|
|
void _refreshRoomRedPacketListIfRoomChanged() {
|
|
try {
|
|
final rtcProvider = Provider.of<RtcProvider>(context, listen: false);
|
|
final currentRoomId =
|
|
rtcProvider.currenRoom?.roomProfile?.roomProfile?.id?.trim() ?? '';
|
|
if (currentRoomId.isEmpty || currentRoomId == _observedRoomId) {
|
|
return;
|
|
}
|
|
_observedRoomId = currentRoomId;
|
|
_elapsedSeconds = 0;
|
|
_verifiedRoomId = '';
|
|
_verifiedRoomRefreshCount = 0;
|
|
_verifiedKnownPacketIds = const <String>{};
|
|
_verifiedVisiblePacketIds = const <String>{};
|
|
_refreshRoomRedPacketList();
|
|
} catch (_) {}
|
|
}
|
|
|
|
void _refreshRoomRedPacketList() {
|
|
if (_refreshingList || !mounted) {
|
|
return;
|
|
}
|
|
try {
|
|
final rtcProvider = Provider.of<RtcProvider>(context, listen: false);
|
|
final currentRoomId =
|
|
rtcProvider.currenRoom?.roomProfile?.roomProfile?.id?.trim() ?? '';
|
|
if (currentRoomId.isEmpty) {
|
|
return;
|
|
}
|
|
_refreshingList = true;
|
|
unawaited(
|
|
rtcProvider
|
|
.loadRoomRedPacketList(1)
|
|
.then((result) {
|
|
final activeRoomId =
|
|
rtcProvider.currenRoom?.roomProfile?.roomProfile?.id
|
|
?.trim() ??
|
|
'';
|
|
if (activeRoomId != currentRoomId) {
|
|
return result;
|
|
}
|
|
final serverPackets =
|
|
result.map(RoomRedPacketUiData.fromListRes).toList();
|
|
final serverPacketIds =
|
|
serverPackets
|
|
.map((item) => item.packetId.trim())
|
|
.where((packetId) => packetId.isNotEmpty)
|
|
.toSet();
|
|
final visiblePacketIds =
|
|
serverPackets
|
|
.map(RoomRedPacketOpenDialog.withLocalClaimState)
|
|
.where(_shouldShowRoomRedPacketEntry)
|
|
.map((item) => item.packetId.trim())
|
|
.where((packetId) => packetId.isNotEmpty)
|
|
.toSet();
|
|
if (!mounted) {
|
|
return result;
|
|
}
|
|
setState(() {
|
|
if (_verifiedRoomId == currentRoomId) {
|
|
_verifiedRoomRefreshCount++;
|
|
_verifiedKnownPacketIds = {
|
|
..._verifiedKnownPacketIds,
|
|
...serverPacketIds,
|
|
};
|
|
} else {
|
|
_verifiedRoomId = currentRoomId;
|
|
_verifiedRoomRefreshCount = 1;
|
|
_verifiedKnownPacketIds = serverPacketIds;
|
|
}
|
|
_verifiedVisiblePacketIds = visiblePacketIds;
|
|
});
|
|
return result;
|
|
})
|
|
.catchError((_) => rtcProvider.redPacketList)
|
|
.whenComplete(() {
|
|
_refreshingList = false;
|
|
}),
|
|
);
|
|
} catch (_) {
|
|
_refreshingList = false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AnimatedBuilder(
|
|
animation: Listenable.merge([
|
|
RoomRedPacketPendingCache.instance,
|
|
RoomRedPacketOpenDialog.claimedStateNotifier,
|
|
]),
|
|
builder: (context, child) {
|
|
return Consumer2<RtcProvider, RtmProvider>(
|
|
builder: (context, rtcProvider, rtmProvider, child) {
|
|
final snapshot = _RoomRedPacketEntrySnapshot.fromProviders(
|
|
rtcProvider: rtcProvider,
|
|
rtmProvider: rtmProvider,
|
|
verifiedRoomId: _verifiedRoomId,
|
|
verifiedRoomRefreshCount: _verifiedRoomRefreshCount,
|
|
verifiedKnownPacketIds: _verifiedKnownPacketIds,
|
|
verifiedVisiblePacketIds: _verifiedVisiblePacketIds,
|
|
);
|
|
if (snapshot.packets.isEmpty) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
return SCDebounceWidget(
|
|
onTap: () {
|
|
final freshSnapshot = _RoomRedPacketEntrySnapshot.fromProviders(
|
|
rtcProvider: Provider.of<RtcProvider>(context, listen: false),
|
|
rtmProvider: Provider.of<RtmProvider>(context, listen: false),
|
|
verifiedRoomId: _verifiedRoomId,
|
|
verifiedRoomRefreshCount: _verifiedRoomRefreshCount,
|
|
verifiedKnownPacketIds: _verifiedKnownPacketIds,
|
|
verifiedVisiblePacketIds: _verifiedVisiblePacketIds,
|
|
);
|
|
if (freshSnapshot.packets.isEmpty) {
|
|
return;
|
|
}
|
|
RoomRedPacketOpenDialog.showList(
|
|
context,
|
|
freshSnapshot.packets,
|
|
);
|
|
},
|
|
child: SizedBox(
|
|
width: 46.w,
|
|
height: 46.w,
|
|
child: Stack(
|
|
clipBehavior: Clip.none,
|
|
alignment: Alignment.center,
|
|
children: [
|
|
Image.asset(
|
|
'sc_images/room/red_packet/small_packet_icon.png',
|
|
width: 44.w,
|
|
height: 44.w,
|
|
fit: BoxFit.contain,
|
|
gaplessPlayback: true,
|
|
),
|
|
if (snapshot.packets.length > 1)
|
|
PositionedDirectional(
|
|
top: -2.w,
|
|
end: -2.w,
|
|
child: Container(
|
|
constraints: BoxConstraints(minWidth: 16.w),
|
|
height: 16.w,
|
|
padding: EdgeInsets.symmetric(horizontal: 4.w),
|
|
alignment: Alignment.center,
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFFF3D34),
|
|
borderRadius: BorderRadius.circular(8.w),
|
|
border: Border.all(color: Colors.white, width: 1.w),
|
|
),
|
|
child: Text(
|
|
snapshot.packets.length > 99
|
|
? '99+'
|
|
: snapshot.packets.length.toString(),
|
|
textScaler: TextScaler.noScaling,
|
|
maxLines: 1,
|
|
style: TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 9.sp,
|
|
fontWeight: FontWeight.w800,
|
|
decoration: TextDecoration.none,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _RoomRedPacketEntrySnapshot {
|
|
const _RoomRedPacketEntrySnapshot(this.packets, this.signature);
|
|
|
|
factory _RoomRedPacketEntrySnapshot.fromProviders({
|
|
required RtcProvider rtcProvider,
|
|
required RtmProvider rtmProvider,
|
|
required String verifiedRoomId,
|
|
required int verifiedRoomRefreshCount,
|
|
required Set<String> verifiedKnownPacketIds,
|
|
required Set<String> verifiedVisiblePacketIds,
|
|
}) {
|
|
final packets = <RoomRedPacketUiData>[];
|
|
final hiddenPacketIds = <String>{};
|
|
final currentRoomId =
|
|
rtcProvider.currenRoom?.roomProfile?.roomProfile?.id?.trim() ?? '';
|
|
final shouldTrustVerifiedAbsence =
|
|
currentRoomId.isNotEmpty &&
|
|
verifiedRoomId == currentRoomId &&
|
|
verifiedRoomRefreshCount >= 2;
|
|
for (final packet in rtcProvider.redPacketList.map(
|
|
RoomRedPacketUiData.fromListRes,
|
|
)) {
|
|
_addVisiblePacket(
|
|
packets,
|
|
packet,
|
|
hiddenPacketIds: hiddenPacketIds,
|
|
authoritative: true,
|
|
);
|
|
}
|
|
for (final packet in RoomRedPacketPendingCache.instance.packetsForRoom(
|
|
currentRoomId,
|
|
)) {
|
|
_addVisiblePacket(
|
|
packets,
|
|
packet,
|
|
hiddenPacketIds: hiddenPacketIds,
|
|
verifiedKnownPacketIds:
|
|
shouldTrustVerifiedAbsence ? verifiedKnownPacketIds : null,
|
|
verifiedVisiblePacketIds:
|
|
shouldTrustVerifiedAbsence ? verifiedVisiblePacketIds : null,
|
|
);
|
|
}
|
|
for (final msg in rtmProvider.roomChatMsgList) {
|
|
if (msg.type != SCRoomMsgType.roomRedPacket) {
|
|
continue;
|
|
}
|
|
_addVisiblePacket(
|
|
packets,
|
|
RoomRedPacketUiData.fromMessagePayload(
|
|
payload: msg.msg,
|
|
fallbackUser: msg.user,
|
|
),
|
|
hiddenPacketIds: hiddenPacketIds,
|
|
verifiedKnownPacketIds:
|
|
shouldTrustVerifiedAbsence ? verifiedKnownPacketIds : null,
|
|
verifiedVisiblePacketIds:
|
|
shouldTrustVerifiedAbsence ? verifiedVisiblePacketIds : null,
|
|
);
|
|
}
|
|
final signature = packets
|
|
.map(
|
|
(item) =>
|
|
'${item.packetId}|${item.status}|${item.remainCount}|${item.grabbed}|${item.claimedAmount}|${item.claimStartTimeMs}|${item.expireTimeMs}',
|
|
)
|
|
.join(';');
|
|
return _RoomRedPacketEntrySnapshot(packets, signature);
|
|
}
|
|
|
|
final List<RoomRedPacketUiData> packets;
|
|
final String signature;
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
return other is _RoomRedPacketEntrySnapshot && other.signature == signature;
|
|
}
|
|
|
|
@override
|
|
int get hashCode => signature.hashCode;
|
|
}
|
|
|
|
void _addVisiblePacket(
|
|
List<RoomRedPacketUiData> packets,
|
|
RoomRedPacketUiData packet, {
|
|
Set<String>? hiddenPacketIds,
|
|
Set<String>? verifiedKnownPacketIds,
|
|
Set<String>? verifiedVisiblePacketIds,
|
|
bool authoritative = false,
|
|
}) {
|
|
final normalizedPacket = RoomRedPacketOpenDialog.withLocalClaimState(packet);
|
|
final packetId = normalizedPacket.packetId.trim();
|
|
if (packetId.isNotEmpty &&
|
|
RoomRedPacketOpenDialog.isClaimedLocally(packetId)) {
|
|
if (authoritative) {
|
|
hiddenPacketIds?.add(packetId);
|
|
}
|
|
return;
|
|
}
|
|
if (packetId.isNotEmpty &&
|
|
RoomRedPacketOpenDialog.isUnavailableLocally(packetId)) {
|
|
if (authoritative) {
|
|
hiddenPacketIds?.add(packetId);
|
|
}
|
|
return;
|
|
}
|
|
if (!authoritative &&
|
|
packetId.isNotEmpty &&
|
|
(hiddenPacketIds?.contains(packetId) ?? false)) {
|
|
return;
|
|
}
|
|
if (!authoritative &&
|
|
packetId.isNotEmpty &&
|
|
verifiedKnownPacketIds != null &&
|
|
verifiedVisiblePacketIds != null &&
|
|
verifiedKnownPacketIds.contains(packetId) &&
|
|
!verifiedVisiblePacketIds.contains(packetId)) {
|
|
return;
|
|
}
|
|
if (!_shouldShowRoomRedPacketEntry(normalizedPacket)) {
|
|
if (authoritative && packetId.isNotEmpty) {
|
|
hiddenPacketIds?.add(packetId);
|
|
}
|
|
return;
|
|
}
|
|
if (packetId.isNotEmpty &&
|
|
packets.any((item) => item.packetId.trim() == packetId)) {
|
|
final existingIndex = packets.indexWhere(
|
|
(item) => item.packetId.trim() == packetId,
|
|
);
|
|
packets[existingIndex] = packets[existingIndex].withFallbackProfile(
|
|
normalizedPacket,
|
|
);
|
|
return;
|
|
}
|
|
packets.add(normalizedPacket);
|
|
}
|
|
|
|
bool _shouldShowRoomRedPacketEntry(RoomRedPacketUiData item) {
|
|
return !item.grabbed && !item.isExpired && !item.isSoldOut;
|
|
}
|