Add information to MDL reader handle_response method (#112)

This updates the MDL reader handle_response method to return the device and issuer authentication status check instead of triggering an error and finishing the flow.

Author: Juliano1612

MobileSdkRs/Sources/MobileSdkRs/mobile_sdk_rs.swift

@@ -7420,15 +7420,39 @@ public struct MdlReaderResponseData {
      * Contains the namespaces for the mDL directly, without top-level doc types
      */
     public var verifiedResponse: [String: [String: MDocItem]]
+    /**
+     * Outcome of issuer authentication.
+     */
+    public var issuerAuthentication: AuthenticationStatus
+    /**
+     * Outcome of device authentication.
+     */
+    public var deviceAuthentication: AuthenticationStatus
+    /**
+     * Errors that occurred during response processing.
+     */
+    public var errors: String?
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(state: MdlSessionManager, 
         /**
          * Contains the namespaces for the mDL directly, without top-level doc types
-         */verifiedResponse: [String: [String: MDocItem]]) {
+         */verifiedResponse: [String: [String: MDocItem]], 
+        /**
+         * Outcome of issuer authentication.
+         */issuerAuthentication: AuthenticationStatus, 
+        /**
+         * Outcome of device authentication.
+         */deviceAuthentication: AuthenticationStatus, 
+        /**
+         * Errors that occurred during response processing.
+         */errors: String?) {
         self.state = state
         self.verifiedResponse = verifiedResponse
+        self.issuerAuthentication = issuerAuthentication
+        self.deviceAuthentication = deviceAuthentication
+        self.errors = errors
     }
 }
 
@@ -7439,13 +7463,19 @@ public struct FfiConverterTypeMDLReaderResponseData: FfiConverterRustBuffer {
         return
             try MdlReaderResponseData(
                 state: FfiConverterTypeMDLSessionManager.read(from: &buf), 
-                verifiedResponse: FfiConverterDictionaryStringDictionaryStringTypeMDocItem.read(from: &buf)
+                verifiedResponse: FfiConverterDictionaryStringDictionaryStringTypeMDocItem.read(from: &buf), 
+                issuerAuthentication: FfiConverterTypeAuthenticationStatus.read(from: &buf), 
+                deviceAuthentication: FfiConverterTypeAuthenticationStatus.read(from: &buf), 
+                errors: FfiConverterOptionString.read(from: &buf)
         )
     }
 
     public static func write(_ value: MdlReaderResponseData, into buf: inout [UInt8]) {
         FfiConverterTypeMDLSessionManager.write(value.state, into: &buf)
         FfiConverterDictionaryStringDictionaryStringTypeMDocItem.write(value.verifiedResponse, into: &buf)
+        FfiConverterTypeAuthenticationStatus.write(value.issuerAuthentication, into: &buf)
+        FfiConverterTypeAuthenticationStatus.write(value.deviceAuthentication, into: &buf)
+        FfiConverterOptionString.write(value.errors, into: &buf)
     }
 }
 
@@ -7720,6 +7750,68 @@ public func FfiConverterTypeStatusMessage_lower(_ value: StatusMessage) -> RustB
     return FfiConverterTypeStatusMessage.lower(value)
 }
 
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+
+public enum AuthenticationStatus {
+    
+    case valid
+    case invalid
+    case unchecked
+}
+
+
+public struct FfiConverterTypeAuthenticationStatus: FfiConverterRustBuffer {
+    typealias SwiftType = AuthenticationStatus
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthenticationStatus {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .valid
+        
+        case 2: return .invalid
+        
+        case 3: return .unchecked
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AuthenticationStatus, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .valid:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .invalid:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .unchecked:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+public func FfiConverterTypeAuthenticationStatus_lift(_ buf: RustBuffer) throws -> AuthenticationStatus {
+    return try FfiConverterTypeAuthenticationStatus.lift(buf)
+}
+
+public func FfiConverterTypeAuthenticationStatus_lower(_ value: AuthenticationStatus) -> RustBuffer {
+    return FfiConverterTypeAuthenticationStatus.lower(value)
+}
+
+
+
+extension AuthenticationStatus: Equatable, Hashable {}
+
+
+
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**

src/mdl/reader.rs

@@ -12,7 +12,7 @@ use isomdl::{
             trust_anchor::{PemTrustAnchor, TrustAnchorRegistry},
         },
     },
-    presentation::{authentication::AuthenticationStatus, reader},
+    presentation::{authentication::AuthenticationStatus as IsoMdlAuthenticationStatus, reader},
 };
 use uuid::Uuid;
 
@@ -151,11 +151,34 @@ impl From<serde_json::Value> for MDocItem {
         }
     }
 }
+
+#[derive(Debug, Clone, PartialEq, uniffi::Enum)]
+pub enum AuthenticationStatus {
+    Valid,
+    Invalid,
+    Unchecked,
+}
+
+impl From<IsoMdlAuthenticationStatus> for AuthenticationStatus {
+    fn from(internal: IsoMdlAuthenticationStatus) -> Self {
+        match internal {
+            IsoMdlAuthenticationStatus::Valid => AuthenticationStatus::Valid,
+            IsoMdlAuthenticationStatus::Invalid => AuthenticationStatus::Invalid,
+            IsoMdlAuthenticationStatus::Unchecked => AuthenticationStatus::Unchecked,
+        }
+    }
+}
 #[derive(uniffi::Record, Debug)]
 pub struct MDLReaderResponseData {
     state: Arc<MDLSessionManager>,
     /// Contains the namespaces for the mDL directly, without top-level doc types
     verified_response: HashMap<String, HashMap<String, MDocItem>>,
+    /// Outcome of issuer authentication.
+    pub issuer_authentication: AuthenticationStatus,
+    /// Outcome of device authentication.
+    pub device_authentication: AuthenticationStatus,
+    /// Errors that occurred during response processing.
+    pub errors: Option<String>,
 }
 
 #[uniffi::export]
@@ -165,23 +188,17 @@ pub fn handle_response(
 ) -> Result<MDLReaderResponseData, MDLReaderResponseError> {
     let mut state = state.0.clone();
     let validated_response = state.handle_response(&response);
-    if !validated_response.errors.is_empty() {
-        return Err(MDLReaderResponseError::Generic {
-            value: serde_json::to_string(&validated_response.errors).map_err(|e| {
+    let errors = if !validated_response.errors.is_empty() {
+        Some(
+            serde_json::to_string(&validated_response.errors).map_err(|e| {
                 MDLReaderResponseError::Generic {
                     value: format!("Could not serialze errors: {e:?}"),
                 }
             })?,
-        });
-    }
-    // These checks should be unreachable as they always have a corresponding entry in `errors`
-    if let AuthenticationStatus::Invalid = validated_response.issuer_authentication {
-        return Err(MDLReaderResponseError::InvalidIssuerAuthentication);
-    }
-    if let AuthenticationStatus::Invalid = validated_response.device_authentication {
-        return Err(MDLReaderResponseError::InvalidDeviceAuthentication);
-    }
-    // We get the namespaces directly without the top-level doc types
+        )
+    } else {
+        None
+    };
     let verified_response: Result<_, _> = validated_response
         .response
         .into_iter()
@@ -205,5 +222,8 @@ pub fn handle_response(
     Ok(MDLReaderResponseData {
         state: Arc::new(MDLSessionManager(state)),
         verified_response,
+        issuer_authentication: AuthenticationStatus::from(validated_response.issuer_authentication),
+        device_authentication: AuthenticationStatus::from(validated_response.device_authentication),
+        errors,
     })
 }