Cross-Platform Connected Car Control & Fleet Monitoring App
Overview of Our Client
Our client was an innovative automotive technology provider developing a proprietary ecosystem of smart devices for connected cars, including dashcams, climate controllers, telemetry sensors, and vehicle security systems.
The client sought an automotive app development company to create a mobile solution that could manage these hardware components through multiple communication channels, including cellular networks, Wi-Fi, and Bluetooth.
To avoid duplicating complex hardware interaction logic on Android and iOS and establish a foundation for future applications, they required a reusable and independently deployable core engine.
- Region: Europe / Global
- Industry: Automotive / IoT / Fleet Management
- Timeline: ~12 months
Challenge
The growing ecosystem of proprietary automotive hardware created several technical and architectural challenges:
- Integrating multiple device types with different APIs and communication protocols
- Separating hardware-control logic from the application UI so it could be reused across future products
- Supporting reliable switching between Bluetooth Low Energy, Wi-Fi, and cellular connectivity
- Processing video streams, downloads, and bulk dashcam operations without affecting UI responsiveness
- Integrating performance-critical C/C++ libraries into a modern cross-platform mobile architecture
- Creating a standardized interface for adding new hardware models without extensive application changes
Main Goals
To build a responsive mobile solution and establish a reusable technology foundation for future products, we set the following goals:
- Develop a high-performance cross-platform application for Android and iOS
- Apply connected car app development practices to create a scalable foundation for remote vehicle monitoring and control
- Create a shared Kotlin Multiplatform (KMP) core that could function as a reusable hardware-control SDK
- Integrate C/C++ components for high-speed telemetry, video processing, and device communication
- Standardize hardware APIs to simplify the integration of new device models
- Support switching between cellular, Wi-Fi, and Bluetooth connections
- Build an intuitive interface for vehicle monitoring, dashcam management, climate control, ignition control, and security alerts
Project Overview
We developed a cross-platform mobile application built around a decoupled hardware-control core.
The Flutter frontend provided a uniform user experience on Android and iOS. The Kotlin Multiplatform core handled communication logic, device management, and business rules.
A native C/C++ layer was integrated into the core to process low-level data streams, cryptographic protocols, video, and peripheral communications.
To support the client's broader product ecosystem, the KMP core was separated from the presentation layer and packaged as a standalone Flutter plugin.
Standardized interfaces allowed different hardware APIs to be mapped to common application commands, making it possible to introduce new device models without modifying the existing UI architecture.
Solution
The delivered solution was a cross-platform connected car application combining a Flutter interface, a reusable Kotlin Multiplatform (KMP) core, and native C/C++ components. The platform provided a unified environment for vehicle monitoring, remote control, dashcam management, and communication with the client's growing range of automotive devices.
Core Platform Capabilities
- Cross-platform Android and iOS vehicle monitoring
- Reusable KMP hardware-control core
- Real-time vehicle telemetry and sensor status
- Dashcam app development capabilities for live streaming and media management
- Gallery downloads and automated storage cleanup
- Bluetooth, Wi-Fi, and cellular connectivity
- Remote ignition and climate control
- Vehicle alarm and security notifications
- Unified interfaces for multiple hardware models
- Low-level C/C++ data and video processing
- Standalone Flutter plugin for reuse across applications
User Workflow
- Vehicle Connection: The application established communication with the vehicle through the most suitable available connection, including BLE, Wi-Fi, or cellular.
- Vehicle Monitoring: Users viewed telemetry, sensor information, and device status in real time.
- Remote Control: Authorized users could manage supported vehicle functions, including ignition, climate settings, and alarm states.
- Dashcam Management: Users accessed live video, downloaded recordings, and managed stored dashcam files.
- Background Processing: Intensive transfers and media operations ran independently from the UI to maintain application responsiveness.
- Hardware Expansion: New device types could be connected through standardized interfaces without requiring changes to the presentation layer.
Technology Stack
To support cross-platform vehicle control, reusable hardware logic, and high-performance IoT communication, we used the following suite of technologies:
Frontend/UI
- Flutter
- Dart
Shared Core
- Kotlin Multiplatform (KMP)
- Kotlin/Native
- Standalone Flutter plugin
Native Integration
- C/C++
- JNI / cinterop
- Pigeon
Connectivity
- Bluetooth Low Energy (BLE)
- Wi-Fi Direct
- TCP/IP
- MQTT / WebSockets
Architecture
- Decoupled presentation and hardware-control layers
- Reusable SDK approach
Processing
- Multithreaded background processing for telemetry, media, and device operations
Results
The connected car control and fleet monitoring solution provided the client with a reusable foundation for managing its growing automotive hardware ecosystem, supported by our experience as an automotive app development company. The project delivered the following outcomes:
- Cross-Platform Application: A unified mobile application for Android and iOS with consistent vehicle-control functionality.
- Reusable KMP Core: A fully decoupled hardware-control SDK ready for integration into future applications.
- Faster Hardware Onboarding: Standardized device interfaces reduced the development time required to integrate new hardware models by over 50%.
- Seamless Connectivity: Automated switching between Bluetooth, Wi-Fi, and cellular networks enabled continuous communication without requiring manual network selection.
- Responsive User Experience: Background processing kept the application responsive during intensive dashcam streaming, downloads, and batch file operations.
- Scalable Product Architecture: The reusable core established a foundation for expanding the client's connected-car software ecosystem.
Related Cases
- Flutter
- Android
- IOS
- Java
- TypeScript
- Node.js
- React
- Java
- Spring Boot
- Flutter
- C/C++
Core Team
- Solution Architect: Designed the decoupled KMP architecture, SDK boundaries, and unified hardware API interfaces.
- Mobile Engineers (Flutter): Developed the cross-platform UI and integrated the reusable KMP core.
- Embedded & Core Engineers: Implemented C/C++ integrations, device communication, memory management, and performance optimization.
- DevOps Engineers: Managed CI/CD pipelines, dual-platform builds, and automated SDK packaging.
- QA Engineers: Tested connectivity switching, vehicle-control workflows, dashcam streaming, file transfers, and cross-application SDK compatibility.