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         int ret = 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         if (RPC_PORT_ERROR_NONE != ret) {
 772                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message, error(%d)", ret);
 773                 return ret;
 774         }
 775
 776         *service_state = tmp_service_state;
 777         *foreground = tmp_forground;
 778         *daemon_pid = tmp_daemon_pid;
 779
 780         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc manager initialize: service_state(%d), foreground(%d), daemon_pid(%d)", *service_state, *foreground, *daemon_pid);
 781
 782         return VC_ERROR_NONE;
 783 }
 784
 785 int vc_mgr_tidl_request_finalize(int pid)
 786 {
 787         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_finalize");
 788
 789         if (NULL == g_proxy_tidl_info) {
 790                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 791                 return VC_ERROR_OPERATION_FAILED;
 792         }
 793
 794         if (!g_proxy_tidl_info->connected) {
 795                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 796                 return VC_ERROR_OPERATION_FAILED;
 797         }
 798
 799         int ret = rpc_port_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid);
 800         if (RPC_PORT_ERROR_NONE != ret) {
 801                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message, error(%d)", ret);
 802                 return ret;
 803         }
 804
 805         return VC_ERROR_NONE;
 806 }
 807
 808 int vc_mgr_tidl_request_set_command(int pid)
 809 {
 810         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_command");
 811
 812         if (NULL == g_proxy_tidl_info) {
 813                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 814                 return VC_ERROR_OPERATION_FAILED;
 815         }
 816
 817         if (!g_proxy_tidl_info->connected) {
 818                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 819                 return VC_ERROR_OPERATION_FAILED;
 820         }
 821
 822         int ret = rpc_port_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid);
 823         if (RPC_PORT_ERROR_NONE != ret) {
 824                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message, error(%d)", ret);
 825                 return ret;
 826         }
 827
 828         return VC_ERROR_NONE;
 829 }
 830
 831 int vc_mgr_tidl_request_unset_command(int pid)
 832 {
 833         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_unset_command");
 834
 835         if (NULL == g_proxy_tidl_info) {
 836                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 837                 return VC_ERROR_OPERATION_FAILED;
 838         }
 839
 840         if (!g_proxy_tidl_info->connected) {
 841                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 842                 return VC_ERROR_OPERATION_FAILED;
 843         }
 844
 845         int ret = rpc_port_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid);
 846         if (RPC_PORT_ERROR_NONE != ret) {
 847                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message, error(%d)", ret);
 848                 return ret;
 849         }
 850
 851         return VC_ERROR_NONE;
 852 }
 853
 854 int vc_mgr_tidl_request_demandable_client(int pid)
 855 {
 856         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_demandable_client");
 857
 858         if (NULL == g_proxy_tidl_info) {
 859                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 860                 return VC_ERROR_OPERATION_FAILED;
 861         }
 862
 863         if (!g_proxy_tidl_info->connected) {
 864                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 865                 return VC_ERROR_OPERATION_FAILED;
 866         }
 867
 868         int ret = rpc_port_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid);
 869         if (RPC_PORT_ERROR_NONE != ret) {
 870                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message, error(%d)", ret);
 871                 return ret;
 872         }
 873
 874         return VC_ERROR_NONE;
 875 }
 876
 877 int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type)
 878 {
 879         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_type");
 880
 881         if (NULL == g_proxy_tidl_info) {
 882                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 883                 return VC_ERROR_OPERATION_FAILED;
 884         }
 885
 886         if (!g_proxy_tidl_info->connected) {
 887                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 888                 return VC_ERROR_OPERATION_FAILED;
 889         }
 890
 891         int ret = rpc_port_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type);
 892         if (RPC_PORT_ERROR_NONE != ret) {
 893                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message, error(%d)", ret);
 894                 return ret;
 895         }
 896
 897         return VC_ERROR_NONE;
 898 }
 899
 900 int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type)
 901 {
 902         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_audio_type");
 903
 904         if (NULL == g_proxy_tidl_info) {
 905                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 906                 return VC_ERROR_OPERATION_FAILED;
 907         }
 908
 909         if (!g_proxy_tidl_info->connected) {
 910                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 911                 return VC_ERROR_OPERATION_FAILED;
 912         }
 913
 914         char *tmp = NULL;
 915         int ret = rpc_port_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp);
 916         if (RPC_PORT_ERROR_NONE != ret) {
 917                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message, error(%d)", ret);
 918                 return ret;
 919         }
 920         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get audio type : Success");
 921
 922         *audio_type = tmp;
 923
 924         return VC_ERROR_NONE;
 925 }
 926
 927 int vc_mgr_tidl_request_set_private_data(int pid, const char* key, const char* data)
 928 {
 929         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_private_data");
 930
 931         if (NULL == g_proxy_tidl_info) {
 932                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 933                 return VC_ERROR_OPERATION_FAILED;
 934         }
 935
 936         if (!g_proxy_tidl_info->connected) {
 937                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 938                 return VC_ERROR_OPERATION_FAILED;
 939         }
 940
 941         rpc_port_proxy_vc_mgr_invoke_set_private_data(g_proxy_tidl_info->rpc_h, pid, key, data);
 942
 943         return VC_ERROR_NONE;
 944 }
 945
 946 int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data)
 947 {
 948         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_private_data");
 949
 950         if (NULL == g_proxy_tidl_info) {
 951                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 952                 return VC_ERROR_OPERATION_FAILED;
 953         }
 954
 955         if (!g_proxy_tidl_info->connected) {
 956                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 957                 return VC_ERROR_OPERATION_FAILED;
 958         }
 959
 960         char *tmp = NULL;
 961         int ret = rpc_port_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp);
 962         if (RPC_PORT_ERROR_NONE != ret) {
 963                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message, error(%d)", ret);
 964                 return ret;
 965         }
 966         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get private data : Success");
 967
 968         *data = tmp;
 969
 970         return VC_ERROR_NONE;
 971 }
 972
 973 int vc_mgr_tidl_request_set_client_info(int pid)
 974 {
 975         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_client_info");
 976
 977         if (NULL == g_proxy_tidl_info) {
 978                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
 979                 return VC_ERROR_OPERATION_FAILED;
 980         }
 981
 982         if (!g_proxy_tidl_info->connected) {
 983                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
 984                 return VC_ERROR_OPERATION_FAILED;
 985         }
 986
 987         int ret = rpc_port_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid);
 988         if (RPC_PORT_ERROR_NONE != ret) {
 989                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message, error(%d)", ret);
 990                 return ret;
 991         }
 992
 993         return VC_ERROR_NONE;
 994 }
 995
 996 int vc_mgr_tidl_request_set_domain(int pid, const char* domain)
 997 {
 998         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_domain");
 999
1000         if (NULL == g_proxy_tidl_info) {
1001                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1002                 return VC_ERROR_OPERATION_FAILED;
1003         }
1004
1005         if (!g_proxy_tidl_info->connected) {
1006                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1007                 return VC_ERROR_OPERATION_FAILED;
1008         }
1009
1010         int ret = rpc_port_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain);
1011         if (RPC_PORT_ERROR_NONE != ret) {
1012                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message, error(%d)", ret);
1013                 return ret;
1014         }
1015
1016         return VC_ERROR_NONE;
1017 }
1018
1019 int vc_mgr_tidl_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
1020 {
1021         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_do_action");
1022
1023         if (NULL == g_proxy_tidl_info) {
1024                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1025                 return VC_ERROR_OPERATION_FAILED;
1026         }
1027
1028         if (!g_proxy_tidl_info->connected) {
1029                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1030                 return VC_ERROR_OPERATION_FAILED;
1031         }
1032
1033         rpc_port_proxy_vc_mgr_invoke_do_action(g_proxy_tidl_info->rpc_h, pid, type, send_event);
1034
1035         return VC_ERROR_NONE;
1036 }
1037
1038 int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type)
1039 {
1040         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_start");
1041
1042         if (NULL == g_proxy_tidl_info) {
1043                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1044                 return VC_ERROR_OPERATION_FAILED;
1045         }
1046
1047         if (!g_proxy_tidl_info->connected) {
1048                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1049                 return VC_ERROR_OPERATION_FAILED;
1050         }
1051
1052         int ret = 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);
1053         if (RPC_PORT_ERROR_NONE != ret) {
1054                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message, error(%d)", ret);
1055                 return ret;
1056         }
1057
1058         return VC_ERROR_NONE;
1059 }
1060
1061 int vc_mgr_tidl_request_stop(int pid)
1062 {
1063         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_stop");
1064
1065         if (NULL == g_proxy_tidl_info) {
1066                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1067                 return VC_ERROR_OPERATION_FAILED;
1068         }
1069
1070         if (!g_proxy_tidl_info->connected) {
1071                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1072                 return VC_ERROR_OPERATION_FAILED;
1073         }
1074
1075         int ret = rpc_port_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid);
1076         if (RPC_PORT_ERROR_NONE != ret) {
1077                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message, error(%d)", ret);
1078                 return ret;
1079         }
1080
1081         return VC_ERROR_NONE;
1082 }
1083
1084 int vc_mgr_tidl_request_cancel(int pid)
1085 {
1086         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_cancel");
1087
1088         if (NULL == g_proxy_tidl_info) {
1089                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1090                 return VC_ERROR_OPERATION_FAILED;
1091         }
1092
1093         if (!g_proxy_tidl_info->connected) {
1094                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1095                 return VC_ERROR_OPERATION_FAILED;
1096         }
1097
1098         int ret = rpc_port_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid);
1099         if (RPC_PORT_ERROR_NONE != ret) {
1100                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message, error(%d)", ret);
1101                 return ret;
1102         }
1103
1104         return VC_ERROR_NONE;
1105 }
1106
1107 int vc_mgr_tidl_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode)
1108 {
1109         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_streaming_mode");
1110
1111         if (NULL == g_proxy_tidl_info) {
1112                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1113                 return VC_ERROR_OPERATION_FAILED;
1114         }
1115
1116         if (!g_proxy_tidl_info->connected) {
1117                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1118                 return VC_ERROR_OPERATION_FAILED;
1119         }
1120
1121         rpc_port_proxy_vc_mgr_invoke_set_audio_streaming_mode(g_proxy_tidl_info->rpc_h, pid, mode);
1122
1123         return VC_ERROR_NONE;
1124 }
1125
1126 int vc_mgr_tidl_send_result_selection(int pid)
1127 {
1128         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection");
1129
1130         if (NULL == g_proxy_tidl_info) {
1131                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1132                 return VC_ERROR_OPERATION_FAILED;
1133         }
1134
1135         if (!g_proxy_tidl_info->connected) {
1136                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1137                 return VC_ERROR_OPERATION_FAILED;
1138         }
1139
1140         rpc_port_proxy_vc_mgr_invoke_send_result_selection(g_proxy_tidl_info->rpc_h, pid);
1141
1142         return VC_ERROR_NONE;
1143 }
1144
1145 int vc_mgr_tidl_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request)
1146 {
1147         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection");
1148
1149         if (NULL == g_proxy_tidl_info) {
1150                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1151                 return VC_ERROR_OPERATION_FAILED;
1152         }
1153
1154         if (!g_proxy_tidl_info->connected) {
1155                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1156                 return VC_ERROR_OPERATION_FAILED;
1157         }
1158
1159         gchar *gEncodedRequest = g_base64_encode((const guchar*)request, strlen(request));
1160
1161         rpc_port_proxy_vc_mgr_invoke_send_specific_engine_request(g_proxy_tidl_info->rpc_h, pid, engine_app_id, event, gEncodedRequest);
1162
1163         if (gEncodedRequest)
1164                 g_free(gEncodedRequest);
1165
1166         return VC_ERROR_NONE;
1167 }
1168
1169 int vc_mgr_tidl_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status)
1170 {
1171         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_utterance_status");
1172
1173         if (NULL == g_proxy_tidl_info) {
1174                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1175                 return VC_ERROR_OPERATION_FAILED;
1176         }
1177
1178         if (!g_proxy_tidl_info->connected) {
1179                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1180                 return VC_ERROR_OPERATION_FAILED;
1181         }
1182
1183         rpc_port_proxy_vc_mgr_invoke_send_utterance_status(g_proxy_tidl_info->rpc_h, utt_id, utt_status);
1184
1185         return VC_ERROR_NONE;
1186 }
1187
1188 int vc_mgr_tidl_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
1189 {
1190         SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_audio_streaming");
1191
1192         if (NULL == g_proxy_tidl_info) {
1193                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info");
1194                 return VC_ERROR_OPERATION_FAILED;
1195         }
1196
1197         if (!g_proxy_tidl_info->connected) {
1198                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected");
1199                 return VC_ERROR_OPERATION_FAILED;
1200         }
1201
1202         rpc_port_proxy_array_char_h data = NULL;
1203         rpc_port_proxy_array_char_create(&data);
1204         if (NULL == data) {
1205                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create data handle");
1206                 return VC_ERROR_OUT_OF_MEMORY;
1207         }
1208
1209         if (NULL != buffer && 0 < len) {
1210                 rpc_port_proxy_array_char_set(data, (char*)buffer, len);
1211         } else {
1212                 SLOG(LOG_ERROR, TAG_VCM, "[TIDL] buffer is empty");
1213         }
1214
1215         rpc_port_proxy_vc_mgr_invoke_send_audio_streaming(g_proxy_tidl_info->rpc_h, pid, event, data);
1216         rpc_port_proxy_array_char_destroy(data);
1217
1218         return VC_ERROR_NONE;
1219 }