ios: card replies name the task, stay under gate coaching, and lock after a new card

ios/HouseScan/UI/Components/InstructionCard.swift

@@ -2,12 +2,12 @@ import SwiftUI
 
 /// The single instruction at the top of a camera screen.
 ///
-/// When the text changes, the words swap at once and the card eases to its new height. A
-/// blur or fade between them left both lines half-transparent for a moment, which the
+/// When the text changes, the words and the reply land at once and the scrim eases to its new
+/// height. A blur or fade between them left both lines half-transparent for a moment, which the
 /// accessibility audit reported as low contrast and, for the outgoing line, as clipped text
-/// (the marking prompt, the end question). Coaching
-/// takes the same slot with an amber icon so a problem replaces the instruction instead of
-/// stacking on top of it.
+/// (the marking prompt, the end question). When the task changes, the reply under the words
+/// swaps with them. Coaching shows in the same slot, marked with an amber icon; the screen
+/// decides whether its words stand in for the task's or go under them.
 struct InstructionCard: View {
     enum Tone: Equatable {
         case normal
@@ -22,6 +22,10 @@ struct InstructionCard: View {
         var identifier: String
         var hint: String
         var perform: () -> Void
+        /// The task the reply answers, when that isn't the card's words: the task under a
+        /// coaching line, or the walk without its distance to go. The reply swaps with the words
+        /// and takes no taps for `replyLock` when this changes. Nil: the card's instruction.
+        var task: Instruction? = nil
     }
 
     var instruction: Instruction
@@ -31,7 +35,18 @@ struct InstructionCard: View {
     /// finish"). Read with the instruction as one VoiceOver element.
     var eyebrow: String?
 
+    /// How long a new card's reply ignores taps, so a tap meant for the card that just left
+    /// can't answer the next one: in the 4.1 field test, quick taps on "Can't get there" each
+    /// answered a different card (#82). A guess, not measured: the card's own change
+    /// (`Motion.text`, 0.2 s) plus a tap's reaction time.
+    static let replyLock: Duration = .milliseconds(600)
+
     @Environment(\.accessibilityReduceMotion) private var reduceMotion
+    /// The task whose reply has been on screen for `replyLock`. Compared with the current task
+    /// in the same update that changes it, so a new reply is locked from its first frame.
+    @State private var unlockedTask: Instruction?
+
+    private var replyTask: Instruction { reply?.task ?? instruction }
 
     var body: some View {
         VStack(alignment: .trailing, spacing: 0) {
@@ -47,6 +62,9 @@ struct InstructionCard: View {
                     .background(Palette.replyFill, in: .capsule)
                     .contentShape(.capsule)
                     .buttonStyle(PressableStyle())
+                    // The colours are set above and PressableStyle doesn't read isEnabled, so the
+                    // pill looks the same while locked; VoiceOver and UI tests read it as dimmed.
+                    .disabled(unlockedTask != replyTask)
                     .accessibilityHint(reply.hint)
                     .accessibilityIdentifier(reply.identifier)
                     .padding([.horizontal, .bottom], 12)
@@ -62,10 +80,29 @@ struct InstructionCard: View {
                     .transition(.identity)
             }
         }
+        // New words land at once with the reply at its final place; only the scrim, outside
+        // this stack, eases to the new height. When the stack's layout eased too, the reply slid
+        // from its old place over the new words for `Motion.text` (#64): on a coaching change,
+        // which swaps the words and keeps the reply, and comes and goes often while walking.
+        .transaction(value: instruction) { $0.animation = nil }
+        // A new task swaps the words and the reply together, as one new view. With the reply
+        // outside the swap it faded out over the new words (#64). The words alone still swap on
+        // their own (a coaching line, the distance to go), so the reply keeps a press that is
+        // under way.
+        .id(replyTask)
+        .transition(.identity)
         .frame(maxWidth: .infinity)
         .background(ScrimShape.rounded())
         .animation(reduceMotion ? .easeOut(duration: 0.15) : Motion.text, value: instruction)
         .animation(Motion.text, value: reply == nil)
+        .task(id: replyTask) {
+            // Cleared first, so a task that comes back within the lock (A, B, A) is locked again.
+            let shown = replyTask
+            unlockedTask = nil
+            // A new id cancels this wait and starts its own.
+            do { try await Task.sleep(for: Self.replyLock) } catch { return }
+            unlockedTask = shown
+        }
     }
 
     private var message: some View {

ios/HouseScan/UI/Copy/ScanCopy.swift

@@ -284,6 +284,30 @@ enum ScanCopy {
     /// The reply on the see-behind step: the homeowner can't get a view past the obstruction.
     static let cannotSeeBehind = "Can't see past it"
 
+    // MARK: Card replies
+
+    /// The walk card's reply (`ScanActions.cannotAccessArea`) and its VoiceOver hint, worded for
+    /// what it does on `step`; nil on a step that offers none. On an aim or tilt step the
+    /// homeowner is already at the spot and it's the view that can't be had, so "Can't get
+    /// there" read as the wrong answer and testers kept tilting (#63). It stays on the steps
+    /// that ask to go somewhere. The wall's end (`markEnd`) has "Wall ends here" instead.
+    static func reply(for step: GuidanceStep) -> (title: String, hint: String)? {
+        switch step {
+        case .aimAtGround, .aimAtWall:
+            (title: "Skip this spot", hint: "An installer will look at it instead.")
+        case .tiltUp:
+            (title: "Skip this", hint: "Skips the view above this part of the wall. An installer will look at it instead.")
+        case .walk:
+            (title: "Can't get there", hint: "Ends the wall at the dashed line on the map. An installer will look at what's past it.")
+        case .markNextWall:
+            (title: "Can't get there", hint: "Skips this part of the wall. An installer will look at it instead.")
+        case .seeBehind:
+            (title: cannotSeeBehind, hint: "Skips the part behind it. An installer will look at it instead.")
+        case .findMeter, .aimAtWallForMeter, .holdOnMeter, .markEnd, .stepBack, .walkComplete, .gap:
+            nil
+        }
+    }
+
     // MARK: Follow-up view
 
     /// The check came back asking for views the camera can take now; the scan goes straight

ios/HouseScan/UI/Preview/DemoEngine.swift

@@ -29,7 +29,10 @@ final class DemoEngine: ScanActions {
     /// How far the walk has seen to each side of the meter, meters.
     private var reachedLeft: Float = 0.3
     private var reachedRight: Float = 0.3
-    private var skippedSpan: ClosedRange<Float>?
+    /// Stretches the homeowner skipped, and in which bands, kept apart so a later skip doesn't
+    /// undo an earlier one. An aim step's skip covers only the band it asked for, as in the real
+    /// engine; skipping the rest of a walk covers both.
+    private var skippedSpans: [(span: ClosedRange<Float>, bands: Set<CoverageBand>)] = []
     /// `-uiDemoEndPreview`: the homeowner walked back 1.5 m, so ending the wall now leaves part
     /// of the walk out.
     private var walkedBack: Float?
@@ -146,6 +149,13 @@ final class DemoEngine: ScanActions {
                 state.path = DemoScene.path(toward: 2.4, out: 1.8)
             }
         }
+        if arguments.contains("-uiDemoAim"), state.phase == .wallWalk {
+            // The walk asks for the ground about 2 ft right of the meter, which it hasn't seen
+            // from two places; the card's reply says "Skip this spot" there.
+            state.guidance = .aimAtGround(s: 0.6)
+            state.target = DemoScene.wall.world(s: 0.6, height: 0, out: 0.5)
+            state.path = []
+        }
         if arguments.contains("-uiDemoCorner") {
             // The walk followed an outside corner right of the meter, between the battery spot and
             // the window, and went on 1.6 m along the next wall: that wall runs away from the
@@ -573,11 +583,12 @@ final class DemoEngine: ScanActions {
             wallCells.append(Self.state(at: center, left: reachedLeft, right: reachedRight, lag: 0))
             groundCells.append(Self.state(at: center, left: reachedLeft, right: reachedRight, lag: 0.35))
         }
-        if let skippedSpan {
+        for skipped in skippedSpans {
             for index in 0..<count {
                 let center = wallRange.lowerBound + (Float(index) + 0.5) * Self.cellWidth
-                if skippedSpan.contains(center), wallCells[index] != .covered { wallCells[index] = .skipped }
-                if skippedSpan.contains(center), groundCells[index] != .covered { groundCells[index] = .skipped }
+                guard skipped.span.contains(center) else { continue }
+                if skipped.bands.contains(.wall), wallCells[index] != .covered { wallCells[index] = .skipped }
+                if skipped.bands.contains(.ground), groundCells[index] != .covered { groundCells[index] = .skipped }
             }
         }
         for obstruction in obstructions {
@@ -854,12 +865,25 @@ final class DemoEngine: ScanActions {
             refreshGuidance()
             return
         }
+        let aimed: (s: Float, band: CoverageBand)? = switch state.guidance {
+        case .aimAtGround(let s): (s, .ground)
+        case .aimAtWall(let s): (s, .wall)
+        default: nil
+        }
+        if let aimed {
+            // Like the real engine: that stretch of the band asked for goes to review, and the
+            // walk moves on.
+            skippedSpans.append((span: (aimed.s - 0.5)...(aimed.s + 0.5), bands: [aimed.band]))
+            refreshCoverage()
+            refreshGuidance()
+            return
+        }
         guard case .walk(let side, _) = state.guidance else { return }
         if side == .right {
-            skippedSpan = (reachedRight + 0.1)...demoRightEnd
+            skippedSpans.append((span: (reachedRight + 0.1)...demoRightEnd, bands: Set(CoverageBand.allCases)))
             reachedRight = demoRightEnd
         } else {
-            skippedSpan = demoLeftEnd...(-reachedLeft - 0.1)
+            skippedSpans.append((span: demoLeftEnd...(-reachedLeft - 0.1), bands: Set(CoverageBand.allCases)))
             reachedLeft = -demoLeftEnd
         }
         refreshCoverage()
@@ -910,7 +934,7 @@ final class DemoEngine: ScanActions {
         reachedRight = 0.3
         demoLeftEnd = -2.9
         demoRightEnd = 4.3
-        skippedSpan = nil
+        skippedSpans = []
         obstructions = []
         seeBehindTicks = 0
         followedUp = false

ios/HouseScan/UI/Preview/UIDemo.swift

@@ -25,6 +25,8 @@ import SwiftUI
 /// - `-uiDemoNextWall`: the right end turns a corner and the walk asks for the next wall; with
 ///   `-uiDemoRefusal` the last mark was refused.
 /// - `-uiDemoTiltUp`: both ends are marked and the walk asks to tilt up by the meter.
+/// - `-uiDemoAim`: with `-uiDemoPhase wallWalk`, the walk asks to tilt down to the ground
+///   about 2 ft right of the meter.
 /// - `-uiDemoOverheadQuestion`: the tilt-up view is in and the walk asks what is overhead.
 /// - `-uiDemoGap <groundOut|walkOut|overhead>`: the gap screen shows that server request.
 /// - `-uiDemoSample`: no server is configured, so the upload screen says the result is a sample.

ios/HouseScan/UI/Screens/GapRequestScreen.swift

@@ -33,7 +33,11 @@ struct GapRequestScreen: View {
                     hint: followUps > 0
                         ? "Skips this view and shows your result. An installer will look at this part instead."
                         : "Skips this view. An installer will look at this part instead.",
-                    perform: { actions.skipGap() }
+                    perform: { actions.skipGap() },
+                    // The request, not the coaching that can show over it: coaching coming and going
+                    // doesn't lock the reply again (InstructionCard.replyLock). Before the request
+                    // is known, the step's own words, for the same reason.
+                    task: state.gap.map { ScanCopy.gap($0) } ?? ScanCopy.guidance(.gap)
                 ),
                 eyebrow: followUps > 0 && state.gap?.isSatisfied != true ? ScanCopy.followUp(remaining: followUps) : nil,
                 photoCount: state.captureCount,

ios/HouseScan/UI/Screens/WallWalkScreen.swift

@@ -121,14 +121,6 @@ struct WallWalkScreen: View {
         return .walking
     }
 
-    /// True while the guidance points at a particular stretch the homeowner might not reach.
-    private var asksForArea: Bool {
-        switch state.guidance {
-        case .walk, .aimAtGround, .aimAtWall, .tiltUp, .markNextWall, .seeBehind: true
-        default: false
-        }
-    }
-
     /// The end preview shows only with the buttons that set it: not over a question, a mark or
     /// the feature tray.
     private var showsEndPreview: Bool {
@@ -170,7 +162,7 @@ struct WallWalkScreen: View {
             }
             .transition(.opacity)
         case .endQuestion:
-            // One question, two equal full-width answers that say what they mean (checklist I4).
+            // One question, three equal full-width answers that say what they mean (checklist I4).
             VStack(spacing: 8) {
                 Button {
                     actions.answerWallEnd(turnsCorner: true)
@@ -189,6 +181,18 @@ struct WallWalkScreen: View {
                 .buttonStyle(.secondaryProminent)
                 .accessibilityHint("A fence, gate, or your neighbor's yard")
                 .accessibilityIdentifier("action.endBlocked")
+                // A garden wall or a fence can just stop, with no corner and nothing in the way,
+                // and neither answer above fits it (#70). Ends the wall as "Something blocks it"
+                // does: the usable wall stops here.
+                Button {
+                    actions.answerWallEnd(turnsCorner: false)
+                } label: {
+                    Label("The wall just ends", systemImage: "arrow.right.to.line")
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.secondaryProminent)
+                .accessibilityHint("No corner and nothing in the way. The wall stops here.")
+                .accessibilityIdentifier("action.endEnds")
             }
             .transition(.opacity)
         case .overheadQuestion:
@@ -262,45 +266,42 @@ struct WallWalkScreen: View {
     }
 
     /// The capture gate's coaching (slow down, texture, light, hold steady) comes and goes within
-    /// a second while the homeowner walks, and the task under it stays the same, so "Can't get
-    /// there" stays put through it: hiding it each time made the button fade in and out under the
+    /// a second while the homeowner walks, and the task under it stays the same, so the card's
+    /// reply stays put through it: hiding it each time made the button fade in and out under the
     /// homeowner's thumb, and the accessibility audit caught it half faded (CI run 36295565916).
     /// Coaching about tracking itself hides it, since where an end would land needs the phone's
-    /// place, as does being past an end.
+    /// place, as does being past an end, where the way on is to walk back (#80). No `default`:
+    /// a new coaching case has to choose.
     private var coachingHidesReply: Bool {
         switch state.coaching {
         case nil, .slowDown?, .needsTexture?, .tooDark?, .holdSteady?: false
         case .initializing?, .relocalizing?, .trackingLost?, .pastWallEnd?: true
         }
     }
 
+    /// The card's reply, worded for the step by `ScanCopy.reply(for:)` ("Skip this spot" on an
+    /// aim step, "Can't get there" on the walk). Its identifier is `action.cannotAccess` on
+    /// every step.
     private var reply: InstructionCard.Reply? {
-        guard asksForArea, state.marking == nil, state.endQuestion == nil, !state.overheadQuestion,
-              !coachingHidesReply, !trayOpen else { return nil }
-        if case .seeBehind = state.guidance {
-            return InstructionCard.Reply(
-                title: ScanCopy.cannotSeeBehind,
-                identifier: "action.cannotAccess",
-                hint: "Skips the part behind it. An installer will look at it instead.",
-                perform: { actions.cannotAccessArea() }
-            )
-        }
-        if case .walk = state.guidance {
-            return InstructionCard.Reply(
-                title: "Can't get there",
-                identifier: "action.cannotAccess",
-                hint: "Ends the wall at the dashed line on the map. An installer will look at what's past it.",
-                perform: { actions.cannotAccessArea() }
-            )
-        }
+        guard state.marking == nil, state.endQuestion == nil, !state.overheadQuestion, !coachingHidesReply, !trayOpen,
+              let copy = ScanCopy.reply(for: state.guidance) else { return nil }
         return InstructionCard.Reply(
-            title: "Can't get there",
+            title: copy.title,
             identifier: "action.cannotAccess",
-            hint: "Skips this part of the wall. An installer will look at it instead.",
-            perform: { actions.cannotAccessArea() }
+            hint: copy.hint,
+            perform: { actions.cannotAccessArea() },
+            task: replyTask
         )
     }
 
+    /// The step the reply answers, in words, for the card's input lock: the step's own words
+    /// while coaching shows over it, and the walk without its distance to go, which changes as
+    /// the homeowner walks and would lock "Can't get there" again each time.
+    private var replyTask: Instruction {
+        if case .walk(let side, _) = state.guidance { return ScanCopy.guidance(.walk(side: side, remaining: nil)) }
+        return ScanCopy.guidance(state.guidance)
+    }
+
     private var nextWallSymbol: String {
         if case .markNextWall(.left, _) = state.guidance { return "arrow.turn.up.left" }
         return "arrow.turn.up.right"