# Android + NVIDIA Jetson + ROS 2: Building an AI Robot

> Source: <https://dev.to/vmodal_ai/android-nvidia-jetson-ros-2-building-an-ai-robot-1jjd>
> Published: 2026-08-17 20:36:31+00:00

A practical Physical AI system often separates the user interface, AI compute, robotics middleware, and hardware control.

In this architecture, Android provides the operator interface, an NVIDIA Jetson provides edge AI compute, and ROS 2 coordinates robotics workloads.

```
             Android / Kotlin
                    |
             Secure Gateway
                    |
                  ROS 2
             /      |              Vision     Nav       Control
          |
    NVIDIA Jetson
          |
     AI Inference
          |
    Robot Sensors
          |
     Robot Hardware
```

This separation makes it possible to upgrade individual components without rebuilding the entire system.

The Android application can provide:

Use Jetpack Compose to build the operator interface.

The Jetson can run computationally intensive workloads such as:

The Android device does not need to perform every AI operation itself.

ROS 2 provides communication between robotics components.

A possible topic layout is:

```
/cmd_vel
/odom
/scan
/camera/image
/detections
/battery_state
/robot_status
```

Keep the topic structure small and intentional for the mobile interface.

Rather than making Android responsible for ROS 2 internals, use a gateway:

```
Android
   |
WebSocket / MQTT / ROS bridge
   |
ROS 2 Gateway
   |
ROS 2 Nodes
```

The gateway can authenticate clients, validate commands, and expose only approved functionality.

The Jetson can process camera frames:

```
Camera
   ↓
ROS 2 Image Topic
   ↓
Jetson AI Node
   ↓
Detection / Tracking
   ↓
ROS 2 Detection Topic
```

The Android app can subscribe to summarized results rather than receiving raw sensor data when bandwidth is limited.

The dashboard can display:

```
Robot: ONLINE
Battery: 87%
Mode: AUTONOMOUS
Objects: 4
Position: X 2.3 / Y 4.8
```

Compose state can be backed by Kotlin `StateFlow`

.

For manual control:

```
Android
   ↓
Velocity Command
   ↓
Gateway
   ↓
ROS 2
   ↓
Safety Controller
   ↓
Robot Base
```

The safety controller should remain authoritative over the physical robot.

For autonomous operation:

```
Sensors
   ↓
Jetson Perception
   ↓
Localization
   ↓
Navigation
   ↓
Safety Controller
   ↓
Robot
```

Android becomes a monitoring and supervisory interface rather than the primary controller.

A production system should include:

Never assume that a mobile application being inside the same Wi-Fi network makes the robot network trusted.

Use simulation before deploying to hardware.

Validate:

The same architecture can support multiple robots:

```
Android
   |
Fleet Gateway
   |
+--+---------+---------+
|            |         |
Robot 01   Robot 02  Robot 03
```

Each robot can expose a controlled namespace and telemetry stream.

Android, NVIDIA Jetson, and ROS 2 form a strong architecture for Physical AI applications. Android handles human interaction, Jetson handles demanding edge AI workloads, and ROS 2 coordinates perception, navigation, and control.

This architecture can later be extended with LLM-based planning, voice interaction, computer vision, and autonomous task execution.

SDK Flutter: [https://github.com/v-modal/vmodal_sdk_flutter](https://github.com/v-modal/vmodal_sdk_flutter)

SDK Android: [https://github.com/v-modal/vmodal_sdk_android](https://github.com/v-modal/vmodal_sdk_android)

Discord: [https://discord.gg/K72z28KUx](https://discord.gg/K72z28KUx)