Runique

A sophisticated multi-module running tracker for Android phones and Wear OS devices

Overview

Runique is a modern running tracker application that seamlessly connects your phone and Wear OS device, providing a comprehensive fitness tracking experience built with the latest Android development practices.

Key Features

• Cross-Device Synchronization: Seamlessly sync your running data between phone and Wear OS
• Real-Time Tracking: Live GPS tracking with Google Maps integration
• Offline Support: Continue tracking even without network connectivity
• Secure Authentication: OAuth-based authentication system
• Analytics Dashboard: Comprehensive insights into your running performance
• Dynamic Features: Modular functionality with dynamic feature delivery
• Health Integration: Direct integration with Wear OS Health Services API
• Modern UI: Built entirely with Jetpack Compose for both phone and Wear OS

Tech Stack & Libraries

Core Technologies

• Kotlin + Coroutines + Flow
• Jetpack Compose (Phone & Wear OS)
• Google Maps SDK
• Wear OS Health Services API
• Dynamic Feature Modules

Architecture & DI

• Multi-module Clean Architecture
• Koin for dependency injection
• Room for local database
• Ktor for networking

Testing

• JUnit 5
• Mockk for mocking
• Turbine for Flow testing
• Custom test modules

Build & Tools

• Version Catalogs
• Custom Gradle Convention Plugins
• Build Logic optimization
• Type-safe project accessors

Module Structure

runique/
├── app/
├── auth/
│   ├── data/
│   ├── domain/
│   └── presentation/
├── core/
│   ├── presentation/
│   │   ├── designsystem/
│   │   ├── designsystem_wear/
│   │   └── ui/
│   ├── domain/
│   ├── data/
│   ├── database/
│   ├── connectivity/
│   │   ├── domain/
│   │   └── data/
│   ├── notification/
│   └── test/
├── run/
│   ├── data/
│   ├── domain/
│   ├── presentation/
│   ├── location/
│   └── network/
├── analytics/
│   ├── data/
│   ├── domain/
│   ├── presentation/
│   └── analytics_feature/
└── wear/
    ├── app/
    └── run/
        ├── data/
        ├── domain/
        └── presentation/

Architecture Overview

Runique implements a multi-module Clean Architecture approach with the following key characteristics:

1. Feature Modules: Self-contained modules for auth, run tracking, and analytics
2. Core Modules: Shared functionality across features
3. Layer Separation: Clear boundaries between data, domain, and presentation layers
4. Platform-Specific UI: Separate design systems for phone and Wear OS
5. Testing Infrastructure: Dedicated test modules for unit and Android tests

Getting Started

Prerequisites

• Android Studio Hedgehog (2023.1.1) or newer
• JDK 17 or newer
• Android device/emulator running API 25+
• Wear OS device/emulator (optional)

Configuration

1. Clone the repository
2. Add required API keys to local.properties:

API_KEY=<RUNIQUE_API_KEY>
MAPS_API_KEY=<GOOGLE_MAPS_API_KEY>

3. Sync project with Gradle files
4. Build and run

API Keys

• Runique API key: Available after course purchase
• Google Maps API key: Obtain from Google Cloud Console

Building

The project uses Gradle with custom convention plugins. Main build commands:

# Build all variants
./gradlew build

# Build and install debug variant
./gradlew installDebug

# Run tests
./gradlew test

Testing Strategy

1. Unit Tests: Using JUnit 5 with Mockk
2. Integration Tests: Custom test modules
3. UI Tests: Compose UI testing
4. Flow Testing: Using Turbine

Course Information

This project is part of the Android Essentials course bundle, covering:

• Project planning and architecture
• Multi-module development
• Gradle optimization
• Authentication systems
• Offline-first architecture
• Dynamic feature modules
• Wear OS development
• Cross-device synchronization

License

This project is for educational purposes as part of the Android Essentials course bundle. Contact the course provider for licensing details.

Acknowledgments

• Android Development Community
• Course instructors and contributors
• Google Maps Platform
• Wear OS Development Team