🚗 CarTalk

Real-time voice communication between nearby vehicles

Discover nearby vehicles using Bluetooth Low Energy (BLE) and talk over low-latency WebRTC voice calls — no phone numbers required.

_{▶️ Click the thumbnail to watch the full demo}

📑 Table of Contents

• Overview
• Features
• Screenshots
• Feature Demos
• Architecture
• Tech Stack
• How It Works
• Getting Started
• Privacy
• Project Status
• Contributing
• Author

🔍 Overview

CarTalk is an Android application that lets drivers traveling near each other discover one another and start a voice call — without ever exchanging phone numbers.

Vehicles are identified by their car model and vehicle number instead of personal contact info.

Capability	Powered by
🔵 Nearby vehicle discovery	Bluetooth Low Energy (BLE)
📡 Proximity estimation	RSSI signal strength
📞 Real-time voice calls	WebRTC (peer-to-peer)
🔥 Call signaling & backend	Firebase
🎨 UI	Jetpack Compose + Material 3

The flow is simple: Find a nearby vehicle → Select it → Start a voice call.

✨ Features

🔍 Nearby Vehicle Discovery Automatically discovers CarTalk users within Bluetooth range. Each vehicle can be identified using: Vehicle number Car model Bluetooth signal strength	📞 Real-Time Voice Calling Uses WebRTC to establish low-latency, peer-to-peer audio communication between two vehicles.
🔐 Privacy Focused Built around vehicle-based identification rather than exposing personal phone numbers.	📡 BLE Proximity Detection BLE is used to scan for nearby CarTalk devices and read their advertising information.
🔥 Firebase Signaling Firebase powers the signaling layer required to establish WebRTC connections between peers.	🎨 Modern Android UI Built entirely with Jetpack Compose, Material 3, and modern Android architecture patterns.

📸 Screenshots

_{Onboarding · Discovery · Incoming Call · Calling · Connected · App Icon}

🎥 Feature Demos

🔍 Vehicle Discovery & Connection cartalkCall.mp4 Discovering and connecting with a nearby CarTalk user.

📞 Real-Time Voice Communication cartalkvideo1.mp4 Real-time voice communication using WebRTC.

🏗 Architecture

CarTalk follows a modular Clean Architecture approach.

CarTalk
│
├── app                     → Application entry point
│
├── core
│   ├── common              → Shared utilities and common components
│   ├── domain              → Shared domain models and abstractions
│   ├── navigation          → Application navigation
│   ├── ui                  → Shared UI components and design system
│   └── firebase            → Firebase-related functionality
│
└── feature
    ├── onboarding          → User and vehicle setup
    │   ├── data
    │   ├── domain
    │   └── presentation
    │
    ├── nearby               → BLE advertising, scanning, discovery
    │   ├── data
    │   ├── domain
    │   └── presentation
    │
    └── calling              → WebRTC voice calling
        ├── data
        ├── domain
        └── presentation

Data → Domain → Presentation
_{Every feature module keeps business logic independent from Android UI and infrastructure.}

📋 Module Responsibility Table (click to expand)

Module	Responsibility
:app	Application entry point and main navigation
:core:common	Shared utilities and common components
:core:domain	Shared domain models and abstractions
:core:navigation	Application navigation
:core:ui	Shared UI components and design system
:core:firebase	Firebase-related functionality
:feature:onboarding	User and vehicle setup
:feature:nearby	BLE advertising, scanning and vehicle discovery
:feature:calling	WebRTC voice calling

🛠 Tech Stack

Android Kotlin Android SDK Jetpack Compose Material 3 Compose Navigation Kotlin Coroutines & Flow

Architecture Clean Architecture MVVM Multi-module setup Repository pattern Dependency Injection

Nearby Comms Bluetooth Low Energy BluetoothLeScanner BluetoothLeAdvertiser RSSI proximity estimation

Voice & Backend WebRTC (P2P audio) Hilt (DI) Firebase Realtime DB Firebase Analytics Firebase Crashlytics

🚦 Getting Started

Requirements

Requirement	Notes
Android Studio	Latest stable version recommended
Android SDK 26+	Minimum supported SDK
Kotlin	Bundled with Android Studio
Physical Android device(s)	Required — BLE + WebRTC don't work reliably on emulators

⚠️ A physical device is strongly recommended since CarTalk relies on real Bluetooth Low Energy hardware and real-time WebRTC communication.

Installation

1. Clone the repository

git clone https://github.com/mohitdamke/CarTalk.git

2. Open the project

Open the cloned project in Android Studio.

3. Configure Firebase

Add your Firebase configuration file to:

app/google-services.json

🔒 Do not commit your google-services.json to a public repository.

4. Build the project

Sync Gradle and build the app.

5. Run on two physical devices

   Device A  ⇄  BLE Discovery  ⇄  Device B
   Device A  ⇄  Firebase Signaling  ⇄  Device B
   Device A  ⇄  WebRTC  ⇄  Device B

🔒 Privacy

CarTalk is designed to minimize the personal information exposed during vehicle discovery — using vehicle info rather than directly exposing a phone number.

⚠️ Important: BLE discovery itself is not a security boundary. Anything placed in a BLE advertisement can potentially be read by any nearby Bluetooth scanner. Sensitive data should never be placed directly into BLE advertisements in production.

🧪 Project Status

CarTalk is currently an MVP / experimental project, validating:

• ✅ BLE-based nearby vehicle discovery
• ✅ Vehicle identification
• ✅ Proximity detection
• ✅ Firebase signaling
• ✅ WebRTC voice communication
• ✅ Modular Android architecture

The project is intended as a foundation for further development.

🤝 Contributing

Contributions, suggestions, and improvements are welcome! If you find a bug or have an idea, feel free to open an issue or submit a pull request.

👨‍💻 Author

Mohit
Android Developer

Made with ❤️ using Kotlin & Android

🚗 CarTalk — Connect with the cars around you.