@procivis/react-native-one-core 1.33398.0 → 1.41710.0

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadViewManager.kt_opensource

@@ -0,0 +1,20 @@
+package ch.procivis.one.core.ubiqu
+
+import android.view.View
+import ch.procivis.one.core.NativeKeyStorageException
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+
+class PinPadViewManager(private val callerContext: ReactApplicationContext) :
+    SimpleViewManager<View>() {
+    companion object {
+        const val REACT_CLASS = "RCTProcivisRSEPinPad"
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): View {
+        throw NativeKeyStorageException.Unsupported()
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadWrapper.kt

@@ -0,0 +1,396 @@
+package ch.procivis.one.core.ubiqu
+
+import android.annotation.SuppressLint
+import android.util.Log
+import androidx.fragment.app.FragmentActivity
+import ch.procivis.one.core.NativeKeyStorageException
+import ch.procivis.one.core.ubiqu.PinPadRunner.digitsEntered
+import ch.procivis.one.core.ubiqu.PinPadRunner.finishPinPadFlowFailure
+import ch.procivis.one.core.ubiqu.PinPadRunner.finishPinPadFlowSuccess
+import ch.procivis.one.core.ubiqu.PinPadRunner.incorrectPin
+import ch.procivis.one.core.ubiqu.PinPadRunner.pinStage
+import com.facebook.react.bridge.ReactContext
+import com.ubiqu.eid.sdk.backend.assets.UbqAsset
+import com.ubiqu.eid.sdk.components.UbqPinPad
+import com.ubiqu.eid.sdk.enums.AddBiometricsState
+import com.ubiqu.eid.sdk.enums.ChangePinState
+import com.ubiqu.eid.sdk.enums.SubscribeState
+import com.ubiqu.eid.sdk.enums.TransactionState
+import com.ubiqu.eid.sdk.exceptions.UbqSdkException
+import com.ubiqu.eid.sdk.interfaces.AddBiometricsFinishInterface
+import com.ubiqu.eid.sdk.interfaces.AddBiometricsUiInterface
+import com.ubiqu.eid.sdk.interfaces.ChangePinFinishInterface
+import com.ubiqu.eid.sdk.interfaces.ChangePinUiInterface
+import com.ubiqu.eid.sdk.interfaces.SubscribeFinishInterface
+import com.ubiqu.eid.sdk.interfaces.SubscribeUiInterface
+import com.ubiqu.eid.sdk.interfaces.TransactionFinishInterface
+import com.ubiqu.eid.sdk.interfaces.TransactionUiInterface
+import com.ubiqu.eid.sdk.interfaces.UbqPinPadReporting
+import com.ubiqu.eid.sdk.requests.UbqAddBiometrics
+import com.ubiqu.eid.sdk.requests.UbqChangePin
+import com.ubiqu.eid.sdk.requests.UbqRequestFlow
+import com.ubiqu.eid.sdk.requests.UbqSubscribe
+import com.ubiqu.eid.sdk.requests.UbqTransaction
+
+
+@SuppressLint("LogNotTimber")
+class PinPadWrapper(
+    private val context: ReactContext,
+    private val pinPad: UbqPinPad,
+    private val flow: UbqRequestFlow,
+    flowType: PinPadRunner.RequestType
+) : SubscribeUiInterface, SubscribeFinishInterface,
+    UbqPinPadReporting, TransactionUiInterface, TransactionFinishInterface,
+    AddBiometricsUiInterface, AddBiometricsFinishInterface, ChangePinUiInterface,
+    ChangePinFinishInterface {
+
+    companion object {
+        private const val TAG = "ch.procivis.one.core.ubiqu.PinPadWrapper"
+    }
+
+    init {
+        pinPad.setKeyPadOnKeyListener(this)
+        pinPad.setOnPinInputFinishListener(flow)
+
+        when (flowType) {
+            PinPadRunner.RequestType.SUBSCRIBE -> {
+                (flow as UbqSubscribe).update(this)
+            }
+
+            PinPadRunner.RequestType.TRANSACTION -> {
+                val fragmentActivity = context.currentActivity as? FragmentActivity
+                val transaction = flow as UbqTransaction
+                transaction.update(this, fragmentActivity = fragmentActivity)
+                if (transaction.ubqAsset?.biometricsEnabled == true) {
+                    pinPad.enableBiometrics(transaction)
+                }
+            }
+
+            PinPadRunner.RequestType.ADD_BIOMETRICS -> {
+                (flow as UbqAddBiometrics).update(this)
+            }
+
+            PinPadRunner.RequestType.CHANGE_PIN -> {
+                (flow as UbqChangePin).update(this)
+            }
+        }
+    }
+
+    // ========== SubscribeUiInterface
+    override fun onSubscribeFirstPinEntered() {
+        Log.d(TAG, "onSubscribeFirstPinEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePinConfirmed() {
+        Log.d(TAG, "onSubscribePinConfirmed")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePinNotConfirmed() {
+        Log.d(TAG, "onSubscribePinNotConfirmed")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePukEntered() {
+        Log.d(TAG, "onSubscribePukEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribeUiError(error: UbqSdkException) {
+        Log.w(TAG, "onSubscribeUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onSubscribeUnallowedPinEntered() {
+        Log.d(TAG, "onSubscribeUnallowedPinEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    // ========== SubscribeFinishInterface
+    override fun onSubscribeCompleted(ubqAsset: UbqAsset) {
+        Log.d(TAG, "onSubscribeCompleted")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribeFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onSubscribeFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onSubscribeIncorrectPukEntered(ubqAsset: UbqAsset) {
+        Log.d(TAG, "onSubscribeIncorrectPukEntered")
+        finishPinPadFlowFailure(context, NativeKeyStorageException.Unknown("Wrong PUK"))
+    }
+
+    // ========== TransactionUiInterface
+    override fun onTransactionBiometricsEntered() {
+        Log.d(TAG, "onTransactionBiometricsEntered")
+        updateTransactionFlow(flow as UbqTransaction)
+    }
+
+    override fun onTransactionPinEntered() {
+        Log.d(TAG, "onTransactionPinEntered")
+        updateTransactionFlow(flow as UbqTransaction)
+    }
+
+    override fun onTransactionUiError(error: UbqSdkException) {
+        Log.w(TAG, "onTransactionUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== TransactionFinishInterface
+    override fun onTransactionCompleted(result: String?) {
+        Log.d(TAG, "onTransactionCompleted")
+        finishPinPadFlowSuccess(context, result)
+    }
+
+    override fun onTransactionIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onTransactionIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinPad.clear(true)
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+        }
+    }
+
+    override fun onTransactionFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onTransactionFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== AddBiometricsUiInterface
+    override fun onAddBiometricsIncorrectBiometricsEntered() {
+        Log.d(TAG, "onAddBiometricsIncorrectBiometricsEntered")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsPinEntered() {
+        Log.d(TAG, "onAddBiometricsPinEntered")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsUiError(error: UbqSdkException) {
+        Log.w(TAG, "onAddBiometricsUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== AddBiometricsFinishInterface
+    override fun onAddBiometricsCompleted() {
+        Log.d(TAG, "onAddBiometricsCompleted")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onAddBiometricsFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onAddBiometricsIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onAddBiometricsIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinPad.clear(true)
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+        }
+    }
+
+    // ========== ChangePinUiInterface
+    override fun onChangePinPinEntered() {
+        Log.d(TAG, "onChangePinPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinNewPinEntered() {
+        Log.d(TAG, "onChangePinNewPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinPinConfirmed() {
+        Log.d(TAG, "onChangePinPinConfirmed")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinPinNotConfirmed() {
+        Log.d(TAG, "onChangePinPinNotConfirmed")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinUiError(error: UbqSdkException) {
+        Log.w(TAG, "onChangePinUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onChangePinUnallowedPinEntered() {
+        Log.d(TAG, "onChangePinUnallowedPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    // ========== ChangePinFinishInterface
+    override fun onChangePinCompleted() {
+        Log.d(TAG, "onChangePinCompleted")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onChangePinFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onChangePinIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onChangePinIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Incorrect PIN entered")
+            )
+        }
+    }
+
+    // ========== UbqPinPadReporting
+    override fun onDigitsChanged(newAmount: Int) {
+        Log.d(TAG, "onDigitsChanged: $newAmount")
+        digitsEntered(context, newAmount)
+    }
+
+    // private
+    private fun updateChangePinFlow(flow: UbqChangePin) {
+        when (flow.state) {
+            ChangePinState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            ChangePinState.AWAITING_NEW_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_FIRST_PIN)
+            }
+
+            ChangePinState.AWAITING_CONFIRMATION_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_SECOND_PIN)
+            }
+
+            ChangePinState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            ChangePinState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            ChangePinState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Change PIN flow failure")
+                )
+            }
+
+            null -> {
+                throw NativeKeyStorageException.Unknown("Missing change PIN flow state")
+            }
+        }
+    }
+
+    private fun updateAddBiometricsFlow(flow: UbqAddBiometrics) {
+        when (flow.state) {
+            AddBiometricsState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            AddBiometricsState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            AddBiometricsState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            AddBiometricsState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Add biometrics flow failure")
+                )
+            }
+
+            null -> {
+                throw NativeKeyStorageException.Unknown("Missing add biometrics flow state")
+            }
+        }
+    }
+
+    private fun updateTransactionFlow(flow: UbqTransaction) {
+        when (flow.state) {
+            TransactionState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            TransactionState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            TransactionState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Transaction flow failure")
+                )
+            }
+
+            else -> {
+                throw NativeKeyStorageException.Unknown("Invalid transaction flow state ${flow.state}")
+            }
+        }
+    }
+
+    private fun updateSubscribeFlow(flow: UbqSubscribe) {
+        when (flow.state) {
+            SubscribeState.AWAITING_FIRST_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_FIRST_PIN)
+            }
+
+            SubscribeState.AWAITING_CONFIRMATION_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_SECOND_PIN)
+            }
+
+            SubscribeState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            SubscribeState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            SubscribeState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Subscribe flow failure")
+                )
+            }
+
+            else -> {
+                throw NativeKeyStorageException.Unknown("Invalid subscribe flow state ${flow.state}")
+            }
+        }
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ubiqu/RegistrationManager.kt

@@ -0,0 +1,59 @@
+package ch.procivis.one.core.ubiqu
+
+import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import ch.procivis.one.core.ubiqu.dataformats.CreateIdentityRequest
+import ch.procivis.one.core.ubiqu.dataformats.CreateIdentityResponse
+import ch.procivis.one.core.ubiqu.dataformats.RegisterRSEResponse
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import retrofit2.Response
+import retrofit2.Retrofit
+import retrofit2.converter.scalars.ScalarsConverterFactory
+import retrofit2.http.Body
+import retrofit2.http.Header
+import retrofit2.http.POST
+import retrofit2.http.Path
+
+object RegistrationManager {
+    private lateinit var retrofitService: IdentityApi
+
+    private val client = OkHttpClient.Builder().build()
+
+    lateinit var organisationId: String
+
+    fun build(identityServiceUrl: String, organisationId: String) {
+        this.organisationId = organisationId
+
+        val retrofit = Retrofit.Builder()
+            .baseUrl(identityServiceUrl)
+            .client(client)
+            .addConverterFactory(ScalarsConverterFactory.create())
+            .addConverterFactory(Json{
+                ignoreUnknownKeys = true
+            }.asConverterFactory("application/json".toMediaType()))
+            .build()
+
+        retrofitService = retrofit.create(IdentityApi::class.java)
+    }
+
+    suspend fun createIdentity(accessToken: String, body: CreateIdentityRequest): Response<CreateIdentityResponse> {
+        val auth = "Bearer $accessToken"
+        return retrofitService.createIdentity(auth, organisationId, body)
+    }
+
+    suspend fun registerRse(accessToken: String, subject: String): Response<RegisterRSEResponse> {
+        val auth = "Bearer $accessToken"
+        return retrofitService.registerRse(auth, organisationId, subject)
+    }
+}
+
+interface IdentityApi {
+
+    @POST("/organisation/{id}/identity/")
+    suspend fun createIdentity(@Header("Authorization") authorization: String, @Path("id") organisationId: String, @Body body: CreateIdentityRequest): Response<CreateIdentityResponse>
+
+    @POST("/organisation/{id}/identity/{subject}/register_rse/")
+    suspend fun registerRse(@Header("Authorization") authorization: String, @Path("id") organisationId: String, @Path("subject") subject: String): Response<RegisterRSEResponse>
+}
+

package/android/src/main/java/ch/procivis/one/core/ubiqu/TokenManager.kt

@@ -0,0 +1,48 @@
+package ch.procivis.one.core.ubiqu
+
+import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import org.json.JSONObject
+import retrofit2.Response
+import retrofit2.Retrofit
+import retrofit2.converter.scalars.ScalarsConverterFactory
+import retrofit2.http.GET
+import retrofit2.http.Header
+
+object TokenManager {
+    private lateinit var retrofitService: TokenApi
+
+    private val client = OkHttpClient.Builder().build()
+
+    lateinit var apiKey: String
+
+    fun build(tokenGeneratorUrl: String, apiKey: String) {
+        this.apiKey = apiKey
+
+        val retrofit = Retrofit.Builder()
+            .baseUrl(tokenGeneratorUrl)
+            .client(client)
+            .addConverterFactory(ScalarsConverterFactory.create())
+            .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
+            .build()
+
+        retrofitService = retrofit.create(TokenApi::class.java)
+    }
+
+    suspend fun getAccessToken(): String {
+        val apiKey = apiKey
+        val auth = "Bearer $apiKey"
+        val response = retrofitService.getAccessToken(auth)
+
+        return JSONObject(response.body()!!).getString("access_token")
+    }
+
+}
+
+interface TokenApi {
+
+    @GET("/ubiqu/")
+    suspend fun getAccessToken(@Header("Authorization") authorization: String): Response<String>
+}