app_links

By default, app_links propagates events to other plugins. If you need to prevent event propagation to other plugins relying on the same events, you can use semi-automatic handling.

Flutter's iOS embedder loops through plugins; plugins return a boolean to indicate if an event was handled (stopping propagation) or if it should continue.

Options for customization:

• Set defaultUrlHandling to .availability to propagate globally only if no URL is provided.
• Set urlHandledCallBack to react to each URL. Returning true stops propagation; returning false continues it.

import app_links

class MyClass {
  // ...

  // Global configuration
  AppLinks.shared.defaultUrlHandling = .availability

  // ... or local callback
  AppLinks.shared.urlHandledCallBack = { (_ url: URL) -> Bool in
    // return true to stop propagation (handled), otherwise false to propagate
    return false
  }
}

If you have a custom AppDelegate that overrides application(_:willFinishLaunchingWithOptions:) or application(_:didFinishLaunchingWithOptions:), you must ensure they call super and return true to maintain the default workflow.

If you cannot follow this pattern or need custom behavior, you must manually intercept the link using AppLinks.shared.getLink(launchOptions:) and propagate it via AppLinks.shared.handleLink(url:) within your didFinishLaunchingWithOptions implementation.

import app_links

@main
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    GeneratedPluginRegistrant.register(with: self)

    // Retrieve the link from parameters
    if let url = AppLinks.shared.getLink(launchOptions: launchOptions) {
      // We have a link, propagate it to your Flutter app or not
      AppLinks.shared.handleLink(url: url)
      return true // Returning true will stop the propagation to other packages
    }

    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}

To support app links (both custom schemes and web-to-app) in a Linux application using GTK, you must modify your application's initialization and activation logic to handle existing windows and command-line arguments.

Key requirements:

1. Update Application Flags: Change the application flags to include G_APPLICATION_HANDLES_COMMAND_LINE and G_APPLICATION_HANDLES_OPEN.
2. Handle Activation: In your activate callback, check if windows are already present using gtk_application_get_windows. If they exist, present the existing window instead of creating a new one.
3. Handle Command Line: Ensure your command-line handler returns FALSE to allow the application to proceed with standard activation logic.

// 1. Update flags in your application initialization
MyApplication* my_application_new() {
  return MY_APPLICATION(g_object_new(my_application_get_type(),
                                     "application-id", APPLICATION_ID,
                                     "flags", G_APPLICATION_HANDLES_COMMAND_LINE | G_APPLICATION_HANDLES_OPEN,
                                     nullptr));
}

// 2. Update activate to handle existing windows
static void my_application_activate(GApplication* application) {
  MyApplication* self = MY_APPLICATION(application);

  GList* windows = gtk_application_get_windows(GTK_APPLICATION(application));
  if (windows) {
    gtk_window_present(GTK_WINDOW(windows->data));
    return;
  }

  GtkWindow* window = GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
  // ... rest of window setup
}

// 3. Ensure command line handler returns FALSE
static gboolean my_application_local_command_line(GApplication* application, ...) {
  g_application_activate(application);
  *exit_status = 0;
  return FALSE;
}

Universal links cannot be configured directly via the plugin embedder. You must manually intercept the user activity in your macOS AppDelegate using the app_links package.

Override the application(_:continue:restorationHandler:) method to extract the URL from the NSUserActivity using AppLinks.shared.getUniversalLink(userActivity) and then pass it to the plugin via AppLinks.shared.handleLink(link:).

import app_links

public override func application(_ application: NSApplication,
                                 continue userActivity: NSUserActivity,
                                 restorationHandler: @escaping ([any NSUserActivityRestoring]) -> Void) -> Bool {

  guard let url = AppLinks.shared.getUniversalLink(userActivity) else {
    return false
  }
  
  AppLinks.shared.handleLink(link: url.absoluteString)
  
  return false // Returning true will stop the propagation to other packages
}

For apps using a SceneDelegate (Scene-based apps), you must manually handle both initial connection options and subsequent URL/User Activity updates to ensure links are forwarded to the Flutter app.

1. In scene(_:willConnectTo:options:), call self.scene(scene, openURLContexts: connectionOptions.urlContexts) and iterate through connectionOptions.userActivities using self.scene(scene, continue: userActivity).
2. Implement scene(_:openURLContexts:) to handle Custom URL schemes by calling AppLinks.shared.handleLink(url: context.url).
3. Implement scene(_:continue:) to handle Universal Links by checking userActivity.webpageURL and calling AppLinks.shared.handleLink(url: url).

import app_links

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
  // Check for initial link
  func scene(_ scene: UIScene,
             willConnectTo session: UISceneSession,
             options connectionOptions: UIScene.ConnectionOptions
  ) {
    // ...

    self.scene(scene, openURLContexts: connectionOptions.urlContexts)

    for userActivity in connectionOptions.userActivities {
      self.scene(scene, continue: userActivity)
    }
  }

  // Check for further Custom URL schemes
  func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    for context in URLContexts {
      AppLinks.shared.handleLink(url: context.url)
    }
  }

  // Check for further Universal Links
  func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    if let url = userActivity.webpageURL {
      AppLinks.shared.handleLink(url: url)
    }
  }
}