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

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

@@ -0,0 +1,123 @@
+package ch.procivis.one.core.ubiqu
+
+import android.content.Intent
+import ch.procivis.one.core.NativeKeyStorageException
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.ubiqu.eid.sdk.requests.UbqRequestFlow
+
+object PinPadRunner {
+    enum class RequestType {
+        SUBSCRIBE,
+        TRANSACTION,
+        ADD_BIOMETRICS,
+        CHANGE_PIN
+    }
+
+    enum class RNEvent {
+        RSE_SHOW_PIN,
+        RSE_HIDE_PIN,
+        RSE_DIGITS_ENTERED,
+        RSE_PIN_STAGE,
+        RSE_INCORRECT_PIN
+    }
+
+    enum class RNEventParam {
+        flowType,
+        digitsEntered,
+        stage,
+        attemptsLeft,
+    }
+
+    enum class RNEventStage {
+        CHECK_CURRENT_PIN,
+        NEW_FIRST_PIN,
+        NEW_SECOND_PIN,
+    }
+
+    data class Flow(
+        val flow: UbqRequestFlow,
+        val promise: Util.Promise<String?>,
+        val type: RequestType
+    )
+
+    @Volatile
+    private var activeFlow: Flow? = null
+
+    @Synchronized
+    fun getActiveFlow(): Flow {
+        return activeFlow ?: throw NativeKeyStorageException.Unknown("No active flow")
+    }
+
+    private fun sendRNEvent(context: ReactContext, eventName: String, params: WritableMap?) {
+        context
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    // ==== called from UbiquKeyStorage
+    @Synchronized
+    fun startPinPadFlow(
+        context: ReactContext,
+        flow: UbqRequestFlow,
+        requestType: RequestType,
+        promise: Util.Promise<String?>
+    ) {
+        if (activeFlow != null) {
+            throw NativeKeyStorageException.Unknown("Another PinPad flow in progress")
+        }
+
+        activeFlow = Flow(flow, promise, requestType)
+
+        val params = Arguments.createMap()
+        params.putString(RNEventParam.flowType.name, requestType.name)
+
+        val initialStage = when (requestType) {
+            RequestType.SUBSCRIBE -> RNEventStage.NEW_FIRST_PIN
+            else -> RNEventStage.CHECK_CURRENT_PIN
+        }
+        params.putString(RNEventParam.stage.name, initialStage.name)
+        sendRNEvent(context, RNEvent.RSE_SHOW_PIN.name, params)
+    }
+
+    @Synchronized
+    fun cancelPinPadFlow() {
+        activeFlow?.promise?.fail(NativeKeyStorageException.Unknown("Canceled by user"))
+        activeFlow = null
+    }
+
+    // ==== called from PinPadWrapper
+    @Synchronized
+    fun finishPinPadFlowSuccess(context: ReactContext, data: String?) {
+        activeFlow?.promise?.succeed(data)
+        activeFlow = null
+        sendRNEvent(context, RNEvent.RSE_HIDE_PIN.name, null)
+    }
+
+    @Synchronized
+    fun finishPinPadFlowFailure(context: ReactContext, error: Throwable) {
+        activeFlow?.promise?.fail(error)
+        activeFlow = null
+        sendRNEvent(context, RNEvent.RSE_HIDE_PIN.name, null)
+    }
+
+    fun digitsEntered(context: ReactContext, numPins: Int) {
+        val params = Arguments.createMap()
+        params.putInt(RNEventParam.digitsEntered.name, numPins)
+        sendRNEvent(context, RNEvent.RSE_DIGITS_ENTERED.name, params)
+    }
+
+    fun pinStage(context: ReactContext, stage: RNEventStage) {
+        val params = Arguments.createMap()
+        params.putString(RNEventParam.stage.name, stage.name)
+        sendRNEvent(context, RNEvent.RSE_PIN_STAGE.name, params)
+    }
+
+    fun incorrectPin(context: ReactContext, attemptsLeft: Int) {
+        val params = Arguments.createMap()
+        params.putInt(RNEventParam.attemptsLeft.name, attemptsLeft)
+        sendRNEvent(context, RNEvent.RSE_INCORRECT_PIN.name, params)
+    }
+}

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

@@ -0,0 +1,23 @@
+package ch.procivis.one.core.ubiqu
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.ubiqu.eid.sdk.components.UbqInternalPad
+import com.ubiqu.eid.sdk.components.UbqPinPad
+
+class PinPadViewManager(private val callerContext: ReactApplicationContext) :
+    SimpleViewManager<UbqPinPad>() {
+    companion object {
+        const val REACT_CLASS = "RCTProcivisRSEPinPad"
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): UbqPinPad {
+        val pinPad = UbqPinPad(context, extraButton = UbqInternalPad.ExtraButtonFunctionality.BIOMETRICS_AUTO.code)
+        val activeFlow = PinPadRunner.getActiveFlow()
+        PinPadWrapper(callerContext, pinPad, activeFlow.flow, activeFlow.type)
+        return pinPad
+    }
+}

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>
+}