flutter – Name Monitoring with CallKit Works in Debug Mode however Not in Launch (TestFlight) – iOS

I’m engaged on an iOS app utilizing Flutter that tracks outgoing calls utilizing CallKit. The decision monitoring performance works completely in Debug mode however doesn’t work when the app is printed to TestFlight.

I’ve already added Background Modes (voip, audio, processing, fetch) in Information.plist.
I’ve added CallKit.framework in Xcode underneath Hyperlink Binary With Libraries (set to Non-obligatory).
I’ve additionally added the required entitlements in Runner.entitlements:

    aps-environment
    manufacturing

These are the required permission which I utilized in information.plist:

    BGTaskSchedulerPermittedIdentifiers
    
        com.agent.mygenie
    
    CADisableMinimumFrameDurationOnPhone
    
    CFBundleDevelopmentRegion
    $(DEVELOPMENT_LANGUAGE)
    CFBundleDisplayName
    MyGenie
    CFBundleDocumentTypes
    
    CFBundleExecutable
    $(EXECUTABLE_NAME)
    CFBundleIdentifier
    $(PRODUCT_BUNDLE_IDENTIFIER)
    CFBundleInfoDictionaryVersion
    6.0
    CFBundleName
    mygenie
    CFBundlePackageType
    APPL
    CFBundleShortVersionString
    $(FLUTTER_BUILD_NAME)
    CFBundleSignature
    ????
    CFBundleVersion
    $(FLUTTER_BUILD_NUMBER)
    LSRequiresIPhoneOS
    
    NSCallKitUsageDescription
    This app wants entry to CallKit for name dealing with
    NSContactsUsageDescription
    This app wants entry to your contacts for calls
    NSMicrophoneUsageDescription
    This app wants entry to microphone for calls
    NSPhotoLibraryUsageDescription
    This app wants entry to photograph library for profile image updation
    UIApplicationSupportsIndirectInputEvents
    
    UIBackgroundModes
    
        voip
        processing
        fetch
        audio
    
    UILaunchStoryboardName
    LaunchScreen
    UIMainStoryboardFile
    Fundamental
    UISupportedInterfaceOrientations
    
        UIInterfaceOrientationPortrait
        UIInterfaceOrientationLandscapeLeft
        UIInterfaceOrientationLandscapeRight
    
    UISupportedInterfaceOrientations~ipad
    
        UIInterfaceOrientationPortrait
        UIInterfaceOrientationPortraitUpsideDown
        UIInterfaceOrientationLandscapeLeft
        UIInterfaceOrientationLandscapeRight
    

That is the app delegate.swift file code :-

import Flutter
import UIKit
import CallKit
import AVFoundation

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
    // MARK: - Properties
    non-public var callObserver: CXCallObserver?
    non-public var callStartTime: Date?
    non-public var flutterChannel: FlutterMethodChannel?
    non-public var isCallActive = false
    non-public var currentCallDuration: Int = 0
    non-public var callTimer: Timer?
    non-public var lastKnownDuration: Int = 0
    non-public var isOutgoingCall = false
    
    // MARK: - Software Lifecycle
    override func software(
        _ software: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        // Guarantee window and root view controller are correctly arrange
        guard let controller = window?.rootViewController as? FlutterViewController else {
            print("Didn't get FlutterViewController")
            return false
        }
        
        // Setup Flutter plugins
        do {
            attempt GeneratedPluginRegistrant.register(with: self)
        } catch {
            print("Didn't register Flutter plugins: (error)")
            return false
        }
        
        // Setup methodology channel
        setupMethodChannel(controller: controller)
        
        // Setup name observer
        setupCallObserver()
        
        return tremendous.software(software, didFinishLaunchingWithOptions: launchOptions)
    }
    
    // MARK: - Non-public Strategies
    non-public func setupMethodChannel(controller: FlutterViewController) {
        flutterChannel = FlutterMethodChannel(
            title: "callkit_channel",
            binaryMessenger: controller.binaryMessenger
        )
        
        flutterChannel?.setMethodCallHandler { [weak self] (name, outcome) in
            self?.handleMethodCall(name, outcome: outcome)
        }
    }
    
    non-public func handleMethodCall(_ name: FlutterMethodCall, outcome: @escaping FlutterResult) {
        change name.methodology {
        case "checkCallStatus":
            outcome([
                "isActive": isCallActive,
                "duration": currentCallDuration,
                "isOutgoing": isOutgoingCall
            ])
            
        case "getCurrentDuration":
            outcome(currentCallDuration)
            
        case "requestPermissions":
            requestPermissions(outcome: outcome)
            
        case "initiateOutgoingCall":
            isOutgoingCall = true
            outcome(true)
            
        default:
            outcome(FlutterMethodNotImplemented)
        }
    }
    
    non-public func setupCallObserver() {
        print("Inside the decision observer setup")
        #if DEBUG
            callObserver = CXCallObserver()
            callObserver?.setDelegate(self, queue: .important)
                print("Name Equipment performance is enabled for this pretend surroundings")
        #else
            // Verify if the app is working in a launch surroundings
            if Bundle.important.bundleIdentifier == "com.agent.mygenie" {
                callObserver = CXCallObserver()
                callObserver?.setDelegate(self, queue: .important)
                print("Name Equipment performance is enabled for this prod surroundings")
            } else {
                print("Name Equipment performance isn't enabled for this surroundings")
            }
        #endif
        // callObserver = CXCallObserver()
        // callObserver?.setDelegate(self, queue: .important)
    }
    
    non-public func startCallTimer() {
        guard isOutgoingCall else { return }
        
        print("Beginning name timer for outgoing name")
        callTimer?.invalidate()
        currentCallDuration = 0
        callStartTime = Date()
        lastKnownDuration = 0
        
        callTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.updateCallDuration()
        }
    }
    
    non-public func updateCallDuration() {
        guard let startTime = callStartTime else { return }
        
        currentCallDuration = Int(Date().timeIntervalSince(startTime))
        lastKnownDuration = currentCallDuration
        
        print("Present length: (currentCallDuration)")
        
        flutterChannel?.invokeMethod("onCallDurationUpdate", arguments: [
            "duration": currentCallDuration,
            "isOutgoing": true
        ])
    }
    
    non-public func stopCallTimer() {
        guard isOutgoingCall else { return }
        
        print("Stopping name timer")
        callTimer?.invalidate()
        callTimer = nil
        
        if let startTime = callStartTime {
            let finalDuration = Int(Date().timeIntervalSince(startTime))
            currentCallDuration = max(finalDuration, lastKnownDuration)
            print("Ultimate length calculated: (currentCallDuration)")
        } else {
            currentCallDuration = lastKnownDuration
            print("Utilizing final recognized length: (lastKnownDuration)")
        }
    }
    
    non-public func requestPermissions(outcome: @escaping FlutterResult) {
        AVAudioSession.sharedInstance().requestRecordPermission { granted in
            DispatchQueue.important.async {
                print("Microphone permission granted: (granted)")
                outcome(granted)
            }
        }
    }
    
    non-public func resetCallState() {
        isCallActive = false
        isOutgoingCall = false
        currentCallDuration = 0
        lastKnownDuration = 0
        callStartTime = nil
        callTimer?.invalidate()
        callTimer = nil
    }
}

// MARK: - CXCallObserverDelegate
extension AppDelegate: CXCallObserverDelegate {
    func callObserver(_ callObserver: CXCallObserver, callChanged name: CXCall) {
        // Replace outgoing name standing if wanted
        if !isOutgoingCall {
            isOutgoingCall = name.isOutgoing
        }
        
        // Solely course of outgoing calls
        guard isOutgoingCall else {
            print("Ignoring incoming name")
            return
        }
        
        handleCallStateChange(name)
    }
    
    non-public func handleCallStateChange(_ name: CXCall) {
        if name.hasConnected && isOutgoingCall {
            handleCallConnected()
        }
        
        if name.hasEnded && isOutgoingCall {
            handleCallEnded()
        }
    }
    
    non-public func handleCallConnected() {
        print("Outgoing name related")
        isCallActive = true
        startCallTimer()
        
        flutterChannel?.invokeMethod("onCallStarted", arguments: [
            "isOutgoing": true
        ])
    }
    
    non-public func handleCallEnded() {
        print("Outgoing name ended")
        isCallActive = false
        stopCallTimer()
        
        let finalDuration = max(currentCallDuration, lastKnownDuration)
        print("Sending ultimate length: (finalDuration)")
        
        DispatchQueue.important.asyncAfter(deadline: .now() + 0.5) { [weak self] in
            self?.sendCallEndedEvent(length: finalDuration)
        }
    }
    
    non-public func sendCallEndedEvent(length: Int) {
        flutterChannel?.invokeMethod("onCallEnded", arguments: [
            "duration": duration,
            "isOutgoing": true
        ])
        resetCallState()
    }
}

// MARK: - CXCall Extension
extension CXCall {
    var isOutgoing: Bool {
        return hasConnected && !hasEnded
    }
}

and that is how I setup it in flutter utilizing methodology channel in a one mixing file to connect that file on a display the place I wanted it :-

import 'dart:async';
import 'bundle:flutter/providers.dart';
import 'bundle:flutter/materials.dart';
import 'dart:io';
import 'bundle:get/get.dart';
import 'bundle:MyGenie/call_state.dart';

mixin CallTrackingMixin on State {
  ultimate CallStateManager callStateManager = CallStateManager();
  static const MethodChannel platform = MethodChannel('callkit_channel');

  Timer? _callDurationTimer;
  bool _isCallActive = false;
  int _currentCallDuration = 0;
  int _callTimeDuration = 0;
  DateTime? _callStartTime;
  StreamController? _durationController;
  int _lastKnownDuration = 0;
  bool _isApiCalled = false;

  @override
  void initState() {
    tremendous.initState();
    print("InitState - Organising name monitoring");
    _setupCallMonitoring();
    print("Name monitoring setup accomplished");
  }

  @override
  void dispose() {
    _durationController?.shut();
    tremendous.dispose();
  }

  Future _setupCallMonitoring() async {
      print("Organising name monitoring");
      _durationController?.shut();
      _durationController = StreamController.broadcast();

      platform.setMethodCallHandler((MethodCall name) async {
        print("Methodology name acquired: ${name.methodology}");

        if (!mounted) {
          print("Widget not mounted, returning");
          return;
        }

        change (name.methodology) {
          case 'onCallStarted':
            print("Name began - Resetting states");
            setState(() {
              _isCallActive = true;
              _callStartTime = DateTime.now();
              _isApiCalled = false; // Reset right here explicitly
            });
            print("Name states reset - isApiCalled: $_isApiCalled");
            break;

          case 'onCallEnded':
            print("Name ended occasion acquired");
            print("Present isApiCalled standing: $_isApiCalled");
            if (name.arguments != null) {
              ultimate Map args = name.arguments;
              ultimate int length = args['duration'] as int;
              print("Processing name finish with length: $_callTimeDuration");

              // Pressure reset isApiCalled right here
              setState(() {
                _isApiCalled = false;
              });

              await _handleCallEnded(_currentCallDuration);
            }
            setState(() {
              _isCallActive = false;
            });
            break;

          case 'onCallDurationUpdate':
            if (name.arguments != null && mounted) {
              ultimate Map args = name.arguments;
              ultimate int length = args['duration'] as int;
              setState(() {
                _currentCallDuration = length;
                _lastKnownDuration = length;
                _callTimeDuration = length;
              });
              _durationController?.add(length);
              print("Period replace: $length seconds");
            }
            break;
        }
      });
    
  }

  void resetCallState() {
    print("Resetting name state");
    setState(() {
      _isApiCalled = false;
      _isCallActive = false;
      _currentCallDuration = 0;
      _lastKnownDuration = 0;
      _callTimeDuration = 0;
      _callStartTime = null;
    });
    print("Name state reset accomplished - isApiCalled: $_isApiCalled");
  }

  Future _handleCallEnded(int durationInSeconds) async {
    print("Getting into _handleCallEnded");
    print("Present state - isApiCalled: $_isApiCalled, mounted: $mounted");
    print("Period to course of: $durationInSeconds seconds");

    // Pressure test and reset if wanted
    if (_isApiCalled) {
      print("Resetting isApiCalled flag because it was true");
      setState(() {
        _isApiCalled = false;
      });
    }

    if (mounted) {
      ultimate length = Period(seconds: durationInSeconds);
      ultimate formattedDuration = _formatDuration(length);
      print("Processing name finish with length: $formattedDuration");

      if (durationInSeconds == 0 && _callStartTime != null) {
        ultimate fallbackDuration = DateTime.now().distinction(_callStartTime!);
        ultimate fallbackSeconds = fallbackDuration.inSeconds;
        print("Utilizing fallback length: $fallbackSeconds seconds");
        await _saveCallDuration(fallbackSeconds);
      } else {
        print("Utilizing offered length: $durationInSeconds seconds");
        await _saveCallDuration(durationInSeconds);
      }

      setState(() {
        _isApiCalled = true;
      });
      print("Name processing accomplished - isApiCalled set to true");
    } else {
      print("Widget not mounted, skipping name processing");
    }
  }

  Future _saveCallDuration(int durationInSeconds) async {
    if (durationInSeconds > 0) {
      ultimate formattedDuration =
          _formatDuration(Period(seconds: durationInSeconds));

      if (callStateManager.callId.isNotEmpty) {
        saveRandomCallDuration(formattedDuration);
      }
      if (callStateManager.leadCallId.isNotEmpty) {
        saveCallDuration(formattedDuration);
      }
    } else {
      print("Warning: Making an attempt to avoid wasting zero length");
    }
  }

  void saveCallDuration(String length);
  void saveRandomCallDuration(String length);

  String _formatDuration(Period length) {
    String twoDigits(int n) => n.toString().padLeft(2, '0');
    String hours =
        length.inHours > 0 ? '${twoDigits(length.inHours)}:' : '';
    String minutes = twoDigits(length.inMinutes.the rest(60));
    String seconds = twoDigits(length.inSeconds.the rest(60));
    return '$hours$minutes:$seconds';
  }

  void resetCallTracking() {
    _setupCallMonitoring();
  }
}

And that is the main_call.dart file code the place I am saving name length to the database with api :-

@override
  Future saveRandomCallDuration(String length) async {
    await Sentry.captureMessage("save random name Period :- ${length} in opposition to this id :- ${callStateManager.callId}");
    print(
        "save random name Period :- ${length} in opposition to this id :- ${callStateManager.callId}");
    attempt {
      String token = await SharedPreferencesHelper.getFcmToken();
      String apiUrl = ApiUrls.saveRandomCallDuration;
      ultimate response = await http.publish(
        Uri.parse(apiUrl),
        headers: {
          'Content material-Sort': 'software/json',
          'Settle for': 'software/json',
          'Authorization': 'Bearer $token',
        },
        physique: jsonEncode({
          "id": callStateManager.callId,
          "call_duration": length
          //default : lead name ; filters : random name
        }),
      );

      if (response.statusCode == 200) {
        _isApiCalled = true;
        saveCallId = '';
        callStateManager.clearCallId();
        resetCallState();
        setState(() {});
      } else {
        setState(() {
          _isApiCalled = true;
          saveCallId = '';
          callStateManager.clearCallId();
          resetCallState();
          //showCustomSnackBar("One thing went improper",isError: true);
        });
      }
    } catch (exception, stackTrace) {
      _isApiCalled = true;
      saveCallId = '';
      callStateManager.clearCallId();
      resetCallState();
      debugPrint("CATCH Error");
      await Sentry.captureException(exception, stackTrace: stackTrace);
      //showCustomSnackBar("One thing went improper",isError: true);
      setState(() {});
    }
  }

• Verified logs in Console.app (No CallKit logs seem in TestFlight).
• Checked that CallKit.framework is linked however not embedded.
• Confirmed that App ID has VoIP and Background Modes enabled within the Apple Developer Portal.
• Tried utilizing UIApplication.shared.beginBackgroundTask to maintain the app alive throughout a name.
• These “Organising name monitoring”, “Name state reset accomplished – isApiCalled: $_isApiCalled” and all these strains print(“Getting into _handleCallEnded”);
  print(“Present state – isApiCalled: $_isApiCalled, mounted: $mounted”);
  print(“Period to course of: $durationInSeconds seconds”); however durationInSeconds has 0 worth in it in mixing file code strains are printing in console.app logs

1. Why does CallKit cease working within the Launch/TestFlight construct however works tremendous in Debug?
2. How can I be certain that CXCallObserver detects calls in a TestFlight construct?
3. Is there an extra entitlement or configuration required for CallKit to work in launch mode?