chore: remove countdown from liveness session check (#36)

* chore: remove countdown from liveness session check

* update state logic

* remove unused constant

* add back missing instructional text

Author: phantumcode

Sources/FaceLiveness/Utilities/LocalizedStringKey+Liveness.swift

@@ -83,11 +83,6 @@ extension LocalizedStringKey {
         "amplify_ui_liveness_challenge_recording_indicator_label"
     )
 
-    /// en = "Hold face position during countdown."
-    static let challenge_instruction_hold_face_during_countdown = LocalizedStringKey(
-        "amplify_ui_liveness_challenge_instruction_hold_face_during_countdown"
-    )
-
     /// en = "Hold face in oval for colored lights."
     static let challenge_instruction_hold_face_during_freshness = LocalizedStringKey(
         "amplify_ui_liveness_challenge_instruction_hold_face_during_freshness"

Sources/FaceLiveness/Views/Countdown/CountdownInstructionContainerView.swift

@@ -91,6 +91,26 @@ struct InstructionContainerView: View {
                 percentage: 0.2
             )
             .frame(width: 200, height: 30)
+        case .pendingFacePreparedConfirmation(let reason):
+            InstructionView(
+                text: .init(reason.rawValue),
+                backgroundColor: .livenessBackground
+            )
+        case .completedDisplayingFreshness:
+            InstructionView(
+                text: .challenge_verifying,
+                backgroundColor: .livenessBackground
+            )
+            .onAppear {
+                UIAccessibility.post(
+                    notification: .announcement,
+                    argument: NSLocalizedString(
+                        "amplify_ui_liveness_challenge_verifying",
+                        bundle: .module,
+                        comment: ""
+                    )
+                )
+            }
         default:
             EmptyView()
         }

Sources/FaceLiveness/Views/Countdown/CountdownView+ViewModel.swift

@@ -10,7 +10,6 @@ import SwiftUI
 @_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
 
 fileprivate let initialFaceDistanceThreshold: CGFloat = 0.32
-fileprivate let countdownFaceDistanceThreshold: CGFloat = 0.37
 
 extension FaceLivenessDetectionViewModel: FaceDetectionResultHandler {
     func process(newResult: FaceDetectionResult) {
@@ -34,25 +33,20 @@ extension FaceLivenessDetectionViewModel: FaceDetectionResultHandler {
             switch livenessState.state {
             case .pendingFacePreparedConfirmation:
                 if face.faceDistance <= initialFaceDistanceThreshold {
-                    DispatchQueue.main.async {
-                        self.livenessState.startCountdown()
-                        self.initializeLivenessStream()
-                    }
+                        DispatchQueue.main.async {
+                            self.livenessState.awaitingRecording()
+                            self.initializeLivenessStream()
+                        }
+                        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                            self.livenessState.beginRecording()
+                        }
                     return
                 } else {
                     DispatchQueue.main.async {
                         self.livenessState.faceNotPrepared(reason: .faceTooClose)
                     }
                     return
                 }
-            case .countingDown:
-                if face.faceDistance >= countdownFaceDistanceThreshold {
-                    DispatchQueue.main.async {
-                        self.livenessState.unrecoverableStateEncountered(
-                            .invalidFaceMovementDuringCountdown
-                        )
-                    }
-                }
             case .recording(ovalDisplayed: false):
                 drawOval()
                 sendInitialFaceDetectedEvent(

Sources/FaceLiveness/Views/Countdown/CountdownView.swift

@@ -25,15 +25,6 @@ struct LivenessStateMachine {
         state = .pendingFacePreparedConfirmation(reason)
     }
 
-    mutating func openSocket() {
-        switch state {
-        case .pendingFacePreparedConfirmation, .countingDown:
-            state = .socketOpened
-        default:
-            break
-        }
-    }
-
     mutating func awaitingFaceMatch(with instruction: Instructor.Instruction, nearnessPercentage: Double) {
         let reason: FaceNotPreparedReason
         let percentage: Double
@@ -56,16 +47,11 @@ struct LivenessStateMachine {
         state = .awaitingFaceInOvalMatch(reason, percentage)
     }
 
-    mutating func awaitingServerInfoEvent() {
-        guard case .socketOpened = state else { return }
-        state = .awaitingServerInfoEvent
-    }
-
-    mutating func receivedServerInfoEvent() throws {
-        guard case .awaitingServerInfoEvent = state else { return }
-        state = .serverInfoEventReceived
+    mutating func awaitingRecording() {
+        guard case .pendingFacePreparedConfirmation = state else { return }
+        state = .waitForRecording
     }
-
+    
     mutating func unrecoverableStateEncountered(_ error: LivenessError) {
         switch state {
         case .encounteredUnrecoverableError, .completed:
@@ -83,11 +69,6 @@ struct LivenessStateMachine {
         state = .recording(ovalDisplayed: true)
     }
 
-    mutating func startCountdown() {
-        guard case .pendingFacePreparedConfirmation = state else { return }
-        state = .countingDown
-    }
-
     mutating func faceMatched() {
         state = .faceMatched
     }
@@ -106,7 +87,7 @@ struct LivenessStateMachine {
 
     var shouldDisplayRecordingIcon: Bool {
         switch state {
-        case .initial, .pendingFacePreparedConfirmation, .encounteredUnrecoverableError, .countingDown:
+        case .initial, .pendingFacePreparedConfirmation, .encounteredUnrecoverableError:
             return false
         default: return true
         }
@@ -115,10 +96,6 @@ struct LivenessStateMachine {
     enum State: Equatable {
         case initial
         case pendingFacePreparedConfirmation(FaceNotPreparedReason)
-        case socketOpened
-        case awaitingServerInfoEvent
-        case serverInfoEventReceived
-        case countingDown
         case recording(ovalDisplayed: Bool)
         case awaitingFaceInOvalMatch(FaceNotPreparedReason, Double)
         case faceMatched
@@ -129,6 +106,7 @@ struct LivenessStateMachine {
         case awaitingDisconnectEvent
         case disconnectEventReceived
         case encounteredUnrecoverableError(LivenessError)
+        case waitForRecording
     }
 
     enum FaceNotPreparedReason: String, Equatable {

Sources/FaceLiveness/Views/Instruction/InstructionContainerView.swift

@@ -50,14 +50,6 @@ struct _FaceLivenessDetectionView<VideoView: View>: View {
                     )
 
                     Spacer()
-
-                    CountdownInstructionContainerView(
-                        viewModel: viewModel,
-                        onCountdownComplete: {
-                            viewModel.livenessState.beginRecording()
-                        }
-                    )
-                    .padding(.bottom)
                 }
                 .padding([.leading, .trailing])
                 .aspectRatio(3/4, contentMode: .fit)

Sources/FaceLiveness/Views/Liveness/FaceLivenessDetectionViewModel+FaceDetectionResultHandler.swift

@@ -100,4 +100,35 @@ final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
             "initializeLivenessStream(withSessionID:userAgent:)"
         ])
     }
+    
+    /// Given:  A `FaceLivenessDetectionViewModel`
+    /// When: The viewModel is processes a single face result with a face distance less than the inital face distance
+    /// Then: The end state of this flow is `.recording(ovalDisplayed: false)` and initializeLivenessStream(withSessionID:userAgent:) is called
+    func testTransitionToRecordingState() async throws {
+        viewModel.livenessService = self.livenessService
+
+        viewModel.livenessState.checkIsFacePrepared()
+        XCTAssertEqual(viewModel.livenessState.state, .pendingFacePreparedConfirmation(.pendingCheck))
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [])
+        
+        let boundingBox = CGRect(x: 0.26788579725878847, y: 0.40317180752754211, width: 0.45549795395626447, height: 0.34162446856498718)
+        let leftEye = CGPoint(x: 0.61124476128552629, y: 0.4918237030506134)
+        let rightEye = CGPoint(x: 0.38036393762719456, y: 0.48050540685653687)
+        let nose = CGPoint(x: 0.48489856674964926, y: 0.54713362455368042)
+        let mouth = CGPoint(x: 0.47411978167652435, y: 0.63170802593231201)
+        let detectedFace = DetectedFace(boundingBox: boundingBox, leftEye: leftEye, rightEye: rightEye, nose: nose, mouth: mouth, confidence: 0.971859633)
+        viewModel.process(newResult: .singleFace(detectedFace))
+        try await Task.sleep(seconds: 1)
+
+        XCTAssertEqual(viewModel.livenessState.state, .recording(ovalDisplayed: false))
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [
+            "initializeLivenessStream(withSessionID:userAgent:)"
+        ])
+    }
 }