Xcode 27 and Airbridge Deep Links: Moving to the Scene-Based Life Cycle

Learn which iOS apps must adopt scenes by April 2027, where Airbridge deep-link calls belong, and what cross-platform frameworks require.

Airbridge5 min read
Xcode 27 and Airbridge Deep Links: Moving to the Scene-Based Life Cycle

Key Takeaway

  • iOS apps using the app delegate life cycle must switch to the scene-based life cycle before building with Xcode 27, and for a deep link that opens a terminated app, call trackDeeplinkWithConnectionOptions: and handleDeeplinkWithConnectionOptions:onSuccess: in scene:willConnectToSession:options:.
  • Starting in April 2027, App Store Connect requires all uploaded iOS apps to be built with the iOS 27 SDK and Xcode 27 or later.
  • In the Scene lifecycle, React Native apps with deep-link collection code in AppDelegate may fail to collect deep-link events under Xcode 27, Flutter apps must set UISceneStoryboardFile to Main, and the Airbridge Expo SDK supports scenes from Expo SDK 58 without additional code.

You update your local build environment to the latest Xcode and compile your iOS subscription app on a test device. When you are wearing five hats and running paid acquisition on a tight budget, you have very little engineering time to spend debugging build updates. If your iOS project still relies on the app delegate life cycle, it must switch to the scene-based life cycle and move existing life-cycle methods from UIApplicationDelegate to UISceneDelegate when building with Xcode 27 or later.

Why AppDelegate callbacks stop firing

An iOS app that still uses the app delegate life cycle can fail to open when built with Xcode 27 or later, so it must switch to the scene-based life cycle. Migrating your app life-cycle logic means moving your existing life-cycle methods from UIApplicationDelegate over to UISceneDelegate Transitioning to the UIKit scene-based life cycle.

Once an iOS app adopts the Scene lifecycle through UIApplicationSceneManifest, the existing AppDelegate callbacks identified for that lifecycle are no longer called.

April 2027 deadline and affected apps

Xcode 27 is currently available. Starting in April 2027, iOS apps uploaded to App Store Connect must be built with the iOS 27 SDK or later, which requires Xcode 27 or later.

If you continue building with Xcode 26 to delay the migration, you have a strict cutoff. Apps built with Xcode 26 can be uploaded to App Store Connect only before April 2027; to keep releasing app updates, you must switch to the scene-based life cycle before then.

Not every iOS codebase requires manual migration work. Apps using the SwiftUI app life cycle already manage screens by scene and do not need to switch to the scene-based life cycle. Before touching your delegate files, check how your app entry point is structured so you do not spend engineering hours refactoring a SwiftUI project that already uses scenes.

Before writing the scene callbacks in Airbridge, make sure your Xcode project has the required URL schemes and domains registered. To set up scheme deep links in the app, add YOUR_SCHEME under Xcode’s [YOUR_PROJECT] > [Info] > [URL Types]. To set up Universal Links in the app, add the Associated Domains capability in Xcode and add applinks:YOUR_APP_NAME.airbridge.io and applinks:YOUR_APP_NAME.abr.ge.

In UISceneDelegate, iOS separates cold starts from warm starts across different methods, so you need to place your tracking and handling calls in the exact callback that matches the app's state when the link is tapped:

  • When a deep link opens a terminated app, scene:willConnectToSession:options: takes connectionOptions; call trackDeeplinkWithConnectionOptions: and then handleDeeplinkWithConnectionOptions:onSuccess:.
  • When the app is in the background and receives a Universal Link, call trackDeeplinkWithUserActivity: and then handleDeeplinkWithUserActivity:onSuccess: in scene:continueUserActivity:, passing userActivity to both.
  • In Swift, when the app is in the background and receives a scheme deep link, call Airbridge.trackDeeplink(openURLContexts:) with URLContexts and then Airbridge.handleDeeplink(openURLContexts:) in scene(_:openURLContexts:).

How the SDK responds depends on the link's origin. When an app opens through an Airbridge deep link, isAirbridgeDeeplink is true and the configured deep link is delivered as the callback function's url. When an app opens through a non-Airbridge deep link, isAirbridgeDeeplink is false and the callback function is not called.

Fixing React Native, Flutter, and Expo builds

Cross-platform frameworks wrap native iOS lifecycle events differently, which changes how SceneDelegate interacts with your JavaScript or Dart layer.

In the React Native SDK iOS troubleshooting context, if the deep-link collection code was added to AppDelegate as in the developer-guide examples, an app built with Xcode 27 may show a blank screen or fail to render properly, and Airbridge deep-link events may not be collected when the app is opened through a scheme deep link or Universal Link.

For a Flutter app using the Scene lifecycle, UISceneStoryboardFile must be set to Main in your iOS configuration; without it, FlutterViewController is not created as the scene's rootViewController and plugin registration can fail. When the SceneDelegate has a FlutterViewController as its window's rootViewController in the Flutter SDK iOS Scene lifecycle, plugins are registered with the FlutterViewController rather than the AppDelegate. For a backgrounded Flutter app opened with a scheme deep link, the SceneDelegate example takes the first context from URLContexts and calls AirbridgeFlutter.trackDeeplink(url:) with its URL (Flutter SDK versions earlier than 4.10.0; later versions pass URLContexts to trackDeeplink(openURLContexts:)).

If your team builds with Expo, check your Expo SDK version first. If an app is built with the iOS 27 SDK in Xcode 27 and has not adopted the UIScene lifecycle, an Expo SDK version that does not support the UIScene lifecycle can cause the app to fail to launch; the Expo SDK version, rather than Airbridge SDK configuration, is the stated cause. The Airbridge Expo SDK supports the Scene lifecycle from Expo SDK 58 without additional code. From Expo SDK 58, expo prebuild generates SceneDelegate.swift and adds UIApplicationSceneManifest to Info.plist, so developers do not need to write a SceneDelegate or add Airbridge deep-link collection code themselves. However, for an Expo app whose ios/ directory is committed and managed directly in a bare workflow, running npx expo prebuild --clean overwrites changes applied directly to the native project; the alternative is to apply the SceneDelegate and Info.plist UIApplicationSceneManifest changes manually.

FAQS

FAQ

How does the SDK handle links that were not created in Airbridge?

When an app opens through a non-Airbridge deep link, isAirbridgeDeeplink returns false and the callback function is not called.

Do I need to write custom SceneDelegate code for an Expo SDK 58 project?

No, from Expo SDK 58, expo prebuild automatically generates SceneDelegate.swift, adds UIApplicationSceneManifest to Info.plist, so no manual SceneDelegate or deep-link collection code is required unless you manage and commit your ios/ directory directly.