client/vc_widget_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 #include <rpc-port.h>
  19
  20 #include "vc_main.h"
  21 #include "vc_widget_client.h"
  22 #include "vc_widget_tidl.h"
  23 #include "vc_widget_proxy.h"
  24 #include "vc_widget_stub.h"
  25
  26 typedef struct {
  27         bool connected;
  28         bool connection_requesting;
  29         bool register_callback_invoked;
  30         rpc_port_proxy_vc_widget_proxy_vc_widget_h rpc_h;
  31         rpc_port_proxy_vc_widget_proxy_vc_widget_notify_cb_h notify_cb_h;
  32 } vc_widget_tidl_info_s;
  33
  34 typedef struct {
  35         bool connected;
  36         bool register_callback_requesting;
  37 } vcd_widget_tidl_info_s;
  38
  39 static vc_widget_tidl_info_s* g_proxy_tidl_info = NULL;
  40
  41 static vcd_widget_tidl_info_s* g_stub_tidl_info = NULL;
  42
  43 static pthread_mutex_t g_w_tidl_mutex = PTHREAD_MUTEX_INITIALIZER;
  44 static pthread_mutex_t g_w_init_mutex = PTHREAD_MUTEX_INITIALIZER;
  45
  46 static rpc_port_stub_vc_widget_stub_vcd_widget_callback_s g_widget_callback;
  47
  48 extern int __vc_widget_cb_error(int reason, int daemon_pid, char* msg);
  49
  50 extern void __vc_widget_cb_show_tooltip(int pid, bool show);
  51
  52 extern void __vc_widget_cb_result();
  53
  54 extern bool __vc_widget_cb_asr_result(int event, const char* asr_result);
  55
  56 extern int __vc_widget_cb_service_state(int state);
  57
  58 static void __notify_cb(void *user_data, bundle *msg)
  59 {
  60         char* method = NULL;
  61         char* val = NULL;
  62         SLOG(LOG_DEBUG, TAG_VCW, "__notify_cb is invoked");
  63
  64         bundle_get_str(msg, VC_WIDGET_BUNDLE_METHOD, &method);
  65
  66         if (0 == strncmp(VCD_WIDGET_METHOD_HELLO, method, strlen(VCD_WIDGET_METHOD_HELLO))) {
  67                 SLOG(LOG_INFO, TAG_VCW, "@@@ Get widget hello");
  68                 bundle_get_str(msg, VC_WIDGET_BUNDLE_MESSAGE, &val);
  69                 if (val) {
  70                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get hello : pid(%d) ", atoi(val));
  71                 } else {
  72                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get hello : invalid pid ");
  73                 }
  74                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
  75         } /* VCD_METHOD_HELLO */
  76
  77         else if (0 == strncmp(VCD_WIDGET_METHOD_SET_SERVICE_STATE, method, strlen(VCD_WIDGET_METHOD_SET_SERVICE_STATE))) {
  78                 bundle_get_str(msg, VC_WIDGET_BUNDLE_MESSAGE, &val);
  79                 int state = 0;
  80                 if (val) {
  81                         state = atoi(val);
  82                         SLOG(LOG_INFO, TAG_VCW, "@@ service state changed : %d", state);
  83                         __vc_widget_cb_service_state(state);
  84                 }
  85         } /* VCD_WIDGET_METHOD_SET_SERVICE_STATE */
  86
  87         else if (0 == strncmp(VCD_WIDGET_METHOD_SHOW_TOOLTIP, method, strlen(VCD_WIDGET_METHOD_SHOW_TOOLTIP))) {
  88                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Show / Hide tooltip");
  89                 char* temp_show = NULL;
  90                 bundle_get_str(msg, VC_WIDGET_BUNDLE_MESSAGE, &val);
  91                 bundle_get_str(msg, VC_WIDGET_BUNDLE_SHOW, &temp_show);
  92                 int pid = 0;
  93                 int show = 0;
  94
  95                 if (val) {
  96                         pid = atoi(val);
  97                 }
  98                 if (temp_show) {
  99                         show = atoi(temp_show);
 100                 }
 101
 102                 if(pid > 0){
 103                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget show tooltip : pid(%d), show(%d)", pid, show);
 104                         __vc_widget_cb_show_tooltip(pid, (bool)show);
 105                 } else {
 106                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget show tooltip : invalid pid");
 107                 }
 108                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 109         } /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
 110
 111         else if (0 == strncmp(VCD_WIDGET_METHOD_RESULT, method, strlen(VCD_WIDGET_METHOD_RESULT))) {
 112                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget result");
 113
 114                 __vc_widget_cb_result();
 115
 116                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 117         } /* VCD_WIDGET_METHOD_RESULT */
 118
 119         else if (0 == strncmp(VCD_WIDGET_METHOD_ERROR, method, strlen(VCD_WIDGET_METHOD_ERROR))) {
 120                 SLOG(LOG_INFO, TAG_VCW, "@@@ Get Pre Result");
 121                 char* temp_reason = NULL;
 122                 char* temp_daemon_pid = NULL;
 123                 char* err_msg = NULL;
 124
 125                 bundle_get_str(msg, VC_WIDGET_BUNDLE_REASON, &temp_reason);
 126                 bundle_get_str(msg, VC_WIDGET_BUNDLE_DAEMON_PID, &temp_daemon_pid);
 127                 bundle_get_str(msg, VC_WIDGET_BUNDLE_ERROR_MESSAGE, &err_msg);
 128                 int reason = 0;
 129                 int daemon_pid = 0;
 130
 131                 if (NULL != temp_reason) {
 132                         reason = atoi(temp_reason);
 133                 }
 134                 if (NULL != temp_daemon_pid) {
 135                         daemon_pid = atoi(temp_daemon_pid);
 136                 }
 137
 138                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
 139                 __vc_widget_cb_error(reason, daemon_pid, err_msg);
 140
 141                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 142         } /* VCD_WIDGET_METHOD_ERROR */
 143
 144         else {
 145                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid msg");
 146         }
 147 }
 148
 149 static void __on_connected(rpc_port_proxy_vc_widget_proxy_vc_widget_h h, void *user_data)
 150 {
 151         g_proxy_tidl_info->connected = true;
 152         g_proxy_tidl_info->connection_requesting = false;
 153         g_proxy_tidl_info->register_callback_invoked = false;
 154
 155         SLOG(LOG_INFO, TAG_VCW, "Connected to server");
 156 }
 157
 158 static void __on_disconnected(rpc_port_proxy_vc_widget_proxy_vc_widget_h h, void *user_data)
 159 {
 160         g_proxy_tidl_info->connected = false;
 161         g_proxy_tidl_info->connection_requesting = false;
 162         g_proxy_tidl_info->register_callback_invoked = false;
 163
 164         SLOG(LOG_INFO, TAG_VCW, "Disonnected to server");
 165
 166         SLOG(LOG_INFO, TAG_VCW, "Re-connection start");
 167         __vc_widget_cb_error(VC_ERROR_SERVICE_RESET, -1, "Server Disconnected, re-launch");
 168 }
 169
 170 static void __on_rejected(rpc_port_proxy_vc_widget_proxy_vc_widget_h h, void *user_data)
 171 {
 172         g_proxy_tidl_info->connection_requesting = false;
 173         g_proxy_tidl_info->register_callback_invoked = false;
 174
 175         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Rejected from server");
 176 }
 177
 178
 179 static rpc_port_proxy_vc_widget_proxy_vc_widget_h __create_rpc_port(const char* engine_app_id)
 180 {
 181         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] __create_rpc_port");
 182         rpc_port_proxy_vc_widget_proxy_vc_widget_callback_s rpc_callback = {
 183                 .connected = __on_connected,
 184                 .disconnected = __on_disconnected,
 185                 .rejected = __on_rejected
 186         };
 187
 188         rpc_port_proxy_vc_widget_proxy_vc_widget_h handle = NULL;
 189         if (0 != rpc_port_proxy_vc_widget_proxy_vc_widget_create(engine_app_id, &rpc_callback, NULL, &handle)) {
 190                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Fail to create proxy");
 191                 return NULL;
 192         }
 193
 194         return handle;
 195 }
 196
 197 static void __vcd_widget_create_cb(rpc_port_stub_vc_widget_stub_vcd_widget_context_h context, void *user_data)
 198 {
 199         g_stub_tidl_info->connected = true;
 200         g_stub_tidl_info->register_callback_requesting = false;
 201
 202         SLOG(LOG_DEBUG, TAG_VCW, "Connected to server");
 203
 204         char *sender = NULL;
 205
 206         rpc_port_stub_vc_widget_stub_vcd_widget_context_get_sender(context, &sender);
 207         if (!sender) {
 208                 SLOG(LOG_ERROR, TAG_VCW, "@@@ Sender is NULL");
 209                 return;
 210         }
 211
 212         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Server connect. appid(%s)", sender);
 213         free(sender);
 214 }
 215
 216 static void __vcd_widget_terminate_cb(rpc_port_stub_vc_widget_stub_vcd_widget_context_h context, void *user_data)
 217 {
 218         g_stub_tidl_info->connected = false;
 219         g_stub_tidl_info->register_callback_requesting = false;
 220
 221         rpc_port_stub_vc_widget_stub_vcd_widget_context_set_tag(context, NULL);
 222
 223         char *sender = NULL;
 224         rpc_port_stub_vc_widget_stub_vcd_widget_context_get_sender(context, &sender);
 225         if (!sender)
 226                 return;
 227
 228         SLOG(LOG_INFO, TAG_VCW, "@@@ Server disconnect. appid(%s)", sender);
 229         free(sender);
 230 }
 231
 232 static int __vcd_widget_asr_result_cb(rpc_port_stub_vc_widget_stub_vcd_widget_context_h context, int pid, int event, const char *asr_result, bool *is_consumed, void *user_data)
 233 {
 234         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget asr result");
 235
 236         bool result = false;
 237         result = __vc_widget_cb_asr_result(event, asr_result);
 238         *is_consumed = result;
 239
 240         return VC_ERROR_NONE;
 241 }
 242
 243 static void __register_stub_callback()
 244 {
 245         if (g_stub_tidl_info->register_callback_requesting) {
 246                 return;
 247         }
 248
 249         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] __register_stub_callback");
 250
 251         g_widget_callback.create = __vcd_widget_create_cb;
 252         g_widget_callback.terminate = __vcd_widget_terminate_cb;
 253         g_widget_callback.send_asr_result = __vcd_widget_asr_result_cb;
 254
 255         int ret = -1;
 256         ret = rpc_port_stub_vc_widget_stub_vcd_widget_register(&g_widget_callback, NULL);
 257         if (0 == ret) {
 258                 SLOG(LOG_DEBUG, TAG_VCW, "register callback");
 259                 g_stub_tidl_info->register_callback_requesting = true;
 260                 return;
 261         }
 262
 263         SLOG(LOG_ERROR, TAG_VCW, "Fail to rister callback(%d)", ret);
 264         return;
 265 }
 266
 267 int vc_widget_tidl_open_connection()
 268 {
 269         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_open_connection");
 270         pthread_mutex_lock(&g_w_tidl_mutex);
 271
 272         if (NULL != g_proxy_tidl_info) {
 273                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] g_proxy_tidl_info already created");
 274                 pthread_mutex_unlock(&g_w_tidl_mutex);
 275                 return VC_ERROR_NONE;
 276         }
 277
 278         g_proxy_tidl_info = (vc_widget_tidl_info_s*)calloc(1, sizeof(vc_widget_tidl_info_s));
 279
 280         if (NULL == g_proxy_tidl_info) {
 281                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Fail to create vc_widget_tidl_info_s");
 282                 pthread_mutex_unlock(&g_w_tidl_mutex);
 283                 return VC_ERROR_OUT_OF_MEMORY;
 284         }
 285
 286         char* engine_app_id = vconf_get_str(VC_ENGINE_DB_DEFAULT);
 287         if (NULL == engine_app_id) {
 288                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL] vconf not found");
 289                 free(g_proxy_tidl_info);
 290                 g_proxy_tidl_info = NULL;
 291                 pthread_mutex_unlock(&g_w_tidl_mutex);
 292                 return VC_ERROR_ENGINE_NOT_FOUND;
 293         }
 294
 295         g_proxy_tidl_info->rpc_h = __create_rpc_port(engine_app_id);
 296         if (NULL == g_proxy_tidl_info->rpc_h) {
 297                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Fail to create proxy");
 298                 free(engine_app_id);
 299                 free(g_proxy_tidl_info);
 300                 g_proxy_tidl_info = NULL;
 301                 pthread_mutex_unlock(&g_w_tidl_mutex);
 302                 return VC_ERROR_OPERATION_FAILED;
 303         }
 304
 305         SLOG(LOG_INFO, TAG_VCW, "[TIDL] rpc_h(%p), engine_app_id(%s)", g_proxy_tidl_info->rpc_h, engine_app_id);
 306         free(engine_app_id);
 307
 308         g_stub_tidl_info = (vcd_widget_tidl_info_s*)calloc(1, sizeof(vcd_widget_tidl_info_s));
 309
 310         if (NULL == g_stub_tidl_info) {
 311                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Fail to create vcd_widget_tidl_info_s");
 312                 pthread_mutex_unlock(&g_w_tidl_mutex);
 313                 return VC_ERROR_OUT_OF_MEMORY;
 314         }
 315
 316         __register_stub_callback();
 317
 318         pthread_mutex_unlock(&g_w_tidl_mutex);
 319
 320         return VC_ERROR_NONE;
 321 }
 322
 323 int vc_widget_tidl_close_connection()
 324 {
 325         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_close_connection");
 326         pthread_mutex_lock(&g_w_tidl_mutex);
 327
 328         if (NULL == g_proxy_tidl_info) {
 329                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 330                 pthread_mutex_unlock(&g_w_tidl_mutex);
 331                 return VC_ERROR_OPERATION_FAILED;
 332         }
 333
 334         if (0 != rpc_port_proxy_vc_widget_proxy_vc_widget_destroy(g_proxy_tidl_info->rpc_h)) {
 335                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Fail to destroy tidl handle");
 336                 pthread_mutex_unlock(&g_w_tidl_mutex);
 337                 return VC_ERROR_OPERATION_FAILED;
 338         }
 339
 340         g_proxy_tidl_info->rpc_h = NULL;
 341         g_proxy_tidl_info->notify_cb_h = NULL;
 342
 343         free(g_proxy_tidl_info);
 344         g_proxy_tidl_info = NULL;
 345
 346         free(g_stub_tidl_info);
 347         g_stub_tidl_info = NULL;
 348
 349         pthread_mutex_unlock(&g_w_tidl_mutex);
 350
 351         return VC_ERROR_NONE;
 352 }
 353
 354 static void __request_tidl_connect()
 355 {
 356         if (g_proxy_tidl_info->connection_requesting) {
 357                 return;
 358         }
 359
 360         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_connect(g_proxy_tidl_info->rpc_h);
 361         SLOG(LOG_INFO, TAG_VCW, "[INFO] Request connection to stub. ret(%d)", ret);
 362
 363         if (0 == ret) {
 364                 g_proxy_tidl_info->connection_requesting = true;
 365         }
 366 }
 367
 368 static int __create_callback_handles()
 369 {
 370         if (NULL != g_proxy_tidl_info->notify_cb_h) {
 371                 rpc_port_proxy_vc_widget_proxy_vc_widget_notify_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->notify_cb_h);
 372                 g_proxy_tidl_info->notify_cb_h = NULL;
 373         }
 374
 375         if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_widget_proxy_vc_widget_notify_cb_create(&g_proxy_tidl_info->notify_cb_h)) {
 376                 return VC_ERROR_OUT_OF_MEMORY;
 377         }
 378
 379         rpc_port_proxy_vc_widget_proxy_vc_widget_notify_cb_set_callback(g_proxy_tidl_info->notify_cb_h, __notify_cb, NULL);
 380
 381         rpc_port_proxy_vc_widget_proxy_vc_widget_notify_cb_set_once(g_proxy_tidl_info->notify_cb_h, false);
 382
 383         return VC_ERROR_NONE;
 384 }
 385
 386 static int __invoke_register_callback()
 387 {
 388         if (g_proxy_tidl_info->register_callback_invoked) {
 389                 SLOG(LOG_ERROR, TAG_VCW, "[INFO] Already register callback is invoked");
 390                 return VC_ERROR_NONE;
 391         }
 392
 393         int ret = __create_callback_handles(g_proxy_tidl_info);
 394         if (VC_ERROR_NONE != ret) {
 395                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create callback handle. ret(%d)", ret);
 396                 return VC_ERROR_OPERATION_FAILED;
 397         }
 398
 399         rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_register_cb(g_proxy_tidl_info->rpc_h, getpid(), g_proxy_tidl_info->notify_cb_h);
 400         g_proxy_tidl_info->register_callback_invoked = true;
 401         return VC_ERROR_NONE;
 402 }
 403
 404 int vc_widget_tidl_request_hello()
 405 {
 406         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_hello");
 407
 408         if (NULL == g_proxy_tidl_info) {
 409                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get proxy tidl info");
 410                 return VC_ERROR_OPERATION_FAILED;
 411         }
 412
 413         if (!g_proxy_tidl_info->connected) {
 414                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Proxy Not Connected");
 415                 __request_tidl_connect();
 416                 return VC_ERROR_OPERATION_FAILED;
 417         }
 418
 419         if (VC_ERROR_NONE != __invoke_register_callback()) {
 420                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to invoke register callback");
 421                 return VC_ERROR_OPERATION_FAILED;
 422         }
 423
 424         if (NULL == g_stub_tidl_info) {
 425                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get stub tidl info");
 426                 return VC_ERROR_OPERATION_FAILED;
 427         }
 428
 429         if (!g_stub_tidl_info->connected) {
 430                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Stub Not Connected");
 431                 __register_stub_callback();
 432                 return VC_ERROR_OPERATION_FAILED;
 433         }
 434
 435         SLOG(LOG_DEBUG, TAG_VCW, ">>>>> VCW Hello");
 436
 437         SLOG(LOG_DEBUG, TAG_VCW, "<<<<");
 438
 439         return VC_ERROR_NONE;
 440 }
 441
 442 int vc_widget_tidl_request_initialize(int pid, int* service_state, int* daemon_pid)
 443 {
 444         pthread_mutex_lock(&g_w_init_mutex);
 445         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_initialize");
 446
 447         if (NULL == g_proxy_tidl_info) {
 448                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 449                 pthread_mutex_unlock(&g_w_init_mutex);
 450                 return VC_ERROR_OPERATION_FAILED;
 451         }
 452
 453         int temp_service_state = 0;
 454         int temp_daemon_pid = 0;
 455         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, &temp_service_state, &temp_daemon_pid);
 456         if (RPC_PORT_ERROR_NONE != ret) {
 457                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget initialize : Fail to invoke message, error(%d)", ret);
 458                 pthread_mutex_unlock(&g_w_init_mutex);
 459                 return ret;
 460         }
 461
 462         *service_state = temp_service_state;
 463         *daemon_pid = temp_daemon_pid;
 464
 465         pthread_mutex_unlock(&g_w_init_mutex);
 466         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc widget initialize: service_state(%d), daemon_pid(%d)", *service_state, *daemon_pid);
 467
 468         return VC_ERROR_NONE;
 469 }
 470
 471 int vc_widget_tidl_request_finalize(int pid)
 472 {
 473         pthread_mutex_lock(&g_w_init_mutex);
 474         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_finalize");
 475
 476         if (NULL == g_proxy_tidl_info) {
 477                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 478                 pthread_mutex_unlock(&g_w_init_mutex);
 479                 return VC_ERROR_OPERATION_FAILED;
 480         }
 481
 482         if (!g_proxy_tidl_info->connected) {
 483                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 484                 pthread_mutex_unlock(&g_w_init_mutex);
 485                 return VC_ERROR_OPERATION_FAILED;
 486         }
 487
 488         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_finalize(g_proxy_tidl_info->rpc_h, pid);
 489         if (RPC_PORT_ERROR_NONE != ret) {
 490                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget finalize : Fail to invoke message, error(%d)", ret);
 491                 pthread_mutex_unlock(&g_w_init_mutex);
 492                 return ret;
 493         }
 494
 495         pthread_mutex_unlock(&g_w_init_mutex);
 496         return VC_ERROR_NONE;
 497 }
 498
 499 int vc_widget_tidl_request_start_recording(int pid, bool command)
 500 {
 501         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_start_recording");
 502
 503         if (NULL == g_proxy_tidl_info) {
 504                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 505                 return VC_ERROR_OPERATION_FAILED;
 506         }
 507
 508         if (!g_proxy_tidl_info->connected) {
 509                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 510                 return VC_ERROR_OPERATION_FAILED;
 511         }
 512
 513         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_start_recording(g_proxy_tidl_info->rpc_h, pid, (int)command);
 514         if (RPC_PORT_ERROR_NONE != ret) {
 515                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start recording : Fail to invoke message, error(%d)", ret);
 516                 return ret;
 517         }
 518
 519         return VC_ERROR_NONE;
 520 }
 521
 522 int vc_widget_tidl_set_foreground(int pid, bool value)
 523 {
 524         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_set_foreground");
 525
 526         if (NULL == g_proxy_tidl_info) {
 527                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 528                 return VC_ERROR_OPERATION_FAILED;
 529         }
 530
 531         if (!g_proxy_tidl_info->connected) {
 532                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 533                 return VC_ERROR_OPERATION_FAILED;
 534         }
 535
 536         // TODO: Error tolerance cannot be applied because this function is asynchronous.
 537         rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_set_foreground(g_proxy_tidl_info->rpc_h, pid, (int)value);
 538
 539         return VC_ERROR_NONE;
 540 }
 541
 542 int vc_widget_tidl_request_enable_asr_result(int pid, bool enable)
 543 {
 544         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_enable_asr_result");
 545
 546         if (NULL == g_proxy_tidl_info) {
 547                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 548                 return VC_ERROR_OPERATION_FAILED;
 549         }
 550
 551         if (!g_proxy_tidl_info->connected) {
 552                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 553                 return VC_ERROR_OPERATION_FAILED;
 554         }
 555
 556         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_enable_asr_result(g_proxy_tidl_info->rpc_h, pid, (int)enable);
 557         if (RPC_PORT_ERROR_NONE != ret) {
 558                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget enable asr result : Fail to invoke message, error(%d)", ret);
 559                 return ret;
 560         }
 561
 562         return VC_ERROR_NONE;
 563 }
 564
 565 int vc_widget_tidl_request_start(int pid, int silence)
 566 {
 567         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_start");
 568
 569         if (NULL == g_proxy_tidl_info) {
 570                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 571                 return VC_ERROR_OPERATION_FAILED;
 572         }
 573
 574         if (!g_proxy_tidl_info->connected) {
 575                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 576                 return VC_ERROR_OPERATION_FAILED;
 577         }
 578
 579         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_start(g_proxy_tidl_info->rpc_h, pid, silence);
 580         if (RPC_PORT_ERROR_NONE != ret) {
 581                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start : Fail to invoke message, error(%d)", ret);
 582                 return ret;
 583         }
 584
 585         return VC_ERROR_NONE;
 586 }
 587
 588 int vc_widget_tidl_request_stop(int pid)
 589 {
 590         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_stop");
 591
 592         if (NULL == g_proxy_tidl_info) {
 593                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 594                 return VC_ERROR_OPERATION_FAILED;
 595         }
 596
 597         if (!g_proxy_tidl_info->connected) {
 598                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 599                 return VC_ERROR_OPERATION_FAILED;
 600         }
 601
 602         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_stop(g_proxy_tidl_info->rpc_h, pid);
 603         if (RPC_PORT_ERROR_NONE != ret) {
 604                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget stop : Fail to invoke message, error(%d)", ret);
 605                 return ret;
 606         }
 607
 608         return VC_ERROR_NONE;
 609 }
 610
 611 int vc_widget_tidl_request_cancel(int pid)
 612 {
 613         SLOG(LOG_DEBUG, TAG_VCW, "[TIDL] vc_widget_tidl_request_cancel");
 614
 615         if (NULL == g_proxy_tidl_info) {
 616                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get tidl info");
 617                 return VC_ERROR_OPERATION_FAILED;
 618         }
 619
 620         if (!g_proxy_tidl_info->connected) {
 621                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Not Connected");
 622                 return VC_ERROR_OPERATION_FAILED;
 623         }
 624
 625         int ret = rpc_port_proxy_vc_widget_proxy_vc_widget_invoke_cancel(g_proxy_tidl_info->rpc_h, pid);
 626         if (RPC_PORT_ERROR_NONE != ret) {
 627                 SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget cancel : Fail to invoke message, error(%d)", ret);
 628                 return ret;
 629         }
 630
 631         return VC_ERROR_NONE;
 632 }