Identification features

app/src/main/java/org/dhis2/simprints/SimprintsCustomIntentResultMapper.kt

@@ -0,0 +1,18 @@
+package org.dhis2.simprints
+
+import android.content.Intent
+import org.dhis2.form.ui.customintent.CustomIntentActivityResultContract
+import org.dhis2.mobile.commons.model.CustomIntentResponseDataModel
+
+class SimprintsCustomIntentResultMapper(
+    private val contract: CustomIntentActivityResultContract = CustomIntentActivityResultContract(),
+) {
+    fun map(
+        responseData: List<CustomIntentResponseDataModel>?,
+        data: Intent?,
+    ): String? =
+        contract
+            .mapIntentResponseData(responseData, data)
+            ?.takeUnless(List<String>::isEmpty)
+            ?.joinToString(separator = ",")
+}

app/src/main/java/org/dhis2/simprints/SimprintsEnrollmentViewModel.kt

@@ -0,0 +1,83 @@
+package org.dhis2.simprints
+
+import android.app.Activity.RESULT_OK
+import android.content.Intent
+import androidx.lifecycle.ViewModel
+import kotlin.concurrent.atomics.AtomicReference
+import kotlin.concurrent.atomics.ExperimentalAtomicApi
+import org.dhis2.commons.simprints.repository.SimprintsD2Repository
+import org.dhis2.commons.simprints.repository.SimprintsSessionRepository
+import org.dhis2.commons.simprints.usecases.SimprintsResolvePendingEnrollmentActionUseCase
+
+@OptIn(ExperimentalAtomicApi::class)
+class SimprintsEnrollmentViewModel(
+    private val simprintsD2Repository: SimprintsD2Repository,
+    private val resolvePendingEnrollmentAction: SimprintsResolvePendingEnrollmentActionUseCase,
+    private val sessionRepository: SimprintsSessionRepository,
+    private val resultMapper: SimprintsCustomIntentResultMapper,
+) : ViewModel() {
+    enum class RegisterLastResult {
+        NONE,
+        CONTINUE_FINISH,
+        ERROR,
+    }
+
+    private val pendingAction =
+        AtomicReference<SimprintsResolvePendingEnrollmentActionUseCase.PendingEnrollmentAction?>(null)
+
+    suspend fun onFinishRequested(
+        isNewEnrollment: Boolean,
+        enrollmentUid: String,
+    ): Intent? {
+        if (!isNewEnrollment) {
+            return null
+        }
+
+        val resolvedAction =
+            sessionRepository.pendingEnrollmentSessionId()?.let {
+                resolvePendingEnrollmentAction(
+                    enrollmentUid = enrollmentUid,
+                    sessionId = it,
+                )
+            } ?: return null
+
+        pendingAction.store(resolvedAction)
+        return resolvedAction.callout.launchIntent
+    }
+
+    suspend fun onRegisterLastResult(
+        resultCode: Int,
+        data: Intent?,
+        teiUid: String?,
+    ): RegisterLastResult {
+        val resolvedAction = pendingAction.exchange(null) ?: return RegisterLastResult.NONE
+
+        val saved =
+            if (resultCode == RESULT_OK && teiUid != null) {
+                val value =
+                    resultMapper.map(
+                        responseData = resolvedAction.callout.responseData,
+                        data = data,
+                    ) ?: return RegisterLastResult.ERROR
+                simprintsD2Repository.saveTrackedEntityAttributeValue(
+                    teiUid = teiUid,
+                    attributeUid = resolvedAction.fieldUid,
+                    value = value,
+                )
+                true
+            } else {
+                false
+            }
+
+        if (saved) {
+            sessionRepository.clear()
+            return RegisterLastResult.CONTINUE_FINISH
+        }
+
+        return RegisterLastResult.ERROR
+    }
+
+    fun onRegisterLastLaunchFailed() {
+        pendingAction.store(null)
+    }
+}

app/src/main/java/org/dhis2/simprints/SimprintsSearchViewModel.kt

@@ -0,0 +1,106 @@
+package org.dhis2.simprints
+
+import android.app.Activity.RESULT_OK
+import android.content.Intent
+import androidx.lifecycle.ViewModel
+import kotlin.concurrent.atomics.AtomicReference
+import kotlin.concurrent.atomics.ExperimentalAtomicApi
+import org.dhis2.commons.simprints.repository.SimprintsSessionRepository
+import org.dhis2.commons.simprints.usecases.SimprintsResolveConfirmIdentityCalloutUseCase
+import org.dhis2.commons.simprints.utils.SimprintsSearchUtils
+
+@OptIn(ExperimentalAtomicApi::class)
+class SimprintsSearchViewModel(
+    private val resolveConfirmIdentityCallout: SimprintsResolveConfirmIdentityCalloutUseCase,
+    private val sessionRepository: SimprintsSessionRepository,
+) : ViewModel() {
+    data class PendingDashboardNavigation(
+        val teiUid: String,
+        val programUid: String?,
+        val enrollmentUid: String?,
+    )
+
+    sealed class DashboardAction {
+        data class LaunchConfirmIdentity(
+            val intent: Intent,
+        ) : DashboardAction()
+
+        data class OpenDashboard(
+            val navigation: PendingDashboardNavigation,
+        ) : DashboardAction()
+    }
+
+    private val pendingDashboardNavigation = AtomicReference<PendingDashboardNavigation?>(null)
+
+    suspend fun onDashboardRequested(
+        searchFields: List<SimprintsSearchUtils.SearchField>,
+        teiUid: String,
+        programUid: String?,
+        enrollmentUid: String?,
+    ): DashboardAction {
+        val searchState = SimprintsSearchUtils.searchState(searchFields)
+        val sessionId =
+            sessionRepository.get()?.takeIf { searchState.hasBiometricIdentificationQuery }
+        val confirmIdentityIntent =
+            sessionId?.let {
+                resolveConfirmIdentityCallout(
+                    teiUid = teiUid,
+                    searchFields = searchFields,
+                    sessionId = it,
+                )?.launchIntent
+            }
+
+        val navigation =
+            PendingDashboardNavigation(
+                teiUid = teiUid,
+                programUid = programUid,
+                enrollmentUid = enrollmentUid,
+            )
+        if (confirmIdentityIntent == null) {
+            return DashboardAction.OpenDashboard(navigation)
+        }
+
+        pendingDashboardNavigation.store(navigation)
+        sessionRepository.clear()
+        return DashboardAction.LaunchConfirmIdentity(confirmIdentityIntent)
+    }
+
+    fun prepareEnrollmentQueryData(
+        searchFields: List<SimprintsSearchUtils.SearchField>,
+        queryData: Map<String, List<String>?>,
+    ): HashMap<String, List<String>> {
+        val searchState = SimprintsSearchUtils.searchState(searchFields)
+
+        if (searchState.hasBiometricIdentificationQuery && sessionRepository.hasPendingSession()) {
+            sessionRepository.markPendingEnrollment()
+        }
+
+        return SimprintsSearchUtils.filterQueryData(
+            queryData = queryData,
+            fields = searchFields,
+        )
+    }
+
+    fun onConfirmIdentityResult(resultCode: Int): PendingDashboardNavigation? =
+        pendingDashboardNavigation.exchange(null)
+            ?.takeIf { resultCode == RESULT_OK }
+
+    fun onConfirmIdentityLaunchFailed() {
+        pendingDashboardNavigation.store(null)
+    }
+
+    fun clearPendingSessionIfNeeded(searchFields: List<SimprintsSearchUtils.SearchField>) {
+        val searchState = SimprintsSearchUtils.searchState(searchFields)
+        if (sessionRepository.hasPendingSession() && searchState.shouldClearPendingSession) {
+            sessionRepository.clear()
+        }
+    }
+
+    fun shouldUseLastBiometricsLabel(searchFields: List<SimprintsSearchUtils.SearchField>): Boolean {
+        val searchState = SimprintsSearchUtils.searchState(searchFields)
+        return SimprintsSearchUtils.shouldUseLastBiometricsLabel(
+            searchState = searchState,
+            hasPendingSession = sessionRepository.hasPendingSession(),
+        )
+    }
+}

app/src/main/java/org/dhis2/simprints/di/SimprintsEnrollmentViewModelFactory.kt

@@ -0,0 +1,24 @@
+package org.dhis2.simprints.di
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import org.dhis2.commons.simprints.repository.SimprintsD2Repository
+import org.dhis2.commons.simprints.repository.SimprintsSessionRepository
+import org.dhis2.commons.simprints.usecases.SimprintsResolvePendingEnrollmentActionUseCase
+import org.dhis2.simprints.SimprintsCustomIntentResultMapper
+import org.dhis2.simprints.SimprintsEnrollmentViewModel
+
+class SimprintsEnrollmentViewModelFactory(
+    private val simprintsD2Repository: SimprintsD2Repository,
+    private val resolvePendingEnrollmentAction: SimprintsResolvePendingEnrollmentActionUseCase,
+    private val sessionRepository: SimprintsSessionRepository,
+    private val resultMapper: SimprintsCustomIntentResultMapper,
+) : ViewModelProvider.Factory {
+    override fun <T : ViewModel> create(modelClass: Class<T>): T =
+        SimprintsEnrollmentViewModel(
+            simprintsD2Repository = simprintsD2Repository,
+            resolvePendingEnrollmentAction = resolvePendingEnrollmentAction,
+            sessionRepository = sessionRepository,
+            resultMapper = resultMapper,
+        ) as T
+}

app/src/main/java/org/dhis2/simprints/di/SimprintsSearchViewModelFactory.kt

@@ -0,0 +1,18 @@
+package org.dhis2.simprints.di
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import org.dhis2.commons.simprints.repository.SimprintsSessionRepository
+import org.dhis2.commons.simprints.usecases.SimprintsResolveConfirmIdentityCalloutUseCase
+import org.dhis2.simprints.SimprintsSearchViewModel
+
+class SimprintsSearchViewModelFactory(
+    private val resolveConfirmIdentityCallout: SimprintsResolveConfirmIdentityCalloutUseCase,
+    private val sessionRepository: SimprintsSessionRepository,
+) : ViewModelProvider.Factory {
+    override fun <T : ViewModel> create(modelClass: Class<T>): T =
+        SimprintsSearchViewModel(
+            resolveConfirmIdentityCallout = resolveConfirmIdentityCallout,
+            sessionRepository = sessionRepository,
+        ) as T
+}

app/src/main/java/org/dhis2/usescases/enrollment/EnrollmentActivity.kt

@@ -7,9 +7,12 @@ import android.os.Bundle
 import android.view.View
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.databinding.DataBindingUtil
+import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.coroutines.launch
 import org.dhis2.App
 import org.dhis2.R
+import org.dhis2.R.string.custom_intent_error
 import org.dhis2.commons.Constants.ENROLLMENT_UID
 import org.dhis2.commons.Constants.PROGRAM_UID
 import org.dhis2.commons.Constants.TEI_UID
@@ -30,8 +33,10 @@ import org.dhis2.usescases.eventsWithoutRegistration.eventCapture.EventCaptureAc
 import org.dhis2.usescases.general.ActivityGlobalAbstract
 import org.dhis2.usescases.teiDashboard.TeiDashboardMobileActivity
 import org.dhis2.utils.granularsync.OPEN_ERROR_LOCATION
+import org.dhis2.simprints.SimprintsEnrollmentViewModel.RegisterLastResult
 import org.hisp.dhis.android.core.common.FeatureType
 import org.hisp.dhis.android.core.enrollment.EnrollmentStatus
+import timber.log.Timber
 import javax.inject.Inject
 
 class EnrollmentActivity :
@@ -53,6 +58,36 @@ class EnrollmentActivity :
 
     lateinit var binding: EnrollmentActivityBinding
     lateinit var mode: EnrollmentMode
+    private val simprintsRegisterLastBiometricsLauncher =
+        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+            lifecycleScope.launch {
+                try {
+                    when (
+                        presenter.onRegisterLastResult(
+                            resultCode = result.resultCode,
+                            data = result.data,
+                        )
+                    ) {
+                        RegisterLastResult.CONTINUE_FINISH -> {
+                            presenter.finish(mode)
+                        }
+
+                        RegisterLastResult.ERROR -> {
+                            displayMessage(getString(custom_intent_error))
+                            formView.reload()
+                        }
+
+                        RegisterLastResult.NONE -> {
+                            // no-op
+                        }
+                    }
+                } catch (e: Exception) {
+                    Timber.e(e)
+                    displayMessage(getString(custom_intent_error))
+                    formView.reload()
+                }
+            }
+        }
 
     companion object {
         const val ENROLLMENT_UID_EXTRA = "ENROLLMENT_UID_EXTRA"
@@ -133,7 +168,32 @@ class EnrollmentActivity :
                 locationProvider = locationProvider,
                 dateEditionWarningHandler = dateEditionWarningHandler,
             ) {
-                presenter.finish(enrollmentMode)
+                lifecycleScope.launch {
+                    val simprintsRegisterLastIntent =
+                        try {
+                            presenter.onFinishRequested(
+                                isNewEnrollment = enrollmentMode == EnrollmentMode.NEW,
+                                enrollmentUid = enrollmentUid,
+                            )
+                        } catch (e: Exception) {
+                            Timber.e(e)
+                            displayMessage(getString(custom_intent_error))
+                            formView.reload()
+                            return@launch
+                        }
+                    if (simprintsRegisterLastIntent != null) {
+                        try {
+                            simprintsRegisterLastBiometricsLauncher.launch(simprintsRegisterLastIntent)
+                        } catch (e: Exception) {
+                            Timber.e(e)
+                            presenter.onRegisterLastLaunchFailed()
+                            displayMessage(getString(custom_intent_error))
+                            formView.reload()
+                        }
+                        return@launch
+                    }
+                    presenter.finish(enrollmentMode)
+                }
             }
 
         presenter.init()