通用任务服务接口

功能	C++	Python	C#	Java
创建任务	✔	✔	✔	✔
试运行任务	✔	✔	✔	✔
执行任务	✔	✔	✔	✔
暂停任务	✔	✔	✔	✔
恢复任务	✔	✔	✔	✔
停止任务	✔	✔	✔	✔
删除任务	✔	✔	✔	✔
获取任务列表	✔	✔	✔	✔
监听任务状态	✔	✔	✔	✔
取消监听任务状态	✔	✔	✔	✔
监听任务脚本	✔		✔	✔
取消监听任务脚本	✔		✔	✔

CreateTask

函数原型

• C#: RobotTaskOperationResponse CreateTask(string taskId, string scriptContent, int id = 301, int timeoutMs = 5000)
• C++: TaskOperationReply createTask(const std::string &task_id, const std::string &script_content)
• Python: async def create_task(task_id: str, script_content: str, timeout: int = 30, wait_timeout: float = 10.0) -> dict
• Java: void CreateTask(String taskId, String scriptContent)

功能说明

创建通用任务。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	必填	任务标识符
scriptContent	string	必填	任务脚本内容
timeout	int	选填	超时时间（仅部分语言支持）

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.CreateTask("task_001", "print('hello'");
if (result.success)
{
    Debug.Log($"✓ Task created successfully: {result.message}");
}
else
{
    Debug.LogError($"✗ Task creation failed: {result.message}");
}

# Python
from daystar_sdk import WebSocketRobotClient

# 初始化客户端  
with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.create_task("task_001", "print('hello')")
    if success:
        print("任务创建成功，结果：", result_dict)
    else:
        print("任务创建失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = task.CreateTask("task001", "print('Hello from robot task')");
if (!response.success) {
    logger.error("创建任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.createTask("task_001", "print('hello')");
if (result.success)
{
    std::cout << "✓ 任务已创建: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务创建失败: " << result.message << std::endl;
}

任务脚本内容示例：

如下示例是一个导航任务，还可以增加云台、操作、上桩等任务，需要了解通用任务脚本的接口完整介绍和示例，请查看本章节的详细内容。

from daystar_api.lowlevel_skills import *
from daystar_api.lowlevel_skills import NavCompleteEvent, NavFailedEvent, NavProgressEvent

# 室外路径点使用这个
travel_params_road = MsgTravelParams() # 室外路径点导航参数，打开避障，忽略朝向
travel_params_road.speed_mode = 2  # HIGH 速度
travel_params_road.distance_tolerance = 0.3  # 30cm 距离容差
travel_params_road.gait = 2  # TROT 步态
travel_params_road.disable_body_obstacle_avoidance = False  # 启用避障
travel_params_road.ignore_final_yaw = True  # 忽略目标朝向
travel_params_road.path_following_mode = 1  # 默认循线
travel_params_road.direction_constraint = 1  # 无方向限制

# 楼梯终点使用这个
travel_params_stair = MsgTravelParams() # 楼梯导航参数，关闭避障，忽略朝向
travel_params_stair.speed_mode = 2  # LOW 速度
travel_params_stair.distance_tolerance = 0.3  # 30cm 距离容差
travel_params_stair.gait = 2  # TROT 步态
travel_params_stair.disable_body_obstacle_avoidance = True  # 关闭避障
travel_params_stair.ignore_final_yaw = True  # 忽略目标朝向
travel_params_stair.path_following_mode = 1  # 默认循线
travel_params_stair.direction_constraint = 1  # 无方向限制


def nav_complete_callback(event : NavCompleteEvent):
    print(f"target: {event.target}")

def nav_failed_callback(event: NavFailedEvent):
    print(f"✗ 导航失败: {event.error_msg}")

def nav_progress_callback(event : NavProgressEvent):
    print(f"distance : {event.distance_remaining}")

navigation_to_location(location='pointD', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)
navigation_to_location(location='pointC', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)
navigation_to_location(location='pointE', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)

ExecuteTask

函数原型

• C#: RobotTaskOperationResponse ExecuteTask(string taskId, string scriptContent = null, int id = 302, int timeoutMs = 5000)
• C++: TaskOperationReply executeTask(const std::string &task_id, const std::string &script_content = "")
• Python: async def execute_task(task_id: str = "", script_content: str = "", timeout: int = 60, wait_timeout: float = 15.0) -> dict
• Java: void ExecuteTask(String taskId, String scriptContent, int timeout)

功能说明

执行通用任务。当 taskId 不为空时，执行已存在的任务；当 taskId 为空且 scriptContent 不为空时，则为试运行脚本。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	选填	任务标识符（执行已有任务时必填）
scriptContent	string	选填	脚本内容（试运行模式必填）
timeout	int	选填	超时时间

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

// C# 执行已有任务
var result_1 = _robotTaskClient.ExecuteTask("task_001");
// C# 试运行脚本
var result_2 = _robotTaskClient.ExecuteTask("", "print('test')");

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.execute_task(task_id="task_001")
    if success:
        print("任务执行成功，结果：", result_dict)
    else:
        print("任务执行失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = task.ExecuteTask("task_001", "", 0);
if (!response.success) {
    logger.error("执行任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.executeTask("task_001");
if (result.success)
{
    std::cout << "✓ 任务已执行: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务执行失败: " << result.message << std::endl;
}

注意事项：

PauseTask

函数原型

• C#: RobotTaskOperationResponse PauseTask(string taskId, int id = 304, int timeoutMs = 5000)
• C++: TaskOperationReply pauseTask(const std::string &task_id)
• Python: async def pause_task(task_id: str, wait_timeout: float = 6.0) -> dict
• Java: void PauseTask(String taskId)

功能说明

暂停指定任务。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	必填	任务标识符

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.PauseTask("task_001");

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.pause_task(task_id="task_001")
    if success:
        print("任务暂停成功，结果：", result_dict)
    else:
        print("任务暂停失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.PauseTask("task_001");
if (!response.success) {
    logger.error("暂停任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.pauseTask("task_001");
if (result.success)
{
    std::cout << "✓ 任务已暂停: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务暂停失败: " << result.message << std::endl;
}

ResumeTask

函数原型

• C#: RobotTaskOperationResponse ResumeTask(string taskId, int id = 305, int timeoutMs = 5000)
• C++: TaskOperationReply resumeTask(const std::string &task_id)
• Python: async def resume_task(task_id: str, wait_timeout: float = 6.0) -> dict
• Java: void ResumeTask(String taskId)

功能说明

恢复被暂停的任务。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	必填	任务标识符

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.ResumeTask("task_001");

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.resume_task(task_id="task_001")
    if success:
        print("任务恢复成功，结果：", result_dict)
    else:
        print("任务恢复失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.ResumeTask("task_001");
if (!response.success) {
    logger.error("恢复任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.resumeTask("task_001");
if (result.success)
{
    std::cout << "✓ 任务已恢复: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务恢复失败: " << result.message << std::endl;
}

StopTask

函数原型

• C#: RobotTaskOperationResponse StopTask(string taskId, int id = 306, int timeoutMs = 5000)
• C++: TaskOperationReply stopTask(const std::string &task_id)
• Python: async def stop_task(task_id: str = "", wait_timeout: float = 10.0) -> dict
• Java: void StopTask(String taskId)

功能说明

停止指定任务。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	必填	任务标识符

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.StopTask("task_001");

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.stop_task(task_id="task_001")
    if success:
        print("任务停止成功，结果：", result_dict)
    else:
        print("任务停止失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.StopTask("task_001");
if (!response.success) {
    logger.error("停止任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.stopTask("task_001");
if (result.success)
{
    std::cout << "✓ 任务已停止: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务停止失败: " << result.message << std::endl;
}

DeleteTask

函数原型

• C#: RobotTaskOperationResponse DeleteTask(string taskId, int id = 307, int timeoutMs = 5000)
• C++: TaskOperationReply deleteTask(const std::string &task_id)
• Python: async def delete_task(task_id: str, wait_timeout: float = 8.0) -> dict
• Java: void DeleteTask(String taskId)

功能说明

删除指定任务。

参数说明

参数名	类型	必填/默认值	说明
taskId	string	必填	任务标识符

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含 success(bool) 和 message(string)
C++	TaskOperationReply	包含 success(bool) 和 message(string)
Python	dict	包含 success(bool) 和 message(string)
Java	void	无返回值

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.DeleteTask("task_001");

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.delete_task(task_id="task_001")
    if success:
        print("任务删除成功，结果：", result_dict)
    else:
        print("任务删除失败，错误信息：", result_dict)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.DeleteTask("task_001");
if (!response.success) {
    logger.error("删除任务失败: " + response.message);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.deleteTask("task_001");
if (result.success)
{
    std::cout << "✓ 任务已删除: " << result.message << std::endl;
}
else
{
    std::cout << "✗ 任务删除失败: " << result.message << std::endl;
}

GetAllTasks

函数原型

• C#: RobotTaskOperationResponse GetAllTasks(int id = 308, int timeoutMs = 5000)
• C++: GetAllTasksReply getAllTasks()
• Python: async def get_all_tasks(wait_timeout: float = 8.0) -> dict
• Java: List<String> GetAllTasks()

功能说明

获取所有已创建的任务列表。

参数说明

无

返回值

语言	返回类型	说明
C#	RobotTaskOperationResponse	包含如下字段： bool success; string message; string status; string[] taskIds;
C++	GetAllTasksReply	包含 std::vector<std::string> tasks
Python	dict	包含 task_ids 列表
Java	List<String>	直接返回任务ID列表

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.GetAllTasks();
if (result.success)
{
    string taskList = "任务列表:\n";
    if (result.taskIds != null && result.taskIds.Length > 0)
    {
        for (int i = 0; i < result.taskIds.Length; i++)
        {
            taskList += $"{i + 1}. {result.taskIds[i]}\n";
        }
    }
    else
    {
        taskList += "无任务";
    }
    
    Debug.Log($"✓ Got all tasks: {result.message}");
}
else
{
    Debug.LogError($"✗ Failed to get all tasks: {result.message}");
}

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    result = await client.get_all_tasks()
    print(f"结果: {result}")

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
List<String> tasks = task.GetAllTasks();
for (String taskId : tasks) {
    System.out.println("Task: " + taskId);
}

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.getAllTasks();
if (result.success)
{
    std::cout << "✓ 任务列表(" << result.task_ids.size() << "个任务):" << std::endl;
    for (size_t i = 0; i < result.task_ids.size(); i++)
    {
        std::cout << "  " << (i + 1) << ". ID: " << result.task_ids[i] << std::endl;
    }
}
else
{
    std::cout << "✗ 获取任务列表失败: " << result.message << std::endl;
}

RegisterTaskStatusCallback

函数原型

• C#: bool RegisterTaskStatusCallback(Action<object> callback)
• C++: void setTaskStatusCallback(std::function<void(const TaskStatus &)> callback)
• Python: async def register_task_status(callback: Callable)
• Java: void RegisterTaskStatusFeedback(Consumer<TaskStatus> callback)

功能说明

注册任务状态变更监听回调。

参数说明

参数名	类型	必填/默认值	说明
callback	function	必填	回调函数，接收任务状态对象

返回值

• C#: bool (是否注册成功)
• Python: bool (是否注册成功)
• C++/Java: void

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

void OnTaskStatusUpdate(object statusData)
{
    try
    {
        Debug.Log($"[TaskStatusCallback] Received task status update: {statusData}");
        
        // 尝试解析任务状态数据
        string statusText = "【任务状态更新】\n";
        
        if (statusData == null)
        {
            statusText += "状态数据为空";
        }
        else
        {
            // 使用反射或类型转换解析状态数据
            var dataType = statusData.GetType();
            statusText += $"数据类型: {dataType.Name}\n";
            statusText += $"详细信息: {statusData}\n";
            
            // 尝试获取常见字段
            try
            {
                var taskIdProp = dataType.GetProperty("task_id") ?? dataType.GetProperty("taskId");
                var statusProp = dataType.GetProperty("status");
                var messageProp = dataType.GetProperty("message");
                var progressProp = dataType.GetProperty("progress");
                
                if (taskIdProp != null)
                {
                    var taskId = taskIdProp.GetValue(statusData);
                    statusText += $"任务ID: {taskId}\n";
                }
                
                if (statusProp != null)
                {
                    var status = statusProp.GetValue(statusData);
                    statusText += $"状态: {status}\n";
                }
                
                if (messageProp != null)
                {
                    var message = messageProp.GetValue(statusData);
                    statusText += $"消息: {message}\n";
                }
                
                if (progressProp != null)
                {
                    var progress = progressProp.GetValue(statusData);
                    statusText += $"进度: {progress}\n";
                }
            }
            catch (Exception parseEx)
            {
                Debug.LogWarning($"Failed to parse task status fields: {parseEx.Message}");
            }
        }
        
    }
    catch (Exception ex)
    {
        Debug.LogError($"Error in OnTaskStatusUpdate: {ex.Message}\n{ex.StackTrace}");
    }
}

bool success = _robotTaskClient.RegisterTaskStatusCallback(OnTaskStatusUpdate);
if (success)
{
    Debug.Log("✓ Task status callback registered successfully");
}
else
{
    Debug.LogError("✗ Failed to register task status callback");
}

# Python
from daystar_sdk import WebSocketRobotClient

async def on_status(data):
    print(data)

with WebSocketRobotClient(host='localhost', port=5252) as client:
    await client.register_task_status(on_status)

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.RegisterTaskStatusFeedback(new Consumer<TaskStatus>() {
    @Override
    public void accept(TaskStatus feedback) {
        logger.info("TaskStatusFeedback with id: " + feedback.task_id + 
                    ", State: " + feedback.state +
                    ", State Name: " + feedback.state_name +
                    ", Progress: " + feedback.progress + 
                    ", Current Operation: " + feedback.current_operation +
                    ", Error Message: " + feedback.error_message +
                    ", Start Time: " + feedback.start_time +
                    ", Last Update: " + feedback.last_update +
                    ", Timeout Seconds: " + feedback.timeout_seconds);
    }
});

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setTaskStatusCallback([](const Lenovo::Daystar::TaskStatus &task_status) {
    std::cout << "[回调] 任务状态更新: ID=" << task_status.task_id 
        << ", 状态=" << task_status.status 
        << ", 消息=" << task_status.message << std::endl;
});
std::cout << "✓ 任务状态回调已注册" << std::endl;

UnregisterTaskStatusCallback

函数原型

• C#: bool UnregisterTaskStatusCallback()
• C++: void setTaskStatusCallback(nullptr)
• Python: async def unregister_task_status() -> bool
• Java: void UnregisterTaskStatusFeedback()

功能说明

取消任务状态变更监听回调。

参数说明

无

返回值

• C#: bool (是否成功)
• Python: bool (是否成功)
• C++/Java: void

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

bool success = _robotTaskClient.UnregisterTaskStatusCallback();
if (success)
{
    Debug.Log("✓ Task status callback unregistered successfully");
}
else
{
    Debug.LogError("✗ Failed to unregister task status callback");
}

# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    await client.unregister_task_status()

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.UnregisterTaskStatusFeedback();

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setTaskStatusCallback(nullptr)
std::cout << "✓ 任务状态回调已注销" << std::endl;

RegisterScriptOutputCallback

函数原型

• C#: bool RegisterScriptOutputCallback(Action<object> callback)
• C++: void setScriptOutputCallback(std::function<void(const ScriptOutput &)> callback)
• Java: void registerScriptOutputFeedback(Consumer<ScriptOutput> callback)
• Python: 无

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

void OnScriptOutput(object outputData)
{
    try
    {
        Debug.Log($"[ScriptOutputCallback] Received script output: {outputData}");
        
        // 尝试解析脚本输出数据
        string outputText = "【脚本输出】\n";
        
        if (outputData == null)
        {
            outputText += "输出数据为空";
        }
        else
        {
            // 使用反射或类型转换解析输出数据
            var dataType = outputData.GetType();
            outputText += $"数据类型: {dataType.Name}\n";
            outputText += $"详细信息: {outputData}\n";
            
            // 尝试获取常见字段
            try
            {
                var taskIdProp = dataType.GetProperty("task_id") ?? dataType.GetProperty("taskId");
                var outputProp = dataType.GetProperty("output") ?? dataType.GetProperty("content");
                var timestampProp = dataType.GetProperty("timestamp");
                
                if (taskIdProp != null)
                {
                    var taskId = taskIdProp.GetValue(outputData);
                    outputText += $"任务ID: {taskId}\n";
                }
                
                if (timestampProp != null)
                {
                    var timestamp = timestampProp.GetValue(outputData);
                    outputText += $"时间戳: {timestamp}\n";
                }
                
                if (outputProp != null)
                {
                    var output = outputProp.GetValue(outputData);
                    outputText += $"输出内容:\n{output}\n";
                }
            }
            catch (Exception parseEx)
            {
                Debug.LogWarning($"Failed to parse script output fields: {parseEx.Message}");
            }
        }
    }
    catch (Exception ex)
    {
        Debug.LogError($"Error in OnScriptOutput: {ex.Message}\n{ex.StackTrace}");
    }
}

bool success = _robotTaskClient.RegisterScriptOutputCallback(OnScriptOutput);
if (success)
{
    Debug.Log("✓ Script output callback registered successfully");
}
else
{
    Debug.LogError("✗ Failed to register script output callback");
}

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.registerScriptOutputFeedback(new Consumer<ScriptOutput>() {
    @Override
    public void accept(ScriptOutput output) {
        logger.info("ScriptOutput with task_id: " + output.task_id + 
                    ", Output Type: " + output.output_type +
                    ", Content: " + output.content +
                    ", Timestamp: " + output.timestamp);
    }
});

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setScriptOutputCallback([](const Lenovo::Daystar::ScriptOutput &output) {
    std::cout << "[回调] 脚本输出: 级别=" << output.level 
        << ", 内容=" << output.output << std::endl;
});
std::cout << "✓ 脚本输出回调已注册" << std::endl;

UnregisterScriptOutputCallback

函数原型

• C#: bool UnregisterScriptOutputCallback()
• C++: void setScriptOutputCallback(nullptr)
• Java: void unregisterScriptOutputFeedback()
• Python: 无

功能说明

取消任务脚本输出监听回调。

参数说明

无

返回值

• C#: bool (是否成功)
• C++/Java: void

调用示例

// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

bool success = _robotTaskClient.UnregisterScriptOutputCallback();
if (success)
{
    Debug.Log("✓ Script output callback unregistered successfully");
}
else
{
    Debug.LogError("✗ Failed to unregister script output callback");
}

// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.unregisterScriptOutputFeedback();

// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setScriptOutputCallback(nullptr); 
std::cout << "✓ 脚本输出回调已注销" << std::endl;