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