Address review comments

HostApp/HostApp.xcodeproj/project.pbxproj

@@ -132,7 +132,6 @@
 				9070FFBD285112B5009867D5 /* HostAppUITests */,
 				9070FFA1285112B4009867D5 /* Products */,
 				90215EED291E9FB60050F2AD /* Frameworks */,
-				A5A9AF5054D0FF13505B212A /* AmplifyConfig */,
 			);
 			sourceTree = "<group>";
 		};
@@ -215,15 +214,6 @@
 			path = Model;
 			sourceTree = "<group>";
 		};
-		A5A9AF5054D0FF13505B212A /* AmplifyConfig */ = {
-			isa = PBXGroup;
-			children = (
-				973619242BA378690003A590 /* awsconfiguration.json */,
-				973619232BA378690003A590 /* amplifyconfiguration.json */,
-			);
-			name = AmplifyConfig;
-			sourceTree = "<group>";
-		};
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */

HostApp/HostApp.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -5,8 +5,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/aws-amplify/amplify-swift",
       "state" : {
-        "branch" : "no-light-implementation",
-        "revision" : "19c7af19dfa1aa1ca49d63a82605ee0f367b9f64"
+        "branch" : "feat/no-light-support",
+        "revision" : "7c1fa2f7a766208f5af69ca8dce5fd02e6de4db6"
       }
     },
     {

Package.resolved

@@ -5,8 +5,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/aws-amplify/amplify-swift",
       "state" : {
-        "branch" : "no-light-implementation",
-        "revision" : "19c7af19dfa1aa1ca49d63a82605ee0f367b9f64"
+        "branch" : "feat/no-light-support",
+        "revision" : "7c1fa2f7a766208f5af69ca8dce5fd02e6de4db6"
       }
     },
     {

Package.swift

@@ -14,7 +14,7 @@ let package = Package(
     ],
     dependencies: [
         // TODO: Change this before merge to main
-        .package(url: "https://github.com/aws-amplify/amplify-swift", branch: "no-light-implementation")
+        .package(url: "https://github.com/aws-amplify/amplify-swift", branch: "feat/no-light-support")
     ],
     targets: [
         .target(

Sources/FaceLiveness/FaceDetection/BlazeFace/FaceDetectorShortRange+Model.swift

@@ -34,15 +34,15 @@ extension FaceDetectorShortRange {
             )
         }
 
-        weak var faceDetectionSessionConfiguration: FaceDetectionSessionConfiguration?
+        weak var faceDetectionSessionConfiguration: FaceDetectionSessionConfigurationWrapper?
         weak var detectionResultHandler: FaceDetectionResultHandler?
 
         func setResultHandler(detectionResultHandler: FaceDetectionResultHandler) {
             self.detectionResultHandler = detectionResultHandler
         }
 
-        func setFaceLivenessDetectionViewModel(faceDetectionSessionConfiguration: FaceDetectionSessionConfiguration) {
-            self.faceDetectionSessionConfiguration = faceDetectionSessionConfiguration
+        func setFaceDetectionSessionConfigurationWrapper(configuration: FaceDetectionSessionConfigurationWrapper) {
+            self.faceDetectionSessionConfiguration = configuration
         }
 
         func detectFaces(from buffer: CVPixelBuffer) {
@@ -113,7 +113,7 @@ extension FaceDetectorShortRange {
             )
 
             let blazeFaceDetectionThreshold: Float
-            if let sessionConfiguration = faceDetectionSessionConfiguration?.getFaceDetectionSessionConfiguration() {
+            if let sessionConfiguration = faceDetectionSessionConfiguration?.sessionConfiguration {
                 blazeFaceDetectionThreshold = Float(sessionConfiguration.ovalMatchChallenge.faceDetectionThreshold)
             } else {
                 blazeFaceDetectionThreshold = confidenceScoreThreshold

Sources/FaceLiveness/FaceDetection/FaceDetector.swift

@@ -17,9 +17,8 @@ protocol FaceDetectionResultHandler: AnyObject {
     func process(newResult: FaceDetectionResult)
 }
 
-protocol FaceDetectionSessionConfiguration: AnyObject {
-    func getFaceDetectionSessionConfiguration() 
-        -> FaceLivenessSession.SessionConfiguration?
+protocol FaceDetectionSessionConfigurationWrapper: AnyObject {
+    var sessionConfiguration: FaceLivenessSession.SessionConfiguration? { get }
 }
 
 enum FaceDetectionResult {

Sources/FaceLiveness/Views/Instruction/InstructionContainerView.swift

@@ -7,6 +7,7 @@
 
 import SwiftUI
 import Combine
+@_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
 
 struct InstructionContainerView: View {
     @ObservedObject var viewModel: FaceLivenessDetectionViewModel
@@ -109,12 +110,17 @@ struct InstructionContainerView: View {
                 )
             }
         case .faceMatched:
-            InstructionView(
-                text: LocalizedStrings.challenge_instruction_hold_still,
-                backgroundColor: .livenessPrimaryBackground,
-                textColor: .livenessPrimaryLabel,
-                font: .title
-            )
+            if let challenge = viewModel.challenge,
+               case .faceMovementAndLightChallenge = challenge.type {
+                InstructionView(
+                    text: LocalizedStrings.challenge_instruction_hold_still,
+                    backgroundColor: .livenessPrimaryBackground,
+                    textColor: .livenessPrimaryLabel,
+                    font: .title
+                )
+            } else {
+                EmptyView()
+            }
         default:
             EmptyView()
         }

Sources/FaceLiveness/Views/Liveness/FaceLivenessDetectionView.swift

@@ -86,6 +86,8 @@ public struct FaceLivenessDetectorView: View {
                 sessionID: sessionID
             )
         )
+
+        faceDetector.setFaceDetectionSessionConfigurationWrapper(configuration: viewModel)
     }
 
     init(
@@ -140,37 +142,37 @@ public struct FaceLivenessDetectorView: View {
                     do {
                         let session = try await sessionTask.value
                         viewModel.livenessService = session
-                        viewModel.registerServiceEvents(onChallengeTypeReceived: {
-                            self.displayState = DisplayState.awaitingLivenessSession
+                        viewModel.registerServiceEvents(onChallengeTypeReceived: { challenge in
+                            self.displayState = DisplayState.awaitingLivenessSession(challenge)
                         })
                         viewModel.initializeLivenessStream()
                     } catch {
                         throw FaceLivenessDetectionError.accessDenied
                     }
                 }
             }
-        case .awaitingLivenessSession:
+        case .awaitingLivenessSession(let challenge):
             Color.clear
                 .onAppear {
                     Task {
                         do {
                             let newState = disableStartView
                             ? DisplayState.displayingLiveness
-                            : DisplayState.displayingGetReadyView
+                            : DisplayState.displayingGetReadyView(challenge)
                             guard self.displayState != newState else { return }
                             self.displayState = newState
                         }
                     }
                 }
 
-        case .displayingGetReadyView:
+        case .displayingGetReadyView(let challenge):
             GetReadyPageView(
                 onBegin: {
                     guard displayState != .displayingLiveness else { return }
                     displayState = .displayingLiveness
                 },
                 beginCheckButtonDisabled: false,
-                challenge: viewModel.challenge!
+                challenge: challenge
             )
             .onAppear {
                 DispatchQueue.main.async {
@@ -234,7 +236,8 @@ public struct FaceLivenessDetectorView: View {
             for: .video,
             completionHandler: { accessGranted in
                 guard accessGranted == true else { return }
-                displayState = .awaitingLivenessSession
+                guard let challenge = viewModel.challenge else { return }
+                displayState = .awaitingLivenessSession(challenge)
             }
         )
 
@@ -252,19 +255,37 @@ public struct FaceLivenessDetectorView: View {
         case .restricted, .denied:
             alertCameraAccessNeeded()
         case .authorized:
-            displayState = .awaitingLivenessSession
+            guard let challenge = viewModel.challenge else { return }
+            displayState = .awaitingLivenessSession(challenge)
         @unknown default:
             break
         }
     }
 }
 
-enum DisplayState {
-    case awaitingLivenessSession
-    case displayingGetReadyView
+enum DisplayState: Equatable {
+    case awaitingChallengeType
+    case awaitingLivenessSession(Challenge)
+    case displayingGetReadyView(Challenge)
     case displayingLiveness
     case awaitingCameraPermission
-    case awaitingChallengeType
+
+    static func == (lhs: DisplayState, rhs: DisplayState) -> Bool {
+        switch (lhs, rhs) {
+        case (.awaitingChallengeType, .awaitingChallengeType):
+            return true
+        case (let .awaitingLivenessSession(c1), let .awaitingLivenessSession(c2)):
+            return c1.type == c2.type && c1.version == c2.version
+        case (let .displayingGetReadyView(c1), let .displayingGetReadyView(c2)):
+            return c1.type == c2.type && c1.version == c2.version
+        case (.displayingLiveness, .displayingLiveness):
+            return true
+        case (.awaitingCameraPermission, .awaitingCameraPermission):
+            return true
+        default:
+            return false
+        }
+    }
 }
 
 enum InstructionState {

Sources/FaceLiveness/Views/Liveness/FaceLivenessDetectionViewModel.swift

@@ -90,7 +90,7 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         NotificationCenter.default.removeObserver(self)
     }
 
-    func registerServiceEvents(onChallengeTypeReceived: @escaping () -> Void) {
+    func registerServiceEvents(onChallengeTypeReceived: @escaping (Challenge) -> Void) {
         livenessService?.register(onComplete: { [weak self] reason in
             self?.stopRecording()
 
@@ -117,7 +117,7 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         livenessService?.register(
             listener: { [weak self] _challenge in
                 self?.challenge = _challenge
-                onChallengeTypeReceived()
+                onChallengeTypeReceived(_challenge)
             },
             on: .challenge)
     }
@@ -186,10 +186,13 @@ class FaceLivenessDetectionViewModel: ObservableObject {
 
     func initializeLivenessStream() {
         do {
-            try livenessService?.initializeLivenessStream(
+            guard let livenessSession = livenessService as? FaceLivenessSession else {
+                throw FaceLivenessDetectionError.unknown
+            }
+
+            try livenessSession.initializeLivenessStream(
                 withSessionID: sessionID,
-                userAgent: UserAgentValues.standard().userAgentString,
-                challenges: nil
+                userAgent: UserAgentValues.standard().userAgentString
             )
         } catch {
             DispatchQueue.main.async {
@@ -235,6 +238,8 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         videoStartTime: UInt64
     ) {
         guard initialClientEvent == nil else { return }
+        guard let challenge else { return }
+
         videoChunker.start()
 
         let initialFace = FaceDetection(
@@ -253,8 +258,8 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         do {
             try livenessService?.send(
                 .initialFaceDetected(event: _initialClientEvent, 
-                                     challenge: .init(version: challenge?.version ?? "2.0.0",
-                                                          type: challenge?.type ?? .faceMovementAndLightChallenge)),
+                                     challenge: .init(version: challenge.version,
+                                                      type: challenge.type)),
                 eventDate: { .init() }
             )
         } catch {
@@ -272,7 +277,8 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         guard
             let sessionConfiguration,
             let initialClientEvent,
-            let faceMatchedTimestamp
+            let faceMatchedTimestamp,
+            let challenge
         else { return }
 
         let finalClientEvent = FinalClientEvent(
@@ -287,8 +293,8 @@ class FaceLivenessDetectionViewModel: ObservableObject {
         do {
             try livenessService?.send(
                 .final(event: finalClientEvent,
-                       challenge: .init(version: challenge?.version ?? "2.0.0",
-                                            type: challenge?.type ?? .faceMovementAndLightChallenge)),
+                       challenge: .init(version: challenge.version,
+                                            type: challenge.type)),
                 eventDate: { .init() }
             )
 
@@ -383,8 +389,4 @@ class FaceLivenessDetectionViewModel: ObservableObject {
     }
 }
 
-extension FaceLivenessDetectionViewModel: FaceDetectionSessionConfiguration {
-    func getFaceDetectionSessionConfiguration() -> FaceLivenessSession.SessionConfiguration? {
-        sessionConfiguration
-    }
-}
+extension FaceLivenessDetectionViewModel: FaceDetectionSessionConfigurationWrapper { }

Sources/FaceLiveness/Views/Liveness/LivenessViewController.swift

@@ -171,8 +171,9 @@ extension _LivenessViewController: FaceLivenessViewControllerPresenter {
     }
 
     func completeNoLightCheck() {
+        guard let faceGuideRect = self.faceGuideRect else { return }
         self.viewModel.completeNoLightCheck(
-            faceGuide: self.faceGuideRect!
+            faceGuide: faceGuideRect
         )
     }
 }

Tests/FaceLivenessTests/LivenessTests.swift

@@ -69,6 +69,7 @@ final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
     /// Then: The end state of this flow is `.faceMatched`
     func testHappyPathToMatchedFace() async throws {
         viewModel.livenessService = self.livenessService
+        viewModel.challenge = Challenge(version: "2.0.0", type: .faceMovementAndLightChallenge)
 
         viewModel.livenessState.checkIsFacePrepared()
         XCTAssertEqual(viewModel.livenessState.state, .pendingFacePreparedConfirmation(.pendingCheck))
@@ -103,16 +104,15 @@ final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
         XCTAssertEqual(faceDetector.interactions, [
             "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
         ])
-        XCTAssertEqual(livenessService.interactions, [
-            "initializeLivenessStream(withSessionID:userAgent:challenges:)"
-        ])
+        XCTAssertEqual(livenessService.interactions, [])
     }
 
     /// 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)`
     func testTransitionToRecordingState() async throws {
         viewModel.livenessService = self.livenessService
+        viewModel.challenge = Challenge(version: "2.0.0", type: .faceMovementAndLightChallenge)
 
         let face = FaceLivenessSession.OvalMatchChallenge.Face(
             distanceThreshold: 0.32,

Tests/FaceLivenessTests/MockLivenessService.swift

@@ -46,7 +46,7 @@ extension MockLivenessService: LivenessService {
     func initializeLivenessStream(
         withSessionID sessionID: String, 
         userAgent: String,
-        challenges: [Challenge]?
+        challenges: [Challenge]
     ) throws {
         interactions.append(#function)
         onInitializeLivenessStream(sessionID, userAgent, challenges)