Getting library ready to publish. (#57)

* Add Android lint baseline for `cmp-sample-android`

* Created `lint-baseline.xml` in `cmp-sample-android` to suppress existing lint issues across multiple categories, including Scoped Storage, Obsolete SDK versions, unused resources, and typos.
* Recorded current lint violations for security (custom trust managers), performance (long vector paths), and API deprecations to serve as a baseline for future checks.

* Update dependencies, Gradle, and build configurations

*   Upgraded Gradle wrapper from 8.13 to 9.1.0.
*   Updated various dependencies in `libs.versions.toml`, including Kotlin, `composeBom`, and `spotless`.
*   Moved `.editorconfig` to the root directory and configured it for ktlint function naming.
*   Added the `vanniktech.mavenPublish` plugin to the `mifos-authenticator-passcode` module.
*   Simplified the `cmp-sample-web` build by removing the custom `commonWebpackConfig` and adding explicit Compose dependencies for `jsMain` and `wasmJsMain`.
*   Updated `yarn.lock` with changes to multiple JS dependencies.
*   Minor clean-up in build scripts and baseline files.

* Update integration guide in README.md

* Rewrote the "How to implement Passcode" section into a comprehensive "Mifos Passcode Authenticator Integration Guide".
* Added detailed steps for implementing `PasscodeStorageAdapter` and initializing `PasscodeManager` using `rememberPasscodeManager`.
* Included code examples for setting up navigation logic and implementing the `PasscodeScreen` composable.
* Added documentation for advanced usage, including changing and deleting passcodes using `PasscodeAction`.
* Provided a summary of key components (`PasscodeStorageAdapter`, `PasscodeManager`, `PasscodeScreen`, and `PasscodeAction`).

* Update project documentation and structure overview

* Refactored the "Project Structure" section in `README.md` to provide a clearer overview of the project's modules, including `build-logic`, `cmp-sample` modules, and shared components.
* Updated descriptions for `mifos-authenticator-biometrics` and `mifos-authenticator-passcode` to accurately reflect platform-specific implementations and logic distribution.
* Added descriptions for the `cmp-sample-shared` module and its role in demonstrating authentication flows.
* Improved formatting and readability of the documentation.

* Add library documentation and improve code comments

* Added a comprehensive `README.md` for the `mifos-authenticator-biometrics` module, providing a library overview, feature list, and usage examples for Android, iOS, and Windows.
* Added detailed KDoc comments to common interfaces and enums, including `AuthenticationResult`, `PlatformAuthOptions`, `PlatformAuthenticatorStatus`, and `RegistrationResult`.
* Enhanced documentation in `PlatformAuthenticationProvider` and `PlatformAuthenticator` to better describe platform-specific requirements (e.g., `FragmentActivity` on Android and passkey registration on Windows).
* Improved parameter descriptions and return type documentation across the public API.
* Added KDoc to `PlatformAvailableAuthenticationOption` to clarify its role in querying available device authentication methods.

* Add comprehensive documentation and library publishing configurations

* Added KDoc documentation to `PasscodeScreen`, `PasscodeManager`, `PasscodeStorageAdapter`, and related configuration classes to improve API clarity.
* Configured `mavenPublishing` in `mifos-authenticator-passcode` and `mifos-authenticator-biometrics` with POM metadata, license information (MPL 2.0), and developer details.
* Updated GitHub Actions `publish.yml` to correctly order GPG signing environment variables.
* Moved the passcode integration guide from the root `README.md` to a module-specific `README.md` in `mifos-authenticator-passcode` and added a customization section.
* Removed the copyright header from `PasscodeScreenConfig.kt`.

* Update documentation for mifos-authenticator-biometrics

*   Extensively updated `mifos-authenticator-biometrics/README.md` with detailed installation instructions, a quick-start guide, and comprehensive API references for `PlatformAuthenticationProvider` and `PlatformAuthenticator`.
*   Added platform-specific implementation details for Android, iOS, Windows, and Web (WebAuthn).
*   Included best practices for Android thread management, registration data storage, and lifecycle handling.
*   Added detailed ViewModel integration examples for registration and authentication flows.
*   Removed redundant platform authenticator usage details from the root `README.md`, centralizing documentation within the module directory.

* Update documentation for mifos-authenticator-biometrics

*   Extensively updated `mifos-authenticator-biometrics/README.md` with detailed installation instructions, a quick-start guide, and comprehensive API references for `PlatformAuthenticationProvider` and `PlatformAuthenticator`.
*   Added platform-specific implementation details for Android, iOS, Windows, and Web (WebAuthn).
*   Included best practices for Android thread management, registration data storage, and lifecycle handling.
*   Added detailed ViewModel integration examples for registration and authentication flows.
*   Removed redundant platform authenticator usage details from the root `README.md`, centralizing documentation within the module directory.

* Configure maven-publish plugin and add module-specific properties

*   Downgraded `vanniktech-mavenPublish` plugin from version `0.35.0` to `0.31.0` in `libs.versions.toml`.
*   Added `gradle.properties` files to `mifos-authenticator-biometrics` and `mifos-authenticator-passcode` modules to define maven publishing coordinates and project metadata.
*   Updated the `build.gradle.kts` files in both modules to utilize the new properties for configuring the `maven-publish` plugin, enabling publishing to Maven Central.
*   Adjusted the `inceptionYear` in the POM configuration for both modules from `2026` to `2025`.

* Update developer information and clean up build configuration

* Updated developer ID, name, and URL to "openMF" and "Mifos Initiative" in the Maven publication settings for `mifos-authenticator-biometrics` and `mifos-authenticator-passcode`.
* Removed a commented-out `coordinates` line in `mifos-authenticator-biometrics/build.gradle.kts`.

Author: TheKalpeshPawar

.editorconfig

@@ -0,0 +1,4 @@
+[*.{kt,kts}]
+ij_kotlin_allow_trailing_comma=true
+ij_kotlin_allow_trailing_comma_on_call_site=true
+ktlint_function_naming_ignore_when_annotated_with=Composable, Test, Preview

.github/workflows/publish.yml

@@ -19,6 +19,6 @@ jobs:
         env:
           ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
           ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
+          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_KEY_CONTENTS }}
           ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.SIGNING_KEY_ID }}
           ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
-          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_KEY_CONTENTS }}

README.md

@@ -35,328 +35,33 @@ Designed with modularity and security in mind, this library is a foundational pa
 | Linux      | ✅ Supported   ||
 | Web        | ✅ Supported   ||
 
----
-
-## Project Structure
-```
-mifos-authenticator
-  -core
-    -designSystem
-  -mifos-authenticator-passcode
-    -commonMain
-  -mifos-authenticator-biometrics
-    -androidMain
-    -commonMain
-    -desktopMain(jvm)
-      -windows
-      -linux
-      -mac
-    -jsMain
-    -wasmJsMain
-```
-### `core`
-- **`designsystem`**
-  	- It provides the foundation for theming.
-### `mifos-authenticator-biometrics`
-- **`commonMain/`**
-	- Platform-agnostic Platform Authenticator logic.
-  - `androidMain/`
-  	- Biometric Prompt implementation for Platform Authenticator. 
-  - `iosMain/`
-  	- LocalAuthenticator implementation for Platform Authenticator. 
-  - `desktopMain(jvm)/`
-	- `windows/`
-  		- Windows Hello implementation for Platform Authenticator.
-   	- `linux/`
-		 
-     - `macOS/`
-       - LocalAuthenticator implementation for Platform Authenticator. 
-  - `jsMain/`
-  	- WebAuthN implementation for using the available FIDO2 or Platform Authenticator.
-  - `wasmMain/`
-  	- WebAuthN implementation for using the available FIDO2 or Platform Authenticator.
-### `mifos-authenticator-passcode`
-This module provides logic for pass-code authentication and the pass-code screen.
-
-- **`commonMain/`**
-  	- Contains working logic for passcode authentication.
-	- Defines the passcode screen ui and its components.
-  	
-
-### `sample`
-
-Cross-platform sample implementation of the passcode screen UI and Platform Authenticator:
-
-- **`commonMain/`** 
-	– Shared Platform Authenticator using Compose Multiplatform.
-	- Logic for using the Passcode implementation.
-- **`<platform>Main/`** 
-	– Platform-specific UI wiring for the Platform Authenticator.
-
----
-
-## How to implement Passcode
-The `PasscodeScreen` is a composable function designed to handle passcode authentication or setup workflows in your app. It is powered by a state-preserving utility `rememberPasscodeSaver`, which manages the current passcode state and provides utility functions for saving and clearing the passcode.
-
-### How to Use
-
-To use the `PasscodeScreen`, you must first set up a `PasscodeSaver` instance using `rememberPasscodeSaver`.
-
-```kotlin
-val passcodeSaver = rememberPasscodeSaver(
-    currentPasscode = currentPasscode,
-    isPasscodeSet = isPasscodeAlreadySet,
-    savePasscode = { passcode -> /* handle saving */ },
-    clearPasscode = { /* handle clearing */ }
-)
-```
-Then pass this `passcodeSaver` to the `PasscodeScreen`:
-
-```kotlin
-PasscodeScreen(
-    passcodeSaver = passcodeSaver,
-    onForgotButton = { /* handle forgot passcode */ },
-    onSkipButton = { /* handle skip action */ },
-    onPasscodeRejected = { /* handle wrong passcode entry */ },
-    onPasscodeConfirm = { passcode -> /* handle successful confirmation */ }
-)
-```
-## Parameters
-
-### `PasscodeScreen`
-
-- **`passcodeSaver`** – Required. Handles the passcode input and stores the current state.
-- **`onForgotButton`** – Called when the user taps the **"Forgot"** button.
-- **`onSkipButton`** – Called when the user taps the **"Skip"** button.
-- **`onPasscodeRejected`** – Optional. Called when the entered passcode is wrong.
-- **`onPasscodeConfirm`** – Called when the user enters the correct passcode or finishes setting a new one.
-
-### `rememberPasscodeSaver`
-
-- **`currentPasscode`** – The current passcode (if already set).
-- **`isPasscodeSet`** – Tells the screen whether the user is verifying an existing passcode or creating a new one.
-- **`savePasscode`** – A function that saves the passcode.
-- **`clearPasscode`** – A function that clears the saved passcode.
-
-## How it works
-
-- If there's already a passcode, the screen asks the user to enter it and checks if it matches.
-- If no passcode is set, the screen helps the user create and confirm a new one.
-- The `rememberPasscodeSaver` keeps everything in sync and remembers the state even if the screen recomposes.
-
-## Screenshots
-
-## Mobile
-|                                       |                                       |                                       
-|:-------------------------------------:|:-------------------------------------:|
-|<img src= https://github.com/user-attachments/assets/b0ea6771-8bd2-403b-9d32-ae0f12eed847 />| <img src= https://github.com/user-attachments/assets/06415a14-3271-42b7-9ddb-93e0bad529fe />|
-
-## Desktop and web
-
-<img src = https://github.com/user-attachments/assets/fe699e95-d911-46c2-8d96-78e80a90dac6 />
-<img src="https://github.com/user-attachments/assets/9c3a3d20-b801-42f0-a345-4bb491f95ce4" />
-<img src="https://github.com/user-attachments/assets/bac1d30a-013d-42b1-8b21-bb3dd8a3ea84" />
 
 ---
 
-## Platform Authenticator Usage
-
-This module provides a unified and multiplatform way to handle device-based authentication. It uses a `PlatformAuthenticator` to interact with platform-specific mechanisms (like Windows Hello or Android BiometricPrompt) and wraps it in a thread-safe `PlatformAuthenticationProvider` for easy and safe use in your application.
-
----
-
-## Getting Started
-
-To use the platform authenticator, first create an instance of `PlatformAuthenticator`, and then pass it to PlatformAuthenticationProvider.
-
-On `Android`, you must pass a `FragmentActivity`  or an  `AppCompatActivity`. On other platforms, this is not required. <br>
-
-```kotlin
-// 1. Create the platform-specific authenticator instance
-// On Android
-val authenticator = PlatformAuthenticator(this) 
-// On other platforms
-val authenticator = PlatformAuthenticator()
-
-// 2. Create the provider instance to interact with
-val authProvider = PlatformAuthenticationProvider(authenticator)
-```
----
-
-## API Overview
-
-### `PlatformAuthenticationProvider` (Recommended)
-This is the main class you should interact with. It acts as a thread-safe facade that simplifies using the `PlatformAuthenticator`.
-
-```kotlin
-final class PlatformAuthenticationProvider(private val authenticator: PlatformAuthenticator) {
-
-    // Checks the current status of the device authenticator.
-    fun deviceAuthenticatorStatus(): Set<PlatformAuthenticatorStatus>
-
-    // Prompts the user to set up a platform authenticator.
-    fun setupPlatformAuthenticator()
-
-    // Registers a user and creates a platform-specific passkey.
-    suspend fun registerUser(
-        userName: String = "",
-        emailId: String = "",
-        displayName: String = ""
-    ): RegistrationResult
-
-    // Verifies the user against their registered credential.
-    suspend fun onAuthenticatorClick(
-        appName: String = "",
-        savedRegistrationData: String? = null
-    ): AuthenticationResult
-}
-```
-`PlatformAuthenticator` (Underlying Engine)
-This `expect class` contains the core platform-specific logic. It's managed by the `PlatformAuthenticationProvider`.
-
-```kotlin
-expect class PlatformAuthenticator private constructor() {
-    constructor(activity: Any? = null)
-    fun getDeviceAuthenticatorStatus(): Set<PlatformAuthenticatorStatus>
-    fun setDeviceAuthOption()
-    suspend fun registerUser(...): RegistrationResult
-    suspend fun authenticate(...): AuthenticationResult
-}
-```
-
-### Important Note for Android Developers
-**Thread Requirement**: The Android `BiometricPrompt` API, which this module uses under the hood, requires that it be invoked from the main thread.
-
-Therefore, you must call `platformAuthenticationProvider.registerUser(...)` and `platformAuthenticationProvider.onAuthenticatorClick(...)` from the **Main dispatcher**. Using `viewModelScope` in Android ViewModels handles this correctly, but it's good practice to be explicit.
-
-```kotlin
-// Always launch from the Main thread for these calls
-viewModelScope.launch(Dispatchers.Main) {
-    // ... call registerUser or onAuthenticatorClick
-}
-```
-
-### PlatformAuthenticatorStatus (enum)
-The `getDeviceAuthenticatorStatus()` function returns a set of the following values:
-
-- `NOT_AVAILABLE` – Platform authenticator is not supported on the device.
-- `NOT_SETUP` – Authenticator is available but not set up yet.
-- `DEVICE_CREDENTIAL_SET` – Device credential (PIN, password, etc.) is available.
-- `BIOMETRICS_NOT_SET` – Biometrics are supported but not configured.
-- `BIOMETRICS_NOT_AVAILABLE` – Biometrics are not available on the device.
-- `BIOMETRICS_UNAVAILABLE` – Biometrics are temporarily unavailable.
-- `BIOMETRICS_SET` – Biometrics are available and configured.
-
-### ViewModel Integration Examples
-Here’s how you can integrate `PlatformAuthenticationProvider` into your ViewModels, ensuring calls are made on the correct thread.
-
-**Registration ViewModel**
-This ViewModel handles the logic for the user registration screen.
-
-```kotlin
-class ChooseAuthOptionScreenViewmodel(
-    private val platformAuthenticationProvider: PlatformAuthenticationProvider,
-    // other dependencies...
-) : ViewModel() {
-
-    private val _registrationResult = MutableStateFlow<RegistrationResult?>(null)
-    val registrationResult = _registrationResult.asStateFlow()
-
-    private val _authenticatorStatus = MutableStateFlow(platformAuthenticationProvider.deviceAuthenticatorStatus())
-    val authenticatorStatus = _authenticatorStatus.asStateFlow()
-
-    fun updatePlatformAuthenticatorStatus() {
-        _authenticatorStatus.value = platformAuthenticationProvider.deviceAuthenticatorStatus()
-    }
-
-    fun registerUser(userID: String = "", userEmail: String = "", displayName: String = "") {
-        // Explicitly launch on the Main thread
-        viewModelScope.launch(Dispatchers.Main) {
-            _registrationResult.value = platformAuthenticationProvider.registerUser(
-                userID,
-                userEmail,
-                displayName
-            )
-        }
-    }
-}
-```
-
-**Possible return values:**
-
-- `RegistrationResult.Success` - Its parameter contains the registration data that has to saved. 
-The same data is passed as an argument to the `authenticate` function
-- `RegistrationResult.Error` - Its parameter contains a message telling what type of error was received.
-- `RegistrationResult.PlatformAuthenticatorNotAvailable`
-- `RegistrationResult.PlatformAuthenticatorNotSet`
-
-
-### Authentication ViewModel
-This ViewModel manages the authentication flow, such as on a login screen.
-
-```kotlin
-class PlatformAuthenticationScreenViewModel(
-    private val platformAuthenticationProvider: PlatformAuthenticationProvider,
-    private val preferenceDataStore: PreferenceDataStore
-) : ViewModel() {
-
-    private val _authenticationResult = MutableStateFlow<AuthenticationResult?>(null)
-    val authenticationResult = _authenticationResult.asStateFlow()
-
-    private val _isLoading = MutableStateFlow(false)
-    val isLoading = _isLoading.asStateFlow()
-    
-    fun authenticateUser(appName: String) {
-        // Explicitly launch on the Main thread
-        viewModelScope.launch(Dispatchers.Main) {
-            _isLoading.value = true
-            val savedData = preferenceDataStore.getRegistrationData()
-            _authenticationResult.value = platformAuthenticationProvider.onAuthenticatorClick(appName, savedData)
-            _isLoading.value = false
-        }
-    }
-
-    fun clearUserRegistrationFromApp() {
-        preferenceDataStore.clearData(REGISTRATION_DATA)
-    }
-}
-```
-
-**Possible return values:**
-- `AuthenticationResult.Success`
-- `AuthenticationResult.Error`
-- `AuthenticationResult.UserNotRegistered` - If the user disables the platform authenticator, or in case of Windows Hello, the passkey is deleted or the Authenticator is disabled. The user should be logged out in this case and registered again.
+## Project Structure
 
-### Setting Up the Authenticator
-Prompt the user to set up a device credential or biometric authentication:
+The project is organized into several modules to ensure a clear separation of concerns and to facilitate multiplatform development:
 
-```kotlin
-authProvider.setupPlatformAuthenticator()
-```
-On `Android`, it actually redirects users to a screen for setting up a platform authentication method.
-On `Windows`, it will only show a message saying `Set up Windows Hello from settings`. Windows Hello
-itself shows a similar message in some cases and doesn't redirect users to the setup screen.
+- **`build-logic`**: Contains Gradle convention plugins used to standardize build configurations across all modules (linting, static analysis, multiplatform setup).
+- **`mifos-authenticator-passcode`**: A Compose Multiplatform library providing the logic and UI components for passcode authentication.
+- **`mifos-authenticator-biometrics`**: A library providing platform-specific implementations for device authentication (Biometrics, Windows Hello, WebAuthn).
+- **`cmp-sample-shared`**: Contains the shared business logic, navigation, and UI for the sample applications.
+- **`cmp-sample-android`**: The Android entry point for the sample application.
+- **`cmp-sample-ios`**: The iOS entry point for the sample application.
+- **`cmp-sample-desktop`**: The Desktop (JVM) entry point for the sample application.
+- **`cmp-sample-web`**: The Web (Wasm & JS) entry point for the sample application.
 
-### RegistrationResult (sealed interface)
-Returned by `authProvider.registerUser()`.
+### `mifos-authenticator-biometrics`
+- **`commonMain/`**: Platform-agnostic interface and provider for device authentication.
+- **`androidMain/`**: Implementation using Android `BiometricPrompt`.
+- **`iosMain/`**: Implementation using iOS `LocalAuthentication`.
+- **`desktopMain/`**: Implementation using JNA for Windows Hello (on Windows) and placeholders for other desktop platforms.
+- **`jsMain/` / `wasmJsMain/`**: Implementation using the Web Authentication API (WebAuthn).
 
-```kotlin
-sealed interface RegistrationResult {
-    data class Success(val registrationData: String) : RegistrationResult
-    data class Error(val message: String) : RegistrationResult
-    data object PlatformAuthenticatorNotSet : RegistrationResult
-    data object PlatformAuthenticatorNotAvailable : RegistrationResult
-}
-```
+### `mifos-authenticator-passcode`
+- **`commonMain/`**: Contains the `PasscodeManager`, `PasscodeStorageAdapter`, and the `PasscodeScreen` UI built with Compose Multiplatform.
 
-### AuthenticationResult (sealed interface)
-Returned by `authProvider.onAuthenticatorClick()`.
+### `cmp-sample-shared`
+- **`commonMain/`**: Defines the shared UI, themes, and navigation logic. It integrates both the passcode and biometric modules to demonstrate a complete authentication flow.
 
-```kotlin
-sealed interface AuthenticationResult {
-    data object Success : AuthenticationResult
-    data class Error(val message: String) : AuthenticationResult
-    data object UserNotRegistered : AuthenticationResult
-}
-```
 

cmp-sample-android/build.gradle.kts

@@ -7,7 +7,6 @@
  *
  * See https://github.com/openMF/mifos-passcode-cmp/blob/development/LICENSE
  */
-import org.gradle.kotlin.dsl.support.kotlinCompilerOptions
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
@@ -29,7 +28,11 @@ android {
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
-
+    buildTypes {
+        getByName("release") {
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
 }
 
 kotlin {
@@ -54,5 +57,4 @@ dependencies {
     androidTestImplementation(libs.androidx.espresso.core)
 
     implementation(libs.androidx.activity.compose)
-
-}
+}