feat: enhance PeerConnectionManager with RTP traffic monitoring, disposal barrier, and pretty JSON logging (#864)

* refactor: extract PeerConnectionManager logic and implement disposal barrier

- Extract `RTCPeerConnection` lifecycle management (create, retrieve, dispose) into `PeerConnectionManager`.
- Implement `PeerConnectionFactory` interface to abstract native WebRTC calls for testability.
- Add "Disposal Barrier" mechanism to prevent race conditions during rapid call cycling.
- Remove inline `Completer` logic from `CallBloc`, simplifying the state machine.
- Add unit and integration tests covering race conditions, zombie connections, and timeouts.

* test: migrate PeerConnectionManager tests to integration_test binding

* refactor: make DefaultPeerConnectionFactory configurable and reuse default ICE config

* docs: clarify PeerConnectionManager factory responsibility for connection configuration

* test: update PeerConnectionManager unit tests for factory API and verify close on replacement

* fix: log dispose errors when cleaning up peer connections

* feat: add RTP traffic monitoring with scoped logging and wire into PeerConnectionManager

* refactor: simplify RTP monitor logging and adjust configuration notes

* refactor: clarify PeerConnectionManager variable naming and improve event logging

* docs: document non-awaited peer connection disposal and disposal barrier rationale

* refactor: simplify RTP traffic logging delegate configuration

* refactor: inject PeerConnectionManager from MainShell

* fix: align logPretty calls with new (data, tag) signature after rebase

Author: SERDUN

integration_test/features/call/utils/peer_connection_manager_integration_test.dart

@@ -404,6 +404,11 @@ class _MainShellState extends State<MainShell> with WidgetsBindingObserver {
                       // If CDRs feature is disabled, the worker will be null and no sync will be performed
                       final cdrsSyncWorker = context.readOrNull<CdrsSyncWorker>();
 
+                      final peerConnectionManager = PeerConnectionManager(
+                        retrieveTimeout: kPeerConnectionRetrieveTimeout,
+                        monitorDelegatesFactory: (callId, logger) => [LoggingRtpTrafficMonitorDelegate(logger: logger)],
+                      );
+
                       return CallBloc(
                         coreUrl: appBloc.state.session.coreUrl!,
                         tenantId: appBloc.state.session.tenantId,
@@ -439,6 +444,7 @@ class _MainShellState extends State<MainShell> with WidgetsBindingObserver {
                           DiagnosticType.androidCallkeepOnly,
                           extras: {'callId': id, 'error': error.name},
                         ),
+                        peerConnectionManager: peerConnectionManager,
                       )..add(const CallStarted());
                     },
                   ),

lib/app/router/main_shell.dart

@@ -0,0 +1,41 @@
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+import 'package:logging/logging.dart';
+
+import 'package:webtrit_phone/extensions/logger_extensions.dart';
+
+import 'rtp_traffic_monitor.dart';
+
+class LoggingRtpTrafficMonitorDelegate implements RtpTrafficMonitorDelegate {
+  LoggingRtpTrafficMonitorDelegate({required this.logger, this.prettyPrintData = true});
+
+  final Logger logger;
+
+  final bool prettyPrintData;
+
+  @override
+  void onStatsUpdated(RtpTrafficContext context, StatsReport report, RtpTrafficMetrics metrics) {
+    _logSummary(context, metrics);
+
+    if (prettyPrintData) {
+      _logDetails(context, report);
+    }
+  }
+
+  void _logSummary(RtpTrafficContext context, RtpTrafficMetrics metrics) {
+    final directionStr = context.direction.name.toUpperCase();
+    final kindStr = context.kind.name.toUpperCase();
+    final statusStr = metrics.isFlowing ? 'Flowing' : 'STALLED';
+    final sign = metrics.deltaBytes > 0 ? '+' : '';
+
+    logger.finer(
+      '[$directionStr $kindStr] '
+      'Bytes: $sign${metrics.deltaBytes} | '
+      'Frames: ${metrics.deltaFrames} | '
+      'Status: $statusStr',
+    );
+  }
+
+  void _logDetails(RtpTrafficContext context, StatsReport report) {
+    logger.logPretty(report.values, tag: '${context.kind.name} ${context.direction.name}-rtp data', level: Level.INFO);
+  }
+}

lib/features/call/bloc/call_bloc.dart

@@ -0,0 +1,35 @@
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+
+/// Abstract factory to create [RTCPeerConnection] instances.
+abstract interface class PeerConnectionFactory {
+  Future<RTCPeerConnection> create([
+    Map<String, dynamic> configuration = const {},
+    Map<String, dynamic> constraints = const {},
+  ]);
+}
+
+/// Default implementation using the actual Flutter WebRTC plugin.
+class DefaultPeerConnectionFactory implements PeerConnectionFactory {
+  static const Map<String, dynamic> _defaultIceConfiguration = {
+    'iceServers': [
+      {'url': 'stun:stun.l.google.com:19302'},
+    ],
+  };
+
+  final Map<String, dynamic> _defaultConfiguration;
+
+  const DefaultPeerConnectionFactory({Map<String, dynamic> defaultConfiguration = _defaultIceConfiguration})
+    : _defaultConfiguration = defaultConfiguration;
+
+  @override
+  Future<RTCPeerConnection> create([
+    Map<String, dynamic> configuration = const {},
+    Map<String, dynamic> constraints = const {},
+  ]) {
+    // Use default configuration only if the provided one is empty.
+    // This allows passing specific configurations when needed.
+    final effectiveConfiguration = configuration.isEmpty ? _defaultConfiguration : configuration;
+
+    return createPeerConnection(effectiveConfiguration, constraints);
+  }
+}