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_h rpc_h;
  33         rpc_port_proxy_vc_mgr_notify_cb_h notify_cb_h;
  34         rpc_port_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_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_MANAGER_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_MANAGER_BUNDLE_MESSAGE, &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_MANAGER_BUNDLE_MESSAGE, &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_MANAGER_BUNDLE_MESSAGE, &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_MANAGER_BUNDLE_EVENT, &event);
 157                 bundle_get_str(msg, VC_MANAGER_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_MANAGER_BUNDLE_ENGINE_APP_ID, &engine_app_id);
 173                 bundle_get_str(msg, VC_MANAGER_BUNDLE_EVENT, &event);
 174                 bundle_get_str(msg, VC_MANAGER_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_MANAGER_BUNDLE_MESSAGE, &pid);
 205                 bundle_get_str(msg, VC_MANAGER_BUNDLE_DISP_TEXT, &disp_text);
 206                 bundle_get_str(msg, VC_MANAGER_BUNDLE_UTT_TEXT, &utt_text);
 207                 bundle_get_str(msg, VC_MANAGER_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_MANAGER_BUNDLE_REASON, &reason);
 226                 bundle_get_str(msg, VC_MANAGER_BUNDLE_DAEMON_PID, &daemon_pid);
 227                 bundle_get_str(msg, VC_MANAGER_BUNDLE_ERROR_MESSAGE, &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_MANAGER_BUNDLE_MESSAGE, &pid);
 250                 bundle_get_str(msg, VC_MANAGER_BUNDLE_KEY, &key);
 251                 bundle_get_str(msg, VC_MANAGER_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_MANAGER_BUNDLE_AUDIO_CHANNEL, &channel);
 270                 bundle_get_str(msg, VC_MANAGER_BUNDLE_AUDIO_TYPE, &audio_type);
 271                 bundle_get_str(msg, VC_MANAGER_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         // else if (0 == strncmp(VCC_MANAGER_METHOD_SET_FOREGROUND, method, strlen(VCC_MANAGER_METHOD_SET_FOREGROUND))) {
 280         //      SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground");
 281         //      char* temp_pid = NULL;
 282         //      char* temp_value = NULL;
 283         //      int pid = 0;
 284         //      int value = 0;
 285
 286         //      bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &temp_pid);
 287         //      bundle_get_str(msg, VC_MANAGER_BUNDLE_VALUE, &temp_value);
 288         //      pid = atoi(temp_pid);
 289         //      value = atoi(temp_value);
 290
 291         //      SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
 292
 293         //      __vc_mgr_cb_set_foreground(pid, (bool)value);
 294         //      SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 295         // } /* VCC_MANAGER_METHOD_SET_FOREGROUND */
 296
 297         else {
 298                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg");
 299         }
 300
 301 }
 302
 303 static void __send_buffer_cb(void *user_data, rpc_port_proxy_array_char_h data_in, bundle *msg)
 304 {
 305         char *method = NULL;
 306         char *val = NULL;
 307
 308         SLOG(LOG_DEBUG, TAG_VCM, "__send_buffer_cb is invoked");
 309
 310         bundle_get_str(msg, VC_MANAGER_BUNDLE_METHOD, &method);
 311
 312         if (0 == strncmp(VCD_MANAGER_METHOD_FEEDBACK_STREAMING, method, strlen(VCD_MANAGER_METHOD_FEEDBACK_STREAMING))) {
 313                 char *utt_id = NULL;
 314                 char *event = NULL;
 315                 char* buffer = NULL;
 316                 int len = 0;
 317
 318                 bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &val);
 319                 bundle_get_str(msg, VC_MANAGER_BUNDLE_UTTID, &utt_id);
 320                 bundle_get_str(msg, VC_MANAGER_BUNDLE_EVENT, &event);
 321
 322                 rpc_port_proxy_array_char_get(data_in, &buffer, &len);
 323                 __vc_mgr_cb_feedback_streaming(atoi(val), atoi(utt_id), atoi(event), buffer, len);
 324                 free(buffer);
 325
 326                 SLOG(LOG_INFO, TAG_VCM, "@@@");
 327         } /* VCD_MANAGER_METHOD_FEEDBACK_STREAMING */
 328
 329         else {
 330                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg");
 331         }
 332
 333 }
 334
 335 static void __on_connected(rpc_port_proxy_vc_mgr_h h, void *user_data)
 336 {
 337         g_proxy_tidl_info->connected = true;
 338         g_proxy_tidl_info->connection_requesting = false;
 339         g_proxy_tidl_info->register_callback_invoked = false;
 340
 341         SLOG(LOG_INFO, TAG_VCM, "Connected to server");
 342 }
 343
 344 static void __on_disconnected(rpc_port_proxy_vc_mgr_h h, void *user_data)
 345 {
 346         g_proxy_tidl_info->connected = false;
 347         g_proxy_tidl_info->connection_requesting = false;
 348         g_proxy_tidl_info->register_callback_invoked = false;
 349
 350         SLOG(LOG_INFO, TAG_VCM, "Disonnected to server");
 351 }
 352
 353 static void __on_rejected(rpc_port_proxy_vc_mgr_h h, void *user_data)
 354 {
 355         g_proxy_tidl_info->connection_requesting = false;
 356         g_proxy_tidl_info->register_callback_invoked = false;
 357
 358         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Rejected from server");
 359 }
 360
 361
 362 static rpc_port_proxy_vc_mgr_h __create_rpc_port(const char* engine_app_id)
 363 {
 364         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __create_rpc_port");
 365         rpc_port_proxy_vc_mgr_callback_s rpc_callback = {
 366                 .connected = __on_connected,
 367                 .disconnected = __on_disconnected,
 368                 .rejected = __on_rejected
 369         };
 370
 371         rpc_port_proxy_vc_mgr_h handle = NULL;
 372         if (0 != rpc_port_proxy_vc_mgr_create(engine_app_id, &rpc_callback, NULL, &handle)) {
 373                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy");
 374                 return NULL;
 375         }
 376
 377         return handle;
 378 }
 379
 380 static void __vcd_mgr_create_cb(rpc_port_stub_vcd_mgr_context_h context, void *user_data)
 381 {
 382         g_stub_tidl_info->connected = true;
 383         g_stub_tidl_info->register_callback_requesting = false;
 384
 385         SLOG(LOG_DEBUG, TAG_VCM, "Connected to server");
 386
 387         char *sender = NULL;
 388
 389         rpc_port_stub_vcd_mgr_context_get_sender(context, &sender);
 390         if (!sender) {
 391                 SLOG(LOG_ERROR, TAG_VCM, "@@@ Sender is NULL");
 392                 return;
 393         }
 394
 395         SLOG(LOG_DEBUG, TAG_VCM, "@@@ Server connect. appid(%s)", sender);
 396         free(sender);
 397 }
 398
 399 static void __vcd_mgr_terminate_cb(rpc_port_stub_vcd_mgr_context_h context, void *user_data)
 400 {
 401         g_stub_tidl_info->connected = false;
 402         g_stub_tidl_info->register_callback_requesting = false;
 403
 404         rpc_port_stub_vcd_mgr_context_set_tag(context, NULL);
 405
 406         char *sender = NULL;
 407         rpc_port_stub_vcd_mgr_context_get_sender(context, &sender);
 408         if (!sender)
 409                 return;
 410
 411         SLOG(LOG_INFO, TAG_VCM, "@@@ Server disconnect. appid(%s)", sender);
 412         free(sender);
 413 }
 414
 415 static void __vcd_mgr_set_foreground_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, int value, void *user_data)
 416 {
 417         SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground");
 418         SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
 419
 420         __vc_mgr_cb_set_foreground(pid, (bool)value);
 421
 422         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 423 }
 424
 425 static int __vcd_mgr_get_private_data_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, const char *key, char **data, void *user_data)
 426 {
 427         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request get private data");
 428         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid);
 429
 430         int ret = -1;
 431         char *temp_data = NULL;
 432
 433         ret = __vc_mgr_cb_private_data_requested(key, &temp_data);
 434         if (0 != ret) {
 435                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 436                 return ret;
 437         }
 438         if (NULL == temp_data) {
 439                 SLOG(LOG_INFO, TAG_VCM, "data parameter is NULL");
 440                 temp_data = strdup("#NULL");
 441         }
 442         *data = temp_data;
 443         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 444
 445         return ret;
 446 }
 447
 448 static int __vcd_mgr_auth_enable_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data)
 449 {
 450         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth enable");
 451         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth enable : pid(%d)", pid);
 452
 453         int ret = -1;
 454
 455         ret = __vc_mgr_request_auth_enable(pid);
 456         if (0 != ret) {
 457                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 458         }
 459
 460         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 461
 462         return ret;
 463 }
 464
 465 static int __vcd_mgr_auth_disable_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data)
 466 {
 467         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth disable");
 468         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth disable : pid(%d)", pid);
 469
 470         int ret = -1;
 471
 472         ret = __vc_mgr_request_auth_disable(pid);
 473         if (0 != ret) {
 474                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 475         }
 476
 477         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 478
 479         return ret;
 480 }
 481
 482 static int __vcd_mgr_auth_start_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data)
 483 {
 484         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth start");
 485         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth start : pid(%d)", pid);
 486
 487         int ret = -1;
 488
 489         ret = __vc_mgr_request_auth_start(pid);
 490         if (0 != ret) {
 491                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 492         }
 493
 494         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 495
 496         return ret;
 497 }
 498
 499 static int __vcd_mgr_auth_stop_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data)
 500 {
 501         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth stop");
 502         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth stop : pid(%d)", pid);
 503
 504         int ret = -1;
 505
 506         ret = __vc_mgr_request_auth_stop(pid);
 507         if (0 != ret) {
 508                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 509         }
 510
 511         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 512
 513         return ret;
 514 }
 515
 516 static int __vcd_mgr_auth_cancel_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data)
 517 {
 518         SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth cancel");
 519         SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth cancel : pid(%d)", pid);
 520
 521         int ret = -1;
 522
 523         ret = __vc_mgr_request_auth_cancel(pid);
 524         if (0 != ret) {
 525                 SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret);
 526         }
 527
 528         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 529
 530         return ret;
 531 }
 532
 533 static void __register_stub_callback()
 534 {
 535         if (g_stub_tidl_info->register_callback_requesting) {
 536                 return;
 537         }
 538
 539         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __register_stub_callback");
 540
 541         g_mgr_callback.create = __vcd_mgr_create_cb;
 542         g_mgr_callback.terminate = __vcd_mgr_terminate_cb;
 543         g_mgr_callback.set_foreground = __vcd_mgr_set_foreground_cb;
 544         g_mgr_callback.get_private_data = __vcd_mgr_get_private_data_cb;
 545         g_mgr_callback.auth_enable = __vcd_mgr_auth_enable_cb;
 546         g_mgr_callback.auth_disable = __vcd_mgr_auth_disable_cb;
 547         g_mgr_callback.auth_start = __vcd_mgr_auth_start_cb;
 548         g_mgr_callback.auth_stop = __vcd_mgr_auth_stop_cb;
 549         g_mgr_callback.auth_cancel = __vcd_mgr_auth_cancel_cb;
 550
 551         int ret = -1;
 552         ret = rpc_port_stub_vcd_mgr_register(&g_mgr_callback, NULL);
 553         if (0 == ret) {
 554                 SLOG(LOG_DEBUG, TAG_VCM, "register callback");
 555                 g_stub_tidl_info->register_callback_requesting = true;
 556                 return;
 557         }
 558
 559         SLOG(LOG_ERROR, TAG_VCM, "Fail to rister callback(%d)", ret);
 560         return;
 561 }
 562
 563 int vc_mgr_tidl_open_connection()
 564 {
 565         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_open_connection");
 566         pthread_mutex_lock(&g_tidl_mutex);
 567
 568         if (NULL != g_proxy_tidl_info) {
 569                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] g_proxy_tidl_info already created");
 570                 pthread_mutex_unlock(&g_tidl_mutex);
 571                 return VC_ERROR_NONE;
 572         }
 573
 574         g_proxy_tidl_info = (vc_mgr_tidl_info_s*)calloc(1, sizeof(vc_mgr_tidl_info_s));
 575
 576         if (NULL == g_proxy_tidl_info) {
 577                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vc_mgr_tidl_info_s");
 578                 pthread_mutex_unlock(&g_tidl_mutex);
 579                 return VC_ERROR_OUT_OF_MEMORY;
 580         }
 581
 582         char* engine_app_id = vconf_get_str(VC_ENGINE_DB_DEFAULT);
 583         if (NULL == engine_app_id) {
 584                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL] vconf not found");
 585                 free(g_proxy_tidl_info);
 586                 g_proxy_tidl_info = NULL;
 587                 pthread_mutex_unlock(&g_tidl_mutex);
 588                 return VC_ERROR_ENGINE_NOT_FOUND;
 589         }
 590
 591         g_proxy_tidl_info->rpc_h = __create_rpc_port(engine_app_id);
 592         if (NULL == g_proxy_tidl_info->rpc_h) {
 593                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy");
 594                 free(engine_app_id);
 595                 free(g_proxy_tidl_info);
 596                 g_proxy_tidl_info = NULL;
 597                 pthread_mutex_unlock(&g_tidl_mutex);
 598                 return VC_ERROR_OPERATION_FAILED;
 599         }
 600
 601         SLOG(LOG_INFO, TAG_VCM, "[TIDL] rpc_h(%p), engine_app_id(%s)", g_proxy_tidl_info->rpc_h, engine_app_id);
 602         free(engine_app_id);
 603
 604         g_stub_tidl_info = (vcd_mgr_tidl_info_s*)calloc(1, sizeof(vcd_mgr_tidl_info_s));
 605
 606         if (NULL == g_stub_tidl_info) {
 607                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vcd_mgr_tidl_info_s");
 608                 pthread_mutex_unlock(&g_tidl_mutex);
 609                 return VC_ERROR_OUT_OF_MEMORY;
 610         }
 611
 612         __register_stub_callback();
 613
 614         pthread_mutex_unlock(&g_tidl_mutex);
 615
 616         return VC_ERROR_NONE;
 617 }
 618
 619 int vc_mgr_tidl_close_connection()
 620 {
 621         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_close_connection");
 622         pthread_mutex_lock(&g_tidl_mutex);
 623
 624         if (NULL == g_proxy_tidl_info) {
 625                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 626                 pthread_mutex_unlock(&g_tidl_mutex);
 627                 return VC_ERROR_OPERATION_FAILED;
 628         }
 629
 630         if (0 != rpc_port_proxy_vc_mgr_destroy(g_proxy_tidl_info->rpc_h)) {
 631                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to destroy tidl handle");
 632                 pthread_mutex_unlock(&g_tidl_mutex);
 633                 return VC_ERROR_OPERATION_FAILED;
 634         }
 635
 636         g_proxy_tidl_info->rpc_h = NULL;
 637         g_proxy_tidl_info->notify_cb_h = NULL;
 638         g_proxy_tidl_info->send_buffer_cb_h = NULL;
 639
 640         free(g_proxy_tidl_info);
 641         g_proxy_tidl_info = NULL;
 642
 643         free(g_stub_tidl_info);
 644         g_stub_tidl_info = NULL;
 645
 646         pthread_mutex_unlock(&g_tidl_mutex);
 647
 648         return VC_ERROR_NONE;
 649 }
 650
 651 static void __request_tidl_connect()
 652 {
 653         if (g_proxy_tidl_info->connection_requesting) {
 654                 return;
 655         }
 656
 657         int ret = rpc_port_proxy_vc_mgr_connect(g_proxy_tidl_info->rpc_h);
 658         SLOG(LOG_INFO, TAG_VCM, "[INFO] Request connection to stub. ret(%d)", ret);
 659
 660         if (0 == ret) {
 661                 g_proxy_tidl_info->connection_requesting = true;
 662         }
 663 }
 664
 665 static int __create_callback_handles()
 666 {
 667         if (NULL != g_proxy_tidl_info->notify_cb_h) {
 668                 rpc_port_proxy_vc_mgr_notify_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->notify_cb_h);
 669                 g_proxy_tidl_info->notify_cb_h = NULL;
 670         }
 671
 672         if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_notify_cb_create(&g_proxy_tidl_info->notify_cb_h)) {
 673                 return VC_ERROR_OUT_OF_MEMORY;
 674         }
 675
 676         rpc_port_proxy_vc_mgr_notify_cb_set_callback(g_proxy_tidl_info->notify_cb_h, __notify_cb, NULL);
 677
 678         rpc_port_proxy_vc_mgr_notify_cb_set_once(g_proxy_tidl_info->notify_cb_h, false);
 679
 680         if (NULL != g_proxy_tidl_info->send_buffer_cb_h) {
 681                 rpc_port_proxy_vc_mgr_send_buffer_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->send_buffer_cb_h);
 682                 g_proxy_tidl_info->send_buffer_cb_h = NULL;
 683         }
 684
 685         if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_send_buffer_cb_create(&g_proxy_tidl_info->send_buffer_cb_h)) {
 686                 return VC_ERROR_OUT_OF_MEMORY;
 687         }
 688
 689         rpc_port_proxy_vc_mgr_send_buffer_cb_set_callback(g_proxy_tidl_info->send_buffer_cb_h, __send_buffer_cb, NULL);
 690
 691         rpc_port_proxy_vc_mgr_send_buffer_cb_set_once(g_proxy_tidl_info->send_buffer_cb_h, false);
 692
 693         return VC_ERROR_NONE;
 694 }
 695
 696 static int __invoke_register_callback()
 697 {
 698         if (g_proxy_tidl_info->register_callback_invoked) {
 699                 SLOG(LOG_ERROR, TAG_VCM, "[INFO] Already register callback is invoked");
 700                 return VC_ERROR_NONE;
 701         }
 702
 703         int ret = __create_callback_handles(g_proxy_tidl_info);
 704         if (VC_ERROR_NONE != ret) {
 705                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create callback handle. ret(%d)", ret);
 706                 return VC_ERROR_OPERATION_FAILED;
 707         }
 708
 709         rpc_port_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);
 710         g_proxy_tidl_info->register_callback_invoked = true;
 711         return VC_ERROR_NONE;
 712 }
 713
 714 int vc_mgr_tidl_request_hello()
 715 {
 716         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_hello");
 717
 718         if (NULL == g_proxy_tidl_info) {
 719                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get proxy tidl info");
 720                 return VC_ERROR_OPERATION_FAILED;
 721         }
 722
 723         if (!g_proxy_tidl_info->connected) {
 724                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Proxy Not Connected");
 725                 __request_tidl_connect();
 726                 return VC_ERROR_OPERATION_FAILED;
 727         }
 728
 729         if (VC_ERROR_NONE != __invoke_register_callback()) {
 730                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to invoke register callback");
 731                 return VC_ERROR_OPERATION_FAILED;
 732         }
 733
 734         if (NULL == g_stub_tidl_info) {
 735                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get stub tidl info");
 736                 return VC_ERROR_OPERATION_FAILED;
 737         }
 738
 739         if (!g_stub_tidl_info->connected) {
 740                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stub Not Connected");
 741                 __register_stub_callback();
 742                 return VC_ERROR_OPERATION_FAILED;
 743         }
 744
 745         SLOG(LOG_DEBUG, TAG_VCM, ">>>>> VCM Hello");
 746
 747         SLOG(LOG_DEBUG, TAG_VCM, "<<<<");
 748
 749         return VC_ERROR_NONE;
 750 }
 751
 752 int vc_mgr_tidl_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid)
 753 {
 754         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_initialize");
 755
 756         if (NULL == g_proxy_tidl_info) {
 757                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 758                 return VC_ERROR_OPERATION_FAILED;
 759         }
 760
 761         int tmp_service_state = 0;
 762         int tmp_forground = 0;
 763         int tmp_daemon_pid = 0;
 764
 765         if (!g_proxy_tidl_info->connected) {
 766                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 767                 return VC_ERROR_OPERATION_FAILED;
 768         }
 769
 770         if (0 != rpc_port_proxy_vc_mgr_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, audio_streaming_mode, &tmp_service_state, &tmp_forground, &tmp_daemon_pid)) {
 771                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message");
 772                 return VC_ERROR_OPERATION_FAILED;
 773         }
 774
 775         *service_state = tmp_service_state;
 776         *foreground = tmp_forground;
 777         *daemon_pid = tmp_daemon_pid;
 778
 779         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc manager initialize: service_state(%d), foreground(%d), daemon_pid(%d)", *service_state, *foreground, *daemon_pid);
 780
 781         return VC_ERROR_NONE;
 782 }
 783
 784 int vc_mgr_tidl_request_finalize(int pid)
 785 {
 786         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_finalize");
 787
 788         if (NULL == g_proxy_tidl_info) {
 789                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 790                 return VC_ERROR_OPERATION_FAILED;
 791         }
 792
 793         if (!g_proxy_tidl_info->connected) {
 794                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 795                 return VC_ERROR_OPERATION_FAILED;
 796         }
 797
 798         if (0 != rpc_port_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid)) {
 799                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message");
 800                 return VC_ERROR_OPERATION_FAILED;
 801         }
 802
 803         return VC_ERROR_NONE;
 804 }
 805
 806 int vc_mgr_tidl_request_set_command(int pid)
 807 {
 808         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_command");
 809
 810         if (NULL == g_proxy_tidl_info) {
 811                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 812                 return VC_ERROR_OPERATION_FAILED;
 813         }
 814
 815         if (!g_proxy_tidl_info->connected) {
 816                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 817                 return VC_ERROR_OPERATION_FAILED;
 818         }
 819
 820         if (0 != rpc_port_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid)) {
 821                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message");
 822                 return VC_ERROR_OPERATION_FAILED;
 823         }
 824
 825         return VC_ERROR_NONE;
 826 }
 827
 828 int vc_mgr_tidl_request_unset_command(int pid)
 829 {
 830         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_unset_command");
 831
 832         if (NULL == g_proxy_tidl_info) {
 833                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 834                 return VC_ERROR_OPERATION_FAILED;
 835         }
 836
 837         if (!g_proxy_tidl_info->connected) {
 838                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 839                 return VC_ERROR_OPERATION_FAILED;
 840         }
 841
 842         if (0 != rpc_port_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid)) {
 843                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message");
 844                 return VC_ERROR_OPERATION_FAILED;
 845         }
 846
 847         return VC_ERROR_NONE;
 848 }
 849
 850 int vc_mgr_tidl_request_demandable_client(int pid)
 851 {
 852         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_demandable_client");
 853
 854         if (NULL == g_proxy_tidl_info) {
 855                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 856                 return VC_ERROR_OPERATION_FAILED;
 857         }
 858
 859         if (!g_proxy_tidl_info->connected) {
 860                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 861                 return VC_ERROR_OPERATION_FAILED;
 862         }
 863
 864         if (0 != rpc_port_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid)) {
 865                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message");
 866                 return VC_ERROR_OPERATION_FAILED;
 867         }
 868
 869         return VC_ERROR_NONE;
 870 }
 871
 872 int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type)
 873 {
 874         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_type");
 875
 876         if (NULL == g_proxy_tidl_info) {
 877                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 878                 return VC_ERROR_OPERATION_FAILED;
 879         }
 880
 881         if (!g_proxy_tidl_info->connected) {
 882                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 883                 return VC_ERROR_OPERATION_FAILED;
 884         }
 885
 886         if (0 != rpc_port_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type)) {
 887                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message");
 888                 return VC_ERROR_OPERATION_FAILED;
 889         }
 890
 891         return VC_ERROR_NONE;
 892 }
 893
 894 int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type)
 895 {
 896         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_audio_type");
 897
 898         if (NULL == g_proxy_tidl_info) {
 899                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 900                 return VC_ERROR_OPERATION_FAILED;
 901         }
 902
 903         if (!g_proxy_tidl_info->connected) {
 904                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 905                 return VC_ERROR_OPERATION_FAILED;
 906         }
 907
 908         char *tmp = NULL;
 909         if (0 != rpc_port_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp)) {
 910                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message");
 911                 return VC_ERROR_OPERATION_FAILED;
 912         }
 913         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get audio type : Success");
 914
 915         *audio_type = tmp;
 916
 917         return VC_ERROR_NONE;
 918 }
 919
 920 int vc_mgr_tidl_request_set_private_data(int pid, const char* key, const char* data)
 921 {
 922         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_private_data");
 923
 924         if (NULL == g_proxy_tidl_info) {
 925                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 926                 return VC_ERROR_OPERATION_FAILED;
 927         }
 928
 929         if (!g_proxy_tidl_info->connected) {
 930                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 931                 return VC_ERROR_OPERATION_FAILED;
 932         }
 933
 934         rpc_port_proxy_vc_mgr_invoke_set_private_data(g_proxy_tidl_info->rpc_h, pid, key, data);
 935
 936         return VC_ERROR_NONE;
 937 }
 938
 939 int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data)
 940 {
 941         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_private_data");
 942
 943         if (NULL == g_proxy_tidl_info) {
 944                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 945                 return VC_ERROR_OPERATION_FAILED;
 946         }
 947
 948         if (!g_proxy_tidl_info->connected) {
 949                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 950                 return VC_ERROR_OPERATION_FAILED;
 951         }
 952
 953         char *tmp = NULL;
 954         if (0 != rpc_port_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp)) {
 955                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message");
 956                 return VC_ERROR_OPERATION_FAILED;
 957         }
 958         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get private data : Success");
 959
 960         *data = tmp;
 961
 962         return VC_ERROR_NONE;
 963 }
 964
 965 int vc_mgr_tidl_request_set_client_info(int pid)
 966 {
 967         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_client_info");
 968
 969         if (NULL == g_proxy_tidl_info) {
 970                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 971                 return VC_ERROR_OPERATION_FAILED;
 972         }
 973
 974         if (!g_proxy_tidl_info->connected) {
 975                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 976                 return VC_ERROR_OPERATION_FAILED;
 977         }
 978
 979         if (0 != rpc_port_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid)) {
 980                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message");
 981                 return VC_ERROR_OPERATION_FAILED;
 982         }
 983
 984         return VC_ERROR_NONE;
 985 }
 986
 987 int vc_mgr_tidl_request_set_domain(int pid, const char* domain)
 988 {
 989         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_domain");
 990
 991         if (NULL == g_proxy_tidl_info) {
 992                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 993                 return VC_ERROR_OPERATION_FAILED;
 994         }
 995
 996         if (!g_proxy_tidl_info->connected) {
 997                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 998                 return VC_ERROR_OPERATION_FAILED;
 999         }
1000
1001         if (0 != rpc_port_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain)) {
1002                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message");
1003                 return VC_ERROR_OPERATION_FAILED;
1004         }
1005
1006         return VC_ERROR_NONE;
1007 }
1008
1009 int vc_mgr_tidl_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
1010 {
1011         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_do_action");
1012
1013         if (NULL == g_proxy_tidl_info) {
1014                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1015                 return VC_ERROR_OPERATION_FAILED;
1016         }
1017
1018         if (!g_proxy_tidl_info->connected) {
1019                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1020                 return VC_ERROR_OPERATION_FAILED;
1021         }
1022
1023         rpc_port_proxy_vc_mgr_invoke_do_action(g_proxy_tidl_info->rpc_h, pid, type, send_event);
1024
1025         return VC_ERROR_NONE;
1026 }
1027
1028 int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type)
1029 {
1030         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_start");
1031
1032         if (NULL == g_proxy_tidl_info) {
1033                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1034                 return VC_ERROR_OPERATION_FAILED;
1035         }
1036
1037         if (!g_proxy_tidl_info->connected) {
1038                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1039                 return VC_ERROR_OPERATION_FAILED;
1040         }
1041
1042         if (0 != rpc_port_proxy_vc_mgr_invoke_start(g_proxy_tidl_info->rpc_h, pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type)) {
1043                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message");
1044                 return VC_ERROR_OPERATION_FAILED;
1045         }
1046
1047         return VC_ERROR_NONE;
1048 }
1049
1050 int vc_mgr_tidl_request_stop(int pid)
1051 {
1052         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_stop");
1053
1054         if (NULL == g_proxy_tidl_info) {
1055                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1056                 return VC_ERROR_OPERATION_FAILED;
1057         }
1058
1059         if (!g_proxy_tidl_info->connected) {
1060                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1061                 return VC_ERROR_OPERATION_FAILED;
1062         }
1063
1064         if (0 != rpc_port_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid)) {
1065                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message");
1066                 return VC_ERROR_OPERATION_FAILED;
1067         }
1068
1069         return VC_ERROR_NONE;
1070 }
1071
1072 int vc_mgr_tidl_request_cancel(int pid)
1073 {
1074         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_cancel");
1075
1076         if (NULL == g_proxy_tidl_info) {
1077                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1078                 return VC_ERROR_OPERATION_FAILED;
1079         }
1080
1081         if (!g_proxy_tidl_info->connected) {
1082                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1083                 return VC_ERROR_OPERATION_FAILED;
1084         }
1085
1086         if (0 != rpc_port_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid)) {
1087                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message");
1088                 return VC_ERROR_OPERATION_FAILED;
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_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_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_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_invoke_send_utterance_status(g_proxy_tidl_info->rpc_h, 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_array_char_h data = NULL;
1190         rpc_port_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_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_invoke_send_audio_streaming(g_proxy_tidl_info->rpc_h, pid, event, data);
1203         rpc_port_proxy_array_char_destroy(data);
1204
1205         return VC_ERROR_NONE;
1206 }