/*
* Copyright (C) 2024 KylinSoft Co., Ltd.
*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see .
*/
#include
#include
#include "exampleglue.h"
#include "log.h"
#include "response.h"
using namespace std;
GDBusConnection* connection;
AiBusinessExample* proxy;
GMainLoop* loop;
const char* objectPath = "/com/kylin/AiBusiness/example";
const char* interfaceName = "com.kylinos.aisdk.business.example";
// 同步接口
void callMethod1() {
gchar* output;
string param = R"({"input1":"hello","input2":"world","input3":10})";
GError* error = nullptr;
gboolean success = ai_business_example_call_sync_method_sync(proxy, param.c_str(), &output, nullptr, &error);
if (!success) {
if (error) {
PRINT_ERROR("Call method1 Error: %s\n", error->message);
g_error_free(error);
return;
}
}
PRINT_INFO("Call method1 result: %s\n", output);
}
void callBack2(GObject* source_object, GAsyncResult* res, gpointer user_data) {
PRINT_INFO("callBack2 回调成功\n");
GError* error = nullptr;
gchar* out_response;
ai_business_example_call_async_method_finish((AiBusinessExample*)source_object, &out_response, res, &error);
if (error) {
PRINT_ERROR("Call method2 Error: %s\n", error->message);
g_error_free(error);
return;
}
PRINT_INFO("Call method2 response: %s\n", out_response);
}
// 异步接口
void callMethod2() {
string param = R"({"input1":"method2","input2":"world","input3":10})";
ai_business_example_call_async_method(proxy, param.c_str(), nullptr, callBack2, nullptr);
PRINT_INFO("Call method2 success.\n");
}
void callBack3Continue(GDBusConnection* conn, const gchar* sender_name, const gchar* object_path,
const gchar* interface_name, const gchar* signal_name, GVariant* parameters,
gpointer user_data) {
PRINT_INFO("callBack3Continue 流式返回\n");
// cout << sender_name << endl; 打印有问题
// cout << object_path << endl;
// cout << interface_name << endl;
// cout << signal_name << endl;
Response response = Response::parseFromGVariant(parameters);
PRINT_INFO("callBack3Continue response: %s\n", response.toString().c_str());
if (!response.isSuccess()) {
g_main_loop_quit(loop);
}
}
void callBack3(GObject* source_object, GAsyncResult* res, gpointer user_data) {
PRINT_INFO("callBack3 回调成功\n");
GError* error = nullptr;
char* out_response;
ai_business_example_call_async_flow_method_finish(reinterpret_cast(source_object),
&out_response, res, &error);
if (error) {
PRINT_ERROR("Call method3 Error: %s\n", error->message);
g_error_free(error);
return;
}
PRINT_INFO("Call method3 response: %s\n", out_response);
}
// 异步流式返回接口
void callMethod3() {
string param = R"({"request":"method3"})";
ai_business_example_call_async_flow_method(proxy, param.c_str(), nullptr, nullptr, nullptr);
PRINT_INFO("call method3 success.\n");
}
void startServer() {
GError* error = nullptr;
PRINT_INFO("start connect\n");
std::string serverUnixPath =
"unix:abstract=/tmp/.kylin-ai-business-unix/" + std::to_string(getuid()) + "/example.sock";
connection = g_dbus_connection_new_for_address_sync(
serverUnixPath.c_str(), G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, nullptr, nullptr, &error);
if (connection == nullptr) {
PRINT_ERROR("Error connecting to D-Bus address %s: %s\n", serverUnixPath.c_str(), error->message);
g_error_free(error);
return;
}
PRINT_INFO("Connected. Negotiated capabilities: unix-fd-passing=%d\n",
g_dbus_connection_get_capabilities(connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
proxy =
ai_business_example_proxy_new_sync(connection, G_DBUS_PROXY_FLAGS_NONE, nullptr, objectPath, nullptr, &error);
if (proxy == nullptr) {
PRINT_ERROR("Error creating speech processor proxy %s: %s\n", objectPath, error->message);
g_error_free(error);
return;
}
PRINT_INFO("connected server.\n");
}
int main() {
startServer();
// 同步请求
callMethod1();
callMethod1();
// 异步请求
callMethod2();
callMethod2();
// 异步流式返回
unsigned int ret =
g_dbus_connection_signal_subscribe(connection, nullptr, interfaceName, "callBack3Continue", objectPath, nullptr,
G_DBUS_SIGNAL_FLAGS_NONE, callBack3Continue, nullptr, nullptr);
std::cout << "g_dbus_connection_signal_subscribe ret = " << ret << std::endl;
callMethod3();
callMethod3();
loop = g_main_loop_new(nullptr, false);
g_main_loop_run(loop);
return 0;
}