Receive Custom URL Parameters

any URLs should be passed to: func application(_ application: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:] ) -> Bool I do not register the above application function to be called

I'm a bit confused by what you're saying here. That's the function the system uses to pass URLs into your app. Why haven't you implemented it?

instead this one is executed during app start with launchOptions always being nil: func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool This is the case regardless of if the App is started fresh or was already running in the background.

Unfortunately, the system's implementation would be much more coherent if we completely removed "launchOptions". The issue here is that application(_:didFinishLaunchingWithOptions:) is very, very old, dating from iOS 3. When it was original introduced the big innovation here was that the system could now pass information into your app when it was launched. More importantly, background execution did NOT exist (that was introduced in iOS 4), that method was called EVERY time the user entered your app.

The problem is that immediately the next year we introduced backgrounding, which means your app can now enter the foreground in two different ways (launching or waking). That means that most UIApplicationLaunchOptionsKey end up needing two different paths:

1. The launch key, in this case "UIApplicationLaunchOptionsURLKey".

2. A delegate method the system can call in the cases where the app is actually suspended (not launching), in this case application(_:open:options:)

The key point here is that the first mechanism isn't really necessary, as the system could simply launch the target app and then call the correct delegate. Unfortunately, that's just where the edge cases here start.

First, the "nil" argument is probably caused by this:

"If the app supports scenes, this is nil. For information about the possible keys in this dictionary and how to handle them, see UIApplication.LaunchOptionsKey."

Note that the scene based has been the preferred architecture since iOS 13. The UIScene delegate ALSO has it's own URL delegate, scene(_:openURLContexts:)

Finally, application(_:open:options:) add it's own layer of complications:

"This method is not called if your implementations return false from both the application(_:willFinishLaunchingWithOptions:) and application(_:didFinishLaunchingWithOptions:) methods. (If only one of the two methods is implemented, its return value determines whether this method is called.) If your app implements the applicationDidFinishLaunching(_:) method instead of application(_:didFinishLaunchingWithOptions:), this method is called to open the specified URL after the app has been initialized."

In any case, the answer here is that either of the specific scene delegate or app delegate methods should work fine, but didFinishLaunchingWithOptions should no longer be used for this.

__
Kevin Elliott
DTS Engineer, CoreOS/Hardware

Thank you very much for this detailed answer!

I double checked my code against your suggestions and read the documentation with all the edge cases but I have not been able to get it to work.

I'm a bit confused by what you're saying here. That's the function the system uses to pass URLs into your app. Why haven't you implemented it?

Sorry for the misunderstanding. What I meant to say is that I implemented this function but it is not being called.

Basically I implemented the functions from which I would expect the url variables and a ContentView struct then proceeds to display whatever it is that has been written to AppState.shared.startParam and it only ever displays: URL Parameters: launchOptions:nil.

First, the "nil" argument is probably "If the app supports scenes, this is nil. For information about the possible keys in this dictionary and how to handle them, see UIApplication.LaunchOptionsKey."

The App does not support scenes.

[quote='835877022, DTS Engineer, /thread/781255?answerId=835877022#835877022'] Finally, application(_:open:options:) add it's own layer of complications: [/quote]

First, the "nil" argument is probably "If the app supports scenes, this is nil. For information about the possible keys in this dictionary and how to handle them, see UIApplication.LaunchOptionsKey."

CustomURLNativeIOSApp.swift:

import SwiftUI

class AppState: ObservableObject {
    static let shared = AppState()
    
    @Published var startParam: String = "No URL parameters detected yet"
    
    private init() {}
}

@main
struct iOSApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self)
    var appDelegate: AppDelegate
    
    @ObservedObject private var appState = AppState.shared
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(AppState.shared)
        }
    }
}

//customurlios://open?test=things
class AppDelegate: NSObject, UIApplicationDelegate {
    
    var window: UIWindow?
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]?) -> Bool {
        print("URL received launchOptions:", launchOptions ?? [:])
        let param = "launchOptions:\(String(describing: launchOptions))"
        AppState.shared.startParam = param
        print("Set startParam to: \(param)")

        return true
    }
    
    func application(_ application: UIApplication, handleOpen url: URL) -> Bool {
        print("URL received handleOpen:", url.absoluteString)
        let param = "handleOpen: \(url.absoluteString)"
        AppState.shared.startParam = param
        print("Set startParam to: \(param)")
        
        return true
    }
    
    func application(_ application: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        print("URL received open url:", url.absoluteString)
        let param = "url: \(url.absoluteString) options:\(options.count)"
        AppState.shared.startParam = param
        print("Set startParam to: \(param)")
        
        return true
    }
}

ContentView.swift:

import SwiftUI

struct ContentView: View {
    @State private var showContent = false
    
    @EnvironmentObject var appState: AppState
    
    var body: some View {
        VStack {
            Button("Click me!") {
                withAnimation {
                    showContent = !showContent
                }
            }
            

            Text("URL Parameters: \(appState.startParam)")
                .font(.system(size: 14))
                .padding()
                .background(Color.gray.opacity(0.1))
                .cornerRadius(8)

            if showContent {
                VStack(spacing: 16) {
                    Image(systemName: "swift")
                        .font(.system(size: 200))
                        .foregroundColor(.accentColor)
                    Text("SwiftUI: Hello")
                }
                .transition(.move(edge: .top).combined(with: .opacity))
            }
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
        .padding()
        .onAppear {
            // Print the current value for debugging
            print("ContentView appeared, startParam: \(appState.startParam)")
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .environmentObject(AppState.shared)
    }
}

Info.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleURLTypes</key>
	<array>
		<dict>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>CFBundleURLName</key>
			<string>dev.customurl.ios</string>
			<key>CFBundleURLSchemes</key>
			<array>
				<string>customurlios</string>
			</array>
		</dict>
	</array>
</dict>
</plist>

Still cannot find my mistake...

Basically I implemented the functions from which I would expect the url variables and a ContentView struct then proceeds to display whatever it is that has been written to AppState.shared.startParam and it only ever displays: URL Parameters: launchOptions:nil.

First, and most importantly, what does the log data show? The key point that isn't yet clear to me is the difference between "My interface isn't updating correctly" vs. "handleOpen/open weren't being called. The way I'd expect the flow here to occur looks like this:

• App launches.
• System calls didFinishLaunching.
• SwiftUI builds out interface include TextView.
• System calls handleOpen
• System calls open

...so you're seeing exactly what I'd expect to see if the only issue was that the TextView wasn't being updated properly.

The App does not support scenes.

Keep in mind that SwiftUI is inherently scene based. Your app may only have one scene, but SwiftUI is still built around the scene architecture. If the testing above doesn't work, then I would add in the scene delegate as well and see what that shows.

__
Kevin Elliott
DTS Engineer, CoreOS/Hardware

Keep in mind that SwiftUI is inherently scene based. Your app may only have one scene, but SwiftUI is still built around the scene architecture. If the testing above doesn't work, then I would add in the scene delegate as well and see what that shows.

This does the trick.

Guess I was too stubborn and just didn't want to fuss around with scenes in any way.

So thank your for your knowledge and patience!