client/vc_mgr_tidl.c

   1 /*
   2 * Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <pthread.h>
  18
  19 #include <rpc-port.h>
  20
  21 #include "vc_main.h"
  22 #include "vc_mgr_client.h"
  23 #include "vc_mgr_tidl.h"
  24 #include "vc_mgr_proxy.h"
  25 #include "vc_mgr_stub.h"
  26 #include "vc_command.h"
  27
  28 typedef struct {
  29         bool connected;
  30         bool connection_requesting;
  31         bool register_callback_invoked;
  32         rpc_port_proxy_vc_mgr_proxy_vc_mgr_h rpc_h;
  33         rpc_port_proxy_vc_mgr_proxy_vc_mgr_notify_cb_h notify_cb_h;
  34         rpc_port_proxy_vc_mgr_proxy_vc_mgr_send_buffer_cb_h send_buffer_cb_h;
  35 } vc_mgr_tidl_info_s;
  36
  37 typedef struct {
  38         bool connected;
  39         bool register_callback_requesting;
  40 } vcd_mgr_tidl_info_s;
  41
  42 static vc_mgr_tidl_info_s* g_proxy_tidl_info = NULL;
  43
  44 static vcd_mgr_tidl_info_s* g_stub_tidl_info = NULL;
  45
  46 static pthread_mutex_t g_tidl_mutex = PTHREAD_MUTEX_INITIALIZER;
  47
  48 static rpc_port_stub_vc_mgr_stub_vcd_mgr_callback_s g_mgr_callback;
  49
  50 static int g_volume_count = 0;
  51
  52
  53 extern void __vc_mgr_cb_all_result(vc_result_type_e type);
  54
  55 extern void __vc_mgr_cb_pre_result(int event, const char* pre_result);
  56
  57 extern void __vc_mgr_cb_system_result();
  58
  59 extern void __vc_mgr_cb_speech_detected();
  60
  61 extern int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg);
  62
  63 extern int __vc_mgr_cb_set_volume(float volume);
  64
  65 extern int __vc_mgr_cb_service_state(int state);
  66
  67 extern int __vc_mgr_cb_set_foreground(int pid, bool value);
  68
  69 extern int __vc_mgr_cb_private_data_set(const char* key, const char* data);
  70
  71 extern int __vc_mgr_cb_private_data_requested(const char* key, char** data);
  72
  73 /* for TTS feedback */
  74 extern int __vc_mgr_cb_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type);
  75
  76 extern int __vc_mgr_cb_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len);
  77
  78 /* Authority */
  79 extern int __vc_mgr_request_auth_enable(int pid);
  80
  81 extern int __vc_mgr_request_auth_disable(int pid);
  82
  83 extern int __vc_mgr_request_auth_start(int pid);
  84
  85 extern int __vc_mgr_request_auth_stop(int pid);
  86
  87 extern int __vc_mgr_request_auth_cancel(int pid);
  88
  89 extern int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous);
  90
  91 extern void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result);
  92
  93 static void __notify_cb(void *user_data, bundle *msg)
  94 {
  95         char *method = NULL;
  96         char *val = NULL;
  97
  98         SLOG(LOG_DEBUG, TAG_VCM, "__notify_cb is invoked");
  99
 100         bundle_get_str(msg, VC_BUNDLE_METHOD, &method);
 101
 102         if (0 == strncmp(VCD_MANAGER_METHOD_SET_VOLUME, method, strlen(VCD_MANAGER_METHOD_SET_VOLUME))) {
 103                 bundle_get_str(msg, VC_BUNDLE_VOLUME, &val);
 104                 float volume = 0;
 105
 106                 if (val) {
 107                         volume = atof(val);
 108                 }
 109                 if (10 == g_volume_count) {
 110                         SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set volume");
 111                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set volume : volume(%f)", volume);
 112                         g_volume_count = 0;
 113                 }
 114
 115                 if (val) {
 116                         __vc_mgr_cb_set_volume(volume);
 117                         g_volume_count++;
 118                 }
 119         } /* VCD_MANAGER_METHOD_SET_VOLUME */
 120
 121         else if (0 == strncmp(VCD_MANAGER_METHOD_SET_SERVICE_STATE, method, strlen(VCD_MANAGER_METHOD_SET_SERVICE_STATE))) {
 122                 bundle_get_str(msg, VC_BUNDLE_SERVICE_STATE, &val);
 123                 int state = 0;
 124                 if (val) {
 125                         state = atoi(val);
 126                         SLOG(LOG_INFO, TAG_VCM, "@@ state changed : %d", state);
 127                         __vc_mgr_cb_service_state(state);
 128                 }
 129         } /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
 130
 131         else if (0 == strncmp(VCD_MANAGER_METHOD_SPEECH_DETECTED, method, strlen(VCD_MANAGER_METHOD_SPEECH_DETECTED))) {
 132                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get Speech detected");
 133
 134                 __vc_mgr_cb_speech_detected();
 135
 136                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 137         } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
 138
 139         else if (0 == strncmp(VCD_MANAGER_METHOD_ALL_RESULT, method, strlen(VCD_MANAGER_METHOD_ALL_RESULT))) {
 140                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get All Result");
 141
 142                 bundle_get_str(msg, VC_BUNDLE_RESULT, &val);
 143
 144                 if (val) {
 145                         __vc_mgr_cb_all_result((vc_result_type_e)atoi(val));
 146                 }
 147
 148                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 149         } /* VCD_MANAGER_METHOD_ALL_RESULT */
 150
 151         else if (0 == strncmp(VCD_MANAGER_METHOD_PRE_RESULT, method, strlen(VCD_MANAGER_METHOD_PRE_RESULT))) {
 152                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get Pre Result");
 153                 char* event = NULL;
 154                 char* pre_result = NULL;
 155
 156                 bundle_get_str(msg, VC_BUNDLE_EVENT, &event);
 157                 bundle_get_str(msg, VC_BUNDLE_PRE_RESULT, &pre_result);
 158
 159                 if (NULL != pre_result) {
 160                         __vc_mgr_cb_pre_result((vc_pre_result_event_e)atoi(event), pre_result);
 161                 }
 162
 163                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 164         } /* VCD_MANAGER_METHOD_PRE_RESULT */
 165
 166         else if (0 == strncmp(VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT, method, strlen(VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT))) {
 167                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get specific engine result");
 168                 char* engine_app_id = NULL;
 169                 char* event = NULL;
 170                 char* result = NULL;
 171
 172                 bundle_get_str(msg, VC_BUNDLE_ENGINE_APP_ID, &engine_app_id);
 173                 bundle_get_str(msg, VC_BUNDLE_EVENT, &event);
 174                 bundle_get_str(msg, VC_BUNDLE_RESULT, &result);
 175
 176                 if (NULL != result) {
 177                         gsize decodingSize=0;
 178                         gchar *gDecodedResult = (gchar *)g_base64_decode((const gchar *)result, &decodingSize);
 179                         if (gDecodedResult)
 180                         {
 181                                 SLOG(LOG_WARN, TAG_VCM, "@@@ Get specific engine result --> %s", gDecodedResult);
 182                                 __vc_mgr_cb_specific_engine_result(engine_app_id, event, gDecodedResult);
 183                                 g_free(gDecodedResult);
 184                         }
 185                 }
 186         } /* VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT */
 187
 188         else if (0 == strncmp(VCD_MANAGER_METHOD_RESULT, method, strlen(VCD_MANAGER_METHOD_RESULT))) {
 189                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get System Result");
 190
 191                 __vc_mgr_cb_system_result();
 192
 193                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 194
 195         } /* VCD_MANAGER_METHOD_RESULT */
 196
 197         else if (0 == strncmp(VCD_MANAGER_METHOD_DIALOG, method, strlen(VCD_MANAGER_METHOD_DIALOG))) {
 198                 SLOG(LOG_INFO, TAG_VCM, "@@@ Request Dialog");
 199                 char* pid = NULL;
 200                 char* disp_text = NULL;
 201                 char* utt_text = NULL;
 202                 char* continous = NULL;
 203
 204                 bundle_get_str(msg, VC_BUNDLE_PID, &pid);
 205                 bundle_get_str(msg, VC_BUNDLE_DISP_TEXT, &disp_text);
 206                 bundle_get_str(msg, VC_BUNDLE_UTT_TEXT, &utt_text);
 207                 bundle_get_str(msg, VC_BUNDLE_CONTINUOUS, &continous);
 208
 209                 if (!strncmp(disp_text, "#NULL", strlen("#NULL") + 1))
 210                         disp_text = NULL;
 211                 if (!strncmp(utt_text, "#NULL", strlen("#NULL") + 1))
 212                         utt_text = NULL;
 213
 214                 __vc_mgr_cb_dialog(atoi(pid), disp_text, utt_text, (bool)atoi(continous));
 215
 216                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 217         } /* VCD_MANAGER_METHOD_DIALOG */
 218
 219         else if (0 == strncmp(VCD_MANAGER_METHOD_ERROR, method, strlen(VCD_MANAGER_METHOD_ERROR))) {
 220                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get Error");
 221                 char* reason = NULL;
 222                 char* daemon_pid = NULL;
 223                 char* err_msg = NULL;
 224
 225                 bundle_get_str(msg, VC_BUNDLE_REASON, &reason);
 226                 bundle_get_str(msg, VC_BUNDLE_DAEMON_PID, &daemon_pid);
 227                 bundle_get_str(msg, VC_BUNDLE_ERR_MSG, &err_msg);
 228
 229                 char* temp_msg = NULL;
 230                 if (NULL != err_msg && strncmp(err_msg, "#NULL", strlen("#NULL") + 1)) {
 231                         temp_msg = strdup(err_msg);
 232                 }
 233                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr Get Error message : reason(%d), daemon_pid(%d), msg(%s)", atoi(reason), atoi(daemon_pid), (temp_msg) ? temp_msg : "NULL");
 234                 __vc_mgr_cb_error(atoi(reason), atoi(daemon_pid), temp_msg);
 235                 if (NULL != temp_msg) {
 236                         free(temp_msg);
 237                         temp_msg = NULL;
 238                 }
 239
 240                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 241         } /* VCD_MANAGER_METHOD_ERROR */
 242
 243         else if (0 == strncmp(VCD_MANAGER_METHOD_SET_PRIVATE_DATA, method, strlen(VCD_MANAGER_METHOD_SET_PRIVATE_DATA))) {
 244                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get request set private data");
 245                 char* pid = NULL;
 246                 char* key = NULL;
 247                 char* private_data = NULL;
 248
 249                 bundle_get_str(msg, VC_BUNDLE_PID, &pid);
 250                 bundle_get_str(msg, VC_BUNDLE_KEY, &key);
 251                 bundle_get_str(msg, VC_BUNDLE_PRIVATE_DATA, &private_data);
 252
 253                 SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", atoi(pid));
 254                 if (pid > 0) {
 255                         __vc_mgr_cb_private_data_set(key, private_data);
 256                 } else {
 257                         SLOG(LOG_ERROR, TAG_VCM, "@@ got invalid pid(%d)", atoi(pid));
 258                 }
 259
 260                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 261         } /* VCD_MANAGER_METHOD_SET_PRIVATE_DATA */
 262
 263         else if (0 == strncmp(VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT, method, strlen(VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT))) {
 264                 SLOG(LOG_INFO, TAG_VCM, "@@@ Get request feedback audio format");
 265                 char* channel = NULL;
 266                 char* audio_type = NULL;
 267                 char* rate = NULL;
 268
 269                 bundle_get_str(msg, VC_BUNDLE_AUDIO_CHANNEL, &channel);
 270                 bundle_get_str(msg, VC_BUNDLE_AUDIO_TYPE, &audio_type);
 271                 bundle_get_str(msg, VC_BUNDLE_AUDIO_RATE, &rate);
 272
 273                 __vc_mgr_cb_feedback_audio_format(atoi(rate), (vc_audio_channel_e)atoi(channel), (vc_audio_type_e)atoi(audio_type));
 274
 275                 SLOG(LOG_INFO, TAG_VCM, "@@@");
 276         } /* VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT */
 277
 278         // TODO: uncomment this line after vcc done
 279         // NEED2CHECK: when vcc send 'set_foreground', __vcd_mgr_set_foreground_cb will be invoked...
 280         // else if (0 == strncmp(VCC_MANAGER_METHOD_SET_FOREGROUND, method, strlen(VCC_MANAGER_METHOD_SET_FOREGROUND))) {
 281         //      SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground");
 282         //      char* temp_pid = NULL;
 283         //      char* temp_value = NULL;
 284         //      int pid = 0;
 285         //      int value = 0;
 286
 287         //      bundle_get_str(msg, VC_BUNDLE_PID, &temp_pid);
 288         //      bundle_get_str(msg, VC_BUNDLE_VALUE, &temp_value);
 289         //      pid = atoi(temp_pid);
 290         //      value = atoi(temp_value);
 291
 292         //      SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
 293
 294         //      __vc_mgr_cb_set_foreground(pid, (bool)value);
 295         //      SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 296         // } /* VCC_MANAGER_METHOD_SET_FOREGROUND */
 297
 298         else {
 299                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg");
 300         }
 301
 302 }
 303
 304 static void __send_buffer_cb(void *user_data, rpc_port_proxy_vc_mgr_proxy_array_char_h data_in, bundle *msg)
 305 {
 306         char *method = NULL;
 307         char *val = NULL;
 308
 309         SLOG(LOG_DEBUG, TAG_VCM, "__send_buffer_cb is invoked");
 310
 311         bundle_get_str(msg, VC_BUNDLE_METHOD, &method);
 312
 313         if (0 == strncmp(VCD_MANAGER_METHOD_FEEDBACK_STREAMING, method, strlen(VCD_MANAGER_METHOD_FEEDBACK_STREAMING))) {
 314                 char *utt_id = NULL;
 315                 char *event = NULL;
 316                 char* buffer = NULL;
 317                 int len = 0;
 318
 319                 bundle_get_str(msg, VC_BUNDLE_PID, &val);
 320                 bundle_get_str(msg, VC_BUNDLE_UTT_ID, &utt_id);
 321                 bundle_get_str(msg, VC_BUNDLE_EVENT, &event);
 322
 323                 rpc_port_proxy_vc_mgr_proxy_array_char_get(data_in, &buffer, &len);
 324                 __vc_mgr_cb_feedback_streaming(atoi(val), atoi(utt_id), atoi(event), buffer, len);
 325                 free(buffer);
 326
 327                 SLOG(LOG_INFO, TAG_VCM, "@@@");
 328         } /* VCD_MANAGER_METHOD_FEEDBACK_STREAMING */
 329
 330         else {
 331                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg");
 332         }
 333
 334 }
 335
 336 static void __on_connected(rpc_port_proxy_vc_mgr_proxy_vc_mgr_h h, void *user_data)
 337 {
 338         g_proxy_tidl_info->connected = true;
 339         g_proxy_tidl_info->connection_requesting = false;
 340         g_proxy_tidl_info->register_callback_invoked = false;
 341
 342         SLOG(LOG_INFO, TAG_VCM, "Connected to server");
 343 }
 344
 345 static void __on_disconnected(rpc_port_proxy_vc_mgr_proxy_vc_mgr_h h, void *user_data)
 346 {
 347         g_proxy_tidl_info->connected = false;
 348         g_proxy_tidl_info->connection_requesting = false;
 349         g_proxy_tidl_info->register_callback_invoked = false;
 350
 351         SLOG(LOG_INFO, TAG_VCM, "Disonnected to server");
 352
 353         SLOG(LOG_INFO, TAG_VCM, "Re-connection start");
 354         __vc_mgr_cb_error(VC_ERROR_SERVICE_RESET, -1, "Server Disconnected, re-launch");
 355 }
 356
 357 static void __on_rejected(rpc_port_proxy_vc_mgr_proxy_vc_mgr_h h, void *user_data)
 358 {
 359         g_proxy_tidl_info->connection_requesting = false;
 360         g_proxy_tidl_info->register_callback_invoked = false;
 361
 362         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Rejected from server");
 363 }
 364
 365
 366 static rpc_port_proxy_vc_mgr_proxy_vc_mgr_h __create_rpc_port(const char* engine_app_id)
 367 {
 368         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __create_rpc_port");
 369         rpc_port_proxy_vc_mgr_proxy_vc_mgr_callback_s rpc_callback = {
 370                 .connected = __on_connected,
 371                 .disconnected = __on_disconnected,
 372                 .rejected = __on_rejected
 373         };
 374
 375         rpc_port_proxy_vc_mgr_proxy_vc_mgr_h handle = NULL;
 376         if (0 != rpc_port_proxy_vc_mgr_proxy_vc_mgr_create(engine_app_id, &rpc_callback, NULL, &handle)) {
 377                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy");
 378                 return NULL;
 379         }
 380
 381         return handle;
 382 }
 383
 384 static void __vcd_mgr_create_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, void *user_data)
 385 {
 386         g_stub_tidl_info->connected = true;
 387         g_stub_tidl_info->register_callback_requesting = false;
 388
 389         SLOG(LOG_DEBUG, TAG_VCM, "Connected to server");
 390
 391         char *sender = NULL;
 392
 393         rpc_port_stub_vc_mgr_stub_vcd_mgr_context_get_sender(context, &sender);
 394         if (!sender) {
 395                 SLOG(LOG_ERROR, TAG_VCM, "@@@ Sender is NULL");
 396                 return;
 397         }
 398
 399         SLOG(LOG_DEBUG, TAG_VCM, "@@@ Server connect. appid(%s)", sender);
 400         free(sender);
 401 }
 402
 403 static void __vcd_mgr_terminate_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, void *user_data)
 404 {
 405         g_stub_tidl_info->connected = false;
 406         g_stub_tidl_info->register_callback_requesting = false;
 407
 408         rpc_port_stub_vc_mgr_stub_vcd_mgr_context_set_tag(context, NULL);
 409
 410         char *sender = NULL;
 411         rpc_port_stub_vc_mgr_stub_vcd_mgr_context_get_sender(context, &sender);
 412         if (!sender)
 413                 return;
 414
 415         SLOG(LOG_INFO, TAG_VCM, "@@@ Server disconnect. appid(%s)", sender);
 416         free(sender);
 417 }
 418
 419 static void __vcd_mgr_set_foreground_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, int value, void *user_data)
 420 {
 421         SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground");
 422         SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
 423
 424         __vc_mgr_cb_set_foreground(pid, (bool)value);
 425
 426         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 427 }
 428
 429 static int __vcd_mgr_get_private_data_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, const char *key, char **data, void *user_data)
 430 {
 431         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request get private data");
 432         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid);
 433
 434         int ret = -1;
 435         char *temp_data = NULL;
 436
 437         ret = __vc_mgr_cb_private_data_requested(key, &temp_data);
 438         if (0 != ret) {
 439                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 440                 return ret;
 441         }
 442         if (NULL == temp_data) {
 443                 SLOG(LOG_INFO, TAG_VCM, "data parameter is NULL");
 444                 temp_data = strdup("#NULL");
 445         }
 446         *data = temp_data;
 447         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 448
 449         return ret;
 450 }
 451
 452 static int __vcd_mgr_auth_enable_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, void *user_data)
 453 {
 454         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth enable");
 455         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth enable : pid(%d)", pid);
 456
 457         int ret = -1;
 458
 459         ret = __vc_mgr_request_auth_enable(pid);
 460         if (0 != ret) {
 461                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 462         }
 463
 464         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 465
 466         return ret;
 467 }
 468
 469 static int __vcd_mgr_auth_disable_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, void *user_data)
 470 {
 471         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth disable");
 472         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth disable : pid(%d)", pid);
 473
 474         int ret = -1;
 475
 476         ret = __vc_mgr_request_auth_disable(pid);
 477         if (0 != ret) {
 478                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 479         }
 480
 481         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 482
 483         return ret;
 484 }
 485
 486 static int __vcd_mgr_auth_start_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, void *user_data)
 487 {
 488         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth start");
 489         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth start : pid(%d)", pid);
 490
 491         int ret = -1;
 492
 493         ret = __vc_mgr_request_auth_start(pid);
 494         if (0 != ret) {
 495                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 496         }
 497
 498         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 499
 500         return ret;
 501 }
 502
 503 static int __vcd_mgr_auth_stop_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, void *user_data)
 504 {
 505         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth stop");
 506         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth stop : pid(%d)", pid);
 507
 508         int ret = -1;
 509
 510         ret = __vc_mgr_request_auth_stop(pid);
 511         if (0 != ret) {
 512                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 513         }
 514
 515         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 516
 517         return ret;
 518 }
 519
 520 static int __vcd_mgr_auth_cancel_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h context, int pid, void *user_data)
 521 {
 522         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth cancel");
 523         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth cancel : pid(%d)", pid);
 524
 525         int ret = -1;
 526
 527         ret = __vc_mgr_request_auth_cancel(pid);
 528         if (0 != ret) {
 529                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 530         }
 531
 532         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 533
 534         return ret;
 535 }
 536
 537 static void __register_stub_callback()
 538 {
 539         if (g_stub_tidl_info->register_callback_requesting) {
 540                 return;
 541         }
 542
 543         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __register_stub_callback");
 544
 545         g_mgr_callback.create = __vcd_mgr_create_cb;
 546         g_mgr_callback.terminate = __vcd_mgr_terminate_cb;
 547         g_mgr_callback.set_foreground = __vcd_mgr_set_foreground_cb;
 548         g_mgr_callback.get_private_data = __vcd_mgr_get_private_data_cb;
 549         g_mgr_callback.auth_enable = __vcd_mgr_auth_enable_cb;
 550         g_mgr_callback.auth_disable = __vcd_mgr_auth_disable_cb;
 551         g_mgr_callback.auth_start = __vcd_mgr_auth_start_cb;
 552         g_mgr_callback.auth_stop = __vcd_mgr_auth_stop_cb;
 553         g_mgr_callback.auth_cancel = __vcd_mgr_auth_cancel_cb;
 554
 555         int ret = -1;
 556         ret = rpc_port_stub_vc_mgr_stub_vcd_mgr_register(&g_mgr_callback, NULL);
 557         if (0 == ret) {
 558                 SLOG(LOG_DEBUG, TAG_VCM, "register callback");
 559                 g_stub_tidl_info->register_callback_requesting = true;
 560                 return;
 561         }
 562
 563         SLOG(LOG_ERROR, TAG_VCM, "Fail to rister callback(%d)", ret);
 564         return;
 565 }
 566
 567 int vc_mgr_tidl_open_connection()
 568 {
 569         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_open_connection");
 570         pthread_mutex_lock(&g_tidl_mutex);
 571
 572         if (NULL != g_proxy_tidl_info) {
 573                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] g_proxy_tidl_info already created");
 574                 pthread_mutex_unlock(&g_tidl_mutex);
 575                 return VC_ERROR_NONE;
 576         }
 577
 578         g_proxy_tidl_info = (vc_mgr_tidl_info_s*)calloc(1, sizeof(vc_mgr_tidl_info_s));
 579
 580         if (NULL == g_proxy_tidl_info) {
 581                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vc_mgr_tidl_info_s");
 582                 pthread_mutex_unlock(&g_tidl_mutex);
 583                 return VC_ERROR_OUT_OF_MEMORY;
 584         }
 585
 586         char* engine_app_id = vconf_get_str(VC_ENGINE_DB_DEFAULT);
 587         if (NULL == engine_app_id) {
 588                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL] vconf not found");
 589                 free(g_proxy_tidl_info);
 590                 g_proxy_tidl_info = NULL;
 591                 pthread_mutex_unlock(&g_tidl_mutex);
 592                 return VC_ERROR_ENGINE_NOT_FOUND;
 593         }
 594
 595         g_proxy_tidl_info->rpc_h = __create_rpc_port(engine_app_id);
 596         if (NULL == g_proxy_tidl_info->rpc_h) {
 597                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy");
 598                 free(engine_app_id);
 599                 free(g_proxy_tidl_info);
 600                 g_proxy_tidl_info = NULL;
 601                 pthread_mutex_unlock(&g_tidl_mutex);
 602                 return VC_ERROR_OPERATION_FAILED;
 603         }
 604
 605         SLOG(LOG_INFO, TAG_VCM, "[TIDL] rpc_h(%p), engine_app_id(%s)", g_proxy_tidl_info->rpc_h, engine_app_id);
 606         free(engine_app_id);
 607
 608         g_stub_tidl_info = (vcd_mgr_tidl_info_s*)calloc(1, sizeof(vcd_mgr_tidl_info_s));
 609
 610         if (NULL == g_stub_tidl_info) {
 611                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vcd_mgr_tidl_info_s");
 612                 pthread_mutex_unlock(&g_tidl_mutex);
 613                 return VC_ERROR_OUT_OF_MEMORY;
 614         }
 615
 616         __register_stub_callback();
 617
 618         pthread_mutex_unlock(&g_tidl_mutex);
 619
 620         return VC_ERROR_NONE;
 621 }
 622
 623 int vc_mgr_tidl_close_connection()
 624 {
 625         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_close_connection");
 626         pthread_mutex_lock(&g_tidl_mutex);
 627
 628         if (NULL == g_proxy_tidl_info) {
 629                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 630                 pthread_mutex_unlock(&g_tidl_mutex);
 631                 return VC_ERROR_OPERATION_FAILED;
 632         }
 633
 634         if (0 != rpc_port_proxy_vc_mgr_proxy_vc_mgr_destroy(g_proxy_tidl_info->rpc_h)) {
 635                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to destroy tidl handle");
 636                 pthread_mutex_unlock(&g_tidl_mutex);
 637                 return VC_ERROR_OPERATION_FAILED;
 638         }
 639
 640         g_proxy_tidl_info->rpc_h = NULL;
 641         g_proxy_tidl_info->notify_cb_h = NULL;
 642         g_proxy_tidl_info->send_buffer_cb_h = NULL;
 643
 644         free(g_proxy_tidl_info);
 645         g_proxy_tidl_info = NULL;
 646
 647         free(g_stub_tidl_info);
 648         g_stub_tidl_info = NULL;
 649
 650         pthread_mutex_unlock(&g_tidl_mutex);
 651
 652         return VC_ERROR_NONE;
 653 }
 654
 655 static void __request_tidl_connect()
 656 {
 657         if (g_proxy_tidl_info->connection_requesting) {
 658                 return;
 659         }
 660
 661         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_connect(g_proxy_tidl_info->rpc_h);
 662         SLOG(LOG_INFO, TAG_VCM, "[INFO] Request connection to stub. ret(%d)", ret);
 663
 664         if (0 == ret) {
 665                 g_proxy_tidl_info->connection_requesting = true;
 666         }
 667 }
 668
 669 static int __create_callback_handles()
 670 {
 671         if (NULL != g_proxy_tidl_info->notify_cb_h) {
 672                 rpc_port_proxy_vc_mgr_proxy_vc_mgr_notify_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->notify_cb_h);
 673                 g_proxy_tidl_info->notify_cb_h = NULL;
 674         }
 675
 676         if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_proxy_vc_mgr_notify_cb_create(&g_proxy_tidl_info->notify_cb_h)) {
 677                 return VC_ERROR_OUT_OF_MEMORY;
 678         }
 679
 680         rpc_port_proxy_vc_mgr_proxy_vc_mgr_notify_cb_set_callback(g_proxy_tidl_info->notify_cb_h, __notify_cb, NULL);
 681
 682         rpc_port_proxy_vc_mgr_proxy_vc_mgr_notify_cb_set_once(g_proxy_tidl_info->notify_cb_h, false);
 683
 684         if (NULL != g_proxy_tidl_info->send_buffer_cb_h) {
 685                 rpc_port_proxy_vc_mgr_proxy_vc_mgr_send_buffer_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->send_buffer_cb_h);
 686                 g_proxy_tidl_info->send_buffer_cb_h = NULL;
 687         }
 688
 689         if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_proxy_vc_mgr_send_buffer_cb_create(&g_proxy_tidl_info->send_buffer_cb_h)) {
 690                 return VC_ERROR_OUT_OF_MEMORY;
 691         }
 692
 693         rpc_port_proxy_vc_mgr_proxy_vc_mgr_send_buffer_cb_set_callback(g_proxy_tidl_info->send_buffer_cb_h, __send_buffer_cb, NULL);
 694
 695         rpc_port_proxy_vc_mgr_proxy_vc_mgr_send_buffer_cb_set_once(g_proxy_tidl_info->send_buffer_cb_h, false);
 696
 697         return VC_ERROR_NONE;
 698 }
 699
 700 static int __invoke_register_callback()
 701 {
 702         if (g_proxy_tidl_info->register_callback_invoked) {
 703                 SLOG(LOG_ERROR, TAG_VCM, "[INFO] Already register callback is invoked");
 704                 return VC_ERROR_NONE;
 705         }
 706
 707         int ret = __create_callback_handles(g_proxy_tidl_info);
 708         if (VC_ERROR_NONE != ret) {
 709                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create callback handle. ret(%d)", ret);
 710                 return VC_ERROR_OPERATION_FAILED;
 711         }
 712
 713         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_register_cb(g_proxy_tidl_info->rpc_h, getpid(), g_proxy_tidl_info->notify_cb_h, g_proxy_tidl_info->send_buffer_cb_h);
 714         g_proxy_tidl_info->register_callback_invoked = true;
 715         return VC_ERROR_NONE;
 716 }
 717
 718 int vc_mgr_tidl_request_hello()
 719 {
 720         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_hello");
 721
 722         if (NULL == g_proxy_tidl_info) {
 723                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get proxy tidl info");
 724                 return VC_ERROR_OPERATION_FAILED;
 725         }
 726
 727         if (!g_proxy_tidl_info->connected) {
 728                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Proxy Not Connected");
 729                 __request_tidl_connect();
 730                 return VC_ERROR_OPERATION_FAILED;
 731         }
 732
 733         if (VC_ERROR_NONE != __invoke_register_callback()) {
 734                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to invoke register callback");
 735                 return VC_ERROR_OPERATION_FAILED;
 736         }
 737
 738         if (NULL == g_stub_tidl_info) {
 739                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get stub tidl info");
 740                 return VC_ERROR_OPERATION_FAILED;
 741         }
 742
 743         if (!g_stub_tidl_info->connected) {
 744                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stub Not Connected");
 745                 __register_stub_callback();
 746                 return VC_ERROR_OPERATION_FAILED;
 747         }
 748
 749         SLOG(LOG_DEBUG, TAG_VCM, ">>>>> VCM Hello");
 750
 751         SLOG(LOG_DEBUG, TAG_VCM, "<<<<");
 752
 753         return VC_ERROR_NONE;
 754 }
 755
 756 int vc_mgr_tidl_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid)
 757 {
 758         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_initialize");
 759
 760         if (NULL == g_proxy_tidl_info) {
 761                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 762                 return VC_ERROR_OPERATION_FAILED;
 763         }
 764
 765         int tmp_service_state = 0;
 766         int tmp_forground = 0;
 767         int tmp_daemon_pid = 0;
 768
 769         if (!g_proxy_tidl_info->connected) {
 770                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 771                 return VC_ERROR_OPERATION_FAILED;
 772         }
 773
 774         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, audio_streaming_mode, &tmp_service_state, &tmp_forground, &tmp_daemon_pid);
 775         if (RPC_PORT_ERROR_NONE != ret) {
 776                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message, error(%d)", ret);
 777                 return ret;
 778         }
 779
 780         *service_state = tmp_service_state;
 781         *foreground = tmp_forground;
 782         *daemon_pid = tmp_daemon_pid;
 783
 784         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc manager initialize: service_state(%d), foreground(%d), daemon_pid(%d)", *service_state, *foreground, *daemon_pid);
 785
 786         return VC_ERROR_NONE;
 787 }
 788
 789 int vc_mgr_tidl_request_finalize(int pid)
 790 {
 791         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_finalize");
 792
 793         if (NULL == g_proxy_tidl_info) {
 794                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 795                 return VC_ERROR_OPERATION_FAILED;
 796         }
 797
 798         if (!g_proxy_tidl_info->connected) {
 799                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 800                 return VC_ERROR_OPERATION_FAILED;
 801         }
 802
 803         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid);
 804         if (RPC_PORT_ERROR_NONE != ret) {
 805                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message, error(%d)", ret);
 806                 return ret;
 807         }
 808
 809         return VC_ERROR_NONE;
 810 }
 811
 812 int vc_mgr_tidl_request_set_command(int pid)
 813 {
 814         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_command");
 815
 816         if (NULL == g_proxy_tidl_info) {
 817                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 818                 return VC_ERROR_OPERATION_FAILED;
 819         }
 820
 821         if (!g_proxy_tidl_info->connected) {
 822                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 823                 return VC_ERROR_OPERATION_FAILED;
 824         }
 825
 826         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid);
 827         if (RPC_PORT_ERROR_NONE != ret) {
 828                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message, error(%d)", ret);
 829                 return ret;
 830         }
 831
 832         return VC_ERROR_NONE;
 833 }
 834
 835 int vc_mgr_tidl_request_unset_command(int pid)
 836 {
 837         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_unset_command");
 838
 839         if (NULL == g_proxy_tidl_info) {
 840                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 841                 return VC_ERROR_OPERATION_FAILED;
 842         }
 843
 844         if (!g_proxy_tidl_info->connected) {
 845                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 846                 return VC_ERROR_OPERATION_FAILED;
 847         }
 848
 849         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid);
 850         if (RPC_PORT_ERROR_NONE != ret) {
 851                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message, error(%d)", ret);
 852                 return ret;
 853         }
 854
 855         return VC_ERROR_NONE;
 856 }
 857
 858 int vc_mgr_tidl_request_demandable_client(int pid)
 859 {
 860         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_demandable_client");
 861
 862         if (NULL == g_proxy_tidl_info) {
 863                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 864                 return VC_ERROR_OPERATION_FAILED;
 865         }
 866
 867         if (!g_proxy_tidl_info->connected) {
 868                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 869                 return VC_ERROR_OPERATION_FAILED;
 870         }
 871
 872         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid);
 873         if (RPC_PORT_ERROR_NONE != ret) {
 874                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message, error(%d)", ret);
 875                 return ret;
 876         }
 877
 878         return VC_ERROR_NONE;
 879 }
 880
 881 int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type)
 882 {
 883         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_type");
 884
 885         if (NULL == g_proxy_tidl_info) {
 886                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 887                 return VC_ERROR_OPERATION_FAILED;
 888         }
 889
 890         if (!g_proxy_tidl_info->connected) {
 891                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 892                 return VC_ERROR_OPERATION_FAILED;
 893         }
 894
 895         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type);
 896         if (RPC_PORT_ERROR_NONE != ret) {
 897                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message, error(%d)", ret);
 898                 return ret;
 899         }
 900
 901         return VC_ERROR_NONE;
 902 }
 903
 904 int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type)
 905 {
 906         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_audio_type");
 907
 908         if (NULL == g_proxy_tidl_info) {
 909                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 910                 return VC_ERROR_OPERATION_FAILED;
 911         }
 912
 913         if (!g_proxy_tidl_info->connected) {
 914                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 915                 return VC_ERROR_OPERATION_FAILED;
 916         }
 917
 918         char *tmp = NULL;
 919         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp);
 920         if (RPC_PORT_ERROR_NONE != ret) {
 921                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message, error(%d)", ret);
 922                 return ret;
 923         }
 924         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get audio type : Success");
 925
 926         *audio_type = tmp;
 927
 928         return VC_ERROR_NONE;
 929 }
 930
 931 int vc_mgr_tidl_request_set_private_data(int pid, const char* key, const char* data)
 932 {
 933         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_private_data");
 934
 935         if (NULL == g_proxy_tidl_info) {
 936                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 937                 return VC_ERROR_OPERATION_FAILED;
 938         }
 939
 940         if (!g_proxy_tidl_info->connected) {
 941                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 942                 return VC_ERROR_OPERATION_FAILED;
 943         }
 944
 945         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_private_data(g_proxy_tidl_info->rpc_h, pid, key, data);
 946
 947         return VC_ERROR_NONE;
 948 }
 949
 950 int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data)
 951 {
 952         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_private_data");
 953
 954         if (NULL == g_proxy_tidl_info) {
 955                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 956                 return VC_ERROR_OPERATION_FAILED;
 957         }
 958
 959         if (!g_proxy_tidl_info->connected) {
 960                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 961                 return VC_ERROR_OPERATION_FAILED;
 962         }
 963
 964         char *tmp = NULL;
 965         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp);
 966         if (RPC_PORT_ERROR_NONE != ret) {
 967                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message, error(%d)", ret);
 968                 return ret;
 969         }
 970         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get private data : Success");
 971
 972         *data = tmp;
 973
 974         return VC_ERROR_NONE;
 975 }
 976
 977 int vc_mgr_tidl_request_set_client_info(int pid)
 978 {
 979         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_client_info");
 980
 981         if (NULL == g_proxy_tidl_info) {
 982                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 983                 return VC_ERROR_OPERATION_FAILED;
 984         }
 985
 986         if (!g_proxy_tidl_info->connected) {
 987                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 988                 return VC_ERROR_OPERATION_FAILED;
 989         }
 990
 991         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid);
 992         if (RPC_PORT_ERROR_NONE != ret) {
 993                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message, error(%d)", ret);
 994                 return ret;
 995         }
 996
 997         return VC_ERROR_NONE;
 998 }
 999
1000 int vc_mgr_tidl_request_set_domain(int pid, const char* domain)
1001 {
1002         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_domain");
1003
1004         if (NULL == g_proxy_tidl_info) {
1005                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1006                 return VC_ERROR_OPERATION_FAILED;
1007         }
1008
1009         if (!g_proxy_tidl_info->connected) {
1010                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1011                 return VC_ERROR_OPERATION_FAILED;
1012         }
1013
1014         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain);
1015         if (RPC_PORT_ERROR_NONE != ret) {
1016                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message, error(%d)", ret);
1017                 return ret;
1018         }
1019
1020         return VC_ERROR_NONE;
1021 }
1022
1023 int vc_mgr_tidl_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
1024 {
1025         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_do_action");
1026
1027         if (NULL == g_proxy_tidl_info) {
1028                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1029                 return VC_ERROR_OPERATION_FAILED;
1030         }
1031
1032         if (!g_proxy_tidl_info->connected) {
1033                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1034                 return VC_ERROR_OPERATION_FAILED;
1035         }
1036
1037         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_do_action(g_proxy_tidl_info->rpc_h, pid, type, send_event);
1038
1039         return VC_ERROR_NONE;
1040 }
1041
1042 int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type)
1043 {
1044         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_start");
1045
1046         if (NULL == g_proxy_tidl_info) {
1047                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1048                 return VC_ERROR_OPERATION_FAILED;
1049         }
1050
1051         if (!g_proxy_tidl_info->connected) {
1052                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1053                 return VC_ERROR_OPERATION_FAILED;
1054         }
1055
1056         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_start(g_proxy_tidl_info->rpc_h, pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type);
1057         if (RPC_PORT_ERROR_NONE != ret) {
1058                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message, error(%d)", ret);
1059                 return ret;
1060         }
1061
1062         return VC_ERROR_NONE;
1063 }
1064
1065 int vc_mgr_tidl_request_stop(int pid)
1066 {
1067         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_stop");
1068
1069         if (NULL == g_proxy_tidl_info) {
1070                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1071                 return VC_ERROR_OPERATION_FAILED;
1072         }
1073
1074         if (!g_proxy_tidl_info->connected) {
1075                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1076                 return VC_ERROR_OPERATION_FAILED;
1077         }
1078
1079         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid);
1080         if (RPC_PORT_ERROR_NONE != ret) {
1081                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message, error(%d)", ret);
1082                 return ret;
1083         }
1084
1085         return VC_ERROR_NONE;
1086 }
1087
1088 int vc_mgr_tidl_request_cancel(int pid)
1089 {
1090         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_cancel");
1091
1092         if (NULL == g_proxy_tidl_info) {
1093                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1094                 return VC_ERROR_OPERATION_FAILED;
1095         }
1096
1097         if (!g_proxy_tidl_info->connected) {
1098                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1099                 return VC_ERROR_OPERATION_FAILED;
1100         }
1101
1102         int ret = rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid);
1103         if (RPC_PORT_ERROR_NONE != ret) {
1104                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message, error(%d)", ret);
1105                 return ret;
1106         }
1107
1108         return VC_ERROR_NONE;
1109 }
1110
1111 int vc_mgr_tidl_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode)
1112 {
1113         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_streaming_mode");
1114
1115         if (NULL == g_proxy_tidl_info) {
1116                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1117                 return VC_ERROR_OPERATION_FAILED;
1118         }
1119
1120         if (!g_proxy_tidl_info->connected) {
1121                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1122                 return VC_ERROR_OPERATION_FAILED;
1123         }
1124
1125         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_set_audio_streaming_mode(g_proxy_tidl_info->rpc_h, pid, mode);
1126
1127         return VC_ERROR_NONE;
1128 }
1129
1130 int vc_mgr_tidl_send_result_selection(int pid)
1131 {
1132         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection");
1133
1134         if (NULL == g_proxy_tidl_info) {
1135                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1136                 return VC_ERROR_OPERATION_FAILED;
1137         }
1138
1139         if (!g_proxy_tidl_info->connected) {
1140                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1141                 return VC_ERROR_OPERATION_FAILED;
1142         }
1143
1144         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_send_result_selection(g_proxy_tidl_info->rpc_h, pid);
1145
1146         return VC_ERROR_NONE;
1147 }
1148
1149 int vc_mgr_tidl_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request)
1150 {
1151         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection");
1152
1153         if (NULL == g_proxy_tidl_info) {
1154                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1155                 return VC_ERROR_OPERATION_FAILED;
1156         }
1157
1158         if (!g_proxy_tidl_info->connected) {
1159                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1160                 return VC_ERROR_OPERATION_FAILED;
1161         }
1162
1163         gchar *gEncodedRequest = g_base64_encode((const guchar*)request, strlen(request));
1164
1165         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_send_specific_engine_request(g_proxy_tidl_info->rpc_h, pid, engine_app_id, event, gEncodedRequest);
1166
1167         if (gEncodedRequest)
1168                 g_free(gEncodedRequest);
1169
1170         return VC_ERROR_NONE;
1171 }
1172
1173 int vc_mgr_tidl_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status)
1174 {
1175         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_utterance_status");
1176
1177         if (NULL == g_proxy_tidl_info) {
1178                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1179                 return VC_ERROR_OPERATION_FAILED;
1180         }
1181
1182         if (!g_proxy_tidl_info->connected) {
1183                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1184                 return VC_ERROR_OPERATION_FAILED;
1185         }
1186
1187         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_send_utterance_status(g_proxy_tidl_info->rpc_h, pid, utt_id, utt_status);
1188
1189         return VC_ERROR_NONE;
1190 }
1191
1192 int vc_mgr_tidl_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
1193 {
1194         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_audio_streaming");
1195
1196         if (NULL == g_proxy_tidl_info) {
1197                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1198                 return VC_ERROR_OPERATION_FAILED;
1199         }
1200
1201         if (!g_proxy_tidl_info->connected) {
1202                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1203                 return VC_ERROR_OPERATION_FAILED;
1204         }
1205
1206         rpc_port_proxy_vc_mgr_proxy_array_char_h data = NULL;
1207         rpc_port_proxy_vc_mgr_proxy_array_char_create(&data);
1208         if (NULL == data) {
1209                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create data handle");
1210                 return VC_ERROR_OUT_OF_MEMORY;
1211         }
1212
1213         if (NULL != buffer && 0 < len) {
1214                 rpc_port_proxy_vc_mgr_proxy_array_char_set(data, (char*)buffer, len);
1215         } else {
1216                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL] buffer is empty");
1217         }
1218
1219         rpc_port_proxy_vc_mgr_proxy_vc_mgr_invoke_send_audio_streaming(g_proxy_tidl_info->rpc_h, pid, event, data);
1220         rpc_port_proxy_vc_mgr_proxy_array_char_destroy(data);
1221
1222         return VC_ERROR_NONE;
1223 }