🪙 CoinRoutine

CoinRoutine is a cross-platform cryptocurrency portfolio application built with Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP).

The project demonstrates how to build a production-style mobile application while sharing business logic, data, and UI between Android and iOS. It follows Clean Architecture + MVI, uses dependency injection, local persistence, networking, biometric authentication, and includes both unit tests and Compose UI tests.

🚧 This project is actively being developed and serves as a practical demonstration of modern Kotlin Multiplatform development.

---

✨ Features

📊 Cryptocurrency

• Browse cryptocurrency information
• View coin details
• Display cryptocurrency market data
• Network-based data fetching
• Image loading for cryptocurrency assets
• Loading and error states

💼 Portfolio

• Create and manage a cryptocurrency portfolio
• Track portfolio holdings
• Calculate portfolio-related values
• Combine portfolio data with current coin information
• Persist portfolio data locally
• Reactive portfolio updates

💰 Trading

• Buy cryptocurrency
• Sell cryptocurrency
• Track trade-related information
• Validate trade input
• Update portfolio after trades

🔐 Biometric Authentication

The feature/biometric branch introduces biometric authentication to protect the application.

• Android biometric authentication
• Platform-specific biometric implementation
• Authentication state management
• Secure access to protected application content
• Multiplatform architecture using platform-specific implementations where required

🧪 Testing

The project places a strong emphasis on automated testing.

• Unit tests
• ViewModel tests
• Repository/domain logic tests
• Coroutine testing
• Flow testing with Turbine
• Assertion testing with AssertK
• Compose UI tests
• Android host tests
• iOS simulator tests
• Fake implementations for testing

---

🏗️ Architecture

CoinRoutine follows Clean Architecture combined with the MVI (Model–View–Intent) pattern.

┌─────────────────────────────────────┐
│ Compose UI │
│ Android + iOS (CMP) │
└─────────────────┬───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Presentation Layer │
│ MVI / ViewModel / State │
└─────────────────┬───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Domain Layer │
│ Use Cases / Models / Logic │
└─────────────────┬───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Data Layer │
│ Repository / Remote / Local Storage │
└───────────────┬───────────┬─────────┘
│ │
▼ ▼
Ktor Room
Network Database

Why MVI?

MVI provides a predictable unidirectional data flow:

User Action
│
▼
Intent
│
▼
ViewModel
│
▼
Use Case
│
▼
Repository
│
├──────────────► Remote Data
│
└──────────────► Local Database
│
▼
New State
│
▼
Compose UI

This makes state management predictable and makes presentation logic easier to test.

---

📁 Project Structure

CoinRoutine/
│
├── androidApp/
│ └── Android application entry point
│
├── iosApp/
│ └── iOS application entry point
│
├── shared/
│ ├── src/
│ │ ├── commonMain/
│ │ │ ├── kotlin/
│ │ │ │ └── com/ahmad/raza/coinroutine/
│ │ │ │ │
│ │ │ │ ├── biometric/
│ │ │ │ │
│ │ │ │ ├── coins/
│ │ │ │ │ ├── data/
│ │ │ │ │ ├── domain/
│ │ │ │ │ └── presentation/
│ │ │ │ │
│ │ │ │ ├── portfolio/
│ │ │ │ │ ├── data/
│ │ │ │ │ ├── domain/
│ │ │ │ │ └── presentation/
│ │ │ │ │
│ │ │ │ ├── trade/
│ │ │ │ │ ├── domain/
│ │ │ │ │ └── presentation/
│ │ │ │ │
│ │ │ │ ├── core/
│ │ │ │ ├── di/
│ │ │ │ ├── navigation/
│ │ │ │ └── theme/
│ │ │ │
│ │ │ └── composeResources/
│ │ │
│ │ ├── androidMain/
│ │ ├── iosMain/
│ │ └── commonTest/
│ │
│ └── schemas/
│ └── Room database schemas
│
├── build.gradle.kts
├── settings.gradle.kts
└── gradle/

The repository currently separates coins, portfolio, trade, biometric, core, dependency injection, navigation, and theme functionality inside the shared module.

---

🛠️ Tech Stack

Kotlin Multiplatform

• Kotlin
• Kotlin Multiplatform
• Kotlin Coroutines
• Kotlinx Serialization
• Kotlinx DateTime

UI

• Compose Multiplatform
• Jetpack Compose
• Material 3
• Compose Resources
• Coil
• Compose UI Testing

Architecture

• Clean Architecture
• MVI
• ViewModel
• Unidirectional Data Flow
• Repository Pattern
• Use Case Pattern
• Dependency Injection

Networking

• Ktor Client
• Kotlinx Serialization
• Platform-specific Ktor engines

Local Storage

• Room for Kotlin Multiplatform
• Bundled SQLite
• Database schema management

Dependency Injection

• Koin
• Koin Compose
• Koin ViewModel integration

Security

• Android BiometricPrompt
• Multiplatform biometric abstraction
• Platform-specific authentication implementation

Testing

• Kotlin Test
• Kotlin Coroutines Test
• Turbine
• AssertK
• Compose UI Test
• Android host tests
• iOS simulator tests

The current shared Gradle configuration includes Compose, Ktor, Room, SQLite, Koin, Coil, biometric support, Kotlin serialization, and the testing libraries listed above.

---

🌍 Supported Platforms

Platform	Status
Android	✅
iOS	✅

The shared module currently configures Android plus iosArm64 and iosSimulatorArm64 targets, while the iOS application lives in the dedicated iosApp module.

---

🧩 Kotlin Multiplatform Structure

CoinRoutine uses Kotlin Multiplatform to maximize code sharing between Android and iOS.

commonMain

Contains code shared between platforms:

• Domain models
• Use cases
• Repositories
• ViewModels
• MVI state
• MVI intents
• Networking abstractions
• Database access
• Compose UI
• Navigation
• Themes
• Business logic

androidMain

Contains Android-specific implementations such as:

• Android biometric authentication
• Android Ktor engine
• Android-specific integrations
• Android Compose configuration

iosMain

Contains iOS-specific implementations such as:

• iOS networking engine
• iOS platform integrations
• iOS-specific implementations required by Kotlin/Native

---

🧪 Testing Strategy

Testing is an important part of CoinRoutine's architecture.

Unit Tests

Business and presentation logic can be tested independently from the UI.

Examples include:

ViewModel
↓
Fake Repository
↓
Test Data
↓
Expected MVI State

The project uses:

• kotlin.test
• kotlinx-coroutines-test
• Turbine
• AssertK

UI Tests

Compose UI tests verify important user interactions and rendered states.

Examples:

• Verify UI elements are displayed
• Verify text content
• Verify user interactions
• Verify loading states
• Verify error states
• Verify portfolio/trading flows

Android Tests

Run Android shared tests with:

./gradlew :shared:testAndroidHostTest

iOS Tests

Run iOS simulator tests with:

./gradlew :shared:iosSimulatorArm64Test

These are also the test tasks currently documented by the project.

---

🔑 API Configuration

CoinRoutine uses an API key loaded from local.properties during the build.

Create:

local.properties

and add:

API_KEY=your_api_key_here

The project uses BuildKonfig to expose the API key to shared Kotlin code without committing the secret into the repository.

⚠️ Never commit your real API key to Git.

---

🚀 Getting Started

Requirements

• Android Studio
• Kotlin Multiplatform support
• Xcode
• JDK
• Android SDK
• iOS Simulator or physical iOS device
• CocoaPods if required by the selected dependencies

Clone the Repository

git clone https://github.com/chle0/CoinRoutine.git
cd CoinRoutine

Checkout the Biometric Feature

git checkout feature/biometric

Configure API Key

Create local.properties:

API_KEY=your_api_key_here

Run Android

Build the Android application:

./gradlew :androidApp:assembleDebug

Then install/run the generated APK on an Android device or emulator.

Run iOS

Open:

iosApp/

in Xcode and run the application on an iOS Simulator or physical device.

The repository also documents Xcode as the entry point for running the iOS application.

---

🔐 Biometric Authentication

The feature/biometric branch demonstrates adding biometric authentication while keeping the application architecture multiplatform.

The architecture separates the shared authentication contract from platform-specific implementations.

 Shared Code
│
Biometric Abstraction
┌─────┴─────┐
│ │
▼ ▼
Android iOS
BiometricPrompt Local Auth

This allows the application to keep its business and presentation logic shared while delegating platform-specific authentication to the appropriate platform APIs.

---

🎯 Project Goals

CoinRoutine was created to demonstrate practical experience with:

• Kotlin Multiplatform
• Compose Multiplatform
• Android + iOS development
• Clean Architecture
• MVI architecture
• Reactive state management
• Ktor networking
• Room Multiplatform
• Koin dependency injection
• Local persistence
• Biometric authentication
• Unit testing
• Coroutine testing
• Flow testing
• Compose UI testing
• Platform-specific implementations
• Shared UI and business logic

---

📚 What This Project Demonstrates

This project is more than a cryptocurrency application. It is a practical example of how a modern mobile application can be structured to share a significant amount of code between Android and iOS while still allowing platform-specific functionality when necessary.

The architecture emphasizes:

Shared Code → Clean Boundaries → Predictable State → Testable Logic → Platform-specific Integrations

---

🔮 Future Improvements

Potential improvements include:

• More comprehensive UI test coverage
• Additional portfolio analytics
• Advanced cryptocurrency charts
• More robust offline-first behavior
• Improved biometric fallback handling
• CI/CD pipeline
• Code coverage reporting
• Automated release builds
• More comprehensive integration tests

---

👨‍💻 Author

Ahmad Raza

Senior Android Developer | Kotlin Multiplatform | Compose Multiplatform

---

📄 License

This project is intended primarily as a demonstration and learning project for modern Kotlin Multiplatform and Compose Multiplatform development.