Android Toolkit - First version.

Author: milos85vasic

Access/.gitignore

@@ -0,0 +1,21 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+
+.idea
+.idea/*
+gradle
+gradlew
+gradlew.bat
+local.properties

Access/Core/.gitignore

@@ -0,0 +1 @@
+/build

Access/Core/build.gradle

@@ -0,0 +1,53 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+
+    compileSdkVersion 33
+
+    defaultConfig {
+
+        minSdkVersion 23
+        targetSdkVersion 33
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    compileOptions {
+
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+
+        jvmTarget = '1.8'
+    }
+
+    buildTypes {
+
+        release {
+
+            minifyEnabled false
+        }
+
+        debug {
+
+            minifyEnabled false
+        }
+    }
+    packagingOptions {
+        resources {
+            excludes += ['META-INF/DEPENDENCIES', 'META-INF/LICENSE', 'META-INF/LICENSE.txt', 'META-INF/license.txt', 'META-INF/NOTICE', 'META-INF/NOTICE.txt', 'META-INF/notice.txt', 'META-INF/ASL2.0', 'META-INF/*.kotlin_module']
+        }
+    }
+    namespace 'com.redelf.access'
+
+}
+
+dependencies {
+
+    implementation project(":Commons:Core")
+
+    implementation "androidx.biometric:biometric:1.2.0-alpha05"
+}

Access/Core/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.USE_BIOMETRIC" />
+    <uses-permission android:name="android.permission.USE_FINGERPRINT" />
+</manifest>

Access/Core/src/main/java/com/redelf/access/Access.kt

@@ -0,0 +1,242 @@
+package com.redelf.access
+
+import com.redelf.access.implementation.AccessActivity
+import com.redelf.access.implementation.FaceRecognitionAccess
+import com.redelf.access.implementation.FingerprintAccess
+import com.redelf.access.implementation.GenericAccess
+import com.redelf.access.implementation.IrisAccess
+import com.redelf.access.implementation.pin.PinAccess
+import com.redelf.access.implementation.pin.PinAccessActivity
+import com.redelf.access.installation.Installation
+import com.redelf.access.installation.InstallationCheckCallback
+import com.redelf.commons.callback.CallbackOperation
+import com.redelf.commons.callback.Callbacks
+import com.redelf.commons.capability.CapabilityCheckCallback
+import com.redelf.commons.execution.Cancellation
+import com.redelf.commons.execution.CommonExecution
+import com.redelf.commons.execution.CommonExecutionCallback
+import com.redelf.commons.execution.Executor
+import com.redelf.commons.lifecycle.Initialization
+import com.redelf.commons.lifecycle.LifecycleCallback
+import timber.log.Timber
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+
+class Access(builder: AccessBuilder) :
+
+    CommonExecution,
+    Cancellation,
+    Initialization<Unit>,
+    Installation {
+
+    companion object {
+
+        fun getGeneric(ctx: PinAccessActivity): Access {
+
+            var priority = -1
+            val generic = GenericAccess(++priority, ctx)
+
+            return AccessBuilder()
+                .addAccessMethod(generic)
+                .build()
+        }
+
+        fun getDefault(ctx: AccessActivity): Access {
+
+            var priority = -1
+            val iris = IrisAccess(++priority, ctx)
+            val faceAccess = FaceRecognitionAccess(++priority, ctx)
+            val fingerprintAccess = FingerprintAccess(++priority, ctx)
+            val pinAccess = PinAccess(++priority, ctx)
+
+            return AccessBuilder()
+                .addAccessMethod(pinAccess)
+                .addAccessMethod(fingerprintAccess)
+                .addAccessMethod(faceAccess)
+                .addAccessMethod(iris)
+                .build()
+        }
+    }
+
+    private val executor = Executor.MAIN
+    private val methods = builder.methods
+    private val initializing = AtomicBoolean()
+    private var method = AtomicReference<AccessMethod>()
+    private val callbacks = Callbacks<LifecycleCallback<Unit>>(identifier = "Access lifecycle")
+
+    private val initCallback = object : LifecycleCallback<Unit> {
+
+        override fun onInitialization(success: Boolean, vararg args: Unit) {
+
+            initializing.set(false)
+            callbacks.doOnAll(object : CallbackOperation<LifecycleCallback<Unit>> {
+
+                override fun perform(callback: LifecycleCallback<Unit>) {
+
+                    callback.onInitialization(success)
+                    callbacks.unregister(callback)
+                }
+            }, name = "Initialisation operation")
+        }
+
+        override fun onShutdown(success: Boolean, vararg args: Unit) {
+
+            // Ignore.
+        }
+    }
+
+    @Throws(IllegalStateException::class)
+    override fun execute(callback: CommonExecutionCallback) {
+
+        if (!isInitialized()) {
+
+            throw  IllegalStateException("Not initialized")
+        }
+        method.get()?.execute(callback)
+    }
+
+    override fun cancel() {
+
+        method.get()?.cancel()
+    }
+
+    override fun isInitialized() = method.get() != null
+
+    override fun isInitializing() = isInitialized()
+
+    @Synchronized
+    fun isExecuting(): Boolean {
+
+        method.get()?.let {
+
+            return it.isExecuting()
+        }
+        return false
+    }
+
+    @Throws(IllegalStateException::class)
+    override fun initialize(callback: LifecycleCallback<Unit>) {
+
+        if (isInitialized()) {
+
+            throw  IllegalStateException("Already initialized")
+        }
+        callbacks.register(callback)
+        if (initializing.get()) {
+
+            Timber.w("Already initializing")
+            return
+        }
+        initializing.set(true)
+        val action = Runnable {
+
+            val iterator = methods.iterator()
+
+            fun initialize(iterator: Iterator<AccessMethod>) {
+
+                if (iterator.hasNext()) {
+
+                    val accessMethod = iterator.next()
+
+                    val capabilityCallback = object : CapabilityCheckCallback {
+
+                        override fun onCapabilityChecked(capable: Boolean) {
+
+                            if (capable) {
+
+                                method.set(accessMethod)
+                                initCallback.onInitialization(true)
+                                Timber.i("Access method: $method")
+                            } else {
+
+                                initialize(iterator)
+                            }
+                        }
+                    }
+
+                    accessMethod.checkCapability(capabilityCallback)
+
+                } else {
+
+                    Timber.w("No access method obtained")
+                    initCallback.onInitialization(false)
+                }
+            }
+
+            initialize(iterator)
+        }
+
+        executor.execute(action)
+    }
+
+    @Throws(IllegalStateException::class)
+    override fun install() {
+
+        if (!isInitialized()) {
+
+            initialize(
+
+                object : LifecycleCallback<Unit> {
+
+                    override fun onInitialization(success: Boolean, vararg args: Unit) {
+
+                        if (success) {
+
+                            method.get()?.install()
+                        } else {
+
+                            throw IllegalStateException("Failed to initialize")
+                        }
+                    }
+
+                    override fun onShutdown(success: Boolean, vararg args: Unit) {
+
+                        throw IllegalStateException("Unexpected shutdown")
+                    }
+                }
+            )
+            return
+        }
+        method.get()?.install()
+    }
+
+    @Throws(IllegalStateException::class)
+    override fun checkInstalled(callback: InstallationCheckCallback) {
+
+        Timber.v("Check installed")
+
+        if (!isInitialized()) {
+
+            initialize(
+
+                object : LifecycleCallback<Unit> {
+
+                    override fun onInitialization(success: Boolean, vararg args: Unit) {
+
+                        if (success) {
+
+                            method.get()?.checkInstalled(callback)
+
+                        } else {
+
+                            throw IllegalStateException("Failed to initialize")
+                        }
+                    }
+
+                    override fun onShutdown(success: Boolean, vararg args: Unit) {
+
+                        throw IllegalStateException("Unexpected shutdown")
+                    }
+
+                }
+            )
+            return
+        }
+        method.get()?.checkInstalled(callback)
+    }
+
+    override fun toString(): String {
+
+        return "Access(methods=$methods)"
+    }
+}

Access/Core/src/main/java/com/redelf/access/AccessBuilder.kt

@@ -0,0 +1,24 @@
+package com.redelf.access
+
+import java.util.*
+
+class AccessBuilder {
+
+    val methods = PriorityQueue<AccessMethod>()
+
+    @Throws(IllegalArgumentException::class)
+    fun addAccessMethod(method: AccessMethod) : AccessBuilder {
+
+        methods.forEach {
+            if (it::class == method::class) {
+
+                val name = method::class.simpleName
+                throw IllegalArgumentException("Access method already present: $name")
+            }
+        }
+        methods.add(method)
+        return this
+    }
+
+    fun build() = Access(this)
+}