feat(video_calls): changed accept flow, fixed ui bugs for PIP and video render sizes

This commit is contained in:
misha
2026-06-23 08:42:55 +03:00
parent 8920fc280f
commit ed72ed9799
31 changed files with 1399 additions and 837 deletions

View File

@@ -1,173 +0,0 @@
import 'package:audio_session/audio_session.dart';
import 'package:eatvio_app/features/video_calls/managers/video_call_manager.dart';
import 'package:eatvio_app/features/video_calls/services/video_call_audio_session_coordinator.dart';
import 'package:eatvio_app/features/video_calls/services/video_call_foreground_coordinator.dart';
import 'package:eatvio_app/features/video_calls/services/video_call_lifecycle_binding.dart';
import 'package:eatvio_app/features/video_calls/repositories/video_call_repository.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:livekit_client/livekit_client.dart' as lk;
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'video_call_manager_audio_interruption_test.mocks.dart';
class _FakeAudioSessionCoordinator extends VideoCallAudioSessionCoordinator {
_FakeAudioSessionCoordinator(this.onStart);
final void Function(void Function(AudioInterruptionEvent event) onInterruption) onStart;
bool reactivateCalled = false;
@override
Future<void> start({required void Function(AudioInterruptionEvent event) onInterruption}) async {
onStart(onInterruption);
}
@override
Future<bool> reactivate() async {
reactivateCalled = true;
return true;
}
@override
Future<void> stop() async {}
}
@GenerateNiceMocks([MockSpec<VideoCallRepository>(), MockSpec<lk.Room>(), MockSpec<lk.LocalParticipant>()])
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('VideoCallManager audio interruption', () {
late MockVideoCallRepository mockRepository;
late MockRoom mockRoom;
late MockLocalParticipant mockLocalParticipant;
late _FakeAudioSessionCoordinator audioCoordinator;
late VideoCallManager manager;
setUp(() {
mockRepository = MockVideoCallRepository();
mockRoom = MockRoom();
mockLocalParticipant = MockLocalParticipant();
audioCoordinator = _FakeAudioSessionCoordinator((_) {});
manager = VideoCallManager(
videoCallRepository: mockRepository,
foregroundCoordinator: VideoCallForegroundCoordinator(),
lifecycleBinding: VideoCallLifecycleBinding(),
audioSessionCoordinator: audioCoordinator,
);
when(mockRoom.connectionState).thenReturn(lk.ConnectionState.connected);
when(mockRoom.localParticipant).thenReturn(mockLocalParticipant);
when(mockLocalParticipant.setMicrophoneEnabled(any, audioCaptureOptions: anyNamed('audioCaptureOptions'))).thenAnswer((_) async {
return null;
});
when(mockLocalParticipant.getTrackPublicationBySource(lk.TrackSource.microphone)).thenReturn(null);
});
tearDown(() {
manager.dispose();
});
test('duck interruption mutes mic and sets interrupted UI state', () async {
manager.markActiveCallForTesting(mockRoom);
manager.handleAudioInterruptionForTesting(
AudioInterruptionEvent(true, AudioInterruptionType.duck),
);
await Future<void>.delayed(Duration.zero);
expect(manager.snapshot.systemAudioInterrupted, isTrue);
verify(
mockLocalParticipant.setMicrophoneEnabled(
false,
audioCaptureOptions: anyNamed('audioCaptureOptions'),
),
).called(1);
});
test('interruption begin mutes mic and sets interrupted state', () async {
manager.markActiveCallForTesting(mockRoom);
manager.handleAudioInterruptionForTesting(AudioInterruptionEvent(true, AudioInterruptionType.pause));
await Future<void>.delayed(Duration.zero);
expect(manager.snapshot.systemAudioInterrupted, isTrue);
expect(manager.snapshot.micEnabled, isTrue);
verify(mockLocalParticipant.setMicrophoneEnabled(false, audioCaptureOptions: anyNamed('audioCaptureOptions'))).called(1);
verifyNever(mockRepository.notifyCallEnded(any));
});
test('interruption end reactivates session and restores mic', () async {
manager.markActiveCallForTesting(mockRoom);
manager.handleAudioInterruptionForTesting(AudioInterruptionEvent(true, AudioInterruptionType.pause));
await Future<void>.delayed(Duration.zero);
manager.handleAudioInterruptionForTesting(AudioInterruptionEvent(false, AudioInterruptionType.pause));
await Future<void>.delayed(Duration.zero);
expect(manager.snapshot.systemAudioInterrupted, isFalse);
expect(audioCoordinator.reactivateCalled, isTrue);
verify(mockLocalParticipant.setMicrophoneEnabled(true, audioCaptureOptions: anyNamed('audioCaptureOptions'))).called(1);
});
test('toggleMic before call stage updates intent without livekit', () async {
manager.markActiveCallForTesting(mockRoom);
manager.setCallStageEnteredForTesting(false);
await manager.toggleMic(false);
expect(manager.snapshot.micEnabled, isTrue);
verifyNever(
mockLocalParticipant.setMicrophoneEnabled(
any,
audioCaptureOptions: anyNamed('audioCaptureOptions'),
),
);
});
test(
'toggleMic from UI off while interrupted keeps interrupted and does not unmute',
() async {
manager.markActiveCallForTesting(mockRoom);
manager.handleAudioInterruptionForTesting(
AudioInterruptionEvent(true, AudioInterruptionType.pause),
);
await Future<void>.delayed(Duration.zero);
clearInteractions(mockLocalParticipant);
await manager.toggleMic(false);
expect(manager.snapshot.systemAudioInterrupted, isTrue);
expect(manager.snapshot.micEnabled, isTrue);
verifyNever(
mockLocalParticipant.setMicrophoneEnabled(
true,
audioCaptureOptions: anyNamed('audioCaptureOptions'),
),
);
},
);
test('toggleMic during interruption disables intent and keeps mic paused', () async {
manager.markActiveCallForTesting(mockRoom);
manager.handleAudioInterruptionForTesting(AudioInterruptionEvent(true, AudioInterruptionType.pause));
await Future<void>.delayed(Duration.zero);
clearInteractions(mockLocalParticipant);
await manager.toggleMic(true);
expect(manager.snapshot.micEnabled, isFalse);
expect(manager.snapshot.systemAudioInterrupted, isTrue);
verify(
mockLocalParticipant.setMicrophoneEnabled(
false,
audioCaptureOptions: anyNamed('audioCaptureOptions'),
),
).called(1);
verifyNever(
mockLocalParticipant.setMicrophoneEnabled(
true,
audioCaptureOptions: anyNamed('audioCaptureOptions'),
),
);
});
});
}

View File

@@ -3,18 +3,19 @@ import 'package:eatvio_app/features/video_calls/managers/video_call_manager_snap
import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_cubit.dart';
import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_state.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:livekit_client/livekit_client.dart' as lk;
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'video_call_session_cubit_test.mocks.dart';
@GenerateNiceMocks([MockSpec<VideoCallManager>()])
@GenerateNiceMocks([MockSpec<VideoCallManager>(), MockSpec<lk.Room>()])
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('VideoCallSessionCubit', () {
late MockVideoCallManager mockManager;
late VideoCallSessionCubit cubit;
late _TestVideoCallSessionCubit cubit;
late VideoCallManagerListener managerListener;
@@ -26,7 +27,7 @@ void main() {
managerListener =
invocation.positionalArguments[0] as VideoCallManagerListener;
});
cubit = VideoCallSessionCubit(videoCallManager: mockManager);
cubit = _TestVideoCallSessionCubit(videoCallManager: mockManager);
});
tearDown(() async {
@@ -120,12 +121,9 @@ void main() {
},
);
test('isMicActiveForUi is false when system audio interrupted', () {
const state = VideoCallSessionState(
micEnabled: true,
systemAudioInterrupted: true,
);
expect(state.isMicActiveForUi, isFalse);
test('isMicActiveForUi mirrors micEnabled', () {
const state = VideoCallSessionState(micEnabled: true);
expect(state.isMicActiveForUi, isTrue);
});
test('onCallEndedExternally resets session state', () async {
@@ -143,6 +141,213 @@ void main() {
expect(cubit.state, const VideoCallSessionState());
});
test('syncPipUiStateFromSystem skips overlay when call screen is visible', () async {
cubit.emit(
const VideoCallSessionState(
conversationUuid: 'uuid',
connectPhase: VideoCallConnectPhase.connected,
callStageEntered: true,
uiMode: VideoCallUiMode.fullscreen,
),
);
await cubit.onCallScreenVisible(conversationUuid: 'uuid');
await cubit.syncPipUiStateFromSystem();
expect(cubit.state.uiMode, VideoCallUiMode.fullscreen);
});
test('manager idle snapshot ignored while call screen is visible', () async {
when(
mockManager.startCall(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {});
await cubit.onCallScreenVisible(
conversationUuid: 'uuid',
entryMode: VideoCallEntryMode.incomingAccepted,
);
managerListener(VideoCallManagerSnapshot.initial);
expect(cubit.state.entryMode, VideoCallEntryMode.incomingAccepted);
expect(cubit.state.conversationUuid, 'uuid');
});
test('incoming accept auto-enters call stage after connect', () async {
when(
mockManager.startCall(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {
managerListener(
const VideoCallManagerSnapshot(
conversationUuid: 'uuid',
micEnabled: false,
videoEnabled: false,
connectPhase: VideoCallConnectPhase.connected,
linkIssue: VideoCallLinkIssue.none,
),
);
});
when(mockManager.onEnterCallStage()).thenAnswer((_) async => true);
await cubit.onCallScreenVisible(
conversationUuid: 'uuid',
entryMode: VideoCallEntryMode.incomingAccepted,
);
verify(
mockManager.startCall(
conversationUuid: 'uuid',
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: false,
videoEnabled: false,
),
).called(1);
verify(mockManager.onEnterCallStage()).called(1);
expect(cubit.state.entryMode, VideoCallEntryMode.incomingAccepted);
expect(cubit.state.callStageEntered, isTrue);
});
test('outgoing call keeps lobby until callee joins', () async {
when(
mockManager.startCall(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {});
when(mockManager.ensureLobbyRoomJoined()).thenAnswer((_) async {});
when(mockManager.onEnterCallStage()).thenAnswer((_) async => true);
await cubit.onCallScreenVisible(conversationUuid: 'uuid');
verifyNever(mockManager.onEnterCallStage());
expect(cubit.state.entryMode, VideoCallEntryMode.outgoing);
expect(cubit.state.callStageEntered, isFalse);
expect(cubit.state.micEnabled, isFalse);
managerListener(
const VideoCallManagerSnapshot(
conversationUuid: 'uuid',
micEnabled: false,
videoEnabled: false,
connectPhase: VideoCallConnectPhase.connected,
linkIssue: VideoCallLinkIssue.none,
),
);
await Future<void>.delayed(Duration.zero);
verify(mockManager.ensureLobbyRoomJoined()).called(1);
verifyNever(mockManager.onEnterCallStage());
});
test('outgoing call auto-enters when callee joins lobby room', () async {
when(
mockManager.startCall(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {});
when(mockManager.ensureLobbyRoomJoined()).thenAnswer((_) async {});
when(mockManager.onEnterCallStage()).thenAnswer((_) async => true);
await cubit.onCallScreenVisible(conversationUuid: 'uuid');
managerListener(
const VideoCallManagerSnapshot(
conversationUuid: 'uuid',
micEnabled: false,
videoEnabled: false,
connectPhase: VideoCallConnectPhase.connected,
linkIssue: VideoCallLinkIssue.none,
counterpartPresentInLobby: true,
),
);
await Future<void>.delayed(Duration.zero);
verify(mockManager.onEnterCallStage()).called(1);
expect(cubit.state.callStageEntered, isTrue);
});
test('duplicate onCallScreenVisible does not restart connecting call', () async {
when(
mockManager.startCall(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {});
await cubit.onCallScreenVisible(
conversationUuid: 'uuid',
entryMode: VideoCallEntryMode.incomingAccepted,
);
await cubit.onCallScreenVisible(
conversationUuid: 'uuid',
entryMode: VideoCallEntryMode.outgoing,
);
verify(
mockManager.startCall(
conversationUuid: 'uuid',
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: false,
videoEnabled: false,
),
).called(1);
expect(cubit.state.entryMode, VideoCallEntryMode.incomingAccepted);
});
test('leaveCallRoute minimizes to pip and marks call screen not visible', () async {
final mockRoom = MockRoom();
when(mockManager.room).thenReturn(mockRoom);
when(
mockManager.onCallScreenVisible(
conversationUuid: anyNamed('conversationUuid'),
counterpartName: anyNamed('counterpartName'),
localParticipantName: anyNamed('localParticipantName'),
micEnabled: anyNamed('micEnabled'),
videoEnabled: anyNamed('videoEnabled'),
),
).thenAnswer((_) async {});
cubit.emit(
const VideoCallSessionState(
conversationUuid: 'uuid',
connectPhase: VideoCallConnectPhase.connected,
callStageEntered: true,
uiMode: VideoCallUiMode.fullscreen,
),
);
await cubit.onCallScreenVisible(conversationUuid: 'uuid');
expect(cubit.isCallScreenRouteVisible, isTrue);
await cubit.leaveCallRoute();
expect(cubit.state.uiMode, VideoCallUiMode.pip);
expect(cubit.isCallScreenRouteVisible, isFalse);
});
test('tracks whether call screen route is visible', () async {
when(
mockManager.startCall(
@@ -171,3 +376,12 @@ void main() {
});
});
}
class _TestVideoCallSessionCubit extends VideoCallSessionCubit {
_TestVideoCallSessionCubit({required super.videoCallManager});
bool grantMicOnRequest = false;
@override
Future<bool> requestMicPermissionForCall() async => grantMicOnRequest;
}