Gesture recognition (drag, magnify, rotate) in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when you drag the view with this code?

Consider this SwiftUI code snippet that handles drag gestures on a rectangle. What will be the final position of the rectangle after dragging?

iOS Swift

struct ContentView: View {
  @State private var offset = CGSize.zero
  var body: some View {
    Rectangle()
      .frame(width: 100, height: 100)
      .offset(offset)
      .gesture(
        DragGesture()
          .onChanged { gesture in
            offset = gesture.translation
          }
      )
  }
}

A The rectangle does not move at all because offset is not updated.

B The rectangle moves but snaps back to the original position after dragging ends.

C The rectangle moves randomly and does not follow the finger.

D The rectangle moves following the finger and stays at the last dragged position.

💡 Hint

Look at how the offset state is updated inside onChanged of DragGesture.

The offset state is updated continuously with the drag translation, so the rectangle moves with the finger and stays where the drag ended.

❓ ui_behavior

intermediate

What is the effect of this magnification gesture code?

Given this SwiftUI code snippet, what will happen when the user pinches to zoom on the circle?

iOS Swift

struct ContentView: View {
  @State private var scale: CGFloat = 1.0
  var body: some View {
    Circle()
      .frame(width: 100, height: 100)
      .scaleEffect(scale)
      .gesture(
        MagnificationGesture()
          .onChanged { value in
            scale = value
          }
      )
  }
}

A The circle scales only once after the pinch ends, not during the gesture.

B The circle does not scale because scaleEffect is not connected to the gesture.

C The circle scales up or down smoothly following the pinch gesture.

D The circle disappears when pinching because scale becomes zero.

💡 Hint

Check how scaleEffect uses the scale state updated in onChanged.

The scale state updates continuously with the magnification gesture value, so the circle scales smoothly as the user pinches.

❓ ui_behavior

advanced

What is the final rotation angle after this gesture ends?

Analyze this SwiftUI code that handles rotation gestures on an image. What will be the value of rotationAngle after the user rotates the image by 90 degrees and lifts their finger?

iOS Swift

struct ContentView: View {
  @State private var rotationAngle: Angle = .zero
  @State private var currentRotation: Angle = .zero
  var body: some View {
    Image(systemName: "arrow.right.circle.fill")
      .resizable()
      .frame(width: 100, height: 100)
      .rotationEffect(rotationAngle + currentRotation)
      .gesture(
        RotationGesture()
          .onChanged { angle in
            currentRotation = angle
          }
          .onEnded { angle in
            rotationAngle += angle
            currentRotation = .zero
          }
      )
  }
}

A rotationAngle will be 90 degrees (π/2 radians) after the gesture ends.

B rotationAngle will be zero because it resets after gesture ends.

C rotationAngle will be 180 degrees because it doubles the rotation.

D rotationAngle will be negative 90 degrees due to angle sign inversion.

💡 Hint

Look at how rotationAngle accumulates the angle on gesture end.

The rotationAngle accumulates the final gesture angle onEnded, so after rotating 90 degrees, rotationAngle becomes 90 degrees.

❓ lifecycle

advanced

Why does the drag gesture not reset the position after lifting the finger?

In this SwiftUI drag gesture code, why does the rectangle stay where it was dragged instead of snapping back to the start?

iOS Swift

struct ContentView: View {
  @State private var offset = CGSize.zero
  var body: some View {
    Rectangle()
      .frame(width: 100, height: 100)
      .offset(offset)
      .gesture(
        DragGesture()
          .onChanged { gesture in
            offset = gesture.translation
          }
          .onEnded { _ in
            // No code here
          }
      )
  }
}

A Because the rectangle has a fixed position and cannot move.

B Because offset is updated during onChanged and not reset in onEnded, the position stays.

C Because the offset resets to zero automatically after the gesture ends.

D Because the gesture is not attached properly, so offset never changes.

💡 Hint

Check what happens in onEnded closure.

Since offset is updated during dragging and onEnded does not reset it, the rectangle remains at the dragged position.

🔧 Debug

expert

Why does this combined gesture fail to recognize rotation?

This SwiftUI code tries to combine drag and rotation gestures on a view. Why does the rotation gesture never trigger?

iOS Swift

struct ContentView: View {
  @State private var offset = CGSize.zero
  @State private var rotation = Angle.zero
  var body: some View {
    Rectangle()
      .frame(width: 100, height: 100)
      .offset(offset)
      .rotationEffect(rotation)
      .gesture(
        DragGesture()
          .onChanged { gesture in
            offset = gesture.translation
          }
          .simultaneously(with: RotationGesture()
            .onChanged { angle in
              rotation = angle
            })
      )
  }
}

A Because simultaneously is called on DragGesture, rotation gesture is ignored; gestures must be combined differently.

B Because rotation gesture is inside simultaneously, it triggers correctly with drag.

C Because rotation gesture is not attached to the view, it never triggers.

D Because offset and rotation states conflict, causing gesture failure.

💡 Hint

Check how simultaneously is used and which gesture it is called on.

Calling simultaneously on DragGesture with RotationGesture inside causes only the drag gesture to be recognized; the rotation gesture is ignored. The correct approach is to combine gestures at the view level using .simultaneousGesture or .gesture with a combined gesture.