mobile‐id‐lib

Android service for signing with Mobile-ID.

Example usage of the MobileSignService

suspend fun performMobileIdWorkRequest(
    activity: Activity,
    context: Context,
    displayMessage: String,
    container: SignedContainer?,
    personalCode: String,
    phoneNumber: String,
    roleData: RoleData?,
) {
    activity.requestedOrientation = activity.resources.configuration.orientation
    resetValues()
    val configurationProvider = configurationRepository.getConfiguration()
    val uuid = dataStore.getSettingsUUID()
    val proxySetting: ProxySetting = dataStore.getProxySetting()
    val manualProxySettings: ManualProxy = dataStore.getManualProxySettings()

    val request: MobileCreateSignatureRequest =
        MobileCreateSignatureRequestHelper
            .create(
                container,
                uuid,
                configurationProvider?.midRestUrl,
                configurationProvider?.midSkRestUrl,
                Locale.getDefault(),
                personalCode,
                phoneNumber,
                displayMessage,
            )
    val certBundle = ArrayList(configurationProvider?.certBundle ?: emptyList())
    withContext(Main) {
        mobileSignService.errorState.observeForever {
            if (it != null) {
                _errorState.postValue(it)
            }
        }
        mobileSignService.challenge.observeForever { challenge ->
            if (challenge != null) {
                _challenge.postValue(challenge)
            }
        }
        mobileSignService.result.observeForever {
            if (it != null) {
                _errorState.postValue(
                    faults[it]?.let { res ->
                        context.getString(
                            res,
                        )
                    },
                )
            }
        }
        mobileSignService.status.observeForever { status ->
            if (status != null) {
                _status.postValue(status)
                if (status != MobileCreateSignatureProcessStatus.OK) {
                    if (status != MobileCreateSignatureProcessStatus.USER_CANCELLED) {
                        setErrorState(context, status)
                    } else {
                        CoroutineScope(Main).launch {
                            val containerSignatures = container?.getSignatures(Main)
                            val signatureInterface =
                                if (containerSignatures?.isEmpty() == true) {
                                    null
                                } else {
                                    containerSignatures
                                        ?.lastOrNull {
                                            it.validator.status == ValidatorInterface.Status.Invalid ||
                                                it.validator.status == ValidatorInterface.Status.Unknown
                                        }
                                }
                            signatureInterface?.let {
                                try {
                                    container?.removeSignature(it)
                                } catch (e: Exception) {
                                    debugLog(
                                        logTag,
                                        "Unable to remove Mobile-ID signature after " +
                                            "cancelling from device: ${e.localizedMessage}",
                                        e,
                                    )
                                }
                            }
                            _signedContainer.postValue(container)
                            setErrorState(context, status)
                        }
                    }
                }
            }
        }
        mobileSignService.response.observeForever {
            when (it?.status) {
                MobileCreateSignatureProcessStatus.OK -> {
                    CoroutineScope(Main).launch {
                        _status.postValue(it.status)
                        _signedContainer.postValue(container)
                    }
                }
                else -> {
                    if (it != null) {
                        _status.postValue(it.status)
                        setErrorState(context, it.status)
                    }
                }
            }
        }
    }
    mobileSignService.resetValues()
    if (container != null) {
        mobileSignService.processMobileIdRequest(
            context = context,
            signedContainer = container,
            request = request,
            roleDataRequest = roleData,
            proxySetting = proxySetting,
            manualProxySettings = manualProxySettings,
            certificateBundle = certBundle,
            accessTokenPath = Objects.requireNonNull(Conf.instance()).PKCS12Cert(),
            accessTokenPass = Objects.requireNonNull(Conf.instance()).PKCS12Pass(),
        )
    } else {
        CoroutineScope(Main).launch {
            _status.postValue(MobileCreateSignatureProcessStatus.GENERAL_ERROR)
            _errorState.postValue(context.getString(R.string.error_general_client))
            errorLog(logTag, "Unable to get container value. Container is 'null'")
        }
    }

    withContext(Main) {
        mobileSignService.errorState.removeObserver {}
        mobileSignService.challenge.removeObserver {}
        mobileSignService.status.removeObserver {}
        mobileSignService.result.removeObserver {}
        mobileSignService.response.removeObserver {}
        activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
    }
}

Details

// Get configurationProvider
val configurationProvider = configurationRepository.getConfiguration()

// Set display message
val displayMessage = "Sign with app"

// Prepare the request object
// Container to be signed, RP UUID, Mobile-ID REST url, MID-SK-REST url, user's personal code, user's phone number and message to display are needed
val request: MobileCreateSignatureRequest =
    MobileCreateSignatureRequestHelper
        .create(
            container,
            uuid,
            configurationProvider?.midRestUrl,
            configurationProvider?.midSkRestUrl,
            Locale.getDefault(),
            personalCode,
            phoneNumber,
            displayMessage,
        )

// Process the Mobile-ID service request
mobileSignService.processMobileIdRequest(
    context = context,
    signedContainer = container,
    request = request,
    roleDataRequest = roleData,
    proxySetting = proxySetting,
    manualProxySettings = manualProxySettings,
    certificateBundle = certBundle,
    accessTokenPath = Objects.requireNonNull(Conf.instance()).PKCS12Cert(),
    accessTokenPass = Objects.requireNonNull(Conf.instance()).PKCS12Pass(),
)