@smile_identity/react-native 10.2.5 → 10.2.6

package/android/gradle.properties

@@ -3,5 +3,5 @@ SmileId_minSdkVersion=21
 SmileId_targetSdkVersion=35
 SmileId_compileSdkVersion=35
 SmileId_ndkversion=21.4.7075529
-SmileId_androidVersion=10.5.0
+SmileId_androidVersion=10.5.2
 SmileId_kotlinCompilerExtensionVersion=1.5.11

package/android/src/main/java/com/smileidentity/react/Mapper.kt

@@ -153,7 +153,12 @@ fun ReadableMap.toEnhancedKycRequest(): EnhancedKycRequest {
       throw IllegalArgumentException("signature is required")
     },
     consentInformation = getMapOrDefault("consentInformation", null)?.toConsentInfo() ?: run {
-      throw IllegalArgumentException("consentInformation is required")
+      ConsentInformation(
+        consentGrantedDate = getCurrentIsoTimestamp(),
+        personalDetailsConsentGranted = false,
+        contactInfoConsentGranted = false,
+        documentInfoConsentGranted = false
+      )
     },
   )
 }

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDBiometricKYCViewManager.kt

@@ -3,9 +3,11 @@ package com.smileidentity.react.viewmanagers
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
+import com.smileidentity.models.ConsentInformation
 import com.smileidentity.react.toConsentInfo
 import com.smileidentity.react.toIdInfo
 import com.smileidentity.react.utils.getBoolOrDefault
+import com.smileidentity.react.utils.getCurrentIsoTimestamp
 import com.smileidentity.react.utils.getImmutableMapOrDefault
 import com.smileidentity.react.utils.getMapOrDefault
 import com.smileidentity.react.utils.getStringOrDefault
@@ -26,10 +28,14 @@ class SmileIDBiometricKYCViewManager(
     args?.let {
       val idInfoMap = it.getMap("idInfo")
         ?: return view.emitFailure(IllegalArgumentException("idInfo is required to run Biometric KYC"))
-      val consentInformationMap = it.getMap("consentInformation")
-        ?: return view.emitFailure(IllegalArgumentException("consentInformation is required to run Biometric KYC"))
       val idInfo = idInfoMap.toIdInfo()
-      view.consentInformation = consentInformationMap.toConsentInfo()
+      view.consentInformation = it.getMapOrDefault("consentInformation")?.toConsentInfo()
+        ?: ConsentInformation(
+          consentGrantedDate = getCurrentIsoTimestamp(),
+          personalDetailsConsentGranted = false,
+          contactInfoConsentGranted = false,
+          documentInfoConsentGranted = false
+        )
       view.extraPartnerParams = it.getImmutableMapOrDefault("extraPartnerParams")
       view.userId = it.getStringOrDefault("userId")
       view.jobId = it.getStringOrDefault("jobId")

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDDocumentVerificationViewManager.kt

@@ -40,7 +40,6 @@ class SmileIDDocumentVerificationViewManager(
       view.documentType = it.getStringOrDefault("documentType", null)
       view.idAspectRatio = it.getFloatOrDefault("idAspectRatio")
       view.allowNewEnroll = it.getBoolOrDefault("allowNewEnroll", false)
-      view.skipApiSubmission = it.getBoolOrDefault("skipApiSubmission", false)
       view.useStrictMode = it.getBoolOrDefault("useStrictMode", false)
     }
   }

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDEnhancedDocumentVerificationViewManager.kt

@@ -6,9 +6,11 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
+import com.smileidentity.models.ConsentInformation
 import com.smileidentity.react.toConsentInfo
 import com.smileidentity.react.toIdInfo
 import com.smileidentity.react.utils.getBoolOrDefault
+import com.smileidentity.react.utils.getCurrentIsoTimestamp
 import com.smileidentity.react.utils.getFloatOrDefault
 import com.smileidentity.react.utils.getImmutableMapOrDefault
 import com.smileidentity.react.utils.getMapOrDefault
@@ -30,10 +32,16 @@ class SmileIDEnhancedDocumentVerificationViewManager(
   override fun applyArgs(view: SmileIDEnhancedDocumentVerificationView, args: ReadableMap?) {
     args?.let {
       val countryCode = it.getString("countryCode")
-        ?: return view.emitFailure(IllegalArgumentException("countryCode is required to run Enhanced Document Verification"))
-      val consentInformationMap = it.getMap("consentInformation")
-        ?: return view.emitFailure(IllegalArgumentException("consentInformation is required to run Biometric KYC"))
-      view.consentInformation = consentInformationMap.toConsentInfo()
+        ?: return view.emitFailure(
+          IllegalArgumentException("countryCode is required to run Enhanced Document Verification")
+        )
+      view.consentInformation = it.getMapOrDefault("consentInformation")?.toConsentInfo()
+        ?: ConsentInformation(
+          consentGrantedDate = getCurrentIsoTimestamp(),
+          personalDetailsConsentGranted = false,
+          contactInfoConsentGranted = false,
+          documentInfoConsentGranted = false
+        )
       view.extraPartnerParams = it.getImmutableMapOrDefault("extraPartnerParams")
       view.userId = it.getStringOrDefault("userId")
       view.jobId = it.getStringOrDefault("jobId")
@@ -46,7 +54,6 @@ class SmileIDEnhancedDocumentVerificationViewManager(
       view.documentType = it.getStringOrDefault("documentType")
       view.idAspectRatio = it.getFloatOrDefault("idAspectRatio")
       view.allowNewEnroll = it.getBoolOrDefault("allowNewEnroll", false)
-      view.skipApiSubmission = it.getBoolOrDefault("skipApiSubmission", false)
       view.useStrictMode = it.getBoolOrDefault("useStrictMode", false)
     }
   }

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDSmartSelfieAuthenticationEnhancedViewManager.kt

@@ -30,6 +30,7 @@ class SmileIDSmartSelfieAuthenticationEnhancedViewManager(
       view.showAttribution = it.getBoolOrDefault("showAttribution", true)
       view.showInstructions = it.getBoolOrDefault("showInstructions", true)
       view.allowNewEnroll = it.getBoolOrDefault("allowNewEnroll", false)
+      view.skipApiSubmission = it.getBoolOrDefault("skipApiSubmission", false)
     }
   }
 

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDSmartSelfieCaptureViewManager.kt

@@ -29,6 +29,7 @@ class SmileIDSmartSelfieCaptureViewManager(
       view.allowAgentMode = it.getBoolOrDefault("allowAgentMode", false)
       view.showAttribution = it.getBoolOrDefault("showAttribution", true)
       view.showInstructions = it.getBoolOrDefault("showInstructions", true)
+      view.useStrictMode = it.getBoolOrDefault("useStrictMode", false)
       view.showConfirmation =
         it.getBoolOrDefault("showConfirmation", true)
     }

package/android/src/main/java/com/smileidentity/react/viewmanagers/SmileIDSmartSelfieEnrollmentEnhancedViewManager.kt

@@ -30,6 +30,7 @@ class SmileIDSmartSelfieEnrollmentEnhancedViewManager(
       view.showAttribution = it.getBoolOrDefault("showAttribution", true)
       view.showInstructions = it.getBoolOrDefault("showInstructions", true)
       view.allowNewEnroll = it.getBoolOrDefault("allowNewEnroll", false)
+      view.skipApiSubmission = it.getBoolOrDefault("skipApiSubmission", false)
     }
   }
 

package/android/src/main/java/com/smileidentity/react/views/SmileIDSelfieView.kt

@@ -0,0 +1,48 @@
+package com.smileidentity.react.views
+
+import android.annotation.SuppressLint
+import android.content.Context
+import com.smileidentity.SmileID
+import com.smileidentity.react.results.SmartSelfieCaptureResult
+import com.smileidentity.react.utils.SelfieCaptureResultAdapter
+import com.smileidentity.results.SmartSelfieResult
+import com.smileidentity.results.SmileIDResult
+
+@SuppressLint("CheckResult")
+abstract class SmileIDSelfieView(currentContext: Context) : SmileIDView(currentContext) {
+
+  protected fun handleResultCallback(res: SmileIDResult<*>) {
+    when (res) {
+      is SmileIDResult.Success -> {
+        val data = res.data as? SmartSelfieResult ?: run {
+          emitFailure(Exception("Unexpected result type"))
+          return
+        }
+        val result = SmartSelfieCaptureResult(
+          selfieFile = data.selfieFile,
+          livenessFiles = data.livenessFiles,
+          apiResponse = data.apiResponse,
+        )
+        val newMoshi =
+          SmileID.moshi
+            .newBuilder()
+            .add(SelfieCaptureResultAdapter.FACTORY)
+            .build()
+        val json =
+          try {
+            newMoshi
+              .adapter(SmartSelfieCaptureResult::class.java)
+              .toJson(result)
+          } catch (e: Exception) {
+            emitFailure(e)
+            return
+          }
+        json?.let { js ->
+          emitSuccess(js)
+        }
+      }
+
+      is SmileIDResult.Error -> emitFailure(res.throwable)
+    }
+  }
+}

package/android/src/main/java/com/smileidentity/react/views/SmileIDSmartSelfieAuthenticationEnhancedView.kt

@@ -8,11 +8,12 @@ import com.smileidentity.SmileID
 import com.smileidentity.compose.SmartSelfieAuthenticationEnhanced
 import com.smileidentity.react.results.SmartSelfieCaptureResult
 import com.smileidentity.react.utils.SelfieCaptureResultAdapter
+import com.smileidentity.results.SmartSelfieResult
 import com.smileidentity.results.SmileIDResult
 import com.smileidentity.util.randomUserId
 
 class SmileIDSmartSelfieAuthenticationEnhancedView(context: ReactApplicationContext) :
-  SmileIDView(context) {
+  SmileIDSelfieView(context) {
 
   override fun renderContent() {
     composeView.apply {
@@ -24,36 +25,10 @@ class SmileIDSmartSelfieAuthenticationEnhancedView(context: ReactApplicationCont
             allowNewEnroll = allowNewEnroll ?: false,
             showAttribution = showAttribution,
             showInstructions = showInstructions,
+            skipApiSubmission = skipApiSubmission,
             extraPartnerParams = extraPartnerParams,
-          ) { res ->
-            when (res) {
-              is SmileIDResult.Success -> {
-                val result =
-                  SmartSelfieCaptureResult(
-                    selfieFile = res.data.selfieFile,
-                    livenessFiles = res.data.livenessFiles,
-                    apiResponse = res.data.apiResponse,
-                  )
-                val json =
-                  try {
-                    SmileID.moshi
-                      .newBuilder()
-                      .add(SelfieCaptureResultAdapter.FACTORY)
-                      .build()
-                      .adapter(SmartSelfieCaptureResult::class.java)
-                      .toJson(result)
-                  } catch (e: Exception) {
-                    emitFailure(e)
-                    return@SmartSelfieAuthenticationEnhanced
-                  }
-                json?.let { response ->
-                  emitSuccess(response)
-                }
-              }
-
-              is SmileIDResult.Error -> emitFailure(res.throwable)
-            }
-          }
+            onResult = { res -> handleResultCallback(res) },
+          )
         }
       }
     }

package/android/src/main/java/com/smileidentity/react/views/SmileIDSmartSelfieAuthenticationView.kt

@@ -8,11 +8,13 @@ import com.smileidentity.SmileID
 import com.smileidentity.compose.SmartSelfieAuthentication
 import com.smileidentity.react.results.SmartSelfieCaptureResult
 import com.smileidentity.react.utils.SelfieCaptureResultAdapter
+import com.smileidentity.results.SmartSelfieResult
 import com.smileidentity.results.SmileIDResult
+import com.smileidentity.util.randomJobId
 import com.smileidentity.util.randomUserId
 
 class SmileIDSmartSelfieAuthenticationView(context: ReactApplicationContext) :
-  SmileIDView(context) {
+  SmileIDSelfieView(context) {
 
   override fun renderContent() {
     composeView.apply {
@@ -21,42 +23,15 @@ class SmileIDSmartSelfieAuthenticationView(context: ReactApplicationContext) :
         CompositionLocalProvider(LocalViewModelStoreOwner provides customViewModelStoreOwner) {
           SmileID.SmartSelfieAuthentication(
             userId = userId ?: rememberSaveable { randomUserId() },
+            jobId = jobId ?: rememberSaveable { randomJobId() },
             allowAgentMode = allowAgentMode ?: false,
             allowNewEnroll = allowNewEnroll ?: false,
             showAttribution = showAttribution,
             showInstructions = showInstructions,
+            skipApiSubmission = skipApiSubmission,
             extraPartnerParams = extraPartnerParams,
-          ) { res ->
-            when (res) {
-              is SmileIDResult.Success -> {
-                val result =
-                  SmartSelfieCaptureResult(
-                    selfieFile = res.data.selfieFile,
-                    livenessFiles = res.data.livenessFiles,
-                    apiResponse = res.data.apiResponse,
-                  )
-                val newMoshi =
-                  SmileID.moshi
-                    .newBuilder()
-                    .add(SelfieCaptureResultAdapter.FACTORY)
-                    .build()
-                val json =
-                  try {
-                    newMoshi
-                      .adapter(SmartSelfieCaptureResult::class.java)
-                      .toJson(result)
-                  } catch (e: Exception) {
-                    emitFailure(e)
-                    return@SmartSelfieAuthentication
-                  }
-                json?.let { js ->
-                  emitSuccess(js)
-                }
-              }
-
-              is SmileIDResult.Error -> emitFailure(res.throwable)
-            }
-          }
+            onResult = { res -> handleResultCallback(res) },
+          )
         }
       }
     }

package/android/src/main/java/com/smileidentity/react/views/SmileIDSmartSelfieCaptureView.kt

@@ -1,222 +1,63 @@
 package com.smileidentity.react.views
 
-import android.graphics.BitmapFactory
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.consumeWindowInsets
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.statusBars
-import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
-import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.toMutableStateList
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.asImageBitmap
-import androidx.compose.ui.graphics.painter.BitmapPainter
-import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
-import androidx.lifecycle.viewmodel.compose.viewModel
 import com.facebook.react.bridge.ReactApplicationContext
-import com.smileidentity.R
 import com.smileidentity.SmileID
 import com.smileidentity.SmileIDOptIn
-import com.smileidentity.compose.components.ImageCaptureConfirmationDialog
-import com.smileidentity.compose.components.LocalMetadata
-import com.smileidentity.compose.selfie.SelfieCaptureScreen
-import com.smileidentity.compose.selfie.SmartSelfieInstructionsScreen
+import com.smileidentity.compose.SmartSelfieEnrollment
+import com.smileidentity.compose.SmartSelfieEnrollmentEnhanced
 import com.smileidentity.compose.theme.colorScheme
 import com.smileidentity.compose.theme.typography
-import com.smileidentity.models.v2.Metadata
 import com.smileidentity.react.results.SmartSelfieCaptureResult
 import com.smileidentity.react.utils.SelfieCaptureResultAdapter
+import com.smileidentity.results.SmartSelfieResult
 import com.smileidentity.results.SmileIDResult
 import com.smileidentity.util.randomJobId
 import com.smileidentity.util.randomUserId
-import com.smileidentity.viewmodel.SelfieUiState
-import com.smileidentity.viewmodel.SelfieViewModel
-import com.smileidentity.viewmodel.viewModelFactory
 
 
 @OptIn(SmileIDOptIn::class)
-class SmileIDSmartSelfieCaptureView(context: ReactApplicationContext) : SmileIDView(context) {
+class SmileIDSmartSelfieCaptureView(context: ReactApplicationContext) : SmileIDSelfieView(context) {
   var showConfirmation: Boolean = true
+  var useStrictMode: Boolean = false
 
   override fun renderContent() {
     composeView.apply {
       val customViewModelStoreOwner = CustomViewModelStoreOwner()
       setContent {
         CompositionLocalProvider(LocalViewModelStoreOwner provides customViewModelStoreOwner) {
-          RenderSmartSelfieCaptureContent()
-        }
-      }
-    }
-  }
-
-  @Composable
-  private fun RenderSmartSelfieCaptureContent() {
-    val userId = randomUserId()
-    val jobId = randomJobId()
-    val metadata = LocalMetadata.current
-    val viewModel: SelfieViewModel =
-      viewModel(
-        factory =
-        viewModelFactory {
-          SelfieViewModel(
-            isEnroll = false,
-            userId = userId,
-            jobId = jobId,
-            allowNewEnroll = false,
-            skipApiSubmission = true,
-            metadata = metadata,
-          )
-        },
-      )
-    val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
-    var acknowledgedInstructions by rememberSaveable { mutableStateOf(false) }
-    CompositionLocalProvider(
-      LocalMetadata provides remember { Metadata.default().items.toMutableStateList() },
-    ) {
-      MaterialTheme(colorScheme = SmileID.colorScheme, typography = SmileID.typography) {
-        Surface(content = {
-          when {
-            showInstructions && !acknowledgedInstructions -> SmartSelfieInstructionsScreen(
-              showAttribution = showAttribution,
-            ) {
-              acknowledgedInstructions = true
-            }
-            uiState.processingState != null -> HandleProcessingState(viewModel)
-            uiState.selfieToConfirm != null ->
-              HandleSelfieConfirmation(
-                showConfirmation,
-                uiState,
-                viewModel,
-              )
-
-            else -> RenderSelfieCaptureScreen(userId, jobId, allowAgentMode ?: true, viewModel)
-          }
-        })
-      }
-    }
-  }
-
-  @Composable
-  private fun RenderSelfieCaptureScreen(
-    userId: String,
-    jobId: String,
-    allowAgentMode: Boolean,
-    viewModel: SelfieViewModel,
-  ) {
-    Box(
-      modifier =
-      Modifier
-        .background(color = Color.White)
-        .windowInsetsPadding(WindowInsets.statusBars)
-        .consumeWindowInsets(WindowInsets.statusBars)
-        .fillMaxSize(),
-    ) {
-      SelfieCaptureScreen(
-        userId = userId,
-        jobId = jobId,
-        allowAgentMode = allowAgentMode,
-        allowNewEnroll = false,
-        skipApiSubmission = true,
-        viewModel = viewModel,
-      )
-    }
-  }
-
-  @Composable
-  private fun HandleSelfieConfirmation(
-    showConfirmation: Boolean,
-    uiState: SelfieUiState,
-    viewModel: SelfieViewModel,
-  ) {
-    if (showConfirmation) {
-      ImageCaptureConfirmationDialog(
-        titleText = stringResource(R.string.si_smart_selfie_confirmation_dialog_title),
-        subtitleText =
-        stringResource(
-          R.string.si_smart_selfie_confirmation_dialog_subtitle,
-        ),
-        painter =
-        BitmapPainter(
-          BitmapFactory
-            .decodeFile(uiState.selfieToConfirm!!.absolutePath)
-            .asImageBitmap(),
-        ),
-        confirmButtonText =
-        stringResource(
-          R.string.si_smart_selfie_confirmation_dialog_confirm_button,
-        ),
-        onConfirm = {
-          viewModel.submitJob()
-        },
-        retakeButtonText =
-        stringResource(
-          R.string.si_smart_selfie_confirmation_dialog_retake_button,
-        ),
-        onRetake = viewModel::onSelfieRejected,
-        scaleFactor = 1.25f,
-      )
-    } else {
-      viewModel.submitJob()
-    }
-  }
-
-  @Composable
-  private fun HandleProcessingState(viewModel: SelfieViewModel) {
-    try {
-      viewModel.onFinished { res ->
-        when (res) {
-          is SmileIDResult.Success -> {
-            res.data?.let { data ->
-              val result = SmartSelfieCaptureResult(
-                selfieFile = data.selfieFile,
-                livenessFiles = data.livenessFiles ?: emptyList()
-              )
-
-              try {
-                val newMoshi = SmileID.moshi
-                  .newBuilder()
-                  .add(SelfieCaptureResultAdapter.FACTORY)
-                  .build()
-
-                newMoshi.adapter(SmartSelfieCaptureResult::class.java)
-                  ?.toJson(result)
-                  ?.let { js ->
-                    emitSuccess(js)
-                  } ?: run {
-                  emitFailure(Exception("Failed to serialize result"))
-                }
-              } catch (e: Exception) {
-                emitFailure(e)
+          val userId = randomUserId()
+          val jobId = randomJobId()
+          MaterialTheme(colorScheme = SmileID.colorScheme, typography = SmileID.typography) {
+            Surface(content = {
+              if (useStrictMode) {
+                SmileID.SmartSelfieEnrollmentEnhanced(
+                  userId = userId,
+                  showAttribution = showAttribution,
+                  showInstructions = showInstructions,
+                  skipApiSubmission = true,
+                  extraPartnerParams = extraPartnerParams,
+                  onResult = { res -> handleResultCallback(res) },
+                )
+              } else {
+                SmileID.SmartSelfieEnrollment(
+                  userId = userId,
+                  jobId = jobId,
+                  allowAgentMode = allowAgentMode ?: false,
+                  showAttribution = showAttribution,
+                  showInstructions = showInstructions,
+                  skipApiSubmission = true,
+                  extraPartnerParams = extraPartnerParams,
+                  onResult = { res -> handleResultCallback(res) },
+                )
               }
-            } ?: run {
-              emitFailure(Exception("No data available in success result"))
-            }
-          }
-
-          is SmileIDResult.Error -> {
-            emitFailure(res.throwable ?: Exception("Unknown error occurred"))
-          }
-
-          else -> {
-            emitFailure(Exception("Unexpected result type"))
+            })
           }
         }
       }
-    } catch (e: Exception) {
-//      emitFailure(e)
     }
   }
 }

package/android/src/main/java/com/smileidentity/react/views/SmileIDSmartSelfieEnrollmentEnhancedView.kt

@@ -8,6 +8,7 @@ import com.smileidentity.SmileID
 import com.smileidentity.compose.SmartSelfieEnrollmentEnhanced
 import com.smileidentity.react.results.SmartSelfieCaptureResult
 import com.smileidentity.react.utils.SelfieCaptureResultAdapter
+import com.smileidentity.results.SmartSelfieResult
 import com.smileidentity.results.SmileIDResult
 import com.smileidentity.util.randomUserId
 import kotlinx.coroutines.CoroutineScope
@@ -15,8 +16,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 
-class SmileIDSmartSelfieEnrollmentEnhancedView(context: ReactApplicationContext) : SmileIDView(context) {
-  private val viewScope = CoroutineScope(Dispatchers.Main + Job())
+class SmileIDSmartSelfieEnrollmentEnhancedView(context: ReactApplicationContext) : SmileIDSelfieView(context) {
   override fun renderContent() {
     composeView.apply {
       setContent {
@@ -27,40 +27,10 @@ class SmileIDSmartSelfieEnrollmentEnhancedView(context: ReactApplicationContext)
             allowNewEnroll = allowNewEnroll ?: false,
             showAttribution = showAttribution,
             showInstructions = showInstructions,
+            skipApiSubmission = skipApiSubmission,
             extraPartnerParams = extraPartnerParams,
-          ) {res ->
-            viewScope.launch {
-              when (res) {
-                is SmileIDResult.Success -> {
-                  val result =
-                    SmartSelfieCaptureResult(
-                      selfieFile = res.data.selfieFile,
-                      livenessFiles = res.data.livenessFiles,
-                      apiResponse = res.data.apiResponse,
-                    )
-                  val newMoshi =
-                    SmileID.moshi
-                      .newBuilder()
-                      .add(SelfieCaptureResultAdapter.FACTORY)
-                      .build()
-                  val json =
-                    try {
-                      newMoshi
-                        .adapter(SmartSelfieCaptureResult::class.java)
-                        .toJson(result)
-                    } catch (e: Exception) {
-                      emitFailure(e)
-                      return@launch
-                    }
-                  json?.let { js ->
-                    emitSuccess(js)
-                  }
-                }
-
-                is SmileIDResult.Error -> emitFailure(res.throwable)
-              }
-            }
-          }
+            onResult = { res -> handleResultCallback(res) },
+          )
         }
       }
     }