Common Task Service Interface

Function	C++	Python	C#	Java
Create Task	✔	✔	✔	✔
Dry Run Task	✔	✔	✔	✔
Execute Task	✔	✔	✔	✔
Pause Task	✔	✔	✔	✔
Resume Task	✔	✔	✔	✔
Stop Task	✔	✔	✔	✔
Delete Task	✔	✔	✔	✔
Get Task List	✔	✔	✔	✔
Listen Task Status	✔	✔	✔	✔
Unregister Task Status	✔	✔	✔	✔
Listen Task Script	✔	-	✔	✔
Unregister Task Script	✔	-	✔	✔

CreateTask

Function Prototypes

• 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)

Function Description

Creates a common task.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Required	Task identifier
scriptContent	string	Required	Task script content
timeout	int	Optional	Timeout (supported by some languages)

Return Value

Language	Return Type	Description
C#	RobotTaskOperationResponse	Contains success(bool) and message(string)
C++	TaskOperationReply	Contains success(bool) and message(string)
Python	dict	Contains success(bool) and message(string)
Java	void	No return value

Code Example

// 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

# Init Client
with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.create_task("task_001", "print('hello')")
    if success:
        print("Task created successfully, result：", result_dict)
    else:
        print("Task creation failed, error message：", 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("Create task failed: " + 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 << "✓ Task created successfully: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task creation failed: " << result.message << std::endl;
}

Task Script Content Example

The following example is a navigation task. You can also add tasks such as gimbal control, manipulation, and charging docking. For a complete introduction and examples of common task scripts, please visit http://im.daystar.cloud:8000/

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

# Use this for outdoor waypoints
travel_params_road = MsgTravelParams() # Outdoor waypoint navigation parameters, open obstacle avoidance, ignore orientation
travel_params_road.speed_mode = 2  # HIGH speed
travel_params_road.distance_tolerance = 0.3  # 30cm distance tolerance
travel_params_road.gait = 2  # TROT gait
travel_params_road.disable_body_obstacle_avoidance = False  # Enable obstacle avoidance
travel_params_road.ignore_final_yaw = True  # Ignore target orientation
travel_params_road.path_following_mode = 1  # Default line following
travel_params_road.direction_constraint = 1  # No direction constraint

# Use this for stair endpoints
travel_params_stair = MsgTravelParams() # Stair navigation parameters, close obstacle avoidance, ignore orientation
travel_params_stair.speed_mode = 2  # LOW speed
travel_params_stair.distance_tolerance = 0.3  # 30cm distance tolerance
travel_params_stair.gait = 2  # TROT gait
travel_params_stair.disable_body_obstacle_avoidance = True  # Disable obstacle avoidance
travel_params_stair.ignore_final_yaw = True  # Ignore target orientation
travel_params_stair.path_following_mode = 1  # Default line following
travel_params_stair.direction_constraint = 1  # No direction constraint


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

def nav_failed_callback(event: NavFailedEvent):
    print(f"✗ Navigation failed: {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

Function Prototypes

• 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)

Function Description

Executes a common task. If taskId is not empty, it executes an existing task. If taskId is empty and scriptContent is not empty, it dry runs the script.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Optional	Task identifier (required for existing tasks)
scriptContent	string	Optional	Script content (required for dry run)
timeout	int	Optional	Timeout

Return Value

Same as CreateTask, Java returns void.

Code Example

private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

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

// C# Execute an existing task
var result_1 = _robotTaskClient.ExecuteTask("task_001");
// C# Test run script
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("Task created successfully, result：", result_dict)
    else:
        print("Task creation failed, error message：", 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("Execute task failed: " + 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 << "✓ Task executed: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task execution failed: " << result.message << std::endl;
}

Notes

1. Before executing a task, ensure that the current navigation status is localization successful and the current position can be obtained.
2. How to verify? You can check it in the SDK visualization tool. For detailed usage, refer to the chapter Application Development - Visualization Tool.

PauseTask

Function Prototypes

• 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)

Function Description

Pauses the specified task.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Required	Task identifier

Return Value

Same as CreateTask, Java returns void.

Code Example

// 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("Task paused successfully, result：", result_dict)
    else:
        print("Task paused failed, error message：", 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("Failed to pause task: " + 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 << "✓ Task paused: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to pause the task: " << result.message << std::endl;
}

ResumeTask

Function Prototypes

• 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)

Function Description

Resumes a paused task.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Required	Task identifier

Return Value

Same as CreateTask, Java returns void.

Code Example

// 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("Task resumed successfully, result：", result_dict)
    else:
        print("Task resumed failed, error message：", 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("Task resumed failed: " + 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 << "✓ Task resumed: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task resumed failed: " << result.message << std::endl;
}

StopTask

Function Prototypes

• 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)

Function Description

Stops the specified task.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Required	Task identifier

Return Value

Same as CreateTask, Java returns void.

Code Example

// 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("Task stopped successfully, result：", result_dict)
    else:
        print("Failed to stop the task, error message：", 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("Failed to stop the task: " + 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 << "✓ Task stopped: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to stop the task: " << result.message << std::endl;
}

DeleteTask

Function Prototypes

• 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)

Function Description

Deletes the specified task.

Parameters

Parameter Name	Type	Required/Default	Description
taskId	string	Required	Task identifier

Return Value

Same as CreateTask, Java returns void.

Code Example

// 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("Task deleted successfully, result：", result_dict)
    else:
        print("Failed to delete task, error message：", 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("Failed to delete task: " + 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 << "✓ Task deleted: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to delete the task: " << result.message << std::endl;
}

GetAllTasks

Function Prototypes

• 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()

Function Description

Retrieves the list of all created tasks.

Parameters

None

Return Value

Language	Return Type	Description
C#	RobotTaskOperationResponse	Parsed to get task list
C++	GetAllTasksReply	Contains std::vector<std::string> tasks
Python	dict	Contains task_ids list
Java	List<String>	Returns task ID list directly

Code Example

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

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

var result = _robotTaskClient.GetAllTasks();
if (result.success)
{
    string taskList = "Task List:\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 += "No tasks";
    }
    
    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: {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 << "✓ Task List(" << result.task_ids.size() << "task):" << 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 << "✗ Failed to get task list: " << result.message << std::endl;
}

RegisterTaskStatusCallback

Function Prototypes

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

Function Description

Registers a callback to listen for task status updates.

Parameters

Parameter Name	Type	Required/Default	Description
callback	function	Required	Callback function, receives the task status object

Return Value

• C#: bool (success)
• Python: bool (success)
• C++/Java: void

Code Example

// 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}");
        
        // Attempt to parse task status data
        string statusText = "【Task Status Update】\n";
        
        if (statusData == null)
        {
            statusText += "Status data is null";
        }
        else
        {
            // Parse status data using reflection or type conversion
            var dataType = statusData.GetType();
            statusText += $"Data Type: {dataType.Name}\n";
            statusText += $"Details: {statusData}\n";
            
            // Attempt to get common fields
            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 += $"Task ID: {taskId}\n";
                }
                
                if (statusProp != null)
                {
                    var status = statusProp.GetValue(statusData);
                    statusText += $"Status: {status}\n";
                }
                
                if (messageProp != null)
                {
                    var message = messageProp.GetValue(statusData);
                    statusText += $"Message: {message}\n";
                }
                
                if (progressProp != null)
                {
                    var progress = progressProp.GetValue(statusData);
                    statusText += $"Progress: {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 << "[Callback] Task status update: ID=" << task_status.task_id 
        << ", Status=" << task_status.status 
        << ", Message=" << task_status.message << std::endl;
});
std::cout << "✓ Task status callback registered" << std::endl;

RegisterScriptOutputCallback

Function Prototypes

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

Function Description

Registers a callback to listen for script execution output.

Parameters

Parameter Name	Type	Required/Default	Description
callback	function	Required	Callback function, receives the script output object

Return Value

None

Code Example

// 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}");
        
        // Attempt to parse script output data
        string outputText = "【Script Output】\n";
        
        if (outputData == null)
        {
            outputText += "Output data is null";
        }
        else
        {
            // Parse output data using reflection or type conversion
            var dataType = outputData.GetType();
            outputText += $"Data Type: {dataType.Name}\n";
            outputText += $"Details: {outputData}\n";
            
            // Attempt to get common fields
            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 += $"Task ID: {taskId}\n";
                }
                
                if (timestampProp != null)
                {
                    var timestamp = timestampProp.GetValue(outputData);
                    outputText += $"Timestamp: {timestamp}\n";
                }
                
                if (outputProp != null)
                {
                    var output = outputProp.GetValue(outputData);
                    outputText += $"Output Content:\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");
}

// 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 << "[Callback] Script output: Level=" << output.level 
        << ", Content=" << output.output << std::endl;
});
std::cout << "✓ Script output callback registered successfully" << std::endl;

UnregisterTaskStatusCallback

Function Prototypes

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

Function Description

Unregisters the task status callback.

Parameters

None

Return Value

• C#: bool (Success)
• Python: bool (Success)
• C++/Java: void

Code Example

// 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 << "✓ Task status callback unregistered successfully" << std::endl;

UnregisterScriptOutputCallback

Function Prototypes

• C#: bool UnregisterScriptOutputCallback()
• C++: void setScriptOutputCallback(nullptr)
• Java: void unregisterScriptOutputFeedback()
• Python: N/A

Function Description

Unregisters the script output callback.

Parameters

None

Return Value

• C#: bool (Success)
• C++/Java: void

Code Example

// 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 << "✓ Script output callback unregistered successfully" << std::endl;