Controlling a robot from a mobile device breaks down into several fundamentally different tasks: real-time teleoperation (joystick for a wheeled platform or manipulator), state monitoring (battery, temperature, task status), mission programming (waypoints, pick-and-place sequences), and video streaming from cameras. A typical problem is high control latency and unstable video, especially when working over public networks. We have been developing mobile applications for robotics for over 5 years — our portfolio includes projects with Boston Dynamics Spot, Universal Robots UR-series, and custom platforms on ROS 2. Thanks to ready-made modules, debugging time is reduced by up to 30%, and support costs are lowered by 40% due to proven architectural solutions. Get a project estimate in 1 day.
How is a mobile app for robot control developed?
ROS 2 and rosbridge: the standard in research and industrial robotics
ROS 2 (Robot Operating System) is the de facto standard in academia and increasingly in industrial robotics (Universal Robots UR-series, MiR mobile platforms, Boston Dynamics Spot SDK). The rosbridge_suite provides a WebSocket API for interacting with ROS topics, services, and parameters from any language.
class RosbridgeClient {
late WebSocketChannel _channel;
final _topicStreams = <String, StreamController<dynamic>>{};
int _opId = 0;
Future<void> connect(String url) async {
_channel = WebSocketChannel.connect(Uri.parse(url));
_channel.stream.listen(_handleMessage);
}
// Subscribe to a ROS topic
Stream<T> subscribe<T>(String topic, String type,
T Function(Map<String, dynamic>) fromJson) {
final controller = StreamController<T>.broadcast();
_topicStreams[topic] = controller as StreamController<dynamic>;
_channel.sink.add(jsonEncode({
'op': 'subscribe',
'topic': topic,
'type': type,
'id': 'sub_${_opId++}',
}));
return controller.stream.map((data) => fromJson(data as Map<String, dynamic>));
}
// Publish to a ROS topic
void publish(String topic, String type, Map<String, dynamic> message) {
_channel.sink.add(jsonEncode({
'op': 'publish',
'topic': topic,
'type': type,
'msg': message,
}));
}
void _handleMessage(dynamic raw) {
final msg = jsonDecode(raw as String) as Map<String, dynamic>;
if (msg['op'] == 'publish') {
final topic = msg['topic'] as String;
_topicStreams[topic]?.add(msg['msg']);
}
}
}
How we ensure low latency in teleoperation
Controlling a wheeled platform via a virtual joystick publishes geometry_msgs/Twist to the /cmd_vel topic. A critical requirement is latency. If the delay exceeds 200 ms, control becomes uncomfortable; above 500 ms, it becomes dangerous. WebRTC outperforms MJPEG in latency by 2–4 times, which is critical for teleoperation.
class TeleopController {
final RosbridgeClient _rosbridge;
Timer? _publishTimer;
void startTeleop(Stream<Offset> joystickInput) {
joystickInput.listen((offset) {
_currentLinear = offset.dy * MAX_LINEAR_SPEED; // m/s
_currentAngular = -offset.dx * MAX_ANGULAR_SPEED; // rad/s
});
// Publish Twist at a fixed frequency of 10 Hz
_publishTimer = Timer.periodic(const Duration(milliseconds: 100), (_) {
_rosbridge.publish('/cmd_vel', 'geometry_msgs/Twist', {
'linear': {'x': _currentLinear, 'y': 0.0, 'z': 0.0},
'angular': {'x': 0.0, 'y': 0.0, 'z': _currentAngular},
});
});
}
void stopTeleop() {
_publishTimer?.cancel();
_rosbridge.publish('/cmd_vel', 'geometry_msgs/Twist', {
'linear': {'x': 0.0, 'y': 0.0, 'z': 0.0},
'angular': {'x': 0.0, 'y': 0.0, 'z': 0.0},
});
}
}
A watchdog on the robot: if /cmd_vel hasn't arrived for 0.5 seconds — emergency stop. This is standard practice for mobile platforms. Loss of WiFi or network switching means the robot stops itself. We ensure that the app correctly handles such scenarios.
Video streaming: MJPEG vs WebRTC
web_video_server — a ROS package that streams sensor_msgs/Image topics via HTTP MJPEG/h264. For a mobile client on Flutter:
Widget buildCameraView(String topic) {
final url = 'http://$robotIp:8080/stream?topic=$topic&type=mjpeg&quality=70';
return MjpegStreamView(url: url);
}
For latency <200 ms, WebRTC is needed — using the webrtc_ros package or Janus Gateway. WebRTC provides real-time video with sub-100 ms delay via flutter_webrtc:
class RobotVideoCall {
late RTCPeerConnection _peerConnection;
Future<void> startStream() async {
_peerConnection = await createPeerConnection({
'iceServers': [{'urls': 'stun:stun.l.google.com:19302'}],
});
_peerConnection.onTrack = (RTCTrackEvent event) {
if (event.track.kind == 'video') {
_videoRenderer.srcObject = event.streams.first;
}
};
final offer = await _peerConnection.createOffer();
await _peerConnection.setLocalDescription(offer);
_signalingChannel.send(offer.sdp);
}
}
| Method | Latency | Quality | Integration Complexity |
|---|---|---|---|
| MJPEG (HTTP) | 200–400 ms | Medium (JPEG compression) | Low (built-in package) |
| WebRTC (UDP) | <100 ms | High (adaptive bitrate) | Medium (signalling required) |
| Platform | Advantages | Disadvantages |
|---|---|---|
| Flutter | High development speed, single codebase | Limited work with native SDKs |
| Native (Kotlin/Swift) | Full API access, best performance | Longer development, two codebases |
The choice of video streaming method depends on requirements: for mapping, MJPEG is sufficient; for teleoperation, only WebRTC works. Our engineers will help you select the optimal solution.
Navigation and waypoints
For autonomous navigation (ROS Navigation Stack, Nav2) — sending a target point via geometry_msgs/PoseStamped to /move_base_simple/goal (ROS 1) or the action server /navigate_to_pose (Nav2 in ROS 2):
Future<void> navigateTo(double x, double y, double yaw) async {
final quaternion = yawToQuaternion(yaw);
_rosbridge.publish('/goal_pose', 'geometry_msgs/PoseStamped', {
'header': {
'frame_id': 'map',
'stamp': {'sec': DateTime.now().millisecondsSinceEpoch ~/ 1000, 'nanosec': 0},
},
'pose': {
'position': {'x': x, 'y': y, 'z': 0.0},
'orientation': quaternion,
},
});
}
Map<String, double> yawToQuaternion(double yaw) {
return {
'x': 0.0, 'y': 0.0,
'z': sin(yaw / 2),
'w': cos(yaw / 2),
};
}
Displaying the map — nav_msgs/OccupancyGrid from the /map topic. The raster map (uint8 array) is converted to PNG and rendered using flutter_map or a custom CustomPainter.
What is included in the development of a mobile app for a robot?
We provide a comprehensive solution following a clear process:
- Analysis and architecture design — interaction scheme, stack selection (Flutter vs native).
- UI/UX development — joystick, map, video, monitoring panel.
- Integration with ROS 2 (rosbridge) or proprietary SDK (Spot SDK, UR RTDE, Doosan, Kuka).
- Implementation of teleoperation (Twist), video streaming (MJPEG/WebRTC), navigation (waypoints, action).
- Testing on a real robot — field trials with latency and reliability measurements.
- Operator training — 2–3 sessions.
- Post-launch support — 1 month of warranty maintenance.
Proprietary robot SDKs
Boston Dynamics Spot — Spot SDK (Python + gRPC, mobile client via REST wrapper). Universal Robots — UR RTDE (Real-Time Data Exchange) for telemetry, URScript via socket for commands. Doosan, Kuka — their own SDKs with REST API or Modbus TCP.
Why order from us?
We have over 5 years of experience in robotics projects, with more than 30 implemented solutions — from educational platforms to industrial manipulators. Certified engineers are proficient in Swift, Kotlin, Flutter, and Dart. We implement best practices: code signing, push notifications (APNs/FCM), deep linking (Universal Links). We ensure compliance with App Store Review Guidelines and Google Play Policy. Contact us — we will evaluate your project in 1 day and offer the optimal solution.