HomeFix Mobile

Cross-platform mobile client for HomeFix, a marketplace that connects people who need home repairs with trusted local professionals.

Overview

HomeFix Mobile provides the customer and professional experience for the HomeFix backend. The application is written in Kotlin Multiplatform and Compose Multiplatform so that most UI, navigation, domain models, networking, authentication, and feature logic are shared between Android and iOS.

The client communicates with the deployed backend at https://homefixbackend.onrender.com by default.

Product flow

Sign in or create an account
        |
Browse tasks or create a repair task
        |
Review offers from professionals
        |
Accept an offer and chat in realtime
        |
Pay for completed work and leave a review

Features

• Email/password registration and login.
• Google sign-in on Android and iOS.
• JWT access-token authentication with refresh-token handling.
• Customer and professional roles.
• Browse and manage repair tasks.
• Create tasks with descriptions, location, and selected images.
• Professional offers and offer acceptance.
• Realtime task conversations over WebSocket/STOMP.
• Stripe payment sheet integration.
• Shared location and image-picker abstractions with platform implementations.
• Persistent auth-token storage using Android DataStore and iOS Keychain.
• Shared loading, error, and empty states using Compose UI.

Project structure

This is the structure of the current HomeFix source code, rather than the default KMP template:

HomeFix/
|-- androidApp/
|   `-- src/main/kotlin/org/homefix/project/
|       |-- MainActivity.kt                    Android Compose entry point
|       `-- data/auth/AndroidGoogleSignInProvider.kt
|                                                 Android Google sign-in adapter
|-- iosApp/
|   `-- iosApp/ContentView.swift               SwiftUI host for Compose
|-- shared/
|   `-- src/
|       |-- commonMain/kotlin/org/homefix/project/
|       |   |-- App.kt                          Root app and dependency setup
|       |   |-- core/ui/                        Theme and HomeFix icons
|       |   |-- data/                           DTOs, repositories, Ktor, STOMP chat
|       |   |-- di/                             Koin and HTTP/auth/task modules
|       |   |-- domain/                         Repository contracts and user roles
|       |   |-- features/                       Auth, main, tasks, payment, location
|       |   `-- navigation/                     Destinations and navigation graph
|       |-- androidMain/                        DataStore, Android location, images, payments
|       |-- iosMain/                            Keychain, iOS location, images, payments
|       |-- commonTest/                         Shared DTO tests
|       |-- androidHostTest/                    Android host tests
|       `-- iosTest/                            iOS tests
|-- gradle/libs.versions.toml                   Central dependency and plugin versions
|-- settings.gradle.kts                         Included modules and repositories
`-- build.gradle.kts                            Root Gradle plugin declarations

How the source is organized

The shared module uses a feature-oriented, layered structure:

Compose screens
      |
ViewModels and UI state
      |
Domain repository contracts
      |
Repository implementations and Ktor HTTP/WebSocket clients
      |
HomeFix backend API

Screens and ViewModels live in features. They depend on interfaces in domain, while concrete API and persistence code lives in data. Platform APIs are exposed through small interfaces in commonMain and implemented in androidMain or iosMain using expect/actual and Koin modules.

Technology stack

Area	Choice
Language	Kotlin 2.4.10
UI	Compose Multiplatform 1.11.1, Material 3
Platforms	Android and iOS
Networking	Ktor 3.5.1, Kotlinx Serialization
Dependency injection	Koin 4.2.2
Async work	Kotlin Coroutines 1.11.0
Navigation	Navigation 3 for Compose Multiplatform
Images	Coil 3.5.0
Payments	Stripe Android SDK; shared platform payment abstraction
Build	Gradle Kotlin DSL

Requirements

• Android Studio with Android SDK and an emulator or physical device.
• JDK 11 or newer.
• Xcode and CocoaPods/Swift tooling for iOS development on macOS.
• A running HomeFix backend, or access to the deployed backend URL.

Configuration

The backend URL is defined in the platform-specific NetworkConfig files:

• Android: shared/src/androidMain/kotlin/org/homefix/project/di/NetworkConfig.android.kt
• iOS: shared/src/iosMain/kotlin/org/homefix/project/di/NetworkConfig.ios.kt

Android reads these optional values from Gradle properties or environment variables:

GOOGLE_BACKEND_CLIENT_ID=<Google web/backend client ID>
STRIPE_PUBLISHABLE_KEY=<Stripe publishable key>

Do not commit private keys, service-account files, or other credentials. Only publishable Stripe configuration belongs in the client.

Run the Android app

Open the project in Android Studio, select the androidApp run configuration, and launch it on an emulator or connected device.

From PowerShell:

.\gradlew.bat :androidApp:assembleDebug

The generated APK is written under androidApp/build/outputs/apk/debug/.

Run the iOS app

On macOS, open iosApp in Xcode, select an iOS simulator or device, and run the application. The SwiftUI entry point hosts the shared Compose view from shared/src/iosMain.

Tests

Run shared and Android host tests with:

.\gradlew.bat :shared:testAndroidHostTest

Run the common test suite with:

.\gradlew.bat :shared:allTests

iOS tests can be run from Xcode or with the appropriate simulator Gradle task on macOS.

Backend integration

The mobile client expects the HomeFix backend API to provide authentication, tasks, offers, conversations, file uploads, payments, and reviews. See the backend README and its OpenAPI/Swagger documentation for local server setup and API details.

Contributing

Keep shared behavior in commonMain whenever possible. Put platform-specific APIs behind expect/ actual interfaces. Add or update tests for behavior changes, and never commit credentials or local machine configuration.

License

This project is intended to be released under the MIT License. See LICENSE.