HTTP、WebSocket、XMPP、CoAP、MQTT、DDS 六大协议在机器人通讯场景应用

在机器人与 Android 通讯场景中，协议的落地依赖于成熟的开发库（SDK / 工具包）。以下针对 HTTP、WebSocket、XMPP、CoAP、MQTT、DDS 六大协议，分别介绍Android 端 和机器人端（含嵌入式 Linux、ROS 等环境）最常用、最稳定的开发库，涵盖库的核心特性、使用场景、优势及基础使用示例，帮助快速上手开发。

一、HTTP 协议常用库

HTTP 协议的库核心目标是简化 "请求 - 响应" 流程，Android 原生支持已足够完善，机器人端则根据开发语言（Python/Java/C++）选择轻量库。

1. Android 端：Retrofit（主流首选）

核心定位 ：Square 公司开发的 HTTP 客户端框架，基于OkHttp封装，支持 RESTful API，是 Android 端 HTTP 开发的行业标准。
核心特性 ：
- 注解驱动开发（如@GET/@POST/@Path），简化请求参数配置；
- 支持同步 / 异步请求，自动适配主线程（避免 Android UI 线程阻塞）；
- 可搭配Gson/Moshi自动完成 JSON 数据与 Java 对象的序列化 / 反序列化；
- 支持拦截器（如添加统一 Header、打印请求日志、处理 Token 过期）。
优势：代码简洁、扩展性强、稳定性高（被抖音、美团等大厂广泛使用），适合机器人与 Android 的 "指令下发""状态查询" 等场景。

基础示例 （获取机器人电量）：

java 复制代码

// 1. 定义API接口
public interface RobotApi {
    @GET("robot/status") // 机器人端HTTP接口路径
    Call<RobotStatus> getRobotStatus(@Query("robotId") String robotId); // 请求参数
}

// 2. 初始化Retrofit
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("http://192.168.1.100:8080/") // 机器人端IP+端口
        .addConverterFactory(GsonConverterFactory.create()) // JSON解析
        .build();

// 3. 发送请求
RobotApi robotApi = retrofit.create(RobotApi.class);
robotApi.getRobotStatus("robot001")
        .enqueue(new Callback<RobotStatus>() {
            @Override
            public void onResponse(Call<RobotStatus> call, Response<RobotStatus> response) {
                if (response.isSuccessful()) {
                    RobotStatus status = response.body();
                    Log.d("HTTP", "机器人电量：" + status.getBattery() + "%");
                }
            }
            @Override
            public void onFailure(Call<RobotStatus> call, Throwable t) {
                Log.e("HTTP", "请求失败：" + t.getMessage());
            }
        });

2. 机器人端：Python-Requests（轻量首选）

核心定位：Python 生态中最流行的 HTTP 库，主打 "简洁易用"，适合机器人端（如树莓派、ROS Python 节点）快速实现 HTTP 服务或客户端。
核心特性 ：
- 支持 GET/POST/PUT/DELETE 等所有 HTTP 方法；
- 自动处理 Cookie、会话保持、SSL 验证；
- 响应数据可直接解析为 JSON（response.json()），无需额外处理。
优势：学习成本极低，一行代码即可发送请求，适合中小型机器人的 HTTP 服务开发（如接收 Android 端的控制指令）。

基础示例 （机器人端实现 HTTP 服务，接收 Android 指令）：

python 复制代码

# 1. 安装库：pip install requests flask（Flask用于搭建HTTP服务）
from flask import Flask, request, jsonify

app = Flask(__name__)

# 2. 定义接口：接收Android端的"移动指令"
@app.route("/robot/control", methods=["POST"])
def control_robot():
    data = request.get_json()  # 解析Android发送的JSON数据
    cmd = data.get("cmd")  # 指令（如"move_forward"）
    speed = data.get("speed")  # 速度（如0.5m/s）
    
    # 3. 执行机器人控制逻辑（此处为示例）
    print(f"执行指令：{cmd}，速度：{speed}")
    
    # 4. 返回响应给Android
    return jsonify({"code": 200, "msg": "指令执行成功"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)  # 监听所有IP，端口8080

二、WebSocket 协议常用库

WebSocket 库的核心需求是 "稳定长连接 + 双向数据传输"，需支持二进制流（如视频 / 传感器数据）和重连机制。

1. Android 端：OkHttp（原生集成，推荐）

核心定位：Square 公司开发的高效 HTTP/WebSocket 客户端，Android 端无需额外引入其他库（多数项目已依赖 OkHttp），支持 WebSocket 全双工通讯。
核心特性 ：
- 支持文本消息（send(String)）和二进制消息（send(ByteString)）；
- 内置连接状态监听（onOpen/onMessage/onClosed/onFailure）；
- 可自定义重连逻辑（如断网后通过ScheduledExecutorService定时重试）；
- 支持 WSS（WebSocket+TLS 加密），保障公网通讯安全。
优势：与 Android 生态兼容性好、性能优异（低内存占用），适合机器人实时控制（如发送 "前进 / 左转" 指令）和实时传感器数据接收。

基础示例 （Android 端连接机器人 WebSocket 服务）：

java 复制代码

// 1. 初始化OkHttpClient
OkHttpClient client = new OkHttpClient.Builder()
        .pingInterval(5, TimeUnit.SECONDS) // 5秒发送一次心跳包，维持连接
        .build();

// 2. 构建WebSocket请求（机器人端WebSocket地址）
Request request = new Request.Builder()
        .url("ws://192.168.1.100:8888/robot/ws")
        .build();

// 3. 建立连接并监听状态
WebSocket webSocket = client.newWebSocket(request, new WebSocketListener() {
    // 连接成功
    @Override
    public void onOpen(WebSocket webSocket, Response response) {
        super.onOpen(webSocket, response);
        Log.d("WebSocket", "连接机器人成功");
        // 发送控制指令（文本消息）
        webSocket.send("{\"cmd\":\"move_forward\",\"speed\":0.5}");
    }

    // 接收机器人发送的消息（如传感器数据）
    @Override
    public void onMessage(WebSocket webSocket, String text) {
        super.onMessage(webSocket, text);
        Log.d("WebSocket", "接收机器人消息：" + text);
    }

    // 连接失败（重连逻辑可在此处实现）
    @Override
    public void onFailure(WebSocket webSocket, Throwable t, Response response) {
        super.onFailure(webSocket, t, response);
        Log.e("WebSocket", "连接失败：" + t.getMessage());
        // 1秒后重试连接
        new Handler(Looper.getMainLooper()).postDelayed(() -> reconnect(), 1000);
    }
});

// 重连方法
private void reconnect() {
    // 重复上述request和newWebSocket逻辑
}

2. 机器人端：Java-WebSocket（跨平台，推荐）

核心定位：轻量级 WebSocket 服务端 / 客户端库，支持 Java/Android，可在机器人嵌入式 Linux（如树莓派）或 ROS Java 节点中运行。
核心特性 ：
- 支持服务端（WebSocketServer）和客户端（WebSocketClient）双模式；
- 低资源占用（适合算力有限的机器人）；
- 支持二进制消息传输（可直接接收 Android 端的视频流数据）。
优势：API 简洁，易与机器人控制逻辑（如 ROS 话题发布）集成，适合中小型机器人的 WebSocket 服务开发。

基础示例 （机器人端实现 WebSocket 服务，接收 Android 指令）：

java 复制代码

// 1. 安装依赖：Maven引入java-websocket（版本1.5.3）
<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.3</version>
</dependency>

// 2. 自定义WebSocket服务端
public class RobotWebSocketServer extends WebSocketServer {
    public RobotWebSocketServer(InetSocketAddress address) {
        super(address);
    }

    // 客户端（Android）连接时触发
    @Override
    public void onOpen(WebSocket conn, ClientHandshake handshake) {
        System.out.println("Android客户端连接成功：" + conn.getRemoteSocketAddress());
    }

    // 接收Android客户端消息（控制指令）
    @Override
    public void onMessage(WebSocket conn, String message) {
        System.out.println("接收Android指令：" + message);
        // 解析指令并执行机器人控制逻辑（如调用ROS节点发布运动指令）
        
        // 向Android发送传感器数据（示例）
        String sensorData = "{\"battery\":85,\"speed\":0.5}";
        conn.send(sensorData);
    }

    // 客户端断开连接时触发
    @Override
    public void onClose(WebSocket conn, int code, String reason, boolean remote) {
        System.out.println("Android客户端断开连接：" + reason);
    }

    // 连接出错时触发
    @Override
    public void onError(WebSocket conn, Exception ex) {
        ex.printStackTrace();
    }

    // 启动服务
    public static void main(String[] args) {
        InetSocketAddress address = new InetSocketAddress(8888); // 监听8888端口
        RobotWebSocketServer server = new RobotWebSocketServer(address);
        server.start();
        System.out.println("机器人WebSocket服务启动，端口：8888");
    }
}

三、XMPP 协议常用库

XMPP 协议的核心是 "即时通讯 + 权限管理"，库需支持账号认证、消息路由、群组管理，Smack 是 Android 端的事实标准。

1. Android 端：Smack（XMPP 开发首选）

核心定位：Ignite Realtime 开发的 XMPP 客户端库，支持 XMPP 所有核心扩展（如用户认证、点对点消息、群组聊天），是 Android 端 XMPP 开发的主流选择。
核心特性 ：
- 支持 TCP/WebSocket 两种传输方式（适配不同网络环境）；
- 内置账号注册、登录、好友管理（如添加机器人为 "好友"）；
- 支持消息回执（确认机器人已接收消息）、离线消息；
- 可通过扩展（如 XEP-0095）传输文件（如向机器人发送地图数据）。
优势：标准化程度高，无需自定义权限逻辑，适合多 Android 设备控制机器人的场景（如家庭多用户权限区分）。

基础示例 （Android 端连接 XMPP 服务器，向机器人发送消息）：

java 复制代码

// 1. 引入依赖（Maven）
<dependency>
    <groupId>org.igniterealtime.smack</groupId>
    <artifactId>smack-android</artifactId>
    <version>4.4.6</version>
</dependency>
<dependency>
    <groupId>org.igniterealtime.smack</groupId>
    <artifactId>smack-tcp</artifactId>
    <version>4.4.6</version>
</dependency>

// 2. 初始化XMPP连接
XMPPTCPConnectionConfiguration config = XMPPTCPConnectionConfiguration.builder()
        .setXmppDomain("xmpp-server.com") // XMPP服务器域名（如Openfire服务器）
        .setHost("192.168.1.101") // XMPP服务器IP（机器人可作为客户端连接此服务器）
        .setPort(5222) // XMPP默认端口
        .setSecurityMode(ConnectionConfiguration.SecurityMode.disabled) // 测试时关闭SSL（生产环境需开启）
        .build();

XMPPTCPConnection connection = new XMPPTCPConnection(config);

// 3. 登录并发送消息给机器人
new Thread(() -> {
    try {
        connection.connect(); // 连接服务器
        connection.login("android-user", "123456"); // Android端账号密码（在XMPP服务器注册）
        
        // 向机器人发送消息（机器人XMPP账号：robot001@xmpp-server.com）
        Jid robotJid = JidCreate.entityBareFrom("robot001@xmpp-server.com");
        Message message = MessageBuilder.buildMessage()
                .to(robotJid)
                .setBody("{\"cmd\":\"start_clean\"}") // 控制指令
                .build();
        
        connection.sendStanza(message); // 发送消息
        Log.d("XMPP", "指令已发送给机器人");
        
    } catch (Exception e) {
        e.printStackTrace();
    }
}).start();

2. 机器人端：Openfire（XMPP 服务器 + 客户端）

核心定位：Ignite Realtime 开发的开源 XMPP 服务器，机器人可通过 Openfire 客户端（如 Smack for Java）连接服务器，实现与 Android 端的消息交互。
核心特性 ：
- 支持用户管理（创建机器人账号、分配权限）；
- 支持群组聊天（多 Android 设备与机器人组成群组，同步指令）；
- 提供 Web 管理界面，可可视化配置用户、权限、消息日志。
优势：无需从零开发 XMPP 服务器，开箱即用，适合商用机器人的多设备权限管理场景。
使用方式 ：
1. 在机器人或局域网服务器上部署 Openfire（下载地址：Openfire 官网）；
2. 通过 Web 界面创建 "机器人账号"（如robot001）和 "Android 用户账号"（如user001）；
3. 机器人通过 Smack for Java 连接 Openfire，接收 Android 端发送的消息并执行指令。

四、CoAP 协议常用库

CoAP 协议的核心是 "低功耗 + 低带宽"，库需轻量、适配 UDP，Californium 是最成熟的实现。

1. Android 端：Californium（CoAP 开发标准）

核心定位：Eclipse 基金会开发的 CoAP 客户端 / 服务端库，支持 CoAP 所有核心特性（如请求 - 响应、订阅 - 通知、CoAPs 加密），是 Android 端 CoAP 开发的首选。
核心特性 ：
- 轻量（jar 包约 300KB），适合低内存的 Android 设备；
- 支持 CoAP 核心方法（GET/POST/PUT/DELETE）和观察（Observe）机制（订阅机器人传感器数据）；
- 支持 UDP 重传（解决 CoAP 基于 UDP 的可靠性问题）。
优势：专为物联网设计，低带宽占用，适合微型机器人（如教育机器人）与 Android 的蓝牙 / BLE 通讯。

基础示例 （Android 端订阅机器人传感器数据）：

java 复制代码

// 1. 引入依赖（Maven）
<dependency>
    <groupId>org.eclipse.californium</groupId>
    <artifactId>californium-core</artifactId>
    <version>3.8.0</version>
</dependency>

// 2. 初始化CoAP客户端
CoapClient client = new CoapClient();
// 机器人CoAP资源地址（coap://IP:端口/资源名，如传感器资源）
URI robotSensorUri = new URI("coap://192.168.1.100:5683/robot/sensor");
client.setURI(robotSensorUri.toString());

// 3. 订阅传感器数据（Observe机制，机器人数据更新时主动推送）
CoapObserveRelation relation = client.observe(new CoapHandler() {
    @Override
    public void onLoad(CoapResponse response) {
        String sensorData = response.getResponseText();
        Log.d("CoAP", "接收机器人传感器数据：" + sensorData);
    }

    @Override
    public void onError() {
        Log.e("CoAP", "订阅传感器数据失败");
    }
});

// 取消订阅（如页面关闭时）
// relation.proactiveCancel();

2. 机器人端：Californium（服务端）

核心定位：与 Android 端共用同一库，机器人端可作为 CoAP 服务端，暴露 "资源"（如传感器数据、控制接口）供 Android 端访问。
核心特性 ：
- 支持自定义 CoAP 资源（如SensorResource、ControlResource）；
- 低资源占用（适合树莓派、Arduino 等嵌入式机器人）；
- 支持 CoAPs（基于 DTLS 加密），保障蓝牙 / BLE 通讯安全。

基础示例 （机器人端实现 CoAP 服务，暴露传感器资源）：

java 复制代码

// 1. 引入Californium-core依赖（同Android端）

// 2. 自定义传感器资源（供Android订阅）
public class SensorResource extends CoapResource {
    private int battery = 100; // 模拟电池电量

    public SensorResource(String name) {
        super(name);
        setObservable(true); // 启用观察（Observe）机制
        setObserveType(CoAP.Type.CON); // 确认消息（保证可靠性）
        // 每2秒更新一次数据，并通知订阅者（Android）
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::updateData, 0, 2, TimeUnit.SECONDS);
    }

    // 更新传感器数据
    private void updateData() {
        battery--; // 模拟电量下降
        changed(); // 通知所有订阅者（Android）数据已更新
    }

    // 处理Android的GET请求（获取当前传感器数据）
    @Override
    public void handleGET(CoapExchange exchange) {
        String data = "{\"battery\":" + battery + ",\"temperature\":25.5}";
        exchange.respond(CoAP.ResponseCode.CONTENT, data, MediaTypeRegistry.APPLICATION_JSON);
    }
}

// 3. 启动CoAP服务
public class RobotCoapServer {
    public static void main(String[] args) {
        CoapServer server = new CoapServer(); // 默认端口5683
        server.add(new SensorResource("robot/sensor")); // 添加传感器资源
        server.start();
        System.out.println("机器人CoAP服务启动，端口：5683");
    }
}

五、MQTT 协议常用库

MQTT 协议的核心是 "发布 - 订阅 + 弱网可靠性"，库需支持 QoS 分级、离线消息，Eclipse Paho 是跨平台标准。

1. Android 端：Eclipse Paho Android Service（官方推荐）

核心定位：Eclipse 基金会开发的 MQTT 客户端库，专为 Android 优化，支持后台服务运行（避免 Activity 销毁后断开连接），是 Android 端 MQTT 开发的主流选择。
核心特性 ：
- 支持 QoS 0/1/2（根据需求选择可靠性等级）；
- 支持离线消息缓存（弱网时消息暂存，联网后自动发送）；
- 支持遗嘱消息（Android 端意外断开时，向机器人发送 "离线通知"）；
- 适配 Android 生命周期（如屏幕熄灭时保持连接）。
优势：弱网抗干扰能力强，适合户外机器人（如巡检机器人）与 Android 的 4G/5G 通讯。

基础示例 （Android 端订阅 "机器人状态" 主题，发布 "控制指令" 主题）：

java 复制代码

// 1. 引入依赖（Gradle）
implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.5'
implementation 'org.eclipse.paho:org.eclipse.paho.android.service:1.1.1'

// 2. 初始化MQTT客户端
String clientId = MqttClient.generateClientId(); // 生成唯一客户端ID
MqttAndroidClient client = new MqttAndroidClient(
        getApplicationContext(),
        "tcp://192.168.1.102:1883", // MQTT Broker地址（如EMQX服务器）
        clientId
);

// 3. 配置连接参数（QoS、遗嘱消息等）
MqttConnectOptions options = new MqttConnectOptions();
options.setUserName("android-user"); // Broker用户名（可选）
options.setPassword("123456".toCharArray()); // Broker密码（可选）
options.setCleanSession(false); // 关闭"清洁会话"，保留离线消息
// 遗嘱消息（Android离线时，Broker向机器人发送）
String willTopic = "robot/control/offline";
String willMessage = "android_client_offline";
options.setWill(willTopic, willMessage.getBytes(), 1, false);

// 4. 连接Broker并订阅/发布主题
try {
    // 连接回调（主线程）
    IMqttToken token = client.connect(options);
    token.setActionCallback(new IMqttActionListener() {
        @Override
        public void onSuccess(IMqttToken asyncActionToken) {
            Log.d("MQTT", "连接Broker成功");
            // 订阅"机器人状态"主题（QoS 1，保证消息至少接收一次）
            try {
                client.subscribe("robot/status", 1, (topic, message) -> {
                    String status = new String(message.getPayload());
                    Log.d("MQTT", "接收机器人状态：" + status);
                });

                // 发布"控制指令"主题（QoS 2，保证消息恰好接收一次）
                String cmdTopic = "robot/control/cmd";
                String cmdMessage = "{\"cmd\":\"move_left\",\"duration\":2000}";
                client.publish(cmdTopic, cmdMessage.getBytes(), 2, false);

            } catch (MqttException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
            Log.e("MQTT", "连接Broker失败：" + exception.getMessage());
        }
    });
} catch (MqttException e) {
    e.printStackTrace();
}

2. 机器人端：Eclipse Paho MQTT Client（跨语言支持）

核心定位：Eclipse Paho 的通用 MQTT 客户端库，支持 Python/Java/C++，机器人端可根据开发语言选择对应版本，与 Android 端通过 MQTT Broker 实现消息交互。
核心特性 ：
- 支持 QoS 0/1/2，适配不同可靠性需求；
- 支持持久化会话（保留订阅关系和离线消息）；
- 轻量（Python 版本仅需pip install paho-mqtt）。
优势：与 Android 端库生态一致，开发成本低，适合多机器人协同场景（如工厂 AGV 机器人）。

基础示例 （Python 机器人端订阅 "控制指令" 主题，发布 "状态" 主题）：

python 复制代码

# 1. 安装库：pip install paho-mqtt
import paho.mqtt.client as mqtt
import json
import time

# 2. 定义MQTT回调函数
def on_connect(client, userdata, flags, rc):
    print(f"连接Broker成功，返回码：{rc}")
    # 订阅"控制指令"主题（Android端发布到此主题）
    client.subscribe("robot/control/cmd", qos=2)

def on_message(client, userdata, msg):
    # 接收Android端的控制指令
    cmd = json.loads(msg.payload.decode())
    print(f"接收控制指令：{cmd}")
    # 执行机器人控制逻辑（示例）

# 3. 初始化MQTT客户端
client = mqtt.Client(client_id="robot001", clean_session=False)
client.username_pw_set("robot-user", "654321") # Broker用户名密码
client.on_connect = on_connect
client.on_message = on_message

# 4. 连接Broker并循环监听
client.connect("192.168.1.102", 1883, 60) # Broker IP+端口，超时60秒
client.loop_start() # 启动后台线程监听消息

# 5. 定时发布"机器人状态"主题（QoS 1）
while True:
    status = {"battery": 80, "position": (10.5, 20.3)}
    client.publish("robot/status", json.dumps(status), qos=1)
    time.sleep(3) # 每3秒发布一次

补充：MQTT Broker 推荐

机器人与 Android 的 MQTT 通讯需依赖 Broker（中间件），常用开源 Broker：

EMQX：高性能、高可用，支持百万级连接，适合工业 / 商用场景；
Mosquitto：轻量级，适合中小型场景（如家庭机器人），部署简单。

六、DDS 协议常用库

DDS 协议的核心是 "硬实时 + 分布式"，库需支持微秒级延迟、QoS 策略，FastDDS 是 ROS 2 的默认选择，适配机器人场景。

1. Android 端：FastDDS（官方 Android 支持）

核心定位：eProsima 开发的开源 DDS 实现，支持 Android 平台，是 ROS 2 生态的核心组件，专为硬实时场景设计。
核心特性 ：
- 支持 "发布 - 订阅" 和 "请求 - 响应" 两种模式；
- 微秒级延迟（满足工业机器人实时控制需求）；
- 丰富的 QoS 策略（如可靠性、 deadlines、资源限制）；
- 支持分布式无中心通讯（无需 Broker）。
优势：实时性顶级，适合高端工业机器人（如机械臂）与 Android 的高精度控制通讯。
注意事项 ：
- Android 端需集成 FastDDS 的 Android 库（通过 CMake 编译）；
- 需定义 DDS "数据类型"（如机器人控制指令、传感器数据），通常使用 IDL（接口定义语言）描述。

2. 机器人端：FastDDS（ROS 2 原生集成）

核心定位：ROS 2 的默认中间件（替代 ROS 1 的 Topic），机器人端（如 ROS 2 节点）可直接通过 FastDDS 实现与 Android 端的分布式通讯。
核心特性 ：
- 与 ROS 2 生态无缝集成（如rclcpp/rclpy接口）；
- 支持多机器人、多 Android 设备的分布式协作；
- 支持数据序列化（CDR 格式，高效紧凑）。
优势：无需额外开发 DDS 底层逻辑，直接复用 ROS 2 的 Topic/Service 接口，适合工业级机器人开发。

基础示例 （ROS 2 Python 机器人端发布 "传感器数据" Topic）：

python 复制代码

# 1. 前提：安装ROS 2（如Humble Hawksbill），FastDDS已默认集成
# 2. 定义DDS数据类型（通过ROS 2 msg文件，自动生成DDS IDL）
#    示例msg文件（sensor_msg/msg/RobotStatus.msg）：
#    int32 battery
#    float32 temperature

# 3. ROS 2节点发布Topic（本质是DDS发布）
import rclpy
from rclpy.node import Node
from sensor_msg.msg import RobotStatus
import time

class RobotStatusPublisher(Node):
    def __init__(self):
        super().__init__('robot_status_publisher')
        # 创建DDS发布者（QoS策略：可靠传输，保持10个历史消息）
        self.publisher_ = self.create_publisher(
            RobotStatus,
            'robot/status',
            10  # QoS历史深度
        )
        # 每1秒发布一次数据
        self.timer = self.create_timer(1.0, self.timer_callback)
        self.battery = 100

    def timer_callback(self):
        msg = RobotStatus()
        msg.battery = self.battery
        msg.temperature = 25.0 + (100 - self.battery) * 0.1
        self.publisher_.publish(msg)
        self.get_logger().info(f"发布机器人状态：电量={msg.battery}%，温度={msg.temperature}℃")
        self.battery -= 1

def main(args=None):
    rclpy.init(args=args)
    publisher = RobotStatusPublisher()
    rclpy.spin(publisher)
    publisher.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

总结：库选型建议

协议	Android 端首选库	机器人端首选库	核心考量因素
HTTP	Retrofit（简洁高效）	Python-Requests（轻量）	开发效率、JSON 解析支持
WebSocket	OkHttp（原生集成）	Java-WebSocket（跨平台）	长连接稳定性、二进制流支持
XMPP	Smack（标准化）	Openfire（服务器 + Smack 客户端）	权限管理、多设备消息路由
CoAP	Californium（轻量）	Californium（服务端）	低带宽、低功耗适配
MQTT	Paho Android Service	Paho MQTT Client（Python/Java）	QoS 分级、弱网抗干扰
DDS	FastDDS（硬实时）	FastDDS（ROS 2 集成）	实时性、分布式协作

选择库时，需优先考虑跨端兼容性 （如 Android 与机器人用同一生态库，减少适配成本）和场景匹配度 （如弱网选 Paho，硬实时选 FastDDS），同时兼顾开发复杂度（如 HTTP 选 Retrofit 而非原生HttpURLConnection）。