From: sooyeon Date: Fri, 3 Jun 2022 09:10:20 +0000 (+0900) Subject: Replace IPC (VCC) from dbus to tidl X-Git-Tag: submit/tizen/20220801.042437~22 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F57%2F278957%2F1;p=platform%2Fcore%2Fuifw%2Fvoice-control.git Replace IPC (VCC) from dbus to tidl Change-Id: Ief592a9240490c404b756b37cb7b887c3a974321 Signed-off-by: sooyeon --- diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index ab5f35f..0001ef9 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -2,7 +2,8 @@ SET(SRCS vc.c vc_data.cpp vc_client.c - vc_dbus.c +# vc_dbus.c + vc_tidl.c ../common/vc_cmd_db.c ../common/vc_command.c ../common/vc_command_util.c diff --git a/client/vc.c b/client/vc.c index f42cc66..0688716 100644 --- a/client/vc.c +++ b/client/vc.c @@ -30,7 +30,8 @@ #include "vc_command.h" #include "vc_config_mgr.h" #include "vc_data.h" -#include "vc_dbus.h" +// #include "vc_dbus.h" +#include "vc_tidl.h" #include "vc_info_parser.h" #include "vc_json_parser.h" #include "vc_main.h" @@ -268,7 +269,7 @@ static Eina_Bool __focus_changed_cb(void *data, int type, void *event) int ret; if (ECORE_WL2_EVENT_FOCUS_IN == type) { SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); - ret = vc_dbus_set_foreground(getpid(), true); + ret = vc_tidl_request_set_foreground(getpid(), true); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); } @@ -291,7 +292,7 @@ static Eina_Bool __focus_changed_cb(void *data, int type, void *event) } } else if (ECORE_WL2_EVENT_FOCUS_OUT == type) { SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background"); - ret = vc_dbus_set_foreground(getpid(), false); + ret = vc_tidl_request_set_foreground(getpid(), false); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret); } @@ -344,7 +345,7 @@ int vc_initialize(void) return VC_ERROR_NONE; //LCOV_EXCL_LINE } - if (0 != vc_dbus_open_connection()) { + if (0 != vc_tidl_open_connection()) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection"); //LCOV_EXCL_LINE return VC_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } @@ -391,7 +392,7 @@ static void __vc_internal_unprepare(void) } } - int ret = vc_dbus_request_finalize(g_vc->handle); + int ret = vc_tidl_request_finalize(g_vc->handle); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE } @@ -471,7 +472,7 @@ int vc_deinitialize(void) SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret); //LCOV_EXCL_LINE } - if (0 != vc_dbus_close_connection()) { + if (0 != vc_tidl_close_connection()) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE } @@ -506,7 +507,7 @@ static Eina_Bool __vc_connect_daemon(void *data) if (0 != ret) SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE - ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid); + ret = vc_tidl_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid); //LCOV_EXCL_START if (VC_ERROR_ENGINE_NOT_FOUND == ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret)); @@ -565,7 +566,7 @@ static Eina_Bool __vc_connect_daemon(void *data) int status = aul_app_get_status(appid); if (STATUS_FOCUS == status) { SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); //LCOV_EXCL_LINE - ret = vc_dbus_set_foreground(getpid(), true); + ret = vc_tidl_request_set_foreground(getpid(), true); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE } @@ -614,7 +615,7 @@ static void __start_prepare_thread(void *data, Ecore_Thread *thread) return; } - ret = vc_dbus_request_hello(); + ret = vc_tidl_request_hello(); if (ret == 0) { SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count); break; @@ -964,7 +965,7 @@ int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list) int ret = -1; bool is_prepared = false; do { - ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid); + ret = vc_tidl_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid); if (0 != ret) { //LCOV_EXCL_START if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { @@ -1211,7 +1212,7 @@ int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type) int count = 0; bool is_prepared = false; do { - ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type); + ret = vc_tidl_request_set_command(g_vc->handle, (vc_cmd_type_e)type); if (0 != ret) { //LCOV_EXCL_START if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { @@ -1276,7 +1277,7 @@ int vc_unset_command_list(int type) int ret = -1; bool is_prepared = false; while (0 != ret) { - ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type); + ret = vc_tidl_request_unset_command(g_vc->handle, (vc_cmd_type_e)type); if (0 != ret) { //LCOV_EXCL_START if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { @@ -1366,7 +1367,7 @@ int vc_set_command_list_from_file(const char* file_path, int type) int count = 0; bool is_prepared = false; do { - ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type); + ret = vc_tidl_request_set_command(g_vc->handle, (vc_cmd_type_e)type); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -2280,7 +2281,7 @@ int vc_set_server_dialog(const char* app_id, const char* credential) int count = 0; bool is_prepared = false; do { - ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential); + ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -2364,7 +2365,7 @@ int vc_unset_server_dialog(const char* app_id) bool is_prepared = false; char* credential = strdup("#NULL"); do { - ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential); + ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -2431,7 +2432,7 @@ int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_sta } SLOG(LOG_DEBUG, TAG_VCC, "Request dialog : pid(%d) disp_text(%s), utt_text(%s), auto_start(%d)", getpid(), disp_text, utt_text, auto_start); - int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start); + int ret = vc_tidl_request_request_dialog(getpid(), disp_text, utt_text, auto_start); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret); return VC_ERROR_OPERATION_FAILED; @@ -2477,7 +2478,7 @@ int vc_auth_enable(void) return VC_ERROR_OPERATION_FAILED; } - if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) { + if (0 != vc_tidl_request_auth_enable(g_vc->handle, mgr_pid)) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled"); return VC_ERROR_OPERATION_FAILED; } @@ -2537,14 +2538,14 @@ int vc_auth_disable(void) SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb"); } - /* request return authority by dbus */ + /* request return authority by tidl */ int mgr_pid = -1; if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info"); return VC_ERROR_OPERATION_FAILED; } - if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) { + if (0 != vc_tidl_request_auth_disable(g_vc->handle, mgr_pid)) { SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable"); return VC_ERROR_OPERATION_FAILED; } @@ -2697,7 +2698,7 @@ int vc_auth_start(void) bool is_prepared = false; /* Request */ while (0 != ret) { - ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid); + ret = vc_tidl_request_auth_start(g_vc->handle, mgr_pid); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -2778,7 +2779,7 @@ int vc_auth_stop(void) bool is_prepared = false; /* do request */ while (0 != ret) { - ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid); + ret = vc_tidl_request_auth_stop(g_vc->handle, mgr_pid); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -2858,7 +2859,7 @@ int vc_auth_cancel(void) int count = 0; bool is_prepared = false; while (0 != ret) { - ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid); + ret = vc_tidl_request_auth_cancel(g_vc->handle, mgr_pid); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -3044,7 +3045,7 @@ int vc_tts_request(const char* text, const char* language, bool to_vc_manager, i int count = 0; bool is_prepared = false; do { - ret = vc_dbus_request_tts(pid, text, language, to_vc_manager, utt_id); + ret = vc_tidl_request_request_tts(pid, text, language, to_vc_manager, utt_id); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -3119,7 +3120,7 @@ int vc_tts_cancel(int utt_id) int count = 0; bool is_prepared = false; do { - ret = vc_dbus_cancel_tts(pid, utt_id); + ret = vc_tidl_request_cancel_tts(pid, utt_id); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); @@ -3189,7 +3190,7 @@ int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel, int count = 0; bool is_prepared = false; do { - ret = vc_dbus_get_tts_audio_format(pid, rate, channel, audio_type); + ret = vc_tidl_request_get_tts_audio_format(pid, rate, channel, audio_type); if (0 != ret) { if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) { vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED); diff --git a/client/vc_proxy.c b/client/vc_proxy.c new file mode 100755 index 0000000..d55b82d --- /dev/null +++ b/client/vc_proxy.c @@ -0,0 +1,2869 @@ +/* + * Generated by tidlc 1.8.1. + */ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vc_proxy.h" + +#undef LOG_TAG +#define LOG_TAG "RPC_PORT_PROXY" + +#undef _E +#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _W +#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _I +#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _D +#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#ifndef TIDL_VERSION +#define TIDL_VERSION "1.8.1" +#endif + +#ifndef nullptr +#define nullptr NULL +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) +#endif + +#ifndef STRING_GET +#define STRING_GET(x) ((x) ? x : "") +#endif + +typedef void (*rpc_port_proxy_delegate_cb)(GList **delegates, rpc_port_parcel_h parcel, int id, int seq_id); + +typedef struct rpc_port_proxy_array_char_s { + rpc_port_parcelable_t parcelable; + char *value; + int size; +} rpc_port_proxy_array_char_t; + +typedef struct rpc_port_proxy_vc_notify_cb_s { + rpc_port_parcelable_t parcelable; + int id; + int seq_id; + bool once; + rpc_port_proxy_vc_notify_cb_cb callback; + void *user_data; +} rpc_port_proxy_vc_notify_cb_t; + +typedef struct rpc_port_proxy_vc_feedback_cb_s { + rpc_port_parcelable_t parcelable; + int id; + int seq_id; + bool once; + rpc_port_proxy_vc_feedback_cb_cb callback; + void *user_data; +} rpc_port_proxy_vc_feedback_cb_t; + +typedef struct rpc_port_proxy_vc_s { + char *stub_appid; + rpc_port_proxy_h proxy; + rpc_port_h port; + rpc_port_h callback_port; + rpc_port_proxy_vc_callback_s callback; + void *user_data; + GList *delegates; + GRecMutex mutex; +} rpc_port_proxy_vc_t; + +static void __rpc_port_proxy_array_char_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_array_char_h h = data; + int i; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, h->size); + + for (i = 0; i < h->size; ++i) + rpc_port_parcel_write_byte(parcel, h->value[i]); +} + +static void __rpc_port_proxy_array_char_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_array_char_h h = data; + char value; + int ret; + int i; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + ret = rpc_port_parcel_read_array_count(parcel, &h->size); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read array count. error(%d)", ret); + set_last_result(ret); + return; + } + + h->value = calloc(h->size, sizeof(char)); + if (h->value == nullptr) { + _E("Out of memory"); + set_last_result(RPC_PORT_ERROR_OUT_OF_MEMORY); + return; + } + + for (i = 0; i < h->size; ++i) { + rpc_port_parcel_read_byte(parcel, &value); + h->value[i] = value; + } + + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_proxy_array_char_create(rpc_port_proxy_array_char_h *h) +{ + rpc_port_proxy_array_char_t *handle; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_proxy_array_char_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_proxy_array_char_to; + handle->parcelable.from = __rpc_port_proxy_array_char_from; + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_array_char_destroy(rpc_port_proxy_array_char_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (h->value) + free(h->value); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_array_char_clone(rpc_port_proxy_array_char_h h, rpc_port_proxy_array_char_h *clone) +{ + rpc_port_proxy_array_char_h handle; + rpc_port_parcel_h parcel; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_array_char_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + ret = rpc_port_parcel_create(&parcel); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret); + rpc_port_proxy_array_char_destroy(handle); + return ret; + } + + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_read(parcel, &handle->parcelable, handle); + ret = get_last_result(); + rpc_port_parcel_destroy(parcel); + + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret); + rpc_port_proxy_array_char_destroy(handle); + return ret; + } + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_array_char_set(rpc_port_proxy_array_char_h h, char *value, int size) +{ + rpc_port_proxy_array_char_h handle; + rpc_port_proxy_array_char_h clone; + int ret; + + if (h == nullptr || value == nullptr || size <= 0) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_array_char_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + handle->value = (char *)value; + handle->size = size; + + ret = rpc_port_proxy_array_char_clone(handle, &clone); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to clone handle. error(%d)", ret); + handle->value = nullptr; + handle->size = 0; + rpc_port_proxy_array_char_destroy(handle); + return ret; + } + + handle->value = h->value; + handle->size = h->size; + rpc_port_proxy_array_char_destroy(handle); + + h->value = clone->value; + h->size = clone->size; + + clone->value = nullptr; + clone->size = 0; + rpc_port_proxy_array_char_destroy(clone); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_array_char_get(rpc_port_proxy_array_char_h h, char **value, int *size) +{ + rpc_port_proxy_array_char_h handle; + int ret; + + if (h == nullptr || value == nullptr || size == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_array_char_clone(h, &handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to clone handle. error(%d)", ret); + return ret; + } + + *value = handle->value; + *size = handle->size; + + handle->value = nullptr; + handle->size = 0; + rpc_port_proxy_array_char_destroy(handle); + + return RPC_PORT_ERROR_NONE; +} + +typedef enum { + RPC_PORT_PROXY_VC_DELEGATE_NOTIFY_CB = 1, + RPC_PORT_PROXY_VC_DELEGATE_FEEDBACK_CB = 2, +} rpc_port_proxy_vc_delegate_e; + +static void __rpc_port_proxy_vc_notify_cb_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_vc_notify_cb_h h = data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, h->id); + + rpc_port_parcel_write_int32(parcel, h->seq_id); + + rpc_port_parcel_write_bool(parcel, h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); +} + +static void __rpc_port_proxy_vc_notify_cb_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_vc_notify_cb_h h = data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + rpc_port_parcel_read_int32(parcel, &h->id); + + rpc_port_parcel_read_int32(parcel, &h->seq_id); + + rpc_port_parcel_read_bool(parcel, &h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_proxy_vc_notify_cb_create(rpc_port_proxy_vc_notify_cb_h *h) +{ + rpc_port_proxy_vc_notify_cb_t *handle; + static int seq_num; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_proxy_vc_notify_cb_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_proxy_vc_notify_cb_to; + handle->parcelable.from = __rpc_port_proxy_vc_notify_cb_from; + handle->id = RPC_PORT_PROXY_VC_DELEGATE_NOTIFY_CB; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + _I("id(%d), seq_id(%d)", handle->id, handle->seq_id); + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_destroy(rpc_port_proxy_vc_notify_cb_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + _W("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_clone(rpc_port_proxy_vc_notify_cb_h h, rpc_port_proxy_vc_notify_cb_h *clone) +{ + rpc_port_proxy_vc_notify_cb_h handle; + rpc_port_parcel_h parcel; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_vc_notify_cb_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + ret = rpc_port_parcel_create(&parcel); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret); + rpc_port_proxy_vc_notify_cb_destroy(handle); + return ret; + } + + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_read(parcel, &handle->parcelable, handle); + ret = get_last_result(); + rpc_port_parcel_destroy(parcel); + + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret); + rpc_port_proxy_vc_notify_cb_destroy(handle); + return ret; + } + + handle->callback = h->callback; + handle->user_data = h->user_data; + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_set_callback(rpc_port_proxy_vc_notify_cb_h h, rpc_port_proxy_vc_notify_cb_cb callback, void *user_data) +{ + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->callback = callback; + h->user_data = user_data; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_set_once(rpc_port_proxy_vc_notify_cb_h h, bool once) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->once = once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_get_id(rpc_port_proxy_vc_notify_cb_h h, int *id) +{ + if (h == nullptr || id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *id = h->id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_get_seq_id(rpc_port_proxy_vc_notify_cb_h h, int *seq_id) +{ + if (h == nullptr || seq_id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *seq_id = h->seq_id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_is_once(rpc_port_proxy_vc_notify_cb_h h, bool *once) +{ + if (h == nullptr || once == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *once = h->once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_get_tag(rpc_port_proxy_vc_notify_cb_h h, char **tag) +{ + char *new_tag; + char buf[128]; + + if (h == nullptr || tag == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + snprintf(buf, sizeof(buf), "%d::%d", h->id, h->seq_id); + new_tag = strdup(buf); + if (new_tag == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *tag = new_tag; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_notify_cb_dispose(rpc_port_proxy_vc_h proxy, rpc_port_proxy_vc_notify_cb_h h) +{ + GList *found; + + if (proxy == nullptr || h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + found = g_list_find(proxy->delegates, h); + if (found == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + proxy->delegates = g_list_remove_link(proxy->delegates, found); + rpc_port_proxy_vc_notify_cb_destroy(h); + g_list_free(found); + + return RPC_PORT_ERROR_NONE; +} + +static void __rpc_port_proxy_vc_notify_cb_delegate_handler(GList **delegates, rpc_port_parcel_h parcel, int id, int seq_id) +{ + rpc_port_proxy_vc_notify_cb_h handle; + GList *iter; + bool once; + int pid = -1; + bundle *msg = nullptr; + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_bundle(parcel, &msg); + if (msg == nullptr) { + _E("Failed to read data"); + goto out; + } + + iter = *delegates; + while (iter) { + handle = iter->data; + iter = g_list_next(iter); + if (handle->id == id && handle->seq_id == seq_id) { + once = handle->once; + _W("Invoke id(%d), seq_id(%d)", id, seq_id); + if (handle->callback) + handle->callback(handle->user_data, pid, msg); + else + _W("The callback function is nullptr"); + + if (once) { + *delegates = g_list_remove(*delegates, handle); + rpc_port_proxy_vc_notify_cb_destroy(handle); + } + + break; + } + } + +out: + + if (msg) + bundle_free(msg); +} + +static void __rpc_port_proxy_vc_feedback_cb_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_vc_feedback_cb_h h = data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, h->id); + + rpc_port_parcel_write_int32(parcel, h->seq_id); + + rpc_port_parcel_write_bool(parcel, h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); +} + +static void __rpc_port_proxy_vc_feedback_cb_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_proxy_vc_feedback_cb_h h = data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + rpc_port_parcel_read_int32(parcel, &h->id); + + rpc_port_parcel_read_int32(parcel, &h->seq_id); + + rpc_port_parcel_read_bool(parcel, &h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_proxy_vc_feedback_cb_create(rpc_port_proxy_vc_feedback_cb_h *h) +{ + rpc_port_proxy_vc_feedback_cb_t *handle; + static int seq_num; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_proxy_vc_feedback_cb_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_proxy_vc_feedback_cb_to; + handle->parcelable.from = __rpc_port_proxy_vc_feedback_cb_from; + handle->id = RPC_PORT_PROXY_VC_DELEGATE_FEEDBACK_CB; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + _I("id(%d), seq_id(%d)", handle->id, handle->seq_id); + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_destroy(rpc_port_proxy_vc_feedback_cb_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + _W("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_clone(rpc_port_proxy_vc_feedback_cb_h h, rpc_port_proxy_vc_feedback_cb_h *clone) +{ + rpc_port_proxy_vc_feedback_cb_h handle; + rpc_port_parcel_h parcel; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_vc_feedback_cb_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + ret = rpc_port_parcel_create(&parcel); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret); + rpc_port_proxy_vc_feedback_cb_destroy(handle); + return ret; + } + + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_read(parcel, &handle->parcelable, handle); + ret = get_last_result(); + rpc_port_parcel_destroy(parcel); + + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret); + rpc_port_proxy_vc_feedback_cb_destroy(handle); + return ret; + } + + handle->callback = h->callback; + handle->user_data = h->user_data; + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_set_callback(rpc_port_proxy_vc_feedback_cb_h h, rpc_port_proxy_vc_feedback_cb_cb callback, void *user_data) +{ + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->callback = callback; + h->user_data = user_data; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_set_once(rpc_port_proxy_vc_feedback_cb_h h, bool once) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->once = once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_get_id(rpc_port_proxy_vc_feedback_cb_h h, int *id) +{ + if (h == nullptr || id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *id = h->id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_get_seq_id(rpc_port_proxy_vc_feedback_cb_h h, int *seq_id) +{ + if (h == nullptr || seq_id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *seq_id = h->seq_id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_is_once(rpc_port_proxy_vc_feedback_cb_h h, bool *once) +{ + if (h == nullptr || once == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *once = h->once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_get_tag(rpc_port_proxy_vc_feedback_cb_h h, char **tag) +{ + char *new_tag; + char buf[128]; + + if (h == nullptr || tag == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + snprintf(buf, sizeof(buf), "%d::%d", h->id, h->seq_id); + new_tag = strdup(buf); + if (new_tag == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *tag = new_tag; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_feedback_cb_dispose(rpc_port_proxy_vc_h proxy, rpc_port_proxy_vc_feedback_cb_h h) +{ + GList *found; + + if (proxy == nullptr || h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + found = g_list_find(proxy->delegates, h); + if (found == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + proxy->delegates = g_list_remove_link(proxy->delegates, found); + rpc_port_proxy_vc_feedback_cb_destroy(h); + g_list_free(found); + + return RPC_PORT_ERROR_NONE; +} + +static void __rpc_port_proxy_vc_feedback_cb_delegate_handler(GList **delegates, rpc_port_parcel_h parcel, int id, int seq_id) +{ + rpc_port_proxy_vc_feedback_cb_h handle; + GList *iter; + bool once; + int utt_id = -1; + int event = -1; + rpc_port_proxy_array_char_h pcm_data = nullptr; + int len = -1; + + rpc_port_parcel_read_int32(parcel, &utt_id); + + rpc_port_parcel_read_int32(parcel, &event); + + rpc_port_proxy_array_char_create(&pcm_data); + if (pcm_data == nullptr) { + _E("Failed to create handle"); + goto out; + } + + rpc_port_parcel_read(parcel, &pcm_data->parcelable, pcm_data); + if (get_last_result() != RPC_PORT_ERROR_NONE) { + _E("Failed to read data"); + goto out; + } + + rpc_port_parcel_read_int32(parcel, &len); + + iter = *delegates; + while (iter) { + handle = iter->data; + iter = g_list_next(iter); + if (handle->id == id && handle->seq_id == seq_id) { + once = handle->once; + _W("Invoke id(%d), seq_id(%d)", id, seq_id); + if (handle->callback) + handle->callback(handle->user_data, utt_id, event, pcm_data, len); + else + _W("The callback function is nullptr"); + + if (once) { + *delegates = g_list_remove(*delegates, handle); + rpc_port_proxy_vc_feedback_cb_destroy(handle); + } + + break; + } + } + +out: + + if (pcm_data) + rpc_port_proxy_array_char_destroy(pcm_data); +} + +static rpc_port_proxy_delegate_cb __rpc_port_proxy_vc_delegate_table[] = { + [RPC_PORT_PROXY_VC_DELEGATE_NOTIFY_CB] = __rpc_port_proxy_vc_notify_cb_delegate_handler, + [RPC_PORT_PROXY_VC_DELEGATE_FEEDBACK_CB] = __rpc_port_proxy_vc_feedback_cb_delegate_handler, +}; + +typedef enum { + RPC_PORT_PROXY_VC_METHOD_RESULT_, + RPC_PORT_PROXY_VC_METHOD_CALLBACK_, + RPC_PORT_PROXY_VC_METHOD_REGISTER_NOTIFY_CB, + RPC_PORT_PROXY_VC_METHOD_REGISTER_NOTIFY_CB_SYNC, + RPC_PORT_PROXY_VC_METHOD_REGISTER_FEEDBACK_CB, + RPC_PORT_PROXY_VC_METHOD_REGISTER_FEEDBACK_CB_SYNC, + RPC_PORT_PROXY_VC_METHOD_INITIALIZE, + RPC_PORT_PROXY_VC_METHOD_FINALIZE, + RPC_PORT_PROXY_VC_METHOD_SET_COMMAND, + RPC_PORT_PROXY_VC_METHOD_UNSET_COMMAND, + RPC_PORT_PROXY_VC_METHOD_SET_FOREGROUND, + RPC_PORT_PROXY_VC_METHOD_SET_SERVER_DIALOG, + RPC_PORT_PROXY_VC_METHOD_REQUEST_DIALOG, + RPC_PORT_PROXY_VC_METHOD_IS_SYSTEM_COMMAND_VALID, + RPC_PORT_PROXY_VC_METHOD_AUTH_ENABLE, + RPC_PORT_PROXY_VC_METHOD_AUTH_DISABLE, + RPC_PORT_PROXY_VC_METHOD_AUTH_START, + RPC_PORT_PROXY_VC_METHOD_AUTH_STOP, + RPC_PORT_PROXY_VC_METHOD_AUTH_CANCEL, + RPC_PORT_PROXY_VC_METHOD_REQUEST_TTS, + RPC_PORT_PROXY_VC_METHOD_CANCEL_TTS, + RPC_PORT_PROXY_VC_METHOD_GET_TTS_AUDIO_FORMAT, +} rpc_port_proxy_vc_method_e; + +static void __rpc_port_proxy_vc_process_received_event(GList **delegates, rpc_port_parcel_h parcel) +{ + int id = 0; + int seq_id = 0; + bool once = false; + + rpc_port_parcel_read_int32(parcel, &id); + rpc_port_parcel_read_int32(parcel, &seq_id); + rpc_port_parcel_read_bool(parcel, &once); + _W("id(%d), seq_id(%d)", id, seq_id); + + if (id > 0 && id < ARRAY_SIZE(__rpc_port_proxy_vc_delegate_table)) { + if (__rpc_port_proxy_vc_delegate_table[id]) + __rpc_port_proxy_vc_delegate_table[id](delegates, parcel, id, seq_id); + } else { + _W("Unknown ID(%d)", id); + } +} + +static void __rpc_port_proxy_vc_consume_command(rpc_port_h port, rpc_port_parcel_h *p) +{ + rpc_port_parcel_h parcel; + int cmd = -1; + int ret; + + do { + ret = rpc_port_parcel_create_from_port(&parcel, port); + if (ret != RPC_PORT_ERROR_NONE) + break; + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd == RPC_PORT_PROXY_VC_METHOD_RESULT_) { + *p = parcel; + return; + } + + rpc_port_parcel_destroy(parcel); + } while (true); + + *p = nullptr; +} + +static void __rpc_port_proxy_vc_connected(const char *endpoint, const char *port_name, rpc_port_h port, void *data) +{ + rpc_port_proxy_vc_h h = data; + + _I("endpoint(%s), port_name(%s)", endpoint, port_name); + h->port = port; + rpc_port_proxy_get_port(h->proxy, RPC_PORT_PORT_CALLBACK, &h->callback_port); + h->callback.connected(h, h->user_data); +} + +static void __rpc_port_proxy_vc_disconnected(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_vc_h h = data; + + _W("endpoint(%s), port_name(%s)", endpoint, port_name); + h->port = nullptr; + h->callback.disconnected(h, h->user_data); +} + +static void __rpc_port_proxy_vc_rejected(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_vc_h h = data; + + _W("endpoint(%s), port_name(%s)", endpoint, port_name); + h->port = nullptr; + h->callback.rejected(h, h->user_data); +} + +static void __rpc_port_proxy_vc_received(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_vc_h h = data; + rpc_port_parcel_h parcel; + int cmd = -1; + int ret; + + _W("endpoint(%s), port_name(%s)", endpoint, port_name); + ret = rpc_port_parcel_create_from_port(&parcel, h->callback_port); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle from port. error(%d)", ret); + return; + } + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd != RPC_PORT_PROXY_VC_METHOD_CALLBACK_) { + _E("Invalid protocol"); + rpc_port_parcel_destroy(parcel); + return; + } + + __rpc_port_proxy_vc_process_received_event(&h->delegates, parcel); + rpc_port_parcel_destroy(parcel); +} + +int rpc_port_proxy_vc_create(const char *stub_appid, rpc_port_proxy_vc_callback_s *callback, void *user_data, rpc_port_proxy_vc_h *h) +{ + rpc_port_proxy_vc_t *handle; + int ret; + + if (stub_appid == nullptr || callback == nullptr || h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (callback->connected == nullptr || callback->disconnected == nullptr || callback->rejected == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_proxy_vc_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + g_rec_mutex_init(&handle->mutex); + + handle->stub_appid = strdup(stub_appid); + if (handle->stub_appid == nullptr) { + _E("Failed to duplicate stub appid"); + rpc_port_proxy_vc_destroy(handle); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + ret = rpc_port_proxy_create(&handle->proxy); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create proxy handle. error(%d)", ret); + rpc_port_proxy_vc_destroy(handle); + return ret; + } + + handle->callback = *callback; + handle->user_data = user_data; + + ret = rpc_port_proxy_add_connected_event_cb(handle->proxy, __rpc_port_proxy_vc_connected, handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add connected event cb. error(%d)", ret); + rpc_port_proxy_vc_destroy(handle); + return ret; + } + + ret = rpc_port_proxy_add_disconnected_event_cb(handle->proxy, __rpc_port_proxy_vc_disconnected, handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add disconnected event cb. error(%d)", ret); + rpc_port_proxy_vc_destroy(handle); + return ret; + } + + ret = rpc_port_proxy_add_rejected_event_cb(handle->proxy, __rpc_port_proxy_vc_rejected, handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add rejected event cb. error(%d)", ret); + rpc_port_proxy_vc_destroy(handle); + return ret; + } + + ret = rpc_port_proxy_add_received_event_cb(handle->proxy, __rpc_port_proxy_vc_received, handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add received event cb. error(%d)", ret); + rpc_port_proxy_vc_destroy(handle); + return ret; + } + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_destroy(rpc_port_proxy_vc_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + g_rec_mutex_lock(&h->mutex); + g_rec_mutex_unlock(&h->mutex); + g_rec_mutex_clear(&h->mutex); + + if (h->delegates) + g_list_free_full(h->delegates, free); + + if (h->proxy) + rpc_port_proxy_destroy(h->proxy); + + if (h->stub_appid) + free(h->stub_appid); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_connect(rpc_port_proxy_vc_h h) +{ + int ret; + + if (h == nullptr || h->proxy == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_connect(h->proxy, h->stub_appid, "vc"); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to connect to stub. error(%d)", ret); + return ret; + } + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_connect_sync(rpc_port_proxy_vc_h h) +{ + int ret; + + if (h == nullptr || h->proxy == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_proxy_connect_sync(h->proxy, h->stub_appid, "vc"); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to connect to stub. error(%d)", ret); + return ret; + } + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_proxy_vc_disconnect(rpc_port_proxy_vc_h h) +{ + int ret; + + if (h == nullptr || h->proxy == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_disconnect(h->port); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to disconnect from stub. error(%d)", ret); + return ret; + } + + return RPC_PORT_ERROR_NONE; +} + +void rpc_port_proxy_vc_invoke_register_notify_cb(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_notify_cb_h callback) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int res_; + + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + g_rec_mutex_unlock(&h->mutex); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + return; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REGISTER_NOTIFY_CB); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write(parcel_, &callback->parcelable, callback); + + h->delegates = g_list_append(h->delegates, callback); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) + _E("Failed to send parcel. error(%d)", res_); + + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); +} + +int rpc_port_proxy_vc_invoke_register_notify_cb_sync(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_notify_cb_h callback) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REGISTER_NOTIFY_CB_SYNC); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write(parcel_, &callback->parcelable, callback); + + h->delegates = g_list_append(h->delegates, callback); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +void rpc_port_proxy_vc_invoke_register_feedback_cb(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_feedback_cb_h callback) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int res_; + + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + g_rec_mutex_unlock(&h->mutex); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + return; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REGISTER_FEEDBACK_CB); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write(parcel_, &callback->parcelable, callback); + + h->delegates = g_list_append(h->delegates, callback); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) + _E("Failed to send parcel. error(%d)", res_); + + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); +} + +int rpc_port_proxy_vc_invoke_register_feedback_cb_sync(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_feedback_cb_h callback) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr || callback == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REGISTER_FEEDBACK_CB_SYNC); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write(parcel_, &callback->parcelable, callback); + + h->delegates = g_list_append(h->delegates, callback); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_initialize(rpc_port_proxy_vc_h h, int pid, int *mgr_pid, int *service_state, int *daemon_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + int new_mgr_pid; + int new_service_state; + int new_daemon_pid; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_INITIALIZE); + + rpc_port_parcel_write_int32(parcel_, pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &new_mgr_pid); + + *mgr_pid = new_mgr_pid; + + rpc_port_parcel_read_int32(parcel_, &new_service_state); + + *service_state = new_service_state; + + rpc_port_parcel_read_int32(parcel_, &new_daemon_pid); + + *daemon_pid = new_daemon_pid; + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_finalize(rpc_port_proxy_vc_h h, int pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_FINALIZE); + + rpc_port_parcel_write_int32(parcel_, pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_set_command(rpc_port_proxy_vc_h h, int pid, int cmd_type) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_SET_COMMAND); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, cmd_type); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_unset_command(rpc_port_proxy_vc_h h, int pid, int cmd_type) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_UNSET_COMMAND); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, cmd_type); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_set_foreground(rpc_port_proxy_vc_h h, int pid, bool value) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_SET_FOREGROUND); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_bool(parcel_, value); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_set_server_dialog(rpc_port_proxy_vc_h h, int pid, const char *app_id, const char *credential) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr || app_id == nullptr || credential == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_SET_SERVER_DIALOG); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_string(parcel_, app_id); + + rpc_port_parcel_write_string(parcel_, credential); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_request_dialog(rpc_port_proxy_vc_h h, int pid, const char *disp_text, const char *utt_text, bool continuous) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr || disp_text == nullptr || utt_text == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REQUEST_DIALOG); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_string(parcel_, disp_text); + + rpc_port_parcel_write_string(parcel_, utt_text); + + rpc_port_parcel_write_bool(parcel_, continuous); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_is_system_command_valid(rpc_port_proxy_vc_h h, int pid, bool *is_sys_cmd_valid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + bool new_is_sys_cmd_valid; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_IS_SYSTEM_COMMAND_VALID); + + rpc_port_parcel_write_int32(parcel_, pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_bool(parcel_, &new_is_sys_cmd_valid); + + *is_sys_cmd_valid = new_is_sys_cmd_valid; + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_auth_enable(rpc_port_proxy_vc_h h, int pid, int mgr_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_AUTH_ENABLE); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_auth_disable(rpc_port_proxy_vc_h h, int pid, int mgr_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_AUTH_DISABLE); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_auth_start(rpc_port_proxy_vc_h h, int pid, int mgr_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_AUTH_START); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_auth_stop(rpc_port_proxy_vc_h h, int pid, int mgr_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_AUTH_STOP); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_auth_cancel(rpc_port_proxy_vc_h h, int pid, int mgr_pid) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_AUTH_CANCEL); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_request_tts(rpc_port_proxy_vc_h h, int pid, const char *text, const char *lang, bool to_vcm, int *utt_id) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + int new_utt_id; + + if (h == nullptr || text == nullptr || lang == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_REQUEST_TTS); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_string(parcel_, text); + + rpc_port_parcel_write_string(parcel_, lang); + + rpc_port_parcel_write_bool(parcel_, to_vcm); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &new_utt_id); + + *utt_id = new_utt_id; + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_cancel_tts(rpc_port_proxy_vc_h h, int pid, int utt_id) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_CANCEL_TTS); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_int32(parcel_, utt_id); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} + +int rpc_port_proxy_vc_invoke_get_tts_audio_format(rpc_port_proxy_vc_h h, int pid, int *rate, int *channel, int *audio_type) +{ + rpc_port_parcel_h parcel_; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + int recv_seq_num_ = -1; + char *tag_ = nullptr; + bool done_ = false; + int res_; + int ret_ = -1; + int new_rate; + int new_channel; + int new_audio_type; + + if (h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return ret_; + } + + g_rec_mutex_lock(&h->mutex); + if (h->port == nullptr) { + _E("Not connected"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + res_ = rpc_port_parcel_create(&parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_PROXY_VC_METHOD_GET_TTS_AUDIO_FORMAT); + + rpc_port_parcel_write_int32(parcel_, pid); + + res_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + if (res_ != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. error(%d)", res_); + set_last_result(res_); + g_rec_mutex_unlock(&h->mutex); + return ret_; + } + + do { + parcel_ = nullptr; + __rpc_port_proxy_vc_consume_command(h->port, &parcel_); + if (parcel_ == nullptr) { + _E("Invalid protocol"); + res_ = RPC_PORT_ERROR_IO_ERROR; + break; + } + + header_ = nullptr; + rpc_port_parcel_get_header(parcel_, &header_); + tag_ = nullptr; + rpc_port_parcel_header_get_tag(header_, &tag_); + if (tag_ && tag_[0] != '\0') { + _W("[Version] %s", tag_); + rpc_port_parcel_header_get_seq_num(header_, &recv_seq_num_); + if (recv_seq_num_ != seq_num_) { + _E("Invalid protocol. %d", recv_seq_num_); + free(tag_); + rpc_port_parcel_destroy(parcel_); + continue; + } + } + done_ = true; + free(tag_); + + rpc_port_parcel_read_int32(parcel_, &new_rate); + + *rate = new_rate; + + rpc_port_parcel_read_int32(parcel_, &new_channel); + + *channel = new_channel; + + rpc_port_parcel_read_int32(parcel_, &new_audio_type); + + *audio_type = new_audio_type; + + rpc_port_parcel_read_int32(parcel_, &ret_); + + rpc_port_parcel_destroy(parcel_); + } while (!done_); + g_rec_mutex_unlock(&h->mutex); + set_last_result(res_); + + return ret_; +} diff --git a/client/vc_proxy.h b/client/vc_proxy.h new file mode 100755 index 0000000..5b2fa31 --- /dev/null +++ b/client/vc_proxy.h @@ -0,0 +1,819 @@ +/* + * Generated by tidlc 1.8.1. + */ + +#pragma once + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief The rpc_port_proxy_array_char handle. + */ +typedef struct rpc_port_proxy_array_char_s *rpc_port_proxy_array_char_h; + +/** + * @brief The rpc_port_proxy_vc handle. + */ +typedef struct rpc_port_proxy_vc_s *rpc_port_proxy_vc_h; + +/** + * @brief The rpc_port_proxy_vc_notify_cb handle. + */ +typedef struct rpc_port_proxy_vc_notify_cb_s *rpc_port_proxy_vc_notify_cb_h; + +/** + * @brief The rpc_port_proxy_vc_feedback_cb handle. + */ +typedef struct rpc_port_proxy_vc_feedback_cb_s *rpc_port_proxy_vc_feedback_cb_h; + +/** + * @briefs Creates a rpc_port_proxy_array_char handle. + * + * @remarks The @a h should be released using the rpc_port_proxy_array_char_destroy() + * if it's no longer needed. + * @param[out] h The rpc_port_proxy_array_char handle that is newly created + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_array_char_destroy() + */ +int rpc_port_proxy_array_char_create(rpc_port_proxy_array_char_h *h); + +/** + * @brief Destroys the rpc_port_proxy_array_char handle. + * + * @param[in] h The rpc_port_proxy_array_char handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_array_char_create() + */ +int rpc_port_proxy_array_char_destroy(rpc_port_proxy_array_char_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_proxy_array_char handle. + * + * @remarks A new created rpc_port_proxy_array_char should be released using + * the rpc_port_proxy_array_char_destroy() if it's no longer needed. + * @param[in] h The rpc_port_proxy_array_char handle + * @param[out] clone If successful, a new created rpc_port_proxy_array_char handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_array_char_destroy() + */ +int rpc_port_proxy_array_char_clone(rpc_port_proxy_array_char_h h, rpc_port_proxy_array_char_h *clone); + +/** + * @brief Sets the value to the rpc_port_proxy_array_char handle. + * + * @remarks The value is internally copied and stored. + * You should release it if it's allocaed when it's no longer needed, + * @param[in] h The rpc_port_proxy_array_char handle + * @param[in] value The array value + * @param[in] size The size of the array + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_array_char_get() + */ +int rpc_port_proxy_array_char_set(rpc_port_proxy_array_char_h h, char *value, int size); + +/** + * @brief Gets the value from the rpc_port_proxy_array_char handle. + * + * @remarks A new created value should be released if it's no longer needed. + * @param[in] h The rpc_port_proxy_array_char handle + * @param[out] value The array value + * @param[out] size The size of the array + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_array_char_set() + */ +int rpc_port_proxy_array_char_get(rpc_port_proxy_array_char_h h, char **value, int *size); + +/** + * @brief Called when the event is received. + * + * @param[in] user_data The user data passed from the callback registration function + * @param[in] ... + * + * @see rpc_port_proxy_vc_notify_cb_create() + */ +typedef void (*rpc_port_proxy_vc_notify_cb_cb)(void *user_data, int pid, bundle *msg); + +/** + * @brief Creates a rpc_port_proxy_vc_notify_cb handle. + * + * @param[out] h The rpc_port_proxy_vc_notify_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memorya + * @see rpc_port_proxy_vc_notify_cb_destroy() + * @see rpc_port_proxy_vc_notify_cb_dispose() + * @see rpc_port_proxy_vc_notify_cb_set_callback() + * @see rpc_port_proxy_vc_notify_cb_set_once() + */ +int rpc_port_proxy_vc_notify_cb_create(rpc_port_proxy_vc_notify_cb_h *h); + +/** + * @brief Destroys the rpc_port_proxy_vc_notify_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_vc_notify_cb_create() + */ +int rpc_port_proxy_vc_notify_cb_destroy(rpc_port_proxy_vc_notify_cb_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_proxy_vc_notify_cb handle. + * + * @remarks A new created rpc_port_proxy_vc_notify_cb should be released using + * the rpc_port_proxy_vc_notify_cb_destroy() if it's no longer needed. + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[out] clone If successful, a new created rpc_port_proxy_vc_notify_cb handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_vc_notify_cb_destroy() + */ +int rpc_port_proxy_vc_notify_cb_clone(rpc_port_proxy_vc_notify_cb_h h, rpc_port_proxy_vc_notify_cb_h *clone); + +/** + * @brief Sets the callback function to the rpc_port_proxy_vc_notify_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[in] callback The callback function + * @param[in] user_data The user data to be passed to the callback function + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_notify_cb_set_callback(rpc_port_proxy_vc_notify_cb_h h, rpc_port_proxy_vc_notify_cb_cb callback, void *user_data); + +/** + * @brief Set the once flag to the rpc_port_proxy_vc_notify_cb handle. + * @details If the once flag is 'true', the delegate handle will be deleted after invocation. + * If the @a h handle is not used using the method, the handle should be released using + * the rpc_port_proxy_vc_notify_cb_destroy() when it's no longer needed. + * If you don't want the delegate callback function to be called after it's used using the method, + * you should release the handle using the rpc_port_proxy_vc_notify_cb_dispose(). + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[in] once The flag if it's true, the delegate will be deleted after invocation + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_notify_cb_set_once(rpc_port_proxy_vc_notify_cb_h h, bool once); + +/** + * @brief Gets the ID of the rpc_port_proxy_vc_notify_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[out] id The ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_notify_cb_get_id(rpc_port_proxy_vc_notify_cb_h h, int *id); + +/** + * @brief Gets the sequence ID of the rpc_port_proxy_vc_notify_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[out] seq_id The Sequence ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_notify_cb_get_seq_id(rpc_port_proxy_vc_notify_cb_h h, int *seq_id); + +/** + * @brief Checks whether the delegate is for one-time or not. + * + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[out] once The flag, it's true, the handle is for one-time + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_notify_cb_is_once(rpc_port_proxy_vc_notify_cb_h h, bool *once); + +/** + * @brief Gets the tag from the rpc_port_proxy_vc_notify_cb handle. + * + * @remarks The @a tag should be released using free(). + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @param[out] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_proxy_vc_notify_cb_get_tag(rpc_port_proxy_vc_notify_cb_h h, char **tag); + +/** + * @brief Disposes the rpc_port_proxy_vc_notify_cb handle from the rpc_port_proxy_vc handle. + * + * @param[in] proxy The rpc_port_proxy_vc handle + * @param[in] h The rpc_port_proxy_vc_notify_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_vc_notify_cb_create() + */ +int rpc_port_proxy_vc_notify_cb_dispose(rpc_port_proxy_vc_h proxy, rpc_port_proxy_vc_notify_cb_h h); + +/** + * @brief Called when the event is received. + * + * @param[in] user_data The user data passed from the callback registration function + * @param[in] ... + * + * @see rpc_port_proxy_vc_feedback_cb_create() + */ +typedef void (*rpc_port_proxy_vc_feedback_cb_cb)(void *user_data, int utt_id, int event, rpc_port_proxy_array_char_h pcm_data, int len); + +/** + * @brief Creates a rpc_port_proxy_vc_feedback_cb handle. + * + * @param[out] h The rpc_port_proxy_vc_feedback_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memorya + * @see rpc_port_proxy_vc_feedback_cb_destroy() + * @see rpc_port_proxy_vc_feedback_cb_dispose() + * @see rpc_port_proxy_vc_feedback_cb_set_callback() + * @see rpc_port_proxy_vc_feedback_cb_set_once() + */ +int rpc_port_proxy_vc_feedback_cb_create(rpc_port_proxy_vc_feedback_cb_h *h); + +/** + * @brief Destroys the rpc_port_proxy_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_vc_feedback_cb_create() + */ +int rpc_port_proxy_vc_feedback_cb_destroy(rpc_port_proxy_vc_feedback_cb_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_proxy_vc_feedback_cb handle. + * + * @remarks A new created rpc_port_proxy_vc_feedback_cb should be released using + * the rpc_port_proxy_vc_feedback_cb_destroy() if it's no longer needed. + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[out] clone If successful, a new created rpc_port_proxy_vc_feedback_cb handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_vc_feedback_cb_destroy() + */ +int rpc_port_proxy_vc_feedback_cb_clone(rpc_port_proxy_vc_feedback_cb_h h, rpc_port_proxy_vc_feedback_cb_h *clone); + +/** + * @brief Sets the callback function to the rpc_port_proxy_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[in] callback The callback function + * @param[in] user_data The user data to be passed to the callback function + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_feedback_cb_set_callback(rpc_port_proxy_vc_feedback_cb_h h, rpc_port_proxy_vc_feedback_cb_cb callback, void *user_data); + +/** + * @brief Set the once flag to the rpc_port_proxy_vc_feedback_cb handle. + * @details If the once flag is 'true', the delegate handle will be deleted after invocation. + * If the @a h handle is not used using the method, the handle should be released using + * the rpc_port_proxy_vc_feedback_cb_destroy() when it's no longer needed. + * If you don't want the delegate callback function to be called after it's used using the method, + * you should release the handle using the rpc_port_proxy_vc_feedback_cb_dispose(). + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[in] once The flag if it's true, the delegate will be deleted after invocation + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_feedback_cb_set_once(rpc_port_proxy_vc_feedback_cb_h h, bool once); + +/** + * @brief Gets the ID of the rpc_port_proxy_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[out] id The ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_feedback_cb_get_id(rpc_port_proxy_vc_feedback_cb_h h, int *id); + +/** + * @brief Gets the sequence ID of the rpc_port_proxy_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[out] seq_id The Sequence ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_feedback_cb_get_seq_id(rpc_port_proxy_vc_feedback_cb_h h, int *seq_id); + +/** + * @brief Checks whether the delegate is for one-time or not. + * + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[out] once The flag, it's true, the handle is for one-time + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_feedback_cb_is_once(rpc_port_proxy_vc_feedback_cb_h h, bool *once); + +/** + * @brief Gets the tag from the rpc_port_proxy_vc_feedback_cb handle. + * + * @remarks The @a tag should be released using free(). + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @param[out] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_proxy_vc_feedback_cb_get_tag(rpc_port_proxy_vc_feedback_cb_h h, char **tag); + +/** + * @brief Disposes the rpc_port_proxy_vc_feedback_cb handle from the rpc_port_proxy_vc handle. + * + * @param[in] proxy The rpc_port_proxy_vc handle + * @param[in] h The rpc_port_proxy_vc_feedback_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_vc_feedback_cb_create() + */ +int rpc_port_proxy_vc_feedback_cb_dispose(rpc_port_proxy_vc_h proxy, rpc_port_proxy_vc_feedback_cb_h h); + +/** + * @brief Called when the proxy is connected. + * @details The callback function is called when the proxy is connected to the stub. + * + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] user_data The user data passed from the registeration function + * @see #rpc_port_proxy_vc_callback_s + */ +typedef void (*rpc_port_proxy_vc_connected_cb)(rpc_port_proxy_vc_h h, void *user_data); + +/** + * @brief Called when the proxy is disconnected. + * @details The callback function is called when the proxy is disconnected from the stub. + * + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] user_data The user data passed from the registeration function + * @see #rpc_port_proxy_vc_callback_s + */ +typedef void (*rpc_port_proxy_vc_disconnected_cb)(rpc_port_proxy_vc_h h, void *user_data); + +/** + * @brief Called when the proxy is rejected. + * @details The callback function is called when the proxy is rejected to connect to the stub. + * + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] user_data The user data passed from the registeration function + * @see #rpc_port_proxy_vc_callback_s + */ +typedef void (*rpc_port_proxy_vc_rejected_cb)(rpc_port_proxy_vc_h h, void *user_data); + +/** + * @brief The structure type containing the set of callback functions for handling proxy events. + * @details It is one of the input parameters of the rpc_port_proxy_vc_create() function. + * + * @see rpc_port_proxy_vc_connected_cb + * @see rpc_port_proxy_vc_disconnected_cb + * @see rpc_port_proxy_vc_rejected_cb + */ +typedef struct { + rpc_port_proxy_vc_connected_cb connected; /**< This callback function is called when the proxy is connected to the stub. */ + rpc_port_proxy_vc_disconnected_cb disconnected; /**< This callback function is called when the proxy is disconnected from the stub. */ + rpc_port_proxy_vc_rejected_cb rejected; /**< This callback function is called when the proxy is rejected to connect to the stub. */ +} rpc_port_proxy_vc_callback_s; + +/** + * @brief Creates a rpc_port_proxy_vc handle. + * @remarks The @a h handle should be released using + * the rpc_port_proxy_vc_destroy() if it's no longer needed. + * + * @param[in] stub_appid The application ID of the stub + * @param[in] callback The set of callback functions to handle proxy events + * @param[in] user_data The user data to be passed to the callback function + * @param[out] h The rpc_port_proxy_vc handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_proxy_vc_destroy() + * @see #rpc_port_proxy_vc_callback_s + */ +int rpc_port_proxy_vc_create(const char *stub_appid, rpc_port_proxy_vc_callback_s *callback, void *user_data, rpc_port_proxy_vc_h *h); + +/** + * @brief Destroys the rpc_port_proxy_vc handle. + * + * @param[in] h The rpc_port_proxy_vc handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_proxy_vc_create() + */ +int rpc_port_proxy_vc_destroy(rpc_port_proxy_vc_h h); + +/** + * @brief Connects to the stub. + * + * @param[in] h The rpc_port_proxy_vc handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_IO_ERROR I/O error + * @retval #RPC_PORT_ERROR_PERMISSION_DENIED Permission denied + */ +int rpc_port_proxy_vc_connect(rpc_port_proxy_vc_h h); + +/** + * @brief Connects to the stub synchronously. + * + * @param[in] h The rpc_port_proxy_vc handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_IO_ERROR I/O error + * @retval #RPC_PORT_ERROR_PERMISSION_DENIED Permission denied + */ +int rpc_port_proxy_vc_connect_sync(rpc_port_proxy_vc_h h); + +/** + * @brief Disconnects from the stub. + * + * @param[in] h The rpc_port_proxy_vc handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_proxy_vc_disconnect(rpc_port_proxy_vc_h h); + +/** + * @brief Calls the register_notify_cb() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +void rpc_port_proxy_vc_invoke_register_notify_cb(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_notify_cb_h callback); + +/** + * @brief Calls the register_notify_cb_sync() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_register_notify_cb_sync(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_notify_cb_h callback); + +/** + * @brief Calls the register_feedback_cb() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +void rpc_port_proxy_vc_invoke_register_feedback_cb(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_feedback_cb_h callback); + +/** + * @brief Calls the register_feedback_cb_sync() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_register_feedback_cb_sync(rpc_port_proxy_vc_h h, int pid, rpc_port_proxy_vc_feedback_cb_h callback); + +/** + * @brief Calls the initialize() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_initialize(rpc_port_proxy_vc_h h, int pid, int *mgr_pid, int *service_state, int *daemon_pid); + +/** + * @brief Calls the finalize() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_finalize(rpc_port_proxy_vc_h h, int pid); + +/** + * @brief Calls the set_command() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_set_command(rpc_port_proxy_vc_h h, int pid, int cmd_type); + +/** + * @brief Calls the unset_command() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_unset_command(rpc_port_proxy_vc_h h, int pid, int cmd_type); + +/** + * @brief Calls the set_foreground() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_set_foreground(rpc_port_proxy_vc_h h, int pid, bool value); + +/** + * @brief Calls the set_server_dialog() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_set_server_dialog(rpc_port_proxy_vc_h h, int pid, const char *app_id, const char *credential); + +/** + * @brief Calls the request_dialog() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_request_dialog(rpc_port_proxy_vc_h h, int pid, const char *disp_text, const char *utt_text, bool continuous); + +/** + * @brief Calls the is_system_command_valid() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_is_system_command_valid(rpc_port_proxy_vc_h h, int pid, bool *is_sys_cmd_valid); + +/** + * @brief Calls the auth_enable() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_auth_enable(rpc_port_proxy_vc_h h, int pid, int mgr_pid); + +/** + * @brief Calls the auth_disable() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_auth_disable(rpc_port_proxy_vc_h h, int pid, int mgr_pid); + +/** + * @brief Calls the auth_start() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_auth_start(rpc_port_proxy_vc_h h, int pid, int mgr_pid); + +/** + * @brief Calls the auth_stop() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_auth_stop(rpc_port_proxy_vc_h h, int pid, int mgr_pid); + +/** + * @brief Calls the auth_cancel() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_auth_cancel(rpc_port_proxy_vc_h h, int pid, int mgr_pid); + +/** + * @brief Calls the request_tts() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_request_tts(rpc_port_proxy_vc_h h, int pid, const char *text, const char *lang, bool to_vcm, int *utt_id); + +/** + * @brief Calls the cancel_tts() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_cancel_tts(rpc_port_proxy_vc_h h, int pid, int utt_id); + +/** + * @brief Calls the get_tts_audio_format() method. + * @details The return value and args are decided by the interface declaration. + * You can get the result using get_last_result(). + * Before returning the function, the function sets the result using set_last_result(). + * @remarks The specific error code can be obtained using the get_last_result() function. Error codes are described in Exception section. + * @param[in] h The rpc_port_proxy_vc handle + * @param[in] ... + * @exception #RPC_PORT_ERROR_NONE Successful + * @exception #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @exception #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_proxy_vc_invoke_get_tts_audio_format(rpc_port_proxy_vc_h h, int pid, int *rate, int *channel, int *audio_type); + +#ifdef __cplusplus +} +#endif diff --git a/client/vc_tidl.c b/client/vc_tidl.c new file mode 100755 index 0000000..e937f0f --- /dev/null +++ b/client/vc_tidl.c @@ -0,0 +1,708 @@ +/* +* Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the License); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an AS IS BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "vc_command.h" +#include "vc_tidl.h" +#include "vc_proxy.h" +#include "vc_main.h" + +#include + +typedef struct { + int pid; + bool connected; + bool connection_requesting; + bool register_notify_callback_invoked; + bool register_feedback_callback_invoked; + + rpc_port_proxy_vc_h rpc_h; + rpc_port_proxy_vc_notify_cb_h notify_cb_h; + rpc_port_proxy_vc_feedback_cb_h feedback_cb_h; + + char* engine_appid; +} vc_tidl_info_s; + +static GList* g_tidl_infos = NULL; + +extern int __vc_cb_error(int reason, int daemon_pid, char* msg); +extern int __vc_cb_error_to_app(int pid, int reason, char* msg); +extern void __vc_cb_result(); +extern int __vc_cb_service_state(int state); +extern int __vc_cb_manager_pid(int manager_pid); +extern int __vc_cb_tts_streaming(int utt_id, vc_feedback_event_e event, char* buffer, int len); +extern int __vc_cb_utterance_status(int utt_id, int utt_status); + + +static vc_tidl_info_s* __get_tidl_info_s(int pid) +{ + GList* iter = NULL; + vc_tidl_info_s* info = NULL; + + if (g_list_length(g_tidl_infos) > 0) { + /* Get a first item */ + iter = g_list_first(g_tidl_infos); + + while (NULL != iter) { + info = iter->data; + + if (info->pid == pid) { + return info; + } + + /* Next item */ + iter = g_list_next(iter); + } + } + + return NULL; +} + +static char* __get_engine_appid(void) +{ + char* engine_name = vconf_get_str(VC_ENGINE_DB_DEFAULT); + if (NULL == engine_name) { + SLOG(LOG_WARN, TAG_VCC, "[WARNING] Fail to get engine name. Please use default engine name."); + engine_name = strdup("org.tizen.vc-engine-default"); + } + + char* appid = strdup(engine_name); + + return appid; +} + +static void __on_connected(rpc_port_proxy_vc_h h, void* user_data) +{ + unsigned int pid = (uintptr_t)user_data; + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETM_IF(NULL == info, "[ERROR] Fail to get tidl info"); + + info->connected = true; + info->connection_requesting = false; + info->register_notify_callback_invoked = false; + + SLOG(LOG_INFO, TAG_VCC, "[INFO] Connected to server"); +} + +static void __on_disconnected(rpc_port_proxy_vc_h h, void* user_data) +{ + unsigned int pid = (uintptr_t)user_data; + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETM_IF(NULL == info, "[ERROR] Fail to get tidl info"); + + info->connected = false; + info->connection_requesting = false; + info->register_notify_callback_invoked = false; + + /* retry to connect */ + SLOG(LOG_INFO, TAG_VCC, "[INFO] Disconnected to server"); +} + +static void __on_rejected(rpc_port_proxy_vc_h h, void* user_data) +{ + unsigned int pid = (uintptr_t)user_data; + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETM_IF(NULL == info, "[ERROR] Fail to get tidl info"); + + info->connection_requesting = false; + info->register_notify_callback_invoked = false; + + SLOG(LOG_INFO, TAG_VCC, "[INFO] Rejected from server(%d)", pid); +} + + +static rpc_port_proxy_vc_h __create_rpc_port(int pid, const char* engine_app_id) +{ + rpc_port_proxy_vc_callback_s rpc_callback = { + .connected = __on_connected, + .disconnected = __on_disconnected, + .rejected = __on_rejected + }; + + rpc_port_proxy_vc_h handle = NULL; + uintptr_t ptr_pid = pid; + if (0 != rpc_port_proxy_vc_create(engine_app_id, &rpc_callback, (void*)ptr_pid, &handle)) { + return NULL; + } + + return handle; +} + +static void __request_tidl_connect(vc_tidl_info_s* info) +{ + if (info->connection_requesting) { + SLOG(LOG_INFO, TAG_VCC, "[TIDL] Already connection is requested. Skip to call rpc_port_proxy_vc_connect()."); + return ; + } + + int ret = rpc_port_proxy_vc_connect(info->rpc_h); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request connection to stub. ret(%d)", ret); + return ; + } + + SLOG(LOG_INFO, TAG_VCC, "[INFO] Request connection to stub. ret(%d)", ret); + info->connection_requesting = true; +} + +static void __notify_cb(void* user_data, int pid, bundle* msg) +{ + // corresponding to listener_event_callback + char* method = NULL; + + SLOG(LOG_DEBUG, TAG_VCC, "__notify_cb is invoked pid(%d)", pid); + + bundle_get_str(msg, VC_BUNDLE_METHOD, &method); + + if (0 == strncmp(VCD_METHOD_HELLO, method, strlen(VCD_METHOD_HELLO))) { + } /* VCD_METHOD_HELLO */ + else if (0 == strncmp(VCD_METHOD_SET_SERVICE_STATE, method, strlen(VCD_METHOD_SET_SERVICE_STATE))) { + /* signal!!! */ + char* state = NULL; + bundle_get_str(msg, VC_BUNDLE_SERVICE_STATE, &state); + if (state) { + __vc_cb_service_state(atoi(state)); + } + } /* VCD_METHOD_SET_SERVICE_STATE */ + else if (0 == strncmp(VCD_METHOD_RESULT, method, strlen(VCD_METHOD_RESULT))) { + SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get Client Result"); + + __vc_cb_result(); + } /* VCD_METHOD_RESULT */ + else if (0 == strncmp(VCD_METHOD_SEND_MANAGER_PID, method, strlen(VCD_METHOD_SEND_MANAGER_PID))) { + /* signal!!! */ + char* manager_pid = NULL; + bundle_get_str(msg, VC_BUNDLE_MANAGER_PID, &manager_pid); + if (manager_pid) { + SLOG(LOG_DEBUG, TAG_VCC, "@@ manager pid is changed : %d", atoi(manager_pid)); + __vc_cb_manager_pid(atoi(manager_pid)); + } + } /* VCD_METHOD_SEND_MANAGER_PID */ + else if (0 == strncmp(VCD_METHOD_ERROR, method, strlen(VCD_METHOD_ERROR))) { + /* signal!!! */ + char* reason; + char* daemon_pid; + char* err_msg = NULL; + + bundle_get_str(msg, VC_BUNDLE_REASON, &reason); + bundle_get_str(msg, VC_BUNDLE_DAEMON_PID, &daemon_pid); + bundle_get_str(msg, VC_BUNDLE_ERR_MSG, &err_msg); + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc Get Error message : reason(%d), daemon_pid(%d), msg(%s)", atoi(reason), atoi(daemon_pid), err_msg); + __vc_cb_error(atoi(reason), atoi(daemon_pid), err_msg); + } /* VCD_METHOD_ERROR */ + else if (0 == strncmp(VCD_METHOD_ERROR_TO_APP, method, strlen(VCD_METHOD_ERROR_TO_APP))) { + /* signal!!! */ + char* pid; + char* reason; + char* err_msg = NULL; + + bundle_get_str(msg, VC_BUNDLE_PID, &pid); + bundle_get_str(msg, VC_BUNDLE_REASON, &reason); + bundle_get_str(msg, VC_BUNDLE_ERR_MSG, &err_msg); + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc Get Error message : reason(%d), pid(%d), msg(%s)", atoi(reason), atoi(pid), err_msg); + __vc_cb_error_to_app(atoi(pid), atoi(reason), err_msg); + } /* VCD_METHOD_ERROR_TO_APP */ + else if (0 == strncmp(VC_MANAGER_METHOD_UTTERANCE_STATUS, method, strlen(VC_MANAGER_METHOD_UTTERANCE_STATUS))) { + } /* VC_MANAGER_METHOD_UTTERANCE_STATUS */ + else { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid msg"); + } +} + +void __feedback_cb(void *user_data, int utt_id, int event, rpc_port_proxy_array_char_h pcm_data, int len) +{ + // corresponding to listener_event_callback (only for tts_streaming) + SLOG(LOG_DEBUG, TAG_VCC, "__feedback_cb is invoked utt_id(%d) event(%d)", utt_id, event); + + // char* utt_id; + // char* event; + + // bundle_get_str(msg, VC_BUNDLE_UTTID, &utt_id); + // bundle_get_str(msg, VC_BUNDLE_FEEDBACK_EVENT, &event); + // __vc_cb_tts_streaming(utt_id, event, buffer, len); + /* VCD_METHOD_FEEDBACK_STREAMING */ +} + +static int __create_notify_callback_handle(vc_tidl_info_s* info) +{ + if (NULL != info->notify_cb_h) { + rpc_port_proxy_vc_notify_cb_dispose(info->rpc_h, info->notify_cb_h); + info->notify_cb_h = NULL; + } + + if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_notify_cb_create(&info->notify_cb_h)) { + return VC_ERROR_OUT_OF_MEMORY; + } + + rpc_port_proxy_vc_notify_cb_set_callback(info->notify_cb_h, __notify_cb, NULL); + rpc_port_proxy_vc_notify_cb_set_once(info->notify_cb_h, false); + + return VC_ERROR_NONE; +} + +static int __create_feedback_callback_handle(vc_tidl_info_s* info) +{ + if (NULL != info) { + rpc_port_proxy_vc_feedback_cb_dispose(info->rpc_h, info->feedback_cb_h); + info->feedback_cb_h = NULL; + } + + if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_feedback_cb_create(&info->feedback_cb_h)) { + return VC_ERROR_OUT_OF_MEMORY; + } + + rpc_port_proxy_vc_feedback_cb_set_callback(info->feedback_cb_h, __feedback_cb, NULL); + rpc_port_proxy_vc_feedback_cb_set_once(info->feedback_cb_h, false); + + return VC_ERROR_NONE; +} + +static int __invoke_register_notify_callback(int pid, vc_tidl_info_s* info) +{ + if (info->register_notify_callback_invoked) { + SLOG(LOG_ERROR, TAG_VCC, "[INFO] Already register callback is invoked"); + return VC_ERROR_NONE; + } + + int ret = __create_notify_callback_handle(info); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create callback handle. ret(%d)", ret); + return VC_ERROR_OPERATION_FAILED; + } + + rpc_port_proxy_vc_invoke_register_notify_cb(info->rpc_h, pid, info->notify_cb_h); + info->register_notify_callback_invoked = true; + return VC_ERROR_NONE; +} + +static int __invoke_register_feedback_callback(int pid, vc_tidl_info_s* info) +{ + if (info->register_feedback_callback_invoked) { + SLOG(LOG_ERROR, TAG_VCC, "[INFO] Already register callback is invoked"); + return VC_ERROR_NONE; + } + + int ret = __create_feedback_callback_handle(info); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create callback handle. ret(%d)", ret); + return VC_ERROR_OPERATION_FAILED; + } + + rpc_port_proxy_vc_invoke_register_feedback_cb(info->rpc_h, pid, info->feedback_cb_h); + info->register_feedback_callback_invoked = true; + return VC_ERROR_NONE; +} + +int vc_tidl_open_connection() +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_open_connection"); + + vc_tidl_info_s* info = (vc_tidl_info_s*)calloc(1, sizeof(vc_tidl_info_s)); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCC, "[TIDL ERROR] Fail to create tidl_info_s"); + return VC_ERROR_OUT_OF_MEMORY; + } + + int pid = getpid(); + char* engine_appid = __get_engine_appid(); + + info->rpc_h = __create_rpc_port(pid, engine_appid); + if (NULL == info->rpc_h) { + SLOG(LOG_ERROR, TAG_VCC, "[TIDL ERROR] Fail to create proxy"); + free(info); + return VC_ERROR_OPERATION_FAILED; + } + + info->pid = pid; + g_tidl_infos = g_list_append(g_tidl_infos, info); + + SLOG(LOG_ERROR, TAG_VCC, "[TIDL] pid(%d) rpc_h(%p), engine_appid(%s)", pid, info->rpc_h, info->engine_appid); + return VC_ERROR_NONE; + +} + +int vc_tidl_close_connection() +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_close_connection"); + + int pid = getpid(); + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + + if (0 != rpc_port_proxy_vc_destroy(info->rpc_h)) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to disconnect"); + return VC_ERROR_OPERATION_FAILED; + } + + info->rpc_h = NULL; + info->notify_cb_h = NULL; + + g_tidl_infos = g_list_remove(g_tidl_infos, info); + free(info); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_hello() +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_hello"); + + int pid = getpid(); + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + + if (!info->connected) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not Connected. Call __request_tidl_connect()"); + __request_tidl_connect(info); + return VC_ERROR_OPERATION_FAILED; + } + + SLOG(LOG_DEBUG, TAG_VCC, ">>>>> VCC Hello"); + if (VC_ERROR_NONE != __invoke_register_notify_callback(pid, info)) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to invoke register callback"); + return VC_ERROR_OPERATION_FAILED; + } + + SLOG(LOG_DEBUG, TAG_VCC, "<<<<"); + return VC_ERROR_NONE; + +} + +static int __covert_unhandled_error(int ret) +{ + if (RPC_PORT_ERROR_IO_ERROR == ret || RPC_PORT_ERROR_OUT_OF_MEMORY == ret) { + return VC_ERROR_OPERATION_FAILED; + } + + return ret; +} + +int vc_tidl_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_initialize"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_initialize(info->rpc_h, pid, mgr_pid, service_state, daemon_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc initialize : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc initialize : mgr = %d service = %d daemon_pid = %d", *mgr_pid, *service_state, *daemon_pid); //LCOV_EXCL_LINE + + return VC_ERROR_NONE; +} + +int vc_tidl_request_finalize(int pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_finalize"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_finalize(info->rpc_h, pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc finalize : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc finalize : result = %d", ret); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_set_command(int pid, vc_cmd_type_e cmd_type) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_set_command"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_set_command(info->rpc_h, pid, cmd_type); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc set command : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc set command : pid(%d), cmd_type(%d)", pid, cmd_type); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_unset_command(int pid, vc_cmd_type_e cmd_type) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_unset_command"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_unset_command(info->rpc_h, pid, cmd_type); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc unset command : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc unset command : pid(%d), cmd_type(%d)", pid, cmd_type); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_set_foreground(int pid, bool value) +{ + // method no reply --> async + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_set_foreground"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_set_foreground(info->rpc_h, pid, value); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc set foreground : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc set foreground : pid(%d), value(%d)", pid, value); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_set_server_dialog(int pid, const char* app_id, const char* credential) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_set_server_dialog"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_set_server_dialog(info->rpc_h, pid, app_id, credential); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc set server dialog : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc set server dialog : pid(%d), app_id(%s), credential(%s)", pid, app_id, credential); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous) +{ + // method no reply --> async + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_request_dialog"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_request_dialog(info->rpc_h, pid, disp_text, utt_text, continuous); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc request dialog : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc request dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", pid, disp_text, utt_text, continuous); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_is_system_command_valid"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_is_system_command_valid(info->rpc_h, pid, is_sys_cmd_valid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc is system command valid : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc is system command valid : pid(%d), is_sys_cmd_valid(%d)", pid, *is_sys_cmd_valid); + + return VC_ERROR_NONE; +} + +/* Authority */ +int vc_tidl_request_auth_enable(int pid, int mgr_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_auth_enable"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_auth_enable(info->rpc_h, pid, mgr_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc auth enable : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc auth enable : pid(%d), mgr_pid(%d)", pid, mgr_pid); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_auth_disable(int pid, int mgr_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_auth_disable"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_auth_disable(info->rpc_h, pid, mgr_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc auth disable : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc auth disable : pid(%d), mgr_pid(%d)", pid, mgr_pid); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_auth_start(int pid, int mgr_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_auth_start"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_auth_start(info->rpc_h, pid, mgr_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc auth start : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc auth start : pid(%d), mgr_pid(%d)", pid, mgr_pid); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_auth_stop(int pid, int mgr_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_auth_stop"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_auth_stop(info->rpc_h, pid, mgr_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc auth stop : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc auth stop : pid(%d), mgr_pid(%d)", pid, mgr_pid); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_auth_cancel(int pid, int mgr_pid) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_auth_cancel"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_auth_cancel(info->rpc_h, pid, mgr_pid); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc auth cancel : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc auth cancel : pid(%d), mgr_pid(%d)", pid, mgr_pid); + + return VC_ERROR_NONE; +} + +/* tts feedback */ +int vc_tidl_request_request_tts(int pid, const char* text, const char* language, bool to_vcm, int* utt_id) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_request_tts"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + if (VC_ERROR_NONE != __invoke_register_feedback_callback(pid, info)) { + SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to invoke register feedback callback"); + return VC_ERROR_OPERATION_FAILED; + } + + int ret = rpc_port_proxy_vc_invoke_request_tts(info->rpc_h, pid, text, language, to_vcm, utt_id); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc request tts : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc request tts : pid(%d)", pid); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_cancel_tts(int pid, int utt_id) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_cancel_tts"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_cancel_tts(info->rpc_h, pid, utt_id); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc cancel tts : Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc cancel tts : pid(%d), utt_id(%d)", pid, utt_id); + + return VC_ERROR_NONE; +} + +int vc_tidl_request_get_tts_audio_format(int pid, int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type) +{ + SLOG(LOG_INFO, TAG_VCC, "[TIDL] vc_tidl_request_get_tts_audio_format"); + + vc_tidl_info_s* info = __get_tidl_info_s(pid); + RETVM_IF(NULL == info, VC_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info"); + RETVM_IF(false == info->connected, VC_ERROR_OPERATION_FAILED, "[ERROR] Not Connected"); + + int ret = rpc_port_proxy_vc_invoke_get_tts_audio_format(info->rpc_h, pid, rate, (int*)channel, (int*)audio_type); + if (RPC_PORT_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc get tts audio format: Fail to invoke message"); + return __covert_unhandled_error(ret); + } + + SLOG(LOG_DEBUG, TAG_VCC, "@@ vc get tts audio format : pid(%d), rate(%d), channel(%d), audio_type(%d)", pid, *rate, *channel, *audio_type); + + return VC_ERROR_NONE; +} diff --git a/client/vc_tidl.h b/client/vc_tidl.h new file mode 100755 index 0000000..7b84703 --- /dev/null +++ b/client/vc_tidl.h @@ -0,0 +1,83 @@ +/* +* Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the License); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an AS IS BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + + +#ifndef __VC_TIDL_H_ +#define __VC_TIDL_H_ + +#include "voice_control_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int vc_tidl_open_connection(); + +int vc_tidl_close_connection(); + + +int vc_tidl_request_hello(); + +int vc_tidl_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid); + +int vc_tidl_request_finalize(int pid); + +int vc_tidl_request_set_command(int pid, vc_cmd_type_e cmd_type); + +int vc_tidl_request_unset_command(int pid, vc_cmd_type_e cmd_type); + +int vc_tidl_request_set_foreground(int pid, bool value); + +int vc_tidl_request_set_server_dialog(int pid, const char* app_id, const char* credential); + +int vc_tidl_request_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous); + +int vc_tidl_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid); + +#if 0 +int vc_tidl_request_start(int pid, int silence); + +int vc_tidl_request_stop(int pid); + +int vc_tidl_request_cancel(int pid); + +int vc_tidl_request_set_exclusive_command(int pid, bool value); +#endif + +/* Authority */ +int vc_tidl_request_auth_enable(int pid, int mgr_pid); + +int vc_tidl_request_auth_disable(int pid, int mgr_pid); + +int vc_tidl_request_auth_start(int pid, int mgr_pid); + +int vc_tidl_request_auth_stop(int pid, int mgr_pid); + +int vc_tidl_request_auth_cancel(int pid, int mgr_pid); + +/* tts feedback */ + +int vc_tidl_request_request_tts(int pid, const char* text, const char* language, bool to_vcm, int* utt_id); + +int vc_tidl_request_cancel_tts(int pid, int utt_id); + +int vc_tidl_request_get_tts_audio_format(int pid, int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type); + +#ifdef __cplusplus +} +#endif + +#endif /* __VC_TIDL_H_ */ diff --git a/common/vc_defs.h b/common/vc_defs.h index 81226ca..cbe89eb 100644 --- a/common/vc_defs.h +++ b/common/vc_defs.h @@ -59,6 +59,21 @@ extern "C" { #define VC_ENGINE_DB_DEFAULT "db/voice/vc/engine/default" /****************************************************************************************** +* Message Definitions for Bundle +*******************************************************************************************/ +#define VC_BUNDLE_METHOD "method" +#define VC_BUNDLE_SERVICE_STATE "service_state" +#define VC_BUNDLE_MANAGER_PID "manager_pid" +#define VC_BUNDLE_REASON "reason" +#define VC_BUNDLE_DAEMON_PID "daemon_pid" +#define VC_BUNDLE_ERR_MSG "err_msg" +#define VC_BUNDLE_PID "pid" +#define VC_BUNDLE_UTTID "uttid" +#define VC_BUNDLE_UTTSTATUS "uttstatus" +#define VC_BUNDLE_FEEDBACK_EVENT "feedback_event" +#define VC_BUNDLE_LENGTH "length" + +/****************************************************************************************** * Message Definition for all *******************************************************************************************/ @@ -267,6 +282,7 @@ extern "C" { #define VC_CONNECTION_RETRY_COUNT 10 #define VC_INVALID_TTS_UID 0 #define VC_TIDL_RETRY_COUNT 100 +#define VC_ENGINE_APPID_LEN 256 #define VC_FEATURE_PATH "tizen.org/feature/speech.control" #define VC_MGR_FEATURE_PATH "tizen.org/feature/speech.control_manager" diff --git a/common/vc_main.h b/common/vc_main.h index 15e94f9..00e079a 100644 --- a/common/vc_main.h +++ b/common/vc_main.h @@ -57,6 +57,34 @@ typedef struct vc_s *vc_h; #define FREE(x) { if (NULL != x) { free(x); x = NULL; } } #define G_FREE(x) { if (NULL != x) { g_free(x); x = NULL; } } +#define COLOR_RED "\033[0;31m" +#define COLOR_GREEN "\033[0;32m" +#define COLOR_BROWN "\033[0;33m" +#define COLOR_BLUE "\033[0;34m" +#define COLOR_PURPLE "\033[0;35m" +#define COLOR_CYAN "\033[0;36m" +#define COLOR_LIGHTBLUE "\033[0;37m" +#define COLOR_END "\033[0;m" + +#define PERR(fmt, args...) LOGE(COLOR_RED "* Critical * " fmt COLOR_END, ##args) + +#define RETM_IF(expr, fmt, arg...) \ +do { \ + if (expr) { \ + PERR(fmt, ##arg); \ + return; \ + } \ +} while (0) + +#define RETVM_IF(expr, val, fmt, arg...) \ +do { \ + if (expr) { \ + PERR(fmt, ##arg); \ + return (val); \ + } \ +} while (0) + + #ifdef __cplusplus } #endif diff --git a/packaging/voice-control.spec b/packaging/voice-control.spec index 2498f9c..bbe1861 100644 --- a/packaging/voice-control.spec +++ b/packaging/voice-control.spec @@ -34,12 +34,13 @@ BuildRequires: pkgconfig(sqlite3) BuildRequires: pkgconfig(pkgmgr-info) BuildRequires: pkgconfig(pkgmgr-installer) BuildRequires: pkgconfig(vconf) -BuildRequires: cmake BuildRequires: pkgconfig(gmock) -BuildRequires: tidl BuildRequires: pkgconfig(rpc-port) BuildRequires: pkgconfig(bundle) +BuildRequires: cmake +BuildRequires: tidl + %if 0%{?gcov:1} BuildRequires: lcov BuildRequires: zip @@ -114,6 +115,9 @@ GTest for Voice Control %setup -q -n %{name}-%{version} cp %{SOURCE1001} %{SOURCE1002} . +tidlc -p -l C -i tidl/vc.tidl -o vc_proxy +tidlc -s -l C -i tidl/vc.tidl -o vcd_stub + tidlc -p -l C -i tidl/vc_mgr.tidl -o vc_mgr_proxy tidlc -s -l C -i tidl/vc_mgr.tidl -o vcd_mgr_stub tidlc -s -l C -i tidl/vcd_mgr.tidl -o vc_mgr_stub diff --git a/server/vcd_client_data.c b/server/vcd_client_data.c index f9bdec8..8d5136d 100644 --- a/server/vcd_client_data.c +++ b/server/vcd_client_data.c @@ -31,6 +31,9 @@ static GSList* g_widget_list = NULL; static manager_info_s g_manager; +/* Client IPC info list */ +static GSList* g_client_ipc_info_list = NULL; + /* Manager IPC info */ static manager_tidl_info_s* g_mgr_tidl_info = NULL; @@ -1226,6 +1229,223 @@ int vcd_client_delete(int pid) return 0; } +GSList* __get_client_ipc_info_item(const int pid) +{ + GSList *iter = NULL; + client_ipc_info_s *data = NULL; + + int count = g_slist_length(g_client_ipc_info_list); + int i; + + if (0 < count) { + iter = g_slist_nth(g_client_ipc_info_list, 0); + for (i = 0; i < count; i++) { + if (NULL == iter) + break; + + data = iter->data; + if (NULL != data) { + if (pid == data->pid) + return iter; + } + + iter = g_slist_next(iter); + } + } + + return NULL; +} + +client_ipc_info_s* __get_client_ipc_info_element(int pid) +{ + GSList *iter = NULL; + client_ipc_info_s *data = NULL; + + int count = g_slist_length(g_client_ipc_info_list); + int i; + + if (0 < count) { + iter = g_slist_nth(g_client_ipc_info_list, 0); + for (i = 0; i < count; i++) { + if (NULL == iter) + break; + + data = iter->data; + + if (NULL != data) { + if (pid == data->pid) + return data; + } + + iter = g_slist_next(iter); + } + } + + return NULL; +} + +int vcd_client_add_ipc_info(int pid) +{ + /*Check pid is duplicated*/ + client_ipc_info_s* info = NULL; + info = __get_client_ipc_info_element(pid); + + if (NULL != info) { + SLOG(LOG_WARN, TAG_VCD, "[Client Data] Client ipc info pid is already registered"); + return VCD_ERROR_NONE; + } + + SLOG(LOG_INFO, TAG_VCD, "[Client Data] There is no ipc info of pid(%d). Create new one.", pid); + info = (client_ipc_info_s*)calloc(1, sizeof(client_ipc_info_s)); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to allocate memory"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + info->pid = pid; + info->notify_cb = NULL; + info->notify_cb_user_data = NULL; + info->feedback_cb = NULL; + info->feedback_cb_user_data = NULL; + + g_client_ipc_info_list = g_slist_append(g_client_ipc_info_list, info); + if (NULL == g_client_ipc_info_list) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to add new client ipc info"); + + free(info); + info = NULL; + + return -1; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new client ipc info. pid(%d)", pid); + } + + return VCD_ERROR_NONE; +} + +int vcd_client_set_ipc_notify_cb(int pid, rpc_port_stub_vc_notify_cb_h callback, void* user_data) +{ + /*Check pid*/ + client_ipc_info_s* info = NULL; + info = __get_client_ipc_info_element(pid); + + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no ipc info in the list. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = rpc_port_stub_vc_notify_cb_clone(callback, &(info->notify_cb)); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to clone notify callback. ret(%d)", ret); + } else { + SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to clone notify callback. ret(%d)", ret); + } + info->notify_cb_user_data = user_data; + + return VCD_ERROR_NONE; +} + +int vcd_client_unset_ipc_notify_cb(int pid) +{ + /*Check pid*/ + client_ipc_info_s* info = NULL; + info = __get_client_ipc_info_element(pid); + + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no ipc info in the list. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = rpc_port_stub_vc_notify_cb_destroy(info->notify_cb); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to destroy notify callback. ret(%d)", ret); + } else { + SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to destroy notify callback. ret(%d)", ret); + } + info->notify_cb = NULL; + info->notify_cb_user_data = NULL; + + return VCD_ERROR_NONE; +} + +int vcd_client_set_ipc_feedback_cb(int pid, rpc_port_stub_vc_feedback_cb_h callback, void* user_data) +{ + /*Check pid*/ + client_ipc_info_s* info = NULL; + info = __get_client_ipc_info_element(pid); + + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no ipc info in the list. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = rpc_port_stub_vc_feedback_cb_clone(callback, &(info->feedback_cb)); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to clone feedback callback. ret(%d)", ret); + } else { + SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to clone feedback callback. ret(%d)", ret); + } + info->feedback_cb_user_data = user_data; + + return VCD_ERROR_NONE; +} + +int vcd_client_unset_ipc_feedback_cb(int pid) +{ + /*Check pid*/ + client_ipc_info_s* info = NULL; + info = __get_client_ipc_info_element(pid); + + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no ipc info in the list. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = rpc_port_stub_vc_feedback_cb_destroy(info->feedback_cb); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to destroy feedback callback. ret(%d)", ret); + } else { + SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to destroy feedback callback. ret(%d)", ret); + } + info->feedback_cb = NULL; + info->feedback_cb_user_data = NULL; + + return VCD_ERROR_NONE; +} + +int vcd_client_delete_ipc_info(int pid) +{ + GSList *tmp = NULL; + client_ipc_info_s* client_ipc_info = NULL; + + /*Get handle*/ + tmp = __get_client_ipc_info_item(pid); + if (NULL == tmp) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT valid", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + /*Free client structure*/ + client_ipc_info = tmp->data; + if (NULL != client_ipc_info) { + free(client_ipc_info); + } + + /*Remove handle from list*/ + g_client_ipc_info_list = g_slist_remove_link(g_client_ipc_info_list, tmp); + + return 0; +} + +client_ipc_info_s* vcd_client_get_ipc_info(int pid) +{ + return __get_client_ipc_info_element(pid); +} + bool vcd_client_is_available(int pid) { vc_client_info_s* client_info = NULL; diff --git a/server/vcd_client_data.h b/server/vcd_client_data.h index 317e1d5..0620b19 100644 --- a/server/vcd_client_data.h +++ b/server/vcd_client_data.h @@ -21,6 +21,7 @@ #include #include "vc_command.h" #include "vc_info_parser.h" +#include "vcd_stub.h" #include "vcd_mgr_stub.h" #include "vcd_mgr_proxy.h" #include "vcd_widget_stub.h" @@ -71,7 +72,14 @@ typedef struct { typedef struct { int pid; + rpc_port_stub_vc_notify_cb_h notify_cb; + void* notify_cb_user_data; + rpc_port_stub_vc_feedback_cb_h feedback_cb; + void* feedback_cb_user_data; +} client_ipc_info_s; +typedef struct { + int pid; rpc_port_stub_vc_mgr_notify_cb_h notify_cb; void* notify_cb_user_data; rpc_port_stub_vc_mgr_send_buffer_cb_h send_buffer_cb; @@ -182,6 +190,20 @@ int vcd_client_add(int pid); int vcd_client_delete(int pid); +int vcd_client_add_ipc_info(int pid); + +int vcd_client_set_ipc_notify_cb(int pid, rpc_port_stub_vc_notify_cb_h callback, void* user_data); + +int vcd_client_unset_ipc_notify_cb(int pid); + +int vcd_client_set_ipc_feedback_cb(int pid, rpc_port_stub_vc_feedback_cb_h callback, void* user_data); + +int vcd_client_unset_ipc_feedback_cb(int pid); + +int vcd_client_delete_ipc_info(int pid); + +client_ipc_info_s* vcd_client_get_ipc_info(int pid); + bool vcd_client_is_available(int pid); int vcd_client_get_ref_count(); diff --git a/server/vcd_dbus.c b/server/vcd_dbus.c index 54bf596..f7cfc10 100755 --- a/server/vcd_dbus.c +++ b/server/vcd_dbus.c @@ -108,73 +108,71 @@ int vcd_check_dbus_connection() return 0; } -int vcdc_send_hello(int pid, vcd_client_type_e type) -{ - if (0 != __dbus_check()) { - return VCD_ERROR_OPERATION_FAILED; - } - - DBusMessage* msg = NULL; - - if (VCD_CLIENT_TYPE_NORMAL == type) { - msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL); - } else if (VCD_CLIENT_TYPE_WIDGET == type) { - // msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET); - vcdc_tidl_send_hello(pid, type); - return VCD_ERROR_NONE; - } else if (VCD_CLIENT_TYPE_MANAGER == type) { - vcdc_tidl_send_hello(pid, type); - return VCD_ERROR_NONE; - } else { - SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid"); - return -1; - } - - if (NULL == msg) { - SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message"); - return VCD_ERROR_OUT_OF_MEMORY; - } - - dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); - - DBusError err; - dbus_error_init(&err); - - DBusMessage* result_msg; - int result = -1; - - result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err); - dbus_message_unref(msg); - - if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message); - if (NULL != err.name) { - if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available"); - dbus_error_free(&err); - return 0; - } - } - dbus_error_free(&err); - } - - if (NULL != result_msg) { - dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID); - - if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message); - dbus_error_free(&err); - result = VCD_ERROR_OPERATION_FAILED; - } - - dbus_message_unref(result_msg); - } else { - SLOG(LOG_WARN, TAG_VCD, "[Dbus] Result message is NULL. Client is not available"); - } - - return result; -} +// int vcdc_send_hello(int pid, vcd_client_type_e type) +// { +// if (0 != __dbus_check()) { +// return VCD_ERROR_OPERATION_FAILED; +// } + +// DBusMessage* msg = NULL; + +// if (VCD_CLIENT_TYPE_NORMAL == type) { +// msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL); +// } else if (VCD_CLIENT_TYPE_WIDGET == type) { +// msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET); +// } else if (VCD_CLIENT_TYPE_MANAGER == type) { +// msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER); +// } else { +// SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid"); +// return -1; +// } + +// if (NULL == msg) { +// SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message"); +// return VCD_ERROR_OUT_OF_MEMORY; +// } + +// dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + +// DBusError err; +// dbus_error_init(&err); + +// DBusMessage* result_msg; +// int result = -1; + +// result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err); +// dbus_message_unref(msg); + +// if (dbus_error_is_set(&err)) { +// SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message); +// if (NULL != err.name) { +// if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) { +// SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available"); +// dbus_error_free(&err); +// return 0; +// } +// } +// dbus_error_free(&err); +// } + +// if (NULL != result_msg) { +// dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID); + +// if (dbus_error_is_set(&err)) { +// SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message); +// dbus_error_free(&err); +// result = VCD_ERROR_OPERATION_FAILED; +// } + +// dbus_message_unref(result_msg); +// } else { +// SLOG(LOG_WARN, TAG_VCD, "[Dbus] Result message is NULL. Client is not available"); +// } + +// return result; +// } +/* int vcdc_send_result(int pid, int manager_pid, int cmd_type) { if (0 != __dbus_check()) { @@ -204,10 +202,6 @@ int vcdc_send_result(int pid, int manager_pid, int cmd_type) case VC_COMMAND_TYPE_SYSTEM: case VC_COMMAND_TYPE_SYSTEM_BACKGROUND: case VC_COMMAND_TYPE_EXCLUSIVE: - // msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER); - // break; - vcdc_tidl_send_result(pid, manager_pid, VCD_CLIENT_TYPE_MANAGER); - return 0; default: SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type); @@ -233,7 +227,7 @@ int vcdc_send_result(int pid, int manager_pid, int cmd_type) return 0; } - +*/ int vcdc_send_manager_pid(int manager_pid) { DBusError err; @@ -416,7 +410,7 @@ int vcdc_send_error_signal(int reason, char *err_msg) return 0; } - +/* int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg) { if (NULL == err_msg) { @@ -456,7 +450,10 @@ int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg) return VCD_ERROR_NONE; } +*/ +/* +>>>>>>> Replace IPC (VCC) from dbus to tidl int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) { SLOG(LOG_INFO, TAG_VCD, "[Dbus] Send TTS feedback streaming : pid(%d), utt_id(%d), feedback event(%d), buffer(%p), length(%d)", pid, utt_id, event, buffer, len); @@ -468,7 +465,7 @@ int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, DBusError err; dbus_error_init(&err); - /* make dbus message */ + // make dbus message DBusMessage* msg = NULL; msg = __get_message(pid, VCD_METHOD_FEEDBACK_STREAMING, VCD_CLIENT_TYPE_NORMAL); if (NULL == msg) { @@ -499,7 +496,7 @@ int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, return ret; } - +*/ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler) { if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW; diff --git a/server/vcd_dbus.h b/server/vcd_dbus.h index fcfaad3..d6ae86c 100644 --- a/server/vcd_dbus.h +++ b/server/vcd_dbus.h @@ -30,18 +30,18 @@ int vcd_dbus_close_connection(); int vcd_check_dbus_connection(); -int vcdc_send_hello(int pid, vcd_client_type_e type); +// int vcdc_send_hello(int pid, vcd_client_type_e type); -int vcdc_send_result(int pid, int manager_pid, int cmd_type); +//int vcdc_send_result(int pid, int manager_pid, int cmd_type); int vcdc_send_error_signal(int reason, char *err_msg); -int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg); +//int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg); int vcdc_send_manager_pid(int manager_pid); /* for TTS feedback */ -int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); +//int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); #ifdef __cplusplus } diff --git a/server/vcd_stub.c b/server/vcd_stub.c new file mode 100755 index 0000000..e84a2e3 --- /dev/null +++ b/server/vcd_stub.c @@ -0,0 +1,2422 @@ +/* + * Generated by tidlc 1.8.1. + */ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vcd_stub.h" + +#undef LOG_TAG +#define LOG_TAG "RPC_PORT_STUB" + +#undef _E +#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _W +#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _I +#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#undef _D +#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#ifndef TIDL_VERSION +#define TIDL_VERSION "1.8.1" +#endif + +#ifndef nullptr +#define nullptr NULL +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) +#endif + +#ifndef STRING_GET +#define STRING_GET(x) ((x) ? x : "") +#endif + +typedef int (*rpc_port_stub_method_handler)(rpc_port_h port, rpc_port_parcel_h parcel, void *data); + +typedef enum { + RPC_PORT_STUB_VC_METHOD_RESULT_, + RPC_PORT_STUB_VC_METHOD_CALLBACK_, + RPC_PORT_STUB_VC_METHOD_REGISTER_NOTIFY_CB, + RPC_PORT_STUB_VC_METHOD_REGISTER_NOTIFY_CB_SYNC, + RPC_PORT_STUB_VC_METHOD_REGISTER_FEEDBACK_CB, + RPC_PORT_STUB_VC_METHOD_REGISTER_FEEDBACK_CB_SYNC, + RPC_PORT_STUB_VC_METHOD_INITIALIZE, + RPC_PORT_STUB_VC_METHOD_FINALIZE, + RPC_PORT_STUB_VC_METHOD_SET_COMMAND, + RPC_PORT_STUB_VC_METHOD_UNSET_COMMAND, + RPC_PORT_STUB_VC_METHOD_SET_FOREGROUND, + RPC_PORT_STUB_VC_METHOD_SET_SERVER_DIALOG, + RPC_PORT_STUB_VC_METHOD_REQUEST_DIALOG, + RPC_PORT_STUB_VC_METHOD_IS_SYSTEM_COMMAND_VALID, + RPC_PORT_STUB_VC_METHOD_AUTH_ENABLE, + RPC_PORT_STUB_VC_METHOD_AUTH_DISABLE, + RPC_PORT_STUB_VC_METHOD_AUTH_START, + RPC_PORT_STUB_VC_METHOD_AUTH_STOP, + RPC_PORT_STUB_VC_METHOD_AUTH_CANCEL, + RPC_PORT_STUB_VC_METHOD_REQUEST_TTS, + RPC_PORT_STUB_VC_METHOD_CANCEL_TTS, + RPC_PORT_STUB_VC_METHOD_GET_TTS_AUDIO_FORMAT, +} rpc_port_stub_vc_method_e; + +typedef enum { + RPC_PORT_STUB_VC_DELEGATE_NOTIFY_CB = 1, + RPC_PORT_STUB_VC_DELEGATE_FEEDBACK_CB = 2, +} rpc_port_stub_vc_delegate_e; + +typedef struct rpc_port_stub_array_char_s { + rpc_port_parcelable_t parcelable; + char *value; + int size; +} rpc_port_stub_array_char_t; + +typedef struct rpc_port_stub_vc_notify_cb_s { + rpc_port_parcelable_t parcelable; + rpc_port_h port; + int id; + int seq_id; + bool once; + bool valid; +} rpc_port_stub_vc_notify_cb_t; + +typedef struct rpc_port_stub_vc_feedback_cb_s { + rpc_port_parcelable_t parcelable; + rpc_port_h port; + int id; + int seq_id; + bool once; + bool valid; +} rpc_port_stub_vc_feedback_cb_t; + +static bool __rpc_port_stub_vc_exist_callback_port(rpc_port_h callback_port); + +typedef struct rpc_port_stub_vc_context_s { + char *sender; + char *instance; + rpc_port_h port; + rpc_port_h callback_port; + void *tag; + rpc_port_stub_vc_callback_s callback; + void *user_data; +#ifdef TIDL_THREAD_ENABLE + GThread *thread; + GQueue *queue; + GMutex mutex; + GCond cond; + bool done; +#endif /* TIDL_THREAD_ENABLE */ +} rpc_port_stub_vc_context_t; + +typedef struct rpc_port_stub_vc_s { + rpc_port_stub_h stub; + rpc_port_stub_vc_callback_s callback; + void *user_data; + GList* contexts; + GList* callback_ports; + GRecMutex mutex; +} rpc_port_stub_vc_t; + +static rpc_port_stub_vc_t __vc; + +static void __rpc_port_stub_array_char_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_array_char_h h = data; + int i; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, h->size); + + for (i = 0; i < h->size; ++i) + rpc_port_parcel_write_byte(parcel, h->value[i]); +} + +static void __rpc_port_stub_array_char_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_array_char_h h = data; + char value; + int ret; + int i; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + ret = rpc_port_parcel_read_array_count(parcel, &h->size); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read array count. error(%d)", ret); + set_last_result(ret); + return; + } + + h->value = calloc(h->size, sizeof(char)); + if (h->value == nullptr) { + _E("Out of memory"); + set_last_result(RPC_PORT_ERROR_OUT_OF_MEMORY); + return; + } + + for (i = 0; i < h->size; ++i) { + rpc_port_parcel_read_byte(parcel, &value); + h->value[i] = value; + } + + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_stub_array_char_create(rpc_port_stub_array_char_h *h) +{ + rpc_port_stub_array_char_t *handle; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_stub_array_char_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_stub_array_char_to; + handle->parcelable.from = __rpc_port_stub_array_char_from; + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_array_char_destroy(rpc_port_stub_array_char_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (h->value) + free(h->value); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_array_char_clone(rpc_port_stub_array_char_h h, rpc_port_stub_array_char_h *clone) +{ + rpc_port_stub_array_char_h handle; + rpc_port_parcel_h parcel; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_stub_array_char_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + ret = rpc_port_parcel_create(&parcel); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret); + rpc_port_stub_array_char_destroy(handle); + return ret; + } + + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_read(parcel, &handle->parcelable, handle); + ret = get_last_result(); + rpc_port_parcel_destroy(parcel); + + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret); + rpc_port_stub_array_char_destroy(handle); + return ret; + } + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_array_char_set(rpc_port_stub_array_char_h h, char *value, int size) +{ + rpc_port_stub_array_char_h handle; + rpc_port_stub_array_char_h clone; + int ret; + + if (h == nullptr || value == nullptr || size <= 0) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_stub_array_char_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + handle->value = (char *)value; + handle->size = size; + + ret = rpc_port_stub_array_char_clone(handle, &clone); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to clone handle. error(%d)", ret); + handle->value = nullptr; + handle->size = 0; + rpc_port_stub_array_char_destroy(handle); + return ret; + } + + handle->value = h->value; + handle->size = h->size; + rpc_port_stub_array_char_destroy(handle); + + h->value = clone->value; + h->size = clone->size; + + clone->value = nullptr; + clone->size = 0; + rpc_port_stub_array_char_destroy(clone); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_array_char_get(rpc_port_stub_array_char_h h, char **value, int *size) +{ + rpc_port_stub_array_char_h handle; + int ret; + + if (h == nullptr || value == nullptr || size == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_stub_array_char_clone(h, &handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to clone handle. error(%d)", ret); + return ret; + } + + *value = handle->value; + *size = handle->size; + + handle->value = nullptr; + handle->size = 0; + rpc_port_stub_array_char_destroy(handle); + + return RPC_PORT_ERROR_NONE; +} + +static void __rpc_port_stub_vc_notify_cb_to(rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_notify_cb_h h = user_data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, h->id); + + rpc_port_parcel_write_int32(parcel, h->seq_id); + + rpc_port_parcel_write_bool(parcel, h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); +} + +static void __rpc_port_stub_vc_notify_cb_from(rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_notify_cb_h h = user_data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + rpc_port_parcel_read_int32(parcel, &h->id); + + rpc_port_parcel_read_int32(parcel, &h->seq_id); + + rpc_port_parcel_read_bool(parcel, &h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_stub_vc_notify_cb_create(rpc_port_stub_vc_notify_cb_h *h) +{ + rpc_port_stub_vc_notify_cb_t *handle; + static int seq_num; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_stub_vc_notify_cb_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_stub_vc_notify_cb_to; + handle->parcelable.from = __rpc_port_stub_vc_notify_cb_from; + handle->id = RPC_PORT_STUB_VC_DELEGATE_NOTIFY_CB; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->once = false; + handle->valid = true; + _I("id(%d), seq_id(%d)", handle->id, handle->seq_id); + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_destroy(rpc_port_stub_vc_notify_cb_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + _W("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_clone(rpc_port_stub_vc_notify_cb_h h, rpc_port_stub_vc_notify_cb_h *clone) +{ + rpc_port_stub_vc_notify_cb_h handle; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_stub_vc_notify_cb_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + handle->port = h->port; + handle->seq_id = h->seq_id; + handle->once = h->once; + handle->valid = h->valid; + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_get_id(rpc_port_stub_vc_notify_cb_h h, int *id) +{ + if (h == nullptr || id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *id = h->id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_get_seq_id(rpc_port_stub_vc_notify_cb_h h, int *seq_id) +{ + if (h == nullptr || seq_id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *seq_id = h->seq_id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_is_once(rpc_port_stub_vc_notify_cb_h h, bool *once) +{ + if (h == nullptr || once == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *once = h->once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_get_tag(rpc_port_stub_vc_notify_cb_h h, char **tag) +{ + char *value; + char buf[128]; + + if (h == nullptr || tag == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + snprintf(buf, sizeof(buf), "%d::%d", h->id, h->seq_id); + value = strdup(buf); + if (value == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *tag = value; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_set_port(rpc_port_stub_vc_notify_cb_h h, rpc_port_h port) +{ + if (h == nullptr || port == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->port = port; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_notify_cb_invoke(rpc_port_stub_vc_notify_cb_h h, int pid, bundle *msg) +{ + rpc_port_parcel_h parcel_; + int ret_; + + if (h == nullptr || h->port == nullptr || msg == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (!__rpc_port_stub_vc_exist_callback_port(h->port)) { + _E("Not connected"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (h->once && !h->valid) { + _E("The delegate handle is already used"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + return ret_; + } + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_CALLBACK_); + + rpc_port_parcel_write(parcel_, &h->parcelable, h); + + rpc_port_parcel_write_int32(parcel_, pid); + + rpc_port_parcel_write_bundle(parcel_, msg); + + ret_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + h->valid = false; + + return ret_; +} + +static void __rpc_port_stub_vc_feedback_cb_to(rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_feedback_cb_h h = user_data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, h->id); + + rpc_port_parcel_write_int32(parcel, h->seq_id); + + rpc_port_parcel_write_bool(parcel, h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); +} + +static void __rpc_port_stub_vc_feedback_cb_from(rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_feedback_cb_h h = user_data; + + if (parcel == nullptr || h == nullptr) { + _E("Invalid parameter"); + set_last_result(RPC_PORT_ERROR_INVALID_PARAMETER); + return; + } + + rpc_port_parcel_read_int32(parcel, &h->id); + + rpc_port_parcel_read_int32(parcel, &h->seq_id); + + rpc_port_parcel_read_bool(parcel, &h->once); + + _I("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + set_last_result(RPC_PORT_ERROR_NONE); +} + +int rpc_port_stub_vc_feedback_cb_create(rpc_port_stub_vc_feedback_cb_h *h) +{ + rpc_port_stub_vc_feedback_cb_t *handle; + static int seq_num; + + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + handle = calloc(1, sizeof(rpc_port_stub_vc_feedback_cb_t)); + if (handle == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + handle->parcelable.to = __rpc_port_stub_vc_feedback_cb_to; + handle->parcelable.from = __rpc_port_stub_vc_feedback_cb_from; + handle->id = RPC_PORT_STUB_VC_DELEGATE_FEEDBACK_CB; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->once = false; + handle->valid = true; + _I("id(%d), seq_id(%d)", handle->id, handle->seq_id); + + *h = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_destroy(rpc_port_stub_vc_feedback_cb_h h) +{ + if (h == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + _W("id(%d), seq_id(%d), once(%s)", h->id, h->seq_id, h->once ? "true" : "false"); + + free(h); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_clone(rpc_port_stub_vc_feedback_cb_h h, rpc_port_stub_vc_feedback_cb_h *clone) +{ + rpc_port_stub_vc_feedback_cb_h handle; + int ret; + + if (h == nullptr || clone == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret = rpc_port_stub_vc_feedback_cb_create(&handle); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret); + return ret; + } + + handle->port = h->port; + handle->seq_id = h->seq_id; + handle->once = h->once; + handle->valid = h->valid; + + *clone = handle; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_get_id(rpc_port_stub_vc_feedback_cb_h h, int *id) +{ + if (h == nullptr || id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *id = h->id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_get_seq_id(rpc_port_stub_vc_feedback_cb_h h, int *seq_id) +{ + if (h == nullptr || seq_id == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *seq_id = h->seq_id; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_is_once(rpc_port_stub_vc_feedback_cb_h h, bool *once) +{ + if (h == nullptr || once == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *once = h->once; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_get_tag(rpc_port_stub_vc_feedback_cb_h h, char **tag) +{ + char *value; + char buf[128]; + + if (h == nullptr || tag == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + snprintf(buf, sizeof(buf), "%d::%d", h->id, h->seq_id); + value = strdup(buf); + if (value == nullptr) { + _E("Out of memory"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *tag = value; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_set_port(rpc_port_stub_vc_feedback_cb_h h, rpc_port_h port) +{ + if (h == nullptr || port == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + h->port = port; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_feedback_cb_invoke(rpc_port_stub_vc_feedback_cb_h h, int utt_id, int event, rpc_port_stub_array_char_h pcm_data, int len) +{ + rpc_port_parcel_h parcel_; + int ret_; + + if (h == nullptr || h->port == nullptr || pcm_data == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (!__rpc_port_stub_vc_exist_callback_port(h->port)) { + _E("Not connected"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (h->once && !h->valid) { + _E("The delegate handle is already used"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + return ret_; + } + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_CALLBACK_); + + rpc_port_parcel_write(parcel_, &h->parcelable, h); + + rpc_port_parcel_write_int32(parcel_, utt_id); + + rpc_port_parcel_write_int32(parcel_, event); + + rpc_port_parcel_write(parcel_, &pcm_data->parcelable, pcm_data); + + rpc_port_parcel_write_int32(parcel_, len); + + ret_ = rpc_port_parcel_send(parcel_, h->port); + rpc_port_parcel_destroy(parcel_); + h->valid = false; + + return ret_; +} + +static int __rpc_port_stub_vc_method_register_notify_cb_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + rpc_port_stub_vc_notify_cb_h callback = nullptr; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + ret_ = rpc_port_stub_vc_notify_cb_create(&callback); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret_); + goto out; + } + + rpc_port_stub_vc_notify_cb_set_port(callback, callback_port_); + rpc_port_parcel_read(parcel, &callback->parcelable, callback); + ret_ = get_last_result(); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret_); + goto out; + } + + if (context_->callback.register_notify_cb) + context_->callback.register_notify_cb(context_, pid, callback, context_->user_data); + +out: + if (callback) + rpc_port_stub_vc_notify_cb_destroy(callback); + + return ret_; +} + +static int __rpc_port_stub_vc_method_register_notify_cb_sync_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + rpc_port_stub_vc_notify_cb_h callback = nullptr; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + ret_ = rpc_port_stub_vc_notify_cb_create(&callback); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret_); + goto out; + } + + rpc_port_stub_vc_notify_cb_set_port(callback, callback_port_); + rpc_port_parcel_read(parcel, &callback->parcelable, callback); + ret_ = get_last_result(); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret_); + goto out; + } + + if (context_->callback.register_notify_cb_sync) + res_ = context_->callback.register_notify_cb_sync(context_, pid, callback, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + if (callback) + rpc_port_stub_vc_notify_cb_destroy(callback); + + return ret_; +} + +static int __rpc_port_stub_vc_method_register_feedback_cb_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + rpc_port_stub_vc_feedback_cb_h callback = nullptr; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + ret_ = rpc_port_stub_vc_feedback_cb_create(&callback); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret_); + goto out; + } + + rpc_port_stub_vc_feedback_cb_set_port(callback, callback_port_); + rpc_port_parcel_read(parcel, &callback->parcelable, callback); + ret_ = get_last_result(); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret_); + goto out; + } + + if (context_->callback.register_feedback_cb) + context_->callback.register_feedback_cb(context_, pid, callback, context_->user_data); + +out: + if (callback) + rpc_port_stub_vc_feedback_cb_destroy(callback); + + return ret_; +} + +static int __rpc_port_stub_vc_method_register_feedback_cb_sync_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + rpc_port_stub_vc_feedback_cb_h callback = nullptr; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + ret_ = rpc_port_stub_vc_feedback_cb_create(&callback); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create handle. error(%d)", ret_); + goto out; + } + + rpc_port_stub_vc_feedback_cb_set_port(callback, callback_port_); + rpc_port_parcel_read(parcel, &callback->parcelable, callback); + ret_ = get_last_result(); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to read data. error(%d)", ret_); + goto out; + } + + if (context_->callback.register_feedback_cb_sync) + res_ = context_->callback.register_feedback_cb_sync(context_, pid, callback, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + if (callback) + rpc_port_stub_vc_feedback_cb_destroy(callback); + + return ret_; +} + +static int __rpc_port_stub_vc_method_initialize_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + int service_state = -1; + int daemon_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + if (context_->callback.initialize) + res_ = context_->callback.initialize(context_, pid, &mgr_pid, &service_state, &daemon_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, mgr_pid); + + rpc_port_parcel_write_int32(parcel_, service_state); + + rpc_port_parcel_write_int32(parcel_, daemon_pid); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_finalize_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + if (context_->callback.finalize) + res_ = context_->callback.finalize(context_, pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_set_command_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int cmd_type = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &cmd_type); + + if (context_->callback.set_command) + res_ = context_->callback.set_command(context_, pid, cmd_type, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_unset_command_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int cmd_type = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &cmd_type); + + if (context_->callback.unset_command) + res_ = context_->callback.unset_command(context_, pid, cmd_type, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_set_foreground_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + bool value = false; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_bool(parcel, &value); + + if (context_->callback.set_foreground) + res_ = context_->callback.set_foreground(context_, pid, value, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_set_server_dialog_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + char *app_id = nullptr; + char *credential = nullptr; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_string(parcel, &app_id); + if (app_id == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + rpc_port_parcel_read_string(parcel, &credential); + if (credential == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + if (context_->callback.set_server_dialog) + res_ = context_->callback.set_server_dialog(context_, pid, app_id, credential, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + if (app_id) + free(app_id); + + if (credential) + free(credential); + + return ret_; +} + +static int __rpc_port_stub_vc_method_request_dialog_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + char *disp_text = nullptr; + char *utt_text = nullptr; + bool continuous = false; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_string(parcel, &disp_text); + if (disp_text == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + rpc_port_parcel_read_string(parcel, &utt_text); + if (utt_text == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + rpc_port_parcel_read_bool(parcel, &continuous); + + if (context_->callback.request_dialog) + res_ = context_->callback.request_dialog(context_, pid, disp_text, utt_text, continuous, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + if (disp_text) + free(disp_text); + + if (utt_text) + free(utt_text); + + return ret_; +} + +static int __rpc_port_stub_vc_method_is_system_command_valid_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + bool is_sys_cmd_valid = false; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + if (context_->callback.is_system_command_valid) + res_ = context_->callback.is_system_command_valid(context_, pid, &is_sys_cmd_valid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_bool(parcel_, is_sys_cmd_valid); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_auth_enable_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &mgr_pid); + + if (context_->callback.auth_enable) + res_ = context_->callback.auth_enable(context_, pid, mgr_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_auth_disable_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &mgr_pid); + + if (context_->callback.auth_disable) + res_ = context_->callback.auth_disable(context_, pid, mgr_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_auth_start_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &mgr_pid); + + if (context_->callback.auth_start) + res_ = context_->callback.auth_start(context_, pid, mgr_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_auth_stop_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &mgr_pid); + + if (context_->callback.auth_stop) + res_ = context_->callback.auth_stop(context_, pid, mgr_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_auth_cancel_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int mgr_pid = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &mgr_pid); + + if (context_->callback.auth_cancel) + res_ = context_->callback.auth_cancel(context_, pid, mgr_pid, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_request_tts_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + char *text = nullptr; + char *lang = nullptr; + bool to_vcm = false; + int utt_id = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_string(parcel, &text); + if (text == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + rpc_port_parcel_read_string(parcel, &lang); + if (lang == nullptr) { + _E("Failed to read data"); + ret_ = RPC_PORT_ERROR_OUT_OF_MEMORY; + goto out; + } + + rpc_port_parcel_read_bool(parcel, &to_vcm); + + if (context_->callback.request_tts) + res_ = context_->callback.request_tts(context_, pid, text, lang, to_vcm, &utt_id, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, utt_id); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + if (text) + free(text); + + if (lang) + free(lang); + + return ret_; +} + +static int __rpc_port_stub_vc_method_cancel_tts_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int utt_id = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + rpc_port_parcel_read_int32(parcel, &utt_id); + + if (context_->callback.cancel_tts) + res_ = context_->callback.cancel_tts(context_, pid, utt_id, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static int __rpc_port_stub_vc_method_get_tts_audio_format_handler(rpc_port_h port, rpc_port_parcel_h parcel, void *user_data) +{ + rpc_port_stub_vc_context_h context_ = user_data; + rpc_port_parcel_header_h header_; + int seq_num_ = -1; + rpc_port_h callback_port_; + int ret_; + int pid = -1; + int rate = -1; + int channel = -1; + int audio_type = -1; + rpc_port_parcel_h parcel_; + int res_ = -1; + + ret_ = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, context_->instance, &callback_port_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel, &header_); + rpc_port_parcel_header_get_seq_num(header_, &seq_num_); + _W("[Sequence] %d", seq_num_); + + rpc_port_parcel_read_int32(parcel, &pid); + + if (context_->callback.get_tts_audio_format) + res_ = context_->callback.get_tts_audio_format(context_, pid, &rate, &channel, &audio_type, context_->user_data); + + ret_ = rpc_port_parcel_create(&parcel_); + if (ret_ != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle. error(%d)", ret_); + goto out; + } + + rpc_port_parcel_get_header(parcel_, &header_); + rpc_port_parcel_header_set_tag(header_, TIDL_VERSION); + rpc_port_parcel_header_set_seq_num(header_, seq_num_); + + rpc_port_parcel_write_int32(parcel_, RPC_PORT_STUB_VC_METHOD_RESULT_); + + rpc_port_parcel_write_int32(parcel_, rate); + + rpc_port_parcel_write_int32(parcel_, channel); + + rpc_port_parcel_write_int32(parcel_, audio_type); + + rpc_port_parcel_write_int32(parcel_, res_); + + ret_ = rpc_port_parcel_send(parcel_, port); + rpc_port_parcel_destroy(parcel_); + +out: + + return ret_; +} + +static rpc_port_stub_method_handler __vc_method_table[] = { + [RPC_PORT_STUB_VC_METHOD_REGISTER_NOTIFY_CB] = __rpc_port_stub_vc_method_register_notify_cb_handler, + [RPC_PORT_STUB_VC_METHOD_REGISTER_NOTIFY_CB_SYNC] = __rpc_port_stub_vc_method_register_notify_cb_sync_handler, + [RPC_PORT_STUB_VC_METHOD_REGISTER_FEEDBACK_CB] = __rpc_port_stub_vc_method_register_feedback_cb_handler, + [RPC_PORT_STUB_VC_METHOD_REGISTER_FEEDBACK_CB_SYNC] = __rpc_port_stub_vc_method_register_feedback_cb_sync_handler, + [RPC_PORT_STUB_VC_METHOD_INITIALIZE] = __rpc_port_stub_vc_method_initialize_handler, + [RPC_PORT_STUB_VC_METHOD_FINALIZE] = __rpc_port_stub_vc_method_finalize_handler, + [RPC_PORT_STUB_VC_METHOD_SET_COMMAND] = __rpc_port_stub_vc_method_set_command_handler, + [RPC_PORT_STUB_VC_METHOD_UNSET_COMMAND] = __rpc_port_stub_vc_method_unset_command_handler, + [RPC_PORT_STUB_VC_METHOD_SET_FOREGROUND] = __rpc_port_stub_vc_method_set_foreground_handler, + [RPC_PORT_STUB_VC_METHOD_SET_SERVER_DIALOG] = __rpc_port_stub_vc_method_set_server_dialog_handler, + [RPC_PORT_STUB_VC_METHOD_REQUEST_DIALOG] = __rpc_port_stub_vc_method_request_dialog_handler, + [RPC_PORT_STUB_VC_METHOD_IS_SYSTEM_COMMAND_VALID] = __rpc_port_stub_vc_method_is_system_command_valid_handler, + [RPC_PORT_STUB_VC_METHOD_AUTH_ENABLE] = __rpc_port_stub_vc_method_auth_enable_handler, + [RPC_PORT_STUB_VC_METHOD_AUTH_DISABLE] = __rpc_port_stub_vc_method_auth_disable_handler, + [RPC_PORT_STUB_VC_METHOD_AUTH_START] = __rpc_port_stub_vc_method_auth_start_handler, + [RPC_PORT_STUB_VC_METHOD_AUTH_STOP] = __rpc_port_stub_vc_method_auth_stop_handler, + [RPC_PORT_STUB_VC_METHOD_AUTH_CANCEL] = __rpc_port_stub_vc_method_auth_cancel_handler, + [RPC_PORT_STUB_VC_METHOD_REQUEST_TTS] = __rpc_port_stub_vc_method_request_tts_handler, + [RPC_PORT_STUB_VC_METHOD_CANCEL_TTS] = __rpc_port_stub_vc_method_cancel_tts_handler, + [RPC_PORT_STUB_VC_METHOD_GET_TTS_AUDIO_FORMAT] = __rpc_port_stub_vc_method_get_tts_audio_format_handler, +}; + +static int __rpc_port_stub_vc_context_handle_request(rpc_port_stub_vc_context_h h, rpc_port_parcel_h parcel) +{ + int ret = RPC_PORT_ERROR_NONE; + int cmd = -1; + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd > 1 && cmd < ARRAY_SIZE(__vc_method_table)) { + if (__vc_method_table[cmd]) + ret = __vc_method_table[cmd](h->port, parcel, h); + } else { + _W("Invalid protocol. cmd(%d)", cmd); + ret = RPC_PORT_ERROR_INVALID_PARAMETER; + } + + return ret; +} + +#ifdef TIDL_THREAD_ENABLE +static int __rpc_port_stub_vc_context_push(rpc_port_stub_vc_context_h h, rpc_port_parcel_h parcel) +{ + g_mutex_lock(&h->mutex); + g_queue_push_tail(h->queue, parcel); + g_cond_signal(&h->cond); + g_mutex_unlock(&h->mutex); + + return 0; +} + +static rpc_port_parcel_h __rpc_port_stub_vc_context_wait_and_pop(rpc_port_stub_vc_context_h h) +{ + rpc_port_parcel_h parcel; + + g_mutex_lock(&h->mutex); + while (g_queue_is_empty(h->queue) && !h->done) + g_cond_wait(&h->cond, &h->mutex); + + parcel = g_queue_pop_head(h->queue); + g_mutex_unlock(&h->mutex); + + return parcel; +} + +static gpointer __rpc_port_stub_vc_context_thread_cb(gpointer user_data) +{ + rpc_port_stub_vc_context_h h = user_data; + rpc_port_parcel_h parcel; + + _W("START"); + while (!h->done) { + parcel = __rpc_port_stub_vc_context_wait_and_pop(h); + if (parcel) { + __rpc_port_stub_vc_context_handle_request(h, parcel); + rpc_port_parcel_destroy(parcel); + } + } + _W("END"); + + return nullptr; +} +#endif /* TIDL_THREAD_ENABLE */ + +static void __rpc_port_stub_vc_context_destroy(gpointer data) +{ + rpc_port_stub_vc_context_h h = data; +#ifdef TIDL_THREAD_ENABLE + rpc_port_parcel_h parcel; +#endif /* TIDL_THREAD_ENABLE */ + + if (h == nullptr) + return; + +#ifdef TIDL_THREAD_ENABLE + g_mutex_lock(&h->mutex); + h->done = true; + g_cond_signal(&h->cond); + g_mutex_unlock(&h->mutex); + + if (h->thread) { + g_thread_join(h->thread); + g_thread_unref(h->thread); + } + + g_mutex_clear(&h->mutex); + g_cond_clear(&h->cond); + + if (h->queue) { + while (!g_queue_is_empty(h->queue)) { + parcel = g_queue_pop_head(h->queue); + rpc_port_parcel_destroy(parcel); + } + + g_queue_free(h->queue); + } +#endif /* TIDL_THREAD_ENABLE */ + + if (h->instance) + free(h->instance); + + if (h->sender) + free(h->sender); + + free(h); +} + +static rpc_port_stub_vc_context_h __rpc_port_stub_vc_context_create(const char *sender, const char *instance, rpc_port_h callback_port) +{ + rpc_port_stub_vc_context_t *handle; + + if (sender == nullptr || instance == nullptr || callback_port == nullptr) { + _E("Invalid parameter"); + return nullptr; + } + + handle = calloc(1, sizeof(rpc_port_stub_vc_context_t)); + if (handle == nullptr) { + _E("Out of memory"); + return nullptr; + } + + handle->sender = strdup(sender); + if (handle->sender == nullptr) { + _E("Failed to duplicate sender"); + __rpc_port_stub_vc_context_destroy(handle); + return nullptr; + } + + handle->instance = strdup(instance); + if (handle->instance == nullptr) { + _E("Failed to duplicate instance"); + __rpc_port_stub_vc_context_destroy(handle); + return nullptr; + } + +#ifdef TIDL_THREAD_ENABLE + g_mutex_init(&handle->mutex); + g_cond_init(&handle->cond); + + handle->queue = g_queue_new(); + if (handle->queue == nullptr) { + _E("Failed to create queue"); + __rpc_port_stub_vc_context_destroy(handle); + return nullptr; + } + + handle->thread = g_thread_new(instance, __rpc_port_stub_vc_context_thread_cb, handle); + if (handle->thread == nullptr) { + _E("Failed to create thread"); + __rpc_port_stub_vc_context_destroy(handle); + return nullptr; + } +#endif /* TIDL_THREAD_ENABLE */ + + handle->callback_port = callback_port; + handle->callback = __vc.callback; + handle->user_data = __vc.user_data; + + return handle; +} + +int rpc_port_stub_vc_context_set_tag(rpc_port_stub_vc_context_h context, void *tag) +{ + if (context == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + context->tag = tag; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_context_get_tag(rpc_port_stub_vc_context_h context, void **tag) +{ + if (context == nullptr || tag == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + *tag = context->tag; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_context_get_sender(rpc_port_stub_vc_context_h context, char **sender) +{ + char *value; + + if (context == nullptr || sender == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + value = strdup(context->sender); + if (value == nullptr) { + _E("Failed to duplicate sender"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *sender = value; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_context_get_instance(rpc_port_stub_vc_context_h context, char **instance) +{ + char *value; + + if (context == nullptr || instance == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + value = strdup(context->instance); + if (value == nullptr) { + _E("Failed to duplicate instance"); + return RPC_PORT_ERROR_OUT_OF_MEMORY; + } + + *instance = value; + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_context_disconnect(rpc_port_stub_vc_context_h context) +{ + int ret; + + if (context == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + g_rec_mutex_lock(&__vc.mutex); + + ret = rpc_port_disconnect(context->callback_port); + if (ret != RPC_PORT_ERROR_NONE) + _E("Failed to disconnect. error(%d)", ret); + + g_rec_mutex_unlock(&__vc.mutex); + + return ret; +} + +static rpc_port_stub_vc_context_h __rpc_port_stub_vc_find_context(const char *instance) +{ + rpc_port_stub_vc_context_h context; + GList *iter; + + g_rec_mutex_lock(&__vc.mutex); + iter = __vc.contexts; + while (iter) { + context = iter->data; + if (!strcmp(context->instance, instance)) { + g_rec_mutex_unlock(&__vc.mutex); + return context; + } + + iter = g_list_next(iter); + } + g_rec_mutex_unlock(&__vc.mutex); + + return nullptr; +} + +static void __rpc_port_stub_vc_add_context(rpc_port_stub_vc_context_h context) +{ + g_rec_mutex_lock(&__vc.mutex); + __vc.contexts = g_list_append(__vc.contexts, context); + g_rec_mutex_unlock(&__vc.mutex); +} + +static void __rpc_port_stub_vc_remove_context(rpc_port_stub_vc_context_h context) +{ + g_rec_mutex_lock(&__vc.mutex); + __vc.contexts = g_list_remove(__vc.contexts, context); + g_rec_mutex_unlock(&__vc.mutex); +} + +static bool __rpc_port_stub_vc_exist_callback_port(rpc_port_h callback_port) +{ + rpc_port_h port; + GList *iter; + + g_rec_mutex_lock(&__vc.mutex); + iter = __vc.callback_ports; + while (iter) { + port = iter->data; + if (port == callback_port) { + g_rec_mutex_unlock(&__vc.mutex); + return true; + } + + iter = g_list_next(iter); + } + g_rec_mutex_unlock(&__vc.mutex); + + return false; +} + +static void __rpc_port_stub_vc_add_callback_port(rpc_port_h callback_port) +{ + g_rec_mutex_lock(&__vc.mutex); + __vc.callback_ports = g_list_append(__vc.callback_ports, callback_port); + g_rec_mutex_unlock(&__vc.mutex); +} + +static void __rpc_port_stub_vc_remove_callback_port(rpc_port_h callback_port) +{ + g_rec_mutex_lock(&__vc.mutex); + __vc.callback_ports = g_list_remove(__vc.callback_ports, callback_port); + g_rec_mutex_unlock(&__vc.mutex); +} + +static void __rpc_port_stub_vc_connected_event_cb(const char *sender, const char *instance, void *user_data) +{ + rpc_port_stub_vc_context_h context; + rpc_port_h callback_port = nullptr; + int ret; + + _W("sender(%s), instance(%s)", sender, instance); + ret = rpc_port_stub_get_port(__vc.stub, RPC_PORT_PORT_CALLBACK, instance, &callback_port); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to get callback port. error(%d)", ret); + return; + } + + context = __rpc_port_stub_vc_context_create(sender, instance, callback_port); + if (context == nullptr) + return; + + __rpc_port_stub_vc_add_context(context); + __rpc_port_stub_vc_add_callback_port(context->callback_port); + context->callback.create(context, context->user_data); +} + +static void __rpc_port_stub_vc_disconnected_event_cb(const char *sender, const char *instance, void *user_data) +{ + rpc_port_stub_vc_context_h context; + + _W("sender(%s), instance(%s)", sender, instance); + context = __rpc_port_stub_vc_find_context(instance); + if (context == nullptr) + return; + + __rpc_port_stub_vc_remove_callback_port(context->callback_port); + context->callback.terminate(context, context->user_data); + __rpc_port_stub_vc_remove_context(context); + __rpc_port_stub_vc_context_destroy(context); +} + +static int __rpc_port_stub_vc_received_event_cb(const char *sender, const char *instance, rpc_port_h port, void *user_data) +{ + rpc_port_stub_vc_context_h context; + rpc_port_parcel_h parcel; + int ret; + + _W("sender(%s), instance(%s)", sender, instance); + context = __rpc_port_stub_vc_find_context(instance); + if (context == nullptr) { + _E("Failed to find context. instance(%s)", instance); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + context->port = port; + ret = rpc_port_parcel_create_from_port(&parcel, port); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create parcel handle from port. error(%d)", ret); + return ret; + } + +#ifdef TIDL_THREAD_ENABLE + ret = __rpc_port_stub_vc_context_push(context, parcel); +#else + ret = __rpc_port_stub_vc_context_handle_request(context, parcel); + rpc_port_parcel_destroy(parcel); +#endif /* TIDL_THREAD_ENABLE */ + + return ret; +} + +static int __rpc_port_stub_vc_set_access_control(void) +{ + int ret = RPC_PORT_ERROR_NONE; + + return ret; +} + +int rpc_port_stub_vc_register(rpc_port_stub_vc_callback_s *callback, void *user_data) +{ + int ret; + + if (callback == nullptr || callback->create == nullptr || callback->terminate == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (__vc.stub) { + _E("Already exists"); + return RPC_PORT_ERROR_NONE; + } + + g_rec_mutex_init(&__vc.mutex); + __vc.callback = *callback; + __vc.user_data = user_data; + + ret = rpc_port_stub_create(&__vc.stub, "vc"); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to create stub handle. error(%d)", ret); + g_rec_mutex_clear(&__vc.mutex); + return ret; + } + + ret = rpc_port_stub_add_received_event_cb(__vc.stub, __rpc_port_stub_vc_received_event_cb, &__vc); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add received event callback"); + rpc_port_stub_vc_unregister(); + return ret; + } + + ret = rpc_port_stub_add_connected_event_cb(__vc.stub, __rpc_port_stub_vc_connected_event_cb, &__vc); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add connected event callback"); + rpc_port_stub_vc_unregister(); + return ret; + } + + ret = rpc_port_stub_add_disconnected_event_cb(__vc.stub, __rpc_port_stub_vc_disconnected_event_cb, &__vc); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add disconnected event callback"); + rpc_port_stub_vc_unregister(); + return ret; + } + + ret = __rpc_port_stub_vc_set_access_control(); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to add privileges"); + rpc_port_stub_vc_unregister(); + return ret; + } + + ret = rpc_port_stub_listen(__vc.stub); + if (ret != RPC_PORT_ERROR_NONE) { + _E("Failed to listen events. error(%d)", ret); + rpc_port_stub_vc_unregister(); + return ret; + } + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_unregister(void) +{ + if (__vc.stub == nullptr) + return RPC_PORT_ERROR_NONE; + + g_rec_mutex_lock(&__vc.mutex); + g_rec_mutex_unlock(&__vc.mutex); + g_rec_mutex_clear(&__vc.mutex); + + if (__vc.contexts) { + g_list_free_full(__vc.contexts, __rpc_port_stub_vc_context_destroy); + __vc.contexts = nullptr; + } + + if (__vc.stub) { + rpc_port_stub_destroy(__vc.stub); + __vc.stub = nullptr; + } + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_foreach_context(rpc_port_stub_vc_context_cb callback, void *user_data) +{ + rpc_port_stub_vc_context_h context; + GList *iter; + + if (callback == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + g_rec_mutex_lock(&__vc.mutex); + iter = __vc.contexts; + while (iter) { + context = iter->data; + if (!callback(context, user_data)) + break; + + iter = g_list_next(iter); + } + g_rec_mutex_unlock(&__vc.mutex); + + return RPC_PORT_ERROR_NONE; +} + +int rpc_port_stub_vc_get_client_number(unsigned int *client_number) +{ + if (client_number == nullptr) { + _E("Invalid parameter"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + if (__vc.stub == nullptr) { + _E("Invalid context"); + return RPC_PORT_ERROR_INVALID_PARAMETER; + } + + g_rec_mutex_lock(&__vc.mutex); + *client_number = g_list_length(__vc.contexts); + g_rec_mutex_unlock(&__vc.mutex); + + return RPC_PORT_ERROR_NONE; +} diff --git a/server/vcd_stub.h b/server/vcd_stub.h new file mode 100755 index 0000000..70c5013 --- /dev/null +++ b/server/vcd_stub.h @@ -0,0 +1,680 @@ +/* + * Generated by tidlc 1.8.1. + */ + +#pragma once + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief The rpc_port_stub_array_char handle. + */ +typedef struct rpc_port_stub_array_char_s *rpc_port_stub_array_char_h; + +/** + * @brief The rpc_port_stub_vc_context handle. + */ +typedef struct rpc_port_stub_vc_context_s *rpc_port_stub_vc_context_h; + +/** + * @brief The rpc_port_stub_vc_notify_cb handle. + */ +typedef struct rpc_port_stub_vc_notify_cb_s *rpc_port_stub_vc_notify_cb_h; + +/** + * @brief The rpc_port_stub_vc_feedback_cb handle. + */ +typedef struct rpc_port_stub_vc_feedback_cb_s *rpc_port_stub_vc_feedback_cb_h; + +/** + * @briefs Creates a rpc_port_stub_array_char handle. + * + * @remarks The @a h should be released using the rpc_port_stub_array_char_destroy() + * if it's no longer needed. + * @param[out] h The rpc_port_stub_array_char handle that is newly created + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_array_char_destroy() + */ +int rpc_port_stub_array_char_create(rpc_port_stub_array_char_h *h); + +/** + * @brief Destroys the rpc_port_stub_array_char handle. + * + * @param[in] h The rpc_port_stub_array_char handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_array_char_create() + */ +int rpc_port_stub_array_char_destroy(rpc_port_stub_array_char_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_stub_array_char handle. + * + * @remarks A new created rpc_port_stub_array_char should be released using + * the rpc_port_stub_array_char_destroy() if it's no longer needed. + * @param[in] h The rpc_port_stub_array_char handle + * @param[out] clone If successful, a new created rpc_port_stub_array_char handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_array_char_destroy() + */ +int rpc_port_stub_array_char_clone(rpc_port_stub_array_char_h h, rpc_port_stub_array_char_h *clone); + +/** + * @brief Sets the value to the rpc_port_stub_array_char handle. + * + * @remarks The value is internally copied and stored. + * You should release it if it's allocaed when it's no longer needed, + * @param[in] h The rpc_port_stub_array_char handle + * @param[in] value The array value + * @param[in] size The size of the array + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_array_char_get() + */ +int rpc_port_stub_array_char_set(rpc_port_stub_array_char_h h, char *value, int size); + +/** + * @brief Gets the value from the rpc_port_stub_array_char handle. + * + * @remarks A new created value should be released if it's no longer needed. + * @param[in] h The rpc_port_stub_array_char handle + * @param[out] value The array value + * @param[out] size The size of the array + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_array_char_set() + */ +int rpc_port_stub_array_char_get(rpc_port_stub_array_char_h h, char **value, int *size); + +/** + * @brief Called when the proxy is connected. + * @details The callback function is called when the proxy is connected to the stub. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s + */ +typedef void (*rpc_port_stub_vc_create_cb)(rpc_port_stub_vc_context_h context, void *user_data); + +/** + * @brief Called when the proxy is disconnected. + * @details The callback function is called when the proxy is disconnected from the stub. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s + */ +typedef void (*rpc_port_stub_vc_terminate_cb)(rpc_port_stub_vc_context_h context, void *user_data); + +/** + * @brief Called to get the proxy context once for each connected proxy. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @return @c true to continue with the next iteration of the loop, + * otherwise @c false to break out of the loop + * @pre rpc_port_stub_vc_foreach_context() will invoke this callback. + * @see rpc_port_stub_vc_foreach_context() + */ +typedef bool (*rpc_port_stub_vc_context_cb)(rpc_port_stub_vc_context_h context, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef void (*rpc_port_stub_vc_register_notify_cb_cb)(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_notify_cb_h callback, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_register_notify_cb_sync_cb)(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_notify_cb_h callback, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef void (*rpc_port_stub_vc_register_feedback_cb_cb)(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_feedback_cb_h callback, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_register_feedback_cb_sync_cb)(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_feedback_cb_h callback, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_initialize_cb)(rpc_port_stub_vc_context_h context, int pid, int *mgr_pid, int *service_state, int *daemon_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_finalize_cb)(rpc_port_stub_vc_context_h context, int pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_set_command_cb)(rpc_port_stub_vc_context_h context, int pid, int cmd_type, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_unset_command_cb)(rpc_port_stub_vc_context_h context, int pid, int cmd_type, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_set_foreground_cb)(rpc_port_stub_vc_context_h context, int pid, bool value, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_set_server_dialog_cb)(rpc_port_stub_vc_context_h context, int pid, const char *app_id, const char *credential, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_request_dialog_cb)(rpc_port_stub_vc_context_h context, int pid, const char *disp_text, const char *utt_text, bool continuous, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_is_system_command_valid_cb)(rpc_port_stub_vc_context_h context, int pid, bool *is_sys_cmd_valid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_auth_enable_cb)(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_auth_disable_cb)(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_auth_start_cb)(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_auth_stop_cb)(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_auth_cancel_cb)(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_request_tts_cb)(rpc_port_stub_vc_context_h context, int pid, const char *text, const char *lang, bool to_vcm, int *utt_id, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_cancel_tts_cb)(rpc_port_stub_vc_context_h context, int pid, int utt_id, void *user_data); + +/** + * @brief Called when the request of the proxy is delivered. + * + * @param[in] context The context handle + * @param[in] user_data The user data passed from the registration function + * @see #rpc_port_stub_vc_callback_s; + */ +typedef int (*rpc_port_stub_vc_get_tts_audio_format_cb)(rpc_port_stub_vc_context_h context, int pid, int *rate, int *channel, int *audio_type, void *user_data); + +/** + * @brief Sets the tag to the context handle. + * + * @param[in] context The context handle + * @param[in] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_vc_context_get_tag() + */ +int rpc_port_stub_vc_context_set_tag(rpc_port_stub_vc_context_h context, void *tag); + +/** + * @brief Gets the tag from the context handle. + * + * @param[in] context The context handle + * @param[out] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_vc_context_set_tag() + */ +int rpc_port_stub_vc_context_get_tag(rpc_port_stub_vc_context_h context, void **tag); + +/** + * @brief Gets the sender ID from the context handle. + * @details The @a sender should be released using free(). + * + * @param[in] context The context handle + * @param[out] sender The sender ID of the context handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_stub_vc_context_get_sender(rpc_port_stub_vc_context_h context, char **sender); + +/** + * @brief Gets the instance ID from the context handle. + * @details The @a instance should be released using free(). + * + * @param[in] context The context handle + * @param[out] instance The instance ID of the context handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_stub_vc_context_get_instance(rpc_port_stub_vc_context_h context, char **instance); + +/** + * @brief Disconnects from the proxy. + * + * @param[in] context The context handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_context_disconnect(rpc_port_stub_vc_context_h context); + +/** + * @brief Creates a rpc_port_stub_vc_notify_cb handle. + * + * @param[out] h The rpc_port_stub_vc_notify_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_vc_notify_cb_destroy() + */ +int rpc_port_stub_vc_notify_cb_create(rpc_port_stub_vc_notify_cb_h *h); + +/** + * @brief Destroys the rpc_port_stub_vc_notify_cb handle. + * + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_vc_notify_cb_clone() + */ +int rpc_port_stub_vc_notify_cb_destroy(rpc_port_stub_vc_notify_cb_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_stub_vc_notify_cb handle. + * + * @remarks A new created rpc_port_stub_vc_notify_cb should be released using + * the rpc_port_stub_vc_notify_cb_destroy() if it's no longer needed. + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[out] clone If successful, a new created rpc_port_stub_vc_notify_cb handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_vc_notify_cb_destroy() + */ +int rpc_port_stub_vc_notify_cb_clone(rpc_port_stub_vc_notify_cb_h h, rpc_port_stub_vc_notify_cb_h *clone); + +/** + * @brief Gets the ID of the rpc_port_stub_vc_notify_cb handle. + * + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[out] id The ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_notify_cb_get_id(rpc_port_stub_vc_notify_cb_h h, int *id); + +/** + * @brief Gets the sequence ID of the rpc_port_stub_vc_notify_cb handle. + * + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[out] seq_id The Sequence ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_notify_cb_get_seq_id(rpc_port_stub_vc_notify_cb_h h, int *seq_id); + +/** + * @brief Checks whether the delegate is for one-time or not. + * + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[out] once The flag, it's true, the handle is for one-time + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_notify_cb_is_once(rpc_port_stub_vc_notify_cb_h h, bool *once); + +/** + * @brief Gets the tag from the rpc_port_stub_vc_notify_cb handle. + * + * @remarks The @a tag should be released using free(). + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[out] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_stub_vc_notify_cb_get_tag(rpc_port_stub_vc_notify_cb_h h, char **tag); + +/** + * @brief Invokes the callback function of the rpc_port_stub_vc_notify_cb handle. + * + * @param[in] h The rpc_port_stub_vc_notify_cb handle + * @param[in] ... + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @retval #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_stub_vc_notify_cb_invoke(rpc_port_stub_vc_notify_cb_h h, int pid, bundle *msg); + +/** + * @brief Creates a rpc_port_stub_vc_feedback_cb handle. + * + * @param[out] h The rpc_port_stub_vc_feedback_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_vc_feedback_cb_destroy() + */ +int rpc_port_stub_vc_feedback_cb_create(rpc_port_stub_vc_feedback_cb_h *h); + +/** + * @brief Destroys the rpc_port_stub_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_vc_feedback_cb_clone() + */ +int rpc_port_stub_vc_feedback_cb_destroy(rpc_port_stub_vc_feedback_cb_h h); + +/** + * @brief Creates and returns a copy of the given rpc_port_stub_vc_feedback_cb handle. + * + * @remarks A new created rpc_port_stub_vc_feedback_cb should be released using + * the rpc_port_stub_vc_feedback_cb_destroy() if it's no longer needed. + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[out] clone If successful, a new created rpc_port_stub_vc_feedback_cb handle will be returned + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @see rpc_port_stub_vc_feedback_cb_destroy() + */ +int rpc_port_stub_vc_feedback_cb_clone(rpc_port_stub_vc_feedback_cb_h h, rpc_port_stub_vc_feedback_cb_h *clone); + +/** + * @brief Gets the ID of the rpc_port_stub_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[out] id The ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_feedback_cb_get_id(rpc_port_stub_vc_feedback_cb_h h, int *id); + +/** + * @brief Gets the sequence ID of the rpc_port_stub_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[out] seq_id The Sequence ID + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_feedback_cb_get_seq_id(rpc_port_stub_vc_feedback_cb_h h, int *seq_id); + +/** + * @brief Checks whether the delegate is for one-time or not. + * + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[out] once The flag, it's true, the handle is for one-time + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_feedback_cb_is_once(rpc_port_stub_vc_feedback_cb_h h, bool *once); + +/** + * @brief Gets the tag from the rpc_port_stub_vc_feedback_cb handle. + * + * @remarks The @a tag should be released using free(). + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[out] tag The tag + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + */ +int rpc_port_stub_vc_feedback_cb_get_tag(rpc_port_stub_vc_feedback_cb_h h, char **tag); + +/** + * @brief Invokes the callback function of the rpc_port_stub_vc_feedback_cb handle. + * + * @param[in] h The rpc_port_stub_vc_feedback_cb handle + * @param[in] ... + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @retval #RPC_PORT_ERROR_IO_ERROR I/O error + */ +int rpc_port_stub_vc_feedback_cb_invoke(rpc_port_stub_vc_feedback_cb_h h, int utt_id, int event, rpc_port_stub_array_char_h pcm_data, int len); + +/** + * @brief The structure type containing the set of callback functions for handling stub events. + * @details It is one of the input parameters of the rpc_port_stub_vc_register() function. + * + * @see rpc_port_stub_vc_create_cb + * @see rpc_port_stub_vc_terminate_cb + */ +typedef struct { + rpc_port_stub_vc_create_cb create; /**< This callback function is invoked when the proxy is connected. */ + rpc_port_stub_vc_terminate_cb terminate; /**< This callback function is invoked when the proxy is disconnected. */ + rpc_port_stub_vc_register_notify_cb_cb register_notify_cb; /**< This callback function is invoked when the register_notify_cb request is delivered. */ + rpc_port_stub_vc_register_notify_cb_sync_cb register_notify_cb_sync; /**< This callback function is invoked when the register_notify_cb_sync request is delivered. */ + rpc_port_stub_vc_register_feedback_cb_cb register_feedback_cb; /**< This callback function is invoked when the register_feedback_cb request is delivered. */ + rpc_port_stub_vc_register_feedback_cb_sync_cb register_feedback_cb_sync; /**< This callback function is invoked when the register_feedback_cb_sync request is delivered. */ + rpc_port_stub_vc_initialize_cb initialize; /**< This callback function is invoked when the initialize request is delivered. */ + rpc_port_stub_vc_finalize_cb finalize; /**< This callback function is invoked when the finalize request is delivered. */ + rpc_port_stub_vc_set_command_cb set_command; /**< This callback function is invoked when the set_command request is delivered. */ + rpc_port_stub_vc_unset_command_cb unset_command; /**< This callback function is invoked when the unset_command request is delivered. */ + rpc_port_stub_vc_set_foreground_cb set_foreground; /**< This callback function is invoked when the set_foreground request is delivered. */ + rpc_port_stub_vc_set_server_dialog_cb set_server_dialog; /**< This callback function is invoked when the set_server_dialog request is delivered. */ + rpc_port_stub_vc_request_dialog_cb request_dialog; /**< This callback function is invoked when the request_dialog request is delivered. */ + rpc_port_stub_vc_is_system_command_valid_cb is_system_command_valid; /**< This callback function is invoked when the is_system_command_valid request is delivered. */ + rpc_port_stub_vc_auth_enable_cb auth_enable; /**< This callback function is invoked when the auth_enable request is delivered. */ + rpc_port_stub_vc_auth_disable_cb auth_disable; /**< This callback function is invoked when the auth_disable request is delivered. */ + rpc_port_stub_vc_auth_start_cb auth_start; /**< This callback function is invoked when the auth_start request is delivered. */ + rpc_port_stub_vc_auth_stop_cb auth_stop; /**< This callback function is invoked when the auth_stop request is delivered. */ + rpc_port_stub_vc_auth_cancel_cb auth_cancel; /**< This callback function is invoked when the auth_cancel request is delivered. */ + rpc_port_stub_vc_request_tts_cb request_tts; /**< This callback function is invoked when the request_tts request is delivered. */ + rpc_port_stub_vc_cancel_tts_cb cancel_tts; /**< This callback function is invoked when the cancel_tts request is delivered. */ + rpc_port_stub_vc_get_tts_audio_format_cb get_tts_audio_format; /**< This callback function is invoked when the get_tts_audio_format request is delivered. */ +} rpc_port_stub_vc_callback_s; + +/** + * @brief Registers the set of the callback functions and the port. + * @details This function registers the set of the callback functions to handle stub events. + * And, the rpc_port_stub_listen() is called internally to handle events. + * + * @param[in] callback The set of callback functions to handle stub events + * @param[in] user_data The user data to be passed to the callback function + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #RPC_PORT_ERROR_OUT_OF_MEMORY Out of memory + * @retval #RPC_PORT_ERROR_IO_ERROR I/O error + * @retval #RPC_PORT_ERROR_PERMISSION_DENIED Permission denied + * @see rpc_port_stub_vc_unregister() + * @see #rpc_port_stub_vc_callback_s + */ +int rpc_port_stub_vc_register(rpc_port_stub_vc_callback_s *callback, void *user_data); + +/** + * @brief Unregisters the registered port. + */ +int rpc_port_stub_vc_unregister(void); + +/** + * @brief Retrieves the connected context handles. + * + * @param[in] callback The callback function + * @param[in] user_data The user data to be passed to the callback function + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + * @see rpc_port_stub_vc_context_cb() + */ +int rpc_port_stub_vc_foreach_context(rpc_port_stub_vc_context_cb callback, void *user_data); + +/** + * @brief Gets the number of connected clients. + * + * @param[out] client_number The client number + * @return @c 0 on success, + * otherwise a negative error value + * @retval #RPC_PORT_ERROR_NONE Successful + * @retval #RPC_PORT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int rpc_port_stub_vc_get_client_number(unsigned int *client_number); + +#ifdef __cplusplus +} +#endif diff --git a/server/vcd_tidl.c b/server/vcd_tidl.c index 784f9c0..c81e81c 100644 --- a/server/vcd_tidl.c +++ b/server/vcd_tidl.c @@ -20,11 +20,13 @@ #include "vcd_config.h" #include "vcd_tidl.h" +#include "vcd_stub.h" #include "vcd_mgr_stub.h" #include "vcd_mgr_proxy.h" #include "vcd_widget_stub.h" #include "vcd_widget_proxy.h" + static rpc_port_stub_vc_mgr_callback_s g_mgr_callback; static pthread_mutex_t g_mgr_tidl_info_mutex = PTHREAD_MUTEX_INITIALIZER; @@ -33,6 +35,8 @@ static rpc_port_stub_vc_widget_callback_s g_widget_callback; static pthread_mutex_t g_widget_tidl_info_mutex = PTHREAD_MUTEX_INITIALIZER; +static rpc_port_stub_vc_callback_s g_vc_callback; + static int g_volume_count = 0; int vcd_mgr_tidl_open_connection(); @@ -309,6 +313,497 @@ void __send_signal(bundle* msg) pthread_mutex_unlock(&g_widget_tidl_info_mutex); } +/** + * TIDL functions for VC client + */ + +static void __vc_create_cb(rpc_port_stub_vc_context_h context, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_create_cb"); + + char *sender = NULL; + + rpc_port_stub_SamsungAIAppPort_context_get_sender(context, &sender); + if (!sender) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Sender is NULL"); + return ; + } + + SLOG(LOG_INFO, TAG_VCD, "[TIDL] sender(%s)", sender); // sender (app_id) + free(sender); +} + +static void __vc_terminate_cb(rpc_port_stub_vc_context_h context, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_terminate_cb"); +} + +static void __vc_register_notify_cb_cb(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_notify_cb_h callback, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_register_notify_cb_cb. pid(%d)", pid); + + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] callback is null."); + return ; + } + + int ret = -1; + ret = vcd_client_add_ipc_info(pid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to add ipc info."); + return ; + } + + ret = vcd_client_set_ipc_notify_cb(pid, callback, user_data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set notify callback."); + } else { + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set notify callback."); + } +} + +static int __vc_register_notify_cb_sync_cb(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_notify_cb_h callback, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_register_notify_cb_sync_cb. pid(%d)", pid); + + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] callback is null."); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = vcd_client_add_ipc_info(pid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to add ipc info."); + return ret; + } + + ret = vcd_client_set_ipc_notify_cb(pid, callback, user_data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set notify callback."); + } else { + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set notify callback."); + } + + return ret; +} + +static void __vc_register_feedback_cb_cb(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_feedback_cb_h callback, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_register_feedback_cb_cb. pid(%d)", pid); + + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] callback is null."); + return ; + } + + int ret = -1; + ret = vcd_client_add_ipc_info(pid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to add ipc info."); + return ; + } + + ret = vcd_client_set_ipc_feedback_cb(pid, callback, user_data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set feedback callback."); + } else { + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set feedback callback."); + } +} + +static int __vc_register_feedback_cb_sync_cb(rpc_port_stub_vc_context_h context, int pid, rpc_port_stub_vc_feedback_cb_h callback, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_register_feedback_cb_sync_cb. pid(%d)", pid); + + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] callback is null."); + return VCD_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + ret = vcd_client_add_ipc_info(pid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to add ipc info."); + return ret; + } + + ret = vcd_client_set_ipc_feedback_cb(pid, callback, user_data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set feedback callback."); + } else { + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set feedback callback."); + } + + return ret; +} + +static int __vc_initialize_cb(rpc_port_stub_vc_context_h context, int pid, int *mgr_pid, int *service_state, int *daemon_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_initialize_cb. pid(%d)", pid); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_initialize(pid); + *service_state = vcd_server_get_service_state(); + *daemon_pid = getpid(); + *mgr_pid = vcd_client_manager_get_pid(); + + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd initialize : pid(%d) daemon_pid(%d) ret(%d)", pid, daemon_pid, ret); + } + + return ret; +} + +static int __vc_finalize_cb(rpc_port_stub_vc_context_h context, int pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_finalize_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_finalize(pid); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd finalize : pid(%d)", pid); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd finalize : pid(%d) ret(%d)", pid, ret); + } + + return ret; +} + +static int __vc_set_command_cb(rpc_port_stub_vc_context_h context, int pid, int cmd_type, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_set_command_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_set_command(pid, (vc_cmd_type_e)cmd_type); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set command : pid(%d), cmd_type(%d)", pid, cmd_type); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd set command : pid(%d), cmd_type(%d) ret(%d)", pid, cmd_type, ret); + } + + return ret; +} + +static int __vc_unset_command_cb(rpc_port_stub_vc_context_h context, int pid, int cmd_type, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_unset_command_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_unset_command(pid, (vc_cmd_type_e)cmd_type); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd unset command : pid(%d), cmd_type(%d)", pid, cmd_type); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd unset command : pid(%d), cmd_type(%d) ret(%d)", pid, cmd_type, ret); + } + + return ret; +} + +static int __vc_set_foreground_cb(rpc_port_stub_vc_context_h context, int pid, bool value, void *user_data) +{ + // check more... + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_set_foreground_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_set_foreground(pid, value); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set foreground : pid(%d)", pid); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd set foreground : pid(%d) ret(%d)", pid, ret); + } + + return ret; +} + +static int __vc_set_server_dialog_cb(rpc_port_stub_vc_context_h context, int pid, const char *app_id, const char *credential, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_set_server_dialog_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_set_server_dialog(pid, app_id, credential); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set server dialog : pid(%d), app_id(%s)", pid, app_id); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd set server dialog : pid(%d), app_id(%s) ret(%d)", pid, app_id, ret); + } + + return ret; +} + +static int __vc_request_dialog_cb(rpc_port_stub_vc_context_h context, int pid, const char *disp_text, const char *utt_text, bool continuous, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_request_dialog_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_dialog(pid, disp_text, utt_text, continuous); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd request dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", pid, disp_text, utt_text, continuous); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd request dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d), ret(%d)", pid, disp_text, utt_text, continuous, ret(%d)); + } + + return ret; +} + +static int __vc_is_system_command_valid_cb(rpc_port_stub_vc_context_h context, int pid, bool *is_sys_cmd_valid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_is_system_command_valid_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_is_system_command_valid(pid, &is_sys_cmd_valid); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd check system command is valid : pid(%d), is_sys_cmd_valid(%d)", pid, *is_sys_cmd_valid); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd check system command is valid : pid(%d), ret(%d)", pid, ret); + } + + return ret; +} + +static int __vc_auth_enable_cb(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_auth_enable_cb"); + +} + +static int __vc_auth_disable_cb(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_auth_disable_cb"); +} + +static int __vc_auth_start_cb(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_auth_start_cb"); +} + +static int __vc_auth_stop_cb(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_auth_stop_cb"); +} + +static int __vc_auth_cancel_cb(rpc_port_stub_vc_context_h context, int pid, int mgr_pid, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_auth_cancel_cb"); +} + +static int __vc_request_tts_cb(rpc_port_stub_vc_context_h context, int pid, const char *text, const char *lang, bool to_vcm, int *utt_id, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_request_tts_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_request_tts(pid, text, lang, to_vcm, &utt_id); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd request tts : pid(%d), text(%s), language(%s), to_vcm(%d)", pid, text, lang, to_vcm); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd request tts : pid(%d), text(%s), language(%s), to_vcm(%d), ret(%d)", pid, text, lang, to_vcm, ret); + } + + return ret; +} + +static int __vc_cancel_tts_cb(rpc_port_stub_vc_context_h context, int pid, int utt_id, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_cancel_tts_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_cancel_tts(pid, utt_id); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd cancel tts : pid(%d), utt_id(%d)", pid, utt_id); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd cancel tts : pid(%d), utt_id(%d), ret(%d)", pid, utt_id, ret); + } + + return ret; +} + +static int __vc_get_tts_audio_format_cb(rpc_port_stub_vc_context_h context, int pid, int *rate, int *channel, int *audio_type, void *user_data) +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] __vc_get_tts_audio_format_cb"); + + int ret = VCD_ERROR_OPERATION_FAILED; + + ret = vcd_server_get_tts_audio_format(pid, &rate, &channel, &audio_type); + if (VCD_ERROR_NONE == ret) { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd get tts audio format : pid(%d), rate(%d), channel(%d), audio_type(%d)", pid, *rate, *channel, *audio_type); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to vcd get tts audio format : pid(%d) ret(%d)", pid, ret); + } + + return ret; +} + +int vcd_tidl_open_connection() +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] vcd_tidl_open_connection"); + + g_vc_callback.create = __vc_create_cb; + g_vc_callback.terminate = __vc_terminate_cb; + g_vc_callback.register_notify_cb = __vc_register_notify_cb_cb; + g_vc_callback.register_notify_cb_sync = __vc_register_notify_cb_sync_cb; + g_vc_callback.register_feedback_cb = __vc_register_feedback_cb_cb; + g_vc_callback.register_feedback_cb_sync = __vc_register_feedback_cb_sync_cb; + g_vc_callback.initialize = __vc_initialize_cb; + g_vc_callback.finalize = __vc_finalize_cb; + g_vc_callback.set_command = __vc_set_command_cb; + g_vc_callback.unset_command = __vc_unset_command_cb; + g_vc_callback.set_foreground = __vc_set_foreground_cb; + g_vc_callback.set_server_dialog = __vc_set_server_dialog_cb; + g_vc_callback.request_dialog = __vc_request_dialog_cb; + g_vc_callback.is_system_command_valid = __vc_is_system_command_valid_cb; + g_vc_callback.auth_enable = __vc_auth_enable_cb; + g_vc_callback.auth_disable = __vc_auth_disable_cb; + g_vc_callback.auth_start = __vc_auth_start_cb; + g_vc_callback.auth_stop = __vc_auth_stop_cb; + g_vc_callback.auth_cancel = __vc_auth_cancel_cb; + g_vc_callback.request_tts = __vc_request_tts_cb; + g_vc_callback.cancel_tts = __vc_cancel_tts_cb; + g_vc_callback.get_tts_audio_format = __vc_get_tts_audio_format_cb; + + int ret = -1; + ret = rpc_port_stub_vc_register(&g_vc_callback, NULL); + if (VCD_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to register TIDL callbacks. ret(%d)", ret); + return VCD_ERROR_OPERATION_FAILED; + } + + return VCD_ERROR_NONE; +} + +int vcd_tidl_close_connection() +{ + SLOG(LOG_INFO, TAG_VCD, "[TIDL] vcd_tidl_close_connection"); + rpc_port_stub_vc_unregister(); + + return VCD_ERROR_NONE; +} + +int vcdc_send_result(int pid, int manager_pid, int cmd_type) +{ + client_ipc_info_s* info = vcd_client_get_ipc_info(pid); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get ipc info. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + bundle* bundle_data = bundle_create(); + if (NULL == bundle_data) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create bundle data"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Result command type(%d)", cmd_type); + + char pid_char[10] = {0}; + snprintf(pid_char, 10, "%d", pid); + bundle_add_str(bundle_data, VC_BUNDLE_PID, pid_char); + + switch (cmd_type) { + case VC_COMMAND_TYPE_FOREGROUND: + case VC_COMMAND_TYPE_BACKGROUND: + if (pid == manager_pid) { + bundle_add_str(bundle_data, VC_BUNDLE_METHOD, VCD_MANAGER_METHOD_RESULT); + } else { + bundle_add_str(bundle_data, VC_BUNDLE_METHOD, VCD_METHOD_RESULT); + } + break; + case VC_COMMAND_TYPE_WIDGET: + bundle_add_str(bundle_data, VC_BUNDLE_METHOD, VCD_WIDGET_METHOD_RESULT); + break; + case VC_COMMAND_TYPE_SYSTEM: + case VC_COMMAND_TYPE_SYSTEM_BACKGROUND: + case VC_COMMAND_TYPE_EXCLUSIVE: + bundle_add_str(bundle_data, VC_BUNDLE_METHOD, VCD_MANAGER_METHOD_RESULT); + break; + + default: + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Command type is NOT valid(%d)", cmd_type); + return -1; + } + + rpc_port_stub_vc_notify_cb_invoke(info->notify_cb, pid, bundle_data); + + return VCD_ERROR_NONE; +} + +int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg) +{ + if (NULL == err_msg) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Input parameter is NULL"); + return VCD_ERROR_INVALID_PARAMETER; + } + + client_ipc_info_s* info = vcd_client_get_ipc_info(pid); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get ipc info. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + bundle* bundle_data = bundle_create(); + if (NULL == bundle_data) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create bundle data"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Send error signal to app(%d)", pid); + + char pid_char[10] = {0}; + char reason_char[10] = {0}; + snprintf(pid_char, 10, "%d", pid); + snprintf(reason_char, 10, "%d", reason); + + bundle_add_str(bundle_data, VC_BUNDLE_METHOD, VCD_METHOD_ERROR_TO_APP); + bundle_add_str(bundle_data, VC_BUNDLE_PID, pid_char); + bundle_add_str(bundle_data, VC_BUNDLE_REASON, reason_char); + bundle_add_str(bundle_data, VC_BUNDLE_ERR_MSG, err_msg); + + rpc_port_stub_vc_notify_cb_invoke(info->notify_cb, pid, bundle_data); + + return VCD_ERROR_NONE; +} + +int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) +{ + if (NULL == buffer || 0 >= len) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Invalid parameter"); + return VCD_ERROR_INVALID_PARAMETER; + } + + client_ipc_info_s* info = vcd_client_get_ipc_info(pid); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get ipc info. pid(%d)", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + bundle* bundle_data = bundle_create(); + if (NULL == bundle_data) { + SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create bundle data"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + SLOG(LOG_INFO, TAG_VCD, "[TIDL] Send feedback streaming to app(%d), utt_id(%d), event(%d), length(%d)", pid, utt_id, event, len); + + rpc_port_stub_array_char_h arr_char = NULL; + rpc_port_stub_array_char_create(&arr_char); + rpc_port_stub_array_char_set(arr_char, buffer, len); + + rpc_port_stub_vc_feedback_cb_invoke(info->feedback_cb, utt_id, event, arr_char, len); + + return VCD_ERROR_NONE; +} + // TODO: remove _tidl after all dbus removed int vcdc_tidl_send_hello(int pid, vcd_client_type_e type) { diff --git a/server/vcd_tidl.h b/server/vcd_tidl.h index 84e61f8..a4cd96e 100644 --- a/server/vcd_tidl.h +++ b/server/vcd_tidl.h @@ -30,6 +30,7 @@ extern "C" { // VCD_CLIENT_TYPE_MANAGER // } vcd_client_type_e; + int vcd_tidl_open_connection(); int vcd_tidl_close_connection(); @@ -69,9 +70,18 @@ int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_aud int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); +int vcdc_send_result(int pid, int manager_pid, int cmd_type); + +int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg); + +int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); #ifdef __cplusplus } #endif +<<<<<<< HEAD +#endif /* __VCD_TIDL_h__ */ +======= #endif /* __VCD_TIDL_h__ */ +>>>>>>> Replace IPC (VCC) from dbus to tidl diff --git a/tidl/vc.tidl b/tidl/vc.tidl new file mode 100755 index 0000000..41348c6 --- /dev/null +++ b/tidl/vc.tidl @@ -0,0 +1,28 @@ +interface vc { + void notify_cb(int pid, bundle msg) delegate; + void feedback_cb(int utt_id, int event, array pcm_data, int len) delegate; + + void register_notify_cb(int pid, notify_cb callback) async; + int register_notify_cb_sync(int pid, notify_cb callback); + void register_feedback_cb(int pid, feedback_cb callback) async; + int register_feedback_cb_sync(int pid, feedback_cb callback); + + int initialize(in int pid, out int mgr_pid, out int service_state, out int daemon_pid); + int finalize(in int pid); + int set_command(in int pid, in int cmd_type); + int unset_command(in int pid, in int cmd_type); + int set_foreground(in int pid, in bool value); + int set_server_dialog(in int pid, in string app_id, in string credential); + int request_dialog(in int pid, in string disp_text, in string utt_text, in bool continuous); + int is_system_command_valid(in int pid, out bool is_sys_cmd_valid); + + int auth_enable(in int pid, in int mgr_pid); + int auth_disable(in int pid, in int mgr_pid); + int auth_start(in int pid, in int mgr_pid); + int auth_stop(in int pid, in int mgr_pid); + int auth_cancel(in int pid, in int mgr_pid); + + int request_tts(in int pid, string text, string lang, bool to_vcm, out int utt_id); + int cancel_tts(in int pid, in int utt_id); + int get_tts_audio_format(in int pid, out int rate, out int channel, out int audio_type); +}