fix(call): handle incoming call hangup when signaling is unavailable (WT-1080) (#1106)

* fix(call): [WT-1080] placeholder — implement incoming call hangup when signaling unavailable

* fix(call): send decline when incoming call registration fails (WT-1080)

Path 1 (_onCallPushEventIncoming): iOS CXProvider may reject incoming call
registration before the user sees it (DND, blocklist, unentitled). Since
signaling is disconnected at push-receive time we cannot decline immediately.
The server replays the incoming event on next handshake reconnect, which
re-enters Path 2 where the SIP line is now known. Replaced the silent drop
with a descriptive log and explanation of the recovery path.

Path 2 (__onCallSignalingEventIncoming): when reportNewIncomingCall returns
an unexpected error (callRejectedBySystem on Android, unknown/internal on iOS)
send a DeclineRequest immediately. The call was never shown to the user so
performEndCall will not fire. _signalingModule.execute returns null when
disconnected — the ?. operator handles that safely.

Author: SERDUN

lib/features/call/bloc/call_bloc.dart

@@ -774,8 +774,25 @@ class CallBloc extends Bloc<CallEvent, CallState> with WidgetsBindingObserver im
   Future<void> _onCallPushEventIncoming(_CallPushEventIncoming event, Emitter<CallState> emit) async {
     final eventError = event.error;
     if (eventError != null) {
-      _logger.warning('_onCallPushEventIncoming event.error: $eventError');
-      // TODO: implement correct incoming call hangup (take into account that _signalingClient is disconnected)
+      // iOS only: CXProvider rejected the incoming call registration before it was
+      // ever presented to the user (e.g. DND / Focus active, Call Directory blocklist,
+      // missing VoIP entitlement, or unexpected CXProvider failure).
+      //
+      // Consequences:
+      // - performEndCall will NOT fire (CallKit never registered the call).
+      // - _signalingModule is very likely disconnected: VoIP push wakes the app
+      //   before the WebSocket is established, so the CXProvider completion fires
+      //   before signaling reconnects.
+      //
+      // Recovery path: when signaling reconnects the server replays the incoming
+      // call event via the handshake. HandshakeProcessor generates a
+      // HandleIncomingCallAction for the unknown callId, which re-enters
+      // __onCallSignalingEventIncoming. At that point we have the SIP line and
+      // can send a DeclineRequest immediately (see that method below).
+      _logger.warning(
+        '_onCallPushEventIncoming: OS rejected call registration '
+        '(callId: ${event.callId}, error: $eventError) — server will be notified on next handshake',
+      );
       return;
     }
 
@@ -950,8 +967,30 @@ class CallBloc extends Bloc<CallEvent, CallState> with WidgetsBindingObserver im
     final callAlreadyTerminated = error == CallkeepIncomingCallError.callIdAlreadyTerminated;
 
     if (error != null && !callAlreadyExists && !callAlreadyAnswered && !callAlreadyTerminated) {
-      _logger.warning('__onCallSignalingEventIncoming reportNewIncomingCall error: $error');
-      // TODO: implement correct incoming call hangup (take into account that _signalingClient could be disconnected)
+      // reportNewIncomingCall rejected the call with an unexpected error:
+      //   - Android: callRejectedBySystem — Telecom already has a call in RINGING state
+      //     (AOSP behaviour, Android 11+), or the 5 s Telecom confirmation timeout elapsed.
+      //   - iOS: unknown / unentitled / internal — rare CXProvider failure on the
+      //     signaling-path reportNewIncomingCall (not the VoIP-push path).
+      //
+      // The call was never presented to the user, so performEndCall will NOT fire.
+      // Notify the server immediately so the remote party is not left ringing.
+      // _signalingModule.execute returns null when disconnected — the ?. handles that safely.
+      _logger.warning(
+        '__onCallSignalingEventIncoming: reportNewIncomingCall error=$error '
+        '(callId: ${event.callId}, line: ${event.line}) — sending decline',
+      );
+      await _signalingModule
+          .execute(
+            DeclineRequest(
+              transaction: WebtritSignalingClient.generateTransactionId(),
+              line: event.line,
+              callId: event.callId,
+            ),
+          )
+          ?.catchError((e, s) {
+            callErrorReporter.handle(e, s, '__onCallSignalingEventIncoming declineRequest error');
+          });
       return;
     }