Deep linking in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when the app receives a deep link URL?

Consider an iOS app configured to handle deep links. When the app receives a URL like myapp://profile/123, what is the expected behavior?

A The app opens and navigates to the profile screen showing user with ID 123.

B The app crashes because the URL scheme is not recognized.

C The app opens but stays on the home screen without navigation.

D The app opens a web browser to load the URL externally.

💡 Hint

Deep links allow apps to open specific screens directly.

Deep linking lets the app open a specific screen based on the URL path. Here, the app should navigate to the profile screen for user 123.

📝 Syntax

intermediate

Which Swift method handles incoming deep link URLs in the app delegate?

In iOS Swift apps, which method is called when the app is asked to open a URL via deep linking?

A func applicationWillTerminate(_ application: UIApplication)

B func applicationDidBecomeActive(_ application: UIApplication)

C func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool

D func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool

💡 Hint

This method receives the URL and options when opening a URL.

The method with signature application(_:open:options:) is called to handle URLs opened by the app, including deep links.

❓ lifecycle

advanced

What happens if the app is not running and a deep link is opened?

If the user taps a deep link URL and the app is not running at all, what is the correct sequence of events in iOS?

A The app launches and immediately crashes due to missing URL handling.

B The app launches, but the URL is ignored because the app was not running.

C The app launches, <code>didFinishLaunchingWithOptions</code> is called with the URL info, then <code>application(_:open:options:)</code> is called.

D The app launches and only <code>applicationDidBecomeActive</code> is called without URL info.

💡 Hint

The launch options contain the URL when the app starts from a deep link.

When launched from a deep link, didFinishLaunchingWithOptions receives the URL in launch options, then the URL handling method is called.

🔧 Debug

advanced

Why does this deep link handler fail to navigate?

Given this Swift code snippet in the app delegate handling a deep link URL:

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
  if url.scheme == "myapp" {
    if url.host == "profile" {
      let userId = url.lastPathComponent
      navigateToProfile(userId: userId)
      return true
    }
  }
  return false
}

Why might the navigation not work as expected?

A The method <code>navigateToProfile</code> is not defined in the app delegate.

B The <code>url.lastPathComponent</code> is empty because the URL path is missing or malformed.

C The <code>url.scheme</code> is incorrect and does not match the app's scheme.

D The method returns false, so the system ignores the URL.

💡 Hint

Check how the URL path is parsed for the user ID.

If the URL does not have a path component after the host, lastPathComponent will be empty, so navigation lacks the user ID.

🧠 Conceptual

expert

How does Universal Links improve deep linking on iOS?

Which statement best describes the advantage of Universal Links over custom URL schemes for deep linking on iOS?

A Universal Links open the app directly without showing a prompt and fallback to the website if the app is not installed.

B Universal Links require the user to manually copy and paste URLs into the app.

C Universal Links only work when the app is already running in the background.

D Universal Links force the app to open a web view instead of native screens.

💡 Hint

Universal Links use standard web URLs and improve user experience.

Universal Links use standard HTTPS URLs that open the app directly if installed, or fallback to the website if not, without prompts.

Practice

1. What is the main purpose of deep linking in an iOS app?

easy

A. To increase app storage capacity

B. To improve app startup speed

C. To open a specific screen or content inside the app from a link

D. To change the app's icon dynamically

Solution

1. Step 1: Understand deep linking concept

   Deep linking allows users to open a specific part of an app directly from a link, not just launch the app.

2. Step 2: Compare options

   Options A, B, and D are unrelated to deep linking's purpose.

3. Final Answer:

   To open a specific screen or content inside the app from a link -> Option C

4. Quick Check:

   Deep linking = open specific app content [OK]

Hint: Deep linking = direct app content access from links [OK]

Common Mistakes:

• Confusing deep linking with app performance improvements
• Thinking deep linking changes app appearance
• Mixing deep linking with app storage features

2. Which method in AppDelegate handles opening your app via a custom URL scheme?

easy

A. application(_:didFinishLaunchingWithOptions:)

B. application(_:open:options:)

C. applicationDidBecomeActive(_:)

D. applicationWillTerminate(_:)

Solution

1. Step 1: Identify URL handling method

   The method application(_:open:options:) is called when the app is opened via a URL scheme.

2. Step 2: Exclude other lifecycle methods

   Other methods handle app launch, active state, or termination, not URL opening.

3. Final Answer:

   application(_:open:options:) -> Option B

4. Quick Check:

   Custom URL open method = application(_:open:options:) [OK]

Hint: URL open handling uses application(_:open:options:) [OK]

Common Mistakes:

• Choosing didFinishLaunchingWithOptions for URL handling
• Confusing app lifecycle methods with URL handling
• Ignoring the options parameter in the method

3. Given this code snippet in AppDelegate, what will happen when the app opens with URL scheme myapp://profile?id=123?

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
  if url.scheme == "myapp" && url.host == "profile" {
    print("Open profile with id: \(url.query ?? "none")")
    return true
  }
  return false
}

medium

A. Returns false without printing anything

B. Prints 'Open profile with id: none' and returns false

C. Crashes because url.query is nil

D. Prints 'Open profile with id: id=123' and returns true

Solution

1. Step 1: Check URL scheme and host

   The URL scheme is "myapp" and host is "profile", so the if condition is true.

2. Step 2: Evaluate url.query value

   The query part is "id=123", so url.query is "id=123" and prints correctly.

3. Final Answer:

   Prints 'Open profile with id: id=123' and returns true -> Option D

4. Quick Check:

   URL matches scheme and host, query printed [OK]

Hint: Check url.scheme and url.host before using url.query [OK]

Common Mistakes:

• Assuming url.query is nil and causes crash
• Ignoring url.host check
• Returning false despite matching URL

4. Identify the error in this AppDelegate method for handling deep links:

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any]) -> Bool {
  if url.scheme = "myapp" {
    // handle URL
    return true
  }
  return false
}

medium

A. Using single equals (=) instead of double equals (==) in the if condition

B. Missing return statement inside the if block

C. Incorrect method signature missing default value for options

D. URL scheme comparison should use url.host instead

Solution

1. Step 1: Check the if condition syntax

   The condition uses single equals (=) which is assignment, not comparison.

2. Step 2: Understand correct comparison operator

   In Swift, equality check uses double equals (==), so this is a syntax error.

3. Final Answer:

   Using single equals (=) instead of double equals (==) in the if condition -> Option A

4. Quick Check:

   Comparison needs '==' not '=' [OK]

Hint: Use '==' for comparison, '=' is assignment [OK]

Common Mistakes:

• Confusing assignment (=) with equality (==)
• Ignoring method signature correctness
• Mixing url.scheme and url.host in condition

5. You want to support universal links in your iOS app. Which of the following is NOT required for universal links to work correctly?

hard

A. Implementing application(_:open:options:) to handle the link

B. Hosting an apple-app-site-association file on your website

C. Adding associated domains capability in your app's entitlements

D. Configuring your website's HTTPS server with a valid certificate

Solution

1. Step 1: Understand universal links requirements

   Universal links require a hosted apple-app-site-association file, entitlements setup, and HTTPS with valid certificate.

2. Step 2: Identify handling method difference

   Universal links use NSUserActivity, not application(_:open:options:), which is for custom URL schemes.

3. Final Answer:

   Implementing application(_:open:options:) to handle the link -> Option A

4. Quick Check:

   Universal links use NSUserActivity, not open URL method [OK]

Hint: Universal links use NSUserActivity, not open URL method [OK]

Common Mistakes:

• Thinking application(_:open:options:) handles universal links
• Ignoring HTTPS requirement for universal links
• Skipping apple-app-site-association file setup