Sheet and fullScreenCover in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

Difference in dismissal behavior between Sheet and fullScreenCover

In SwiftUI, what is the main difference in how a Sheet and a fullScreenCover are dismissed by default?

A Both Sheet and fullScreenCover can be dismissed by swiping down by default.

B Sheet can be dismissed by swiping down, but fullScreenCover requires explicit dismissal.

C fullScreenCover can be dismissed by swiping down, but Sheet requires explicit dismissal.

D Neither Sheet nor fullScreenCover can be dismissed by swiping down.

💡 Hint

Think about the default user interaction for modal views in iOS.

Sheets in SwiftUI support swipe-to-dismiss by default, allowing users to drag down to close. fullScreenCover modals cover the entire screen and do not support swipe-to-dismiss by default; they require programmatic dismissal.

❓ navigation

intermediate

State variable usage for presenting Sheet vs fullScreenCover

Which SwiftUI state variable type is best suited to control the presentation of a Sheet or fullScreenCover when you want to present a modal based on a Boolean condition?

A @State Bool variable toggled true/false to show or hide the modal.

B @State Array variable holding multiple modal views.

C @State Int variable counting how many times modal was shown.

D @State String variable holding the modal content title.

💡 Hint

Think about what type controls visibility: true means visible, false means hidden.

Using a Boolean @State variable is the standard way to control modal presentation in SwiftUI. Setting it to true shows the modal, false hides it.

❓ lifecycle

advanced

Effect of dismissing a fullScreenCover on parent view lifecycle

When a fullScreenCover is dismissed in SwiftUI, what happens to the parent view's lifecycle?

A The parent view pauses and resumes animations but resets state.

B The parent view reloads completely and resets all its state variables.

C The parent view is destroyed and recreated from scratch.

D The parent view remains active and does not reload or reset its state.

💡 Hint

Consider how modal presentation affects the underlying view in SwiftUI.

Dismissing a fullScreenCover returns control to the parent view without recreating or resetting it. The parent view remains active with its current state intact.

📝 Syntax

advanced

Correct syntax for presenting a Sheet with data binding

Which SwiftUI code snippet correctly presents a Sheet that passes a binding to a detail view?

iOS Swift

struct ContentView: View {
  @State private var showSheet = false
  @State private var selectedName = ""

  var body: some View {
    Button("Show Sheet") {
      showSheet = true
    }
    .sheet(isPresented: $showSheet) {
      DetailView(name: $selectedName)
    }
  }
}

struct DetailView: View {
  @Binding var name: String
  var body: some View {
    TextField("Enter name", text: $name)
  }
}

A .sheet(isPresented: showSheet) { DetailView(name: $selectedName) }

B .sheet(showSheet) { DetailView(name: selectedName) }

C .sheet(isPresented: $showSheet) { DetailView(name: $selectedName) }

D .sheet(isPresented: $showSheet) { DetailView(name: selectedName) }

💡 Hint

Remember to pass bindings with a $ prefix and use the correct parameter name.

The sheet modifier requires a binding to a Boolean for isPresented. The detail view expects a binding, so pass $selectedName. Option C correctly uses $showSheet and $selectedName.

🔧 Debug

expert

Why does fullScreenCover not dismiss when swiping down?

Given this SwiftUI code, why does the fullScreenCover not dismiss when the user swipes down?

struct ContentView: View {
  @State private var showModal = true

  var body: some View {
    Button("Show") { showModal = true }
      .fullScreenCover(isPresented: $showModal) {
        ModalView()
      }
  }
}

struct ModalView: View {
  var body: some View {
    Text("Modal")
  }
}

A fullScreenCover does not support swipe-to-dismiss by default; dismissal must be handled programmatically.

B The @State variable showModal is not toggled to false inside ModalView, so it never dismisses.

C The Button is inside the fullScreenCover, blocking swipe gestures.

D The ModalView must have a NavigationView to enable swipe-to-dismiss.

💡 Hint

Think about default user interactions for fullScreenCover modals.

fullScreenCover modals cover the entire screen and do not support swipe-to-dismiss by default. You must dismiss them by changing the binding variable to false programmatically.

Practice

1. What is the main difference between sheet and fullScreenCover in SwiftUI?

easy

A. sheet shows a partial screen popup, fullScreenCover covers the entire screen.

B. sheet covers the entire screen, fullScreenCover shows a partial popup.

C. Both behave the same and can be dismissed by swiping down.

D. sheet is used only for navigation, fullScreenCover is for alerts.

Solution

1. Step 1: Understand sheet behavior

   sheet presents a view that covers part of the screen and can be dismissed by swiping down.

2. Step 2: Understand fullScreenCover behavior

   fullScreenCover presents a view that covers the entire screen and usually requires a close button to dismiss.

3. Final Answer:

   sheet shows a partial screen popup, fullScreenCover covers the entire screen. -> Option A

4. Quick Check:

   Partial vs full screen = A [OK]

Hint: Remember: sheet is partial, fullScreenCover is full screen [OK]

Common Mistakes:

• Confusing which one covers full screen
• Thinking both can be dismissed by swipe
• Assuming fullScreenCover is for alerts only

2. Which of the following is the correct syntax to present a sheet in SwiftUI?

easy

A. .fullScreenCover(showModal) { Text("Hello") }

B. .sheet(isPresented: $showModal) { Text("Hello") }

C. .sheet(showModal) { Text("Hello") }

D. .fullScreenCover(isPresented: showModal) { Text("Hello") }

Solution

1. Step 1: Check correct parameter usage

   The sheet modifier requires a binding boolean with isPresented: to control showing.

2. Step 2: Validate closure syntax

   The closure provides the view to present, here Text("Hello").

3. Final Answer:

   .sheet(isPresented: $showModal) { Text("Hello") } -> Option B

4. Quick Check:

   Correct syntax uses isPresented with $ binding [OK]

Hint: Use .sheet(isPresented: $var) { View } for sheets [OK]

Common Mistakes:

• Omitting $ for binding variable
• Using wrong parameter name
• Confusing sheet and fullScreenCover syntax

3. Given this SwiftUI code snippet, what will happen when the button is tapped?

struct ContentView: View {
  @State private var showSheet = false
  var body: some View {
    Button("Show") {
      showSheet = true
    }
    .sheet(isPresented: $showSheet) {
      Text("Sheet Content")
    }
  }
}

medium

A. A partial sheet appears with "Sheet Content" that can be swiped down to dismiss.

B. Nothing happens because showSheet is not bound correctly.

C. A full screen modal appears with "Sheet Content".

D. The app crashes due to missing dismiss button.

Solution

1. Step 1: Identify the modifier used

   The code uses .sheet(isPresented: $showSheet), which shows a partial sheet.

2. Step 2: Understand the button action

   When tapped, showSheet becomes true, triggering the sheet to appear with the text.

3. Final Answer:

   A partial sheet appears with "Sheet Content" that can be swiped down to dismiss. -> Option A

4. Quick Check:

   Button sets showSheet true, sheet appears partially [OK]

Hint: sheet with isPresented true shows partial popup [OK]

Common Mistakes:

• Thinking sheet covers full screen
• Assuming dismiss button is mandatory
• Confusing binding syntax

4. Identify the error in this SwiftUI code that tries to present a full screen cover:

struct ContentView: View {
  @State var showFullScreen = false
  var body: some View {
    Button("Open") {
      showFullScreen = true
    }
    .fullScreenCover(isPresented: showFullScreen) {
      Text("Full Screen")
    }
  }
}

medium

A. State variable must be private.

B. fullScreenCover cannot be used with Text views.

C. Missing $ before showFullScreen in isPresented binding.

D. Button label must be a View, not a String.

Solution

1. Step 1: Check isPresented parameter

   The isPresented parameter requires a binding, so it must be $showFullScreen, not showFullScreen.

2. Step 2: Confirm other code parts

   Using Text inside fullScreenCover is valid, and Button label can be a String.

3. Final Answer:

   Missing $ before showFullScreen in isPresented binding. -> Option C

4. Quick Check:

   Binding needs $ prefix [OK]

Hint: Use $ for binding variables in isPresented [OK]

Common Mistakes:

• Forgetting $ for binding
• Thinking fullScreenCover needs complex views
• Assuming Button label can't be String

5. You want to present a full screen modal that shows user profile details and requires a close button to dismiss. Which SwiftUI code snippet correctly implements this behavior?

hard

A. Use .sheet(showProfile) { ProfileView() } and rely on swipe to dismiss.

B. Use .sheet(isPresented: $showProfile) { ProfileView() } with a close button inside ProfileView.

C. Use .fullScreenCover(showProfile) { ProfileView() } without a close button.

D. Use .fullScreenCover(isPresented: $showProfile) { ProfileView() } and add a close button inside ProfileView that sets showProfile = false.

Solution

1. Step 1: Choose correct presentation style

   A full screen modal requires fullScreenCover, not sheet.

2. Step 2: Implement dismissal method

   Since fullScreenCover does not support swipe to dismiss, a close button inside ProfileView must set showProfile = false.

3. Final Answer:

   Use .fullScreenCover(isPresented: $showProfile) { ProfileView() } and add a close button inside ProfileView that sets showProfile = false. -> Option D

4. Quick Check:

   Full screen + manual close button = A [OK]

Hint: Full screen modals need manual close button inside view [OK]

Common Mistakes:

• Using sheet for full screen modal
• Omitting $ in binding
• Relying on swipe to dismiss fullScreenCover