Hey there! I totally get the frustration here—when you fire off a FaceTime call with an invalid number, the system tells you everything worked (via canOpenURL and the open completion handler), but the call window just flashes and dies. Let’s break down why this happens and walk through some solid fixes.

Why This Happens #

First, a quick reality check:

• canOpenURL(_:) only verifies that the facetime:// scheme is supported by the system—it doesn’t validate the actual number/URL content.
• The open(_:options:completionHandler:) callback returns true because the system successfully processed the URL request, not because the FaceTime call itself succeeded. Apple doesn’t expose direct status updates for FaceTime calls through this API, so we have to get creative.

Solution 1: Pre-Validate Number Formats (Foundational Step) #

Even though you mentioned knowing you need to validate, let’s make this robust. FaceTime accepts phone numbers (with proper international formatting, e.g., +1234567890) and email addresses. Use regex to catch obvious invalid entries before even trying to open the URL.

Example Swift regex for phone numbers (adjust for your target regions):

func isValidFaceTimeNumber(_ number: String) -> Bool {
    // Matches numbers with optional +, digits only, 10-15 characters (adjust as needed)
    let phoneRegex = #"^\+?[0-9]{10,15}$"#
    return NSPredicate(format: "SELF MATCHES %@", phoneRegex).evaluate(with: number)
}

This weeds out garbage like 123456789 before it ever reaches FaceTime.

Solution 2: Indirect Status Check via App State (iOS <15) #

For older iOS versions, we can leverage app lifecycle changes to detect failed calls. When you launch FaceTime, your app moves to the background. If the call fails immediately, the system bounces your app back to the foreground quickly. We can use a timer to check this:

func startFaceTimeCall(for number: String) {
    guard let facetimeURL = URL(string: "facetime://\(number)"), isValidFaceTimeNumber(number) else {
        showFailureAlert()
        return
    }
    
    UIApplication.shared.open(facetimeURL) { [weak self] success in
        guard let self = self, success else {
            self?.showFailureAlert()
            return
        }
        
        // Set a timer to check if we're back in the foreground too soon
        Timer.scheduledTimer(withTimeInterval: 2.5, repeats: false) { _ in
            if UIApplication.shared.applicationState == .active {
                // App returned to foreground—likely the call failed
                self.showFailureAlert()
            }
        }
    }
}

private func showFailureAlert() {
    let alert = UIAlertController(title: "Call Failed", message: "Please check if the number is valid.", preferredStyle: .alert)
    alert.addAction(UIAlertAction(title: "OK", style: .default))
    present(alert, animated: true)
}

Notes:

• Adjust the timer interval (2.5 seconds works for most cases) based on testing.
• Always invalidate the timer if your view controller deallocates to avoid retain cycles.

Solution 3: Use CallKit (iOS 15+) #

Apple introduced better FaceTime integration via CallKit in iOS 15, which gives us direct error feedback and call state updates. This is the most reliable approach for modern iOS versions:

First, import CallKit:

import CallKit

Then implement the call initiation and state monitoring:

class FaceTimeCallManager: NSObject, CXCallObserverDelegate {
    private let callController = CXCallController()
    private let callObserver = CXCallObserver()
    
    override init() {
        super.init()
        callObserver.setDelegate(self, queue: DispatchQueue.main)
    }
    
    func startVideoCall(with number: String) {
        let handle = CXHandle(type: .phoneNumber, value: number)
        let startAction = CXStartCallAction(call: UUID(), handle: handle)
        startAction.isVideo = true // Set to false for FaceTime Audio
        
        let transaction = CXTransaction(action: startAction)
        callController.request(transaction) { [weak self] error in
            if let error = error {
                print("Call request failed: \(error.localizedDescription)")
                self?.showFailureAlert()
                return
            }
        }
    }
    
    // MARK: - CXCallObserverDelegate
    func callObserver(_ callObserver: CXCallObserver, callChanged call: CXCall) {
        // Detect calls that end immediately with no duration (likely invalid number)
        if call.hasEnded && call.duration == 0 {
            showFailureAlert()
        }
    }
    
    private func showFailureAlert() {
        // Present alert from your view controller (adjust as needed)
        guard let topVC = UIApplication.shared.keyWindow?.rootViewController else { return }
        let alert = UIAlertController(title: "Call Failed", message: "Invalid number or FaceTime unavailable.", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        topVC.present(alert, animated: true)
    }
}

Why this works:

• CallKit will return an error immediately if the number is malformed or unsupported.
• The CXCallObserver lets us track when a call ends prematurely, which is a strong signal of an invalid number.

Final Recommendations #

• For iOS 15+, use the CallKit approach—it’s the most reliable and Apple-approved method.
• For older versions, combine strict number validation with the app state timer check.
• Always test edge cases (e.g., numbers with special characters, short numbers, invalid emails) to refine your validation and detection logic.

内容的提问来源于stack exchange，提问作者Snacks