feat: add startGraphCmd in go binding

Author: sunxilin

core/src/ten_runtime/binding/go/interface/ten/cmd.go

@@ -26,6 +26,14 @@ type Cmd interface {
 	Clone() (Cmd, error)
 }
 
+type StartGraphCmd interface {
+	Cmd
+
+	SetPredefinedGraphName(predefinedGraphName string) error
+	SetGraphFromJSONBytes(graphJsonBytes []byte) error
+	SetLongRunningMode(longRunningMode bool) error
+}
+
 // NewCmd creates a custom cmd which is intended to be sent to another
 // extension using tenEnv.SendCmd().
 func NewCmd(cmdName string) (Cmd, error) {
@@ -106,6 +114,23 @@ func NewCmd(cmdName string) (Cmd, error) {
 	return newCmd(bridge), nil
 }
 
+func NewStartGraphCmd() (StartGraphCmd, error) {
+	var bridge C.uintptr_t
+	err := withCGOLimiter(func() error {
+		cStatus := C.ten_go_cmd_create_start_graph_cmd(
+			&bridge,
+		)
+		e := withCGoError(&cStatus)
+
+		return e
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return newStartGraphCmd(bridge), nil
+}
+
 type cmd struct {
 	*msg
 }
@@ -116,6 +141,16 @@ func newCmd(bridge C.uintptr_t) *cmd {
 	}
 }
 
+type startGraphCmd struct {
+	*cmd
+}
+
+func newStartGraphCmd(bridge C.uintptr_t) *startGraphCmd {
+	return &startGraphCmd{
+		cmd: newCmd(bridge),
+	}
+}
+
 func (p *cmd) Clone() (Cmd, error) {
 	var bridge C.uintptr_t
 	err := withCGOLimiter(func() error {
@@ -141,4 +176,49 @@ func (p *cmd) Clone() (Cmd, error) {
 	return newCmd(bridge), nil
 }
 
+func (p *startGraphCmd) SetPredefinedGraphName(predefinedGraphName string) error {
+	defer p.keepAlive()
+
+	err := withCGOLimiter(func() error {
+		apiStatus := C.ten_go_cmd_start_graph_set_predefined_graph_name(
+			p.getCPtr(),
+			unsafe.Pointer(unsafe.StringData(predefinedGraphName)),
+			C.int(len(predefinedGraphName)),
+		)
+		return withCGoError(&apiStatus)
+	})
+
+	return err
+}
+
+func (p *startGraphCmd) SetGraphFromJSONBytes(graphJsonBytes []byte) error {
+	defer p.keepAlive()
+
+	err := withCGOLimiter(func() error {
+		apiStatus := C.ten_go_cmd_start_graph_set_graph_from_json_bytes(
+			p.getCPtr(),
+			unsafe.Pointer(unsafe.SliceData(graphJsonBytes)),
+			C.int(len(graphJsonBytes)),
+		)
+		return withCGoError(&apiStatus)
+	})
+
+	return err
+}
+
+func (p *startGraphCmd) SetLongRunningMode(longRunningMode bool) error {
+	defer p.keepAlive()
+
+	err := withCGOLimiter(func() error {
+		apiStatus := C.ten_go_cmd_start_graph_set_long_running_mode(
+			p.getCPtr(),
+			C.bool(longRunningMode),
+		)
+		return withCGoError(&apiStatus)
+	})
+
+	return err
+}
+
 var _ Cmd = new(cmd)
+var _ StartGraphCmd = new(startGraphCmd)

core/src/ten_runtime/binding/go/interface/ten/cmd.h

@@ -54,3 +54,15 @@ ten_go_handle_t ten_go_cmd_result_get_detail(uintptr_t bridge_addr);
 
 ten_go_error_t ten_go_cmd_result_get_detail_json_and_size(
     uintptr_t bridge_addr, uintptr_t *json_str_len, const char **json_str);
+
+ten_go_error_t ten_go_cmd_create_start_graph_cmd(uintptr_t *bridge);
+
+ten_go_error_t ten_go_cmd_start_graph_set_predefined_graph_name(
+    uintptr_t bridge_addr, const void *predefined_graph_name,
+    int predefined_graph_name_len);
+
+ten_go_error_t ten_go_cmd_start_graph_set_graph_from_json_bytes(
+    uintptr_t bridge_addr, const void *json_bytes, int json_bytes_len);
+
+ten_go_error_t ten_go_cmd_start_graph_set_long_running_mode(
+    uintptr_t bridge_addr, bool long_running_mode);

core/src/ten_runtime/binding/go/native/msg/cmd/cmd.c

@@ -14,6 +14,7 @@
 #include "ten_runtime/binding/go/interface/ten/msg.h"
 #include "ten_runtime/common/status_code.h"
 #include "ten_runtime/msg/cmd/cmd.h"
+#include "ten_runtime/msg/cmd/start_graph/cmd.h"
 #include "ten_runtime/msg/cmd_result/cmd_result.h"
 #include "ten_utils/lib/error.h"
 #include "ten_utils/lib/smart_ptr.h"
@@ -213,3 +214,105 @@ ten_go_error_t ten_go_cmd_result_clone(uintptr_t bridge_addr,
 
   return cgo_error;
 }
+
+ten_go_error_t ten_go_cmd_create_start_graph_cmd(uintptr_t *bridge) {
+  ten_go_error_t cgo_error;
+  ten_go_error_init_with_error_code(&cgo_error, TEN_ERROR_CODE_OK);
+
+  ten_shared_ptr_t *c_cmd = ten_cmd_start_graph_create();
+  TEN_ASSERT(c_cmd && ten_cmd_check_integrity(c_cmd), "Should not happen.");
+
+  ten_go_msg_t *msg_bridge = ten_go_msg_create(c_cmd);
+  TEN_ASSERT(msg_bridge, "Should not happen.");
+
+  *bridge = (uintptr_t)msg_bridge;
+  ten_shared_ptr_destroy(c_cmd);
+
+  return cgo_error;
+}
+
+ten_go_error_t ten_go_cmd_start_graph_set_predefined_graph_name(
+    uintptr_t bridge_addr, const void *predefined_graph_name,
+    int predefined_graph_name_len) {
+  ten_go_msg_t *msg_bridge = ten_go_msg_reinterpret(bridge_addr);
+  TEN_ASSERT(msg_bridge && ten_go_msg_check_integrity(msg_bridge),
+             "Should not happen.");
+
+  ten_go_error_t cgo_error;
+  ten_go_error_init_with_error_code(&cgo_error, TEN_ERROR_CODE_OK);
+
+  ten_string_t predefined_graph_name_str;
+  ten_string_init_from_c_str_with_size(&predefined_graph_name_str,
+                                       predefined_graph_name,
+                                       predefined_graph_name_len);
+
+  ten_error_t err;
+  TEN_ERROR_INIT(err);
+
+  bool success = ten_cmd_start_graph_set_predefined_graph_name(
+      ten_go_msg_c_msg(msg_bridge),
+      ten_string_get_raw_str(&predefined_graph_name_str), &err);
+
+  if (!success) {
+    ten_go_error_set(&cgo_error, ten_error_code(&err), ten_error_message(&err));
+  }
+
+  ten_error_deinit(&err);
+  ten_string_deinit(&predefined_graph_name_str);
+
+  return cgo_error;
+}
+
+ten_go_error_t ten_go_cmd_start_graph_set_graph_from_json_bytes(
+    uintptr_t bridge_addr, const void *json_bytes, int json_bytes_len) {
+  ten_go_msg_t *msg_bridge = ten_go_msg_reinterpret(bridge_addr);
+  TEN_ASSERT(msg_bridge && ten_go_msg_check_integrity(msg_bridge),
+             "Should not happen.");
+
+  ten_go_error_t cgo_error;
+  ten_go_error_init_with_error_code(&cgo_error, TEN_ERROR_CODE_OK);
+
+  ten_string_t json_str_str;
+  ten_string_init_from_c_str_with_size(&json_str_str, json_bytes,
+                                       json_bytes_len);
+
+  ten_error_t err;
+  TEN_ERROR_INIT(err);
+
+  bool success = ten_cmd_start_graph_set_graph_from_json_str(
+      ten_go_msg_c_msg(msg_bridge), ten_string_get_raw_str(&json_str_str),
+      &err);
+
+  if (!success) {
+    ten_go_error_set(&cgo_error, ten_error_code(&err), ten_error_message(&err));
+  }
+
+  ten_error_deinit(&err);
+  ten_string_deinit(&json_str_str);
+
+  return cgo_error;
+}
+
+ten_go_error_t ten_go_cmd_start_graph_set_long_running_mode(
+    uintptr_t bridge_addr, bool long_running_mode) {
+  ten_go_msg_t *msg_bridge = ten_go_msg_reinterpret(bridge_addr);
+  TEN_ASSERT(msg_bridge && ten_go_msg_check_integrity(msg_bridge),
+             "Should not happen.");
+
+  ten_go_error_t cgo_error;
+  ten_go_error_init_with_error_code(&cgo_error, TEN_ERROR_CODE_OK);
+
+  ten_error_t err;
+  TEN_ERROR_INIT(err);
+
+  bool success = ten_cmd_start_graph_set_long_running_mode(
+      ten_go_msg_c_msg(msg_bridge), long_running_mode, &err);
+
+  if (!success) {
+    ten_go_error_set(&cgo_error, ten_error_code(&err), ten_error_message(&err));
+  }
+
+  ten_error_deinit(&err);
+
+  return cgo_error;
+}

tests/ten_runtime/integration/go/BUILD.gn

@@ -32,6 +32,8 @@ group("go") {
       "send_data_go",
       "send_video_frame_go",
       "start_app_sync_go",
+      "start_graph_go",
+      "start_predefined_graph_go",
       "three_extension_cmd_go",
       "transfer_pointer_go",
       "two_extension_one_group_cmd_go",

tests/ten_runtime/integration/go/start_graph_go/BUILD.gn

@@ -0,0 +1,65 @@
+#
+# Copyright © 2025 Agora
+# This file is part of TEN Framework, an open source project.
+# Licensed under the Apache License, Version 2.0, with certain conditions.
+# Refer to the "LICENSE" file in the root directory for more information.
+#
+import("//build/ten_runtime/feature/test.gni")
+import("//build/ten_runtime/ten.gni")
+
+ten_package_test_prepare_app("start_graph_go_app") {
+  src_app = "default_app_go"
+  src_app_language = "go"
+  generated_app_src_root_dir_name = "start_graph_go_app"
+
+  replace_paths_after_install_app = [
+    "start_graph_go_app/manifest.json",
+    "start_graph_go_app/property.json",
+    "start_graph_go_app/ten_packages/extension/default_extension_go/extension.go",
+    "start_graph_go_app/ten_packages/extension/default_extension_go/go.mod",
+    "start_graph_go_app/ten_packages/extension/default_extension_go/manifest.json",
+    "start_graph_go_app/ten_packages/extension/default_extension_go/property.json",
+  ]
+
+  if (ten_enable_go_app_leak_check) {
+    replace_paths_after_install_app += [ "start_graph_go_app/main.go" ]
+  }
+
+  deps = [
+    "//core/src/ten_manager",
+    "//packages/core_apps/default_app_go:upload_default_app_go_to_server",
+    "//packages/core_extensions/default_extension_go:upload_default_extension_go_to_server",
+    "//packages/example_extensions/simple_http_server_cpp:upload_simple_http_server_cpp_to_server",
+  ]
+}
+
+ten_package_test_prepare_auxiliary_resources("start_graph_go_app_test_files") {
+  resources = [
+    "__init__.py",
+    "test_case.py",
+  ]
+
+  common_files =
+      exec_script("//.gnfiles/build/scripts/glob_file.py",
+                  [
+                    "--dir",
+                    rebase_path("//tests/ten_runtime/integration/common/**/*"),
+                    "--dir-base",
+                    rebase_path("//tests/ten_runtime/integration/common"),
+                    "--recursive",
+                    "--only-output-file",
+                  ],
+                  "json")
+
+  foreach(common_file, common_files) {
+    common_file_rel_path = common_file.relative_path
+    resources += [ "//tests/ten_runtime/integration/common/${common_file_rel_path}=>common/${common_file_rel_path}" ]
+  }
+}
+
+group("start_graph_go") {
+  deps = [
+    ":start_graph_go_app",
+    ":start_graph_go_app_test_files",
+  ]
+}

tests/ten_runtime/integration/go/start_graph_go/__init__.py

@@ -0,0 +1,60 @@
+//
+// This file is part of TEN Framework, an open source project.
+// Licensed under the Apache License, Version 2.0.
+// See the LICENSE file for more information.
+//
+
+package main
+
+// void __lsan_do_leak_check(void);
+import "C"
+
+import (
+	"fmt"
+	"runtime"
+	"runtime/debug"
+	"time"
+
+	"ten_framework/ten"
+)
+
+type defaultApp struct {
+	ten.DefaultApp
+}
+
+func (p *defaultApp) OnInit(tenEnv ten.TenEnv) {
+	tenEnv.LogDebug("onInit")
+	tenEnv.OnInitDone()
+}
+
+func (p *defaultApp) OnDeinit(tenEnv ten.TenEnv) {
+	tenEnv.LogDebug("onDeinit")
+	tenEnv.OnDeinitDone()
+}
+
+func main() {
+	// test app
+	app, err := ten.NewApp(&defaultApp{})
+	if err != nil {
+		fmt.Println("Failed to create app.")
+	}
+
+	app.Run(true)
+	app.Wait()
+
+	// A single GC is not enough; multiple rounds of GC are needed to clean up
+	// as thoroughly as possible.
+	for i := 0; i < 10; i++ {
+		// Explicitly trigger GC to increase the likelihood of finalizer
+		// execution.
+		debug.FreeOSMemory()
+		runtime.GC()
+
+		// Wait for a short period to give the GC time to run.
+		runtime.Gosched()
+		time.Sleep(1 * time.Second)
+	}
+
+	// To detect memory leaks with ASan, need to enable the following cgo code.
+	C.__lsan_do_leak_check()
+}