Camera Connect & Control DSLR and Mirrorless Control App

This case study reflects Adequate Infosoft's deep expertise in Flutter app development, multi-brand hardware SDK integration , and custom camera communication protocol engineering.

The application is developed with Flutter (Dart) using a native Kotlin and Swift platform and combines Canon PTP/IP/CCAPI and Nikon MTP/PTP protocols from USB and WiFi, and the Sony Camera Remote API, into one mobile application.

For Photographers, the application provides liveview, full camera control, handling of RAW files (CR2, CR3, NEF), tethered shooting, casting to Chromecast, GPS tagging, Focus Bracketing, taking Photo in Bulb Mode, and a companion application for WearOS.

The case study will provide examples of how Adequate Infosoft provides production-ready hardware integrated Flutter applications globally, from USB OTG hardware communications to Dart Isolations for real-time streaming.

Technology:

Flutter | Dart | USB OTG | WiFi P2P | PTP/IP Protocol | Canon SDK | Nikon SDK | Sony SDK |

Camera Connect and Control is a professional quality cross platform application for controlling your Canon, Nikon or Sony DSLR remotely and tethering as you shoot using your iOS or Android smartphone or tablet.

Built using Flutter, the Camera Connect & Control app provides one performance codebase across both Android and iOS with features including Live View streaming, full camera settings control, file browsing, downloading of both RAW and JPEG format images, GPS tagging of images, Chromecast Support and WearOS Companion.

A hallmark of this architectural accomplishment is the fact that multiple different camera communication SDKs and protocols (Canon's CCAPI/PTP, Nikon's MTP/PTP-over-USB/WiFi, and Sony's Smart Remote Control API) are all integrated together in order to provide a single and consistent UI layer in Flutter for each camera brand.

The main problem for professional photographers using dozens of thousands-of-dollars’ worth of DSLR cameras is the need for a properly functioning brand-specific manufacturer’s official app to remotely control their camera.

Canon Camera Connect, Nikon SnapBridge, and Sony Imaging Edge each can only function with their owner’s brands, have limited amounts of features common across brands, and often will not maintain stable connectivity while communicating with the camera.

Photographers required:

• One app to control cameras from multiple manufacturers
• Stable USB and Wifi connectivity between any of the installation’s dozens of cameras
• Remote liveview (real-time control of shutter speed, aperture, ISO, white balance, drive mode) for both still and video camera/video recording
• Capability to browse, preview, bulk download, and share RAW (CR2, CR3, NEF) and JPEG image files directly to their phone
• The ability to shoot tethered for studio and event photography
• Integration with existing sharing ecosystems such as WhatsApp, Instagram, Chromecast and iCloud.

The task was not only to create a new app that functions as a remote camera control; but to also build a unified communication abstraction layer to talk to the proprietary camera protocols of Canon, Nikon and Sony simultaneously in one Flutter application.

Flutter (Dart) from Google was selected to produce this solution; it is an open-source mobile UI framework that enables the development of high-performance native applications with one codebase.

There were several technical reasons for selecting Flutter as the framework for this project:

1. Platform Channel Architecture.

The team was able to use Flutter's platform channels to develop camera communication logic in native code (Kotlin, Android) and in native code (Swift, iOS), where deep hardware access was required — with a focus on USB on-the-Go communication, therefore enabling "raw hardware access" while still having the benefits of a native cross-platform application.

2. Isolate Background Processes

PTP/IP communications, file transfer pipelines, and live view frame decode tasks were run in the background to not block the app's main thread. This was critical to end-user experience.

3. Custom Rendering for Liveview:

The Liveview video stream - offering MJPEG or proprietary compressed frames from the camera - is decoded and rendered using Flutter's Texture widget utilizing a native SurfaceTexture (Android) or CVPixelBuffer (iOS) to provide hardware-accelerated frame rendering without going through Flutter's widget compositor.

4. State Management:

The application is built on a BLoC (Business Logic Component) pattern using Dart Streams to provide a reactive camera state (connected/disconnected, current setting values, battery level, card space) to all screens of the UI without race conditions.

The core engineering challenge of this project was integrating three fundamentally different camera communication ecosystems into a single unified Flutter abstraction layer.

Camera Integration - PTP/IP and CCAPI

According to Canon, communication between its cameras and laptop or mobile device is dependent upon the camera model. In particular, older DSLR models (5D, 7D, Rebel) utilize PTP/IP (Picture Transfer Protocol over Internet Protocol) which follows the ISO 15740 standard for transmitting files from a camera to a device as well as remotely capturing images.

Newer Canon mirrorless cameras (EOS R series) support Canon's Camera Control API (CCAPI) which is a more modern REST-based HTTP API.

Canon's team developed a dual-stack Canon Communication Layer with the following capabilities:

For older models (legacy) supporting PTP/IP:

A parser for PTP/IP packets as well as a command dispatcher for handling opcodes used for capturing pictures, streaming liveview images, downloading images and changing settings.

For newer models supporting CCAPI:

An HTTP client to wrap CCAPI endpoints with built-in support for polling to retrieve liveview images/shoot and utilize JSON format for negotiating settings.

For models that do not have WiFi capabilities:

Used USB communication by implementing the PTP/MTP command pipeline via USB bulk transfers; used Android USB Host API through a Flutter platform channel.

Canon Integration — PTP/IP + CCAPI

Canon

Canon cameras communicate over two protocols depending on model. Older DSLR bodies (5D series, 7D series, Rebel series) use PTP/IP (Picture Transfer Protocol over IP) — a standardized ISO 15740 protocol for camera-to-device file transfer and remote capture. Newer Canon mirrorless bodies (EOS R series) support CCAPI (Camera Control API), Canon's modern REST-based HTTP API.

The team implemented a dual-stack Canon communication layer:

• A PTP/IP packet parser and command dispatcher for legacy bodies, handling opcodes for capture, liveview frames, object download, and settings changes
• An HTTP client wrapping CCAPI endpoints for EOS R series, with polling-based liveview and JSON settings negotiation
• USB communication for models without WiFi, using Android's USB Host API via a Flutter platform channel, implementing the PTP/MTP command pipeline over USB bulk transfers

Nikon Integration - USB and Wi-Fi Adapter Options with MTP/PTP.

Nikon

Nikon implements MTP over USB and also offers a Wi-Fi implementation of PTP in its wireless models.

However, in order to support wireless implementations with the WU-1a and WU-1b wireless adapters, both WU adapters create their own access points and the application must programmatically switch the phone's Wi-Fi connection to the camera's SSID.

The above was accomplished by implementing:

• An integration to manage Wi-Fi networks (using the WiFiManager class on Android and NEHotspotConfiguration on iOS) to enable automatic connections to camera-generated access points.
• Hotspot bridge mode, which is unique to this application, allows the camera to connect to the phone's hotspot rather than the phone to the camera. (This requires that the camera's expected SSID and password be injected into the phone's hotspot configuration).
• Full implementation of the equivalent MTP/PTP command sets for all current Nikon-compatible camera bodies, including the D series and Z series mirrorless cameras, including firmware version-aware implementation compatibility tables.

Sony Integration -Smart Remote Control API

Sony

The integration of the Sony Alpha camera with the Smart Remote Control PlayMemories app uses the JSON-over-HTTP API to interface with Sony's Camera Remote API.

The integration includes device discovery via SSDP, API version negotiation and command dispatching over the camera's local WiFi network.

Additionally, the liveview frames sent from the Sony camera to this API are transmitted in a binary stream, making it necessary to implement custom logic for framing the binary stream and extracting JPEG images.

Beyond the three major brands, the platform was architected to support custom OEM camera hardware developed by Adequate Infosoft's hardware partners. These custom cameras communicate over a simplified REST + WebSocket hybrid API designed in-house.

The Flutter app includes a custom camera module that authenticates via device serial number, establishes a persistent WebSocket connection for liveview frame delivery, and exposes the full camera settings control surface through the same unified Flutter UI used for Canon, Nikon, and Sony.

This architecture demonstrates Adequate Infosoft's capability to not just integrate existing SDKs but define and implement camera communication protocols from scratch.

Liveview with Full Camera Control:

The Pro tier delivers real-time liveview with in-app controls for shutter speed, aperture, exposure compensation, ISO, white balance, picture style, drive mode, metering mode, and image format. Settings changes are dispatched as camera protocol commands and confirmed via state polling, with UI controls reflecting confirmed camera state rather than optimistic local state.

RAW File Handling (CR2, CR3, NEF):

RAW file preview was implemented using platform-native RAW decoders — libraw on Android via JNI bindings, and iOS's native RAWFilter (Core Image) — surfaced through Flutter platform channels. This allowed quick thumbnail generation and full preview of RAW files without requiring upload to a cloud service.

Chromecast Integration:

The Google Cast SDK was integrated via a Flutter plugin wrapping the Cast SDK's Android and iOS native libraries. Photos browsed on the camera are castable directly to any Chromecast on the same network, enabling live tethered shooting display on a large screen — a popular studio and event photography workflow.

GPS Tagging via Foreground Service:

A persistent Android foreground service (exposed to Flutter via a platform channel) continuously reads GPS coordinates from the phone and injects them into the camera as EXIF GPS tags in real time during shooting — something the camera hardware itself cannot do without an accessory.

Focus Bracketing and Bulb Capture:

Advanced capture modes were implemented with configurable inter-capture delays, step counts, and exposure timing. Bulb capture uses a timed command hold pattern against each brand's protocol, with millisecond-precision timing implemented in native layers to avoid Dart VM scheduling jitter.

WearOS Companion App:

A Wear OS app was built as a Flutter module using the wear Flutter package, providing a minimal capture trigger and liveview thumbnail display on the user's wrist, communicating with the phone app via the Wearable Data Layer API.

The iOS App has received high ratings from users as well and continues to provide stable USB and WiFi connections, which many users believe are better than the similar applications from camera manufacturers.

The freemium model (Free, Lite, Pro tiers) and in-app purchases have proven that this application can be commercially viable.

Live App

Developed for RupiApps, Camera Connect & Control has achieved over 1 million downloads on Google Play and is available on both Android and iOS.

This project validates Adequate Infosoft's experience in developing applications that focus on camera connectivity, video surveillance , security applications, live streaming with cameras, camera integration into hardware, and mobile application development that can be used across multiple platforms.

Google Play App Store

Layer	Technology
Mobile Framework	Flutter (Dart)
Native Android Layer	Kotlin, Android USB Host API, WifiManager
Native iOS Layer	Swift, NEHotspotConfiguration, AVFoundation
Canon Protocol	PTP/IP (ISO 15740), CCAPI REST, USB PTP/MTP
Nikon Protocol	MTP/PTP over USB, PTP-over-WiFi, WU-1a/WU-1b
Sony Protocol	Camera Remote API, SSDP Discovery, MJPEG Stream
Custom Camera	REST + WebSocket, Proprietary Protocol
RAW Processing	libraw (Android/JNI), Core Image RAWFilter (iOS)
Liveview Rendering	Flutter Texture Widget, SurfaceTexture / CVPixelBuffer
State Management	BLoC Pattern, Dart Streams
Casting	Google Cast SDK (Chromecast)
Wearable	Wear OS, Wearable Data Layer API
Background Services	Android Foreground Service, iOS Background Modes
File Formats	CR2, CR3, NEF, JPEG, MP4